feat: import existing sessions and restore Codex runtime UI

cli/package.json

@@ -35,6 +35,7 @@
   "scripts": {
     "postinstall": "node -e \"try{require('fs').chmodSync(require('path').join(__dirname,'bin','hapi.cjs'),0o755)}catch(e){}\"",
     "typecheck": "tsc --noEmit",
+    "build": "bun run typecheck",
     "build:exe": "bun run scripts/build-executable.ts",
     "build:exe:all": "bun run scripts/build-executable.ts --all",
     "build:exe:allinone": "bun run scripts/build-executable.ts --with-web-assets",

cli/src/agent/sessionBase.ts

@@ -6,7 +6,8 @@ import type {
     SessionEffort,
     SessionModel,
     SessionModelReasoningEffort,
-    SessionPermissionMode
+    SessionPermissionMode,
+    SessionServiceTier
 } from '@/api/types';
 import { logger } from '@/ui/logger';
 
@@ -26,6 +27,7 @@ export type AgentSessionBaseOptions<Mode> = {
     model?: SessionModel;
     modelReasoningEffort?: SessionModelReasoningEffort;
     effort?: SessionEffort;
+    serviceTier?: SessionServiceTier;
     collaborationMode?: SessionCollaborationMode;
 };
 
@@ -50,6 +52,7 @@ export class AgentSessionBase<Mode> {
     protected model?: SessionModel;
     protected modelReasoningEffort?: SessionModelReasoningEffort;
     protected effort?: SessionEffort;
+    protected serviceTier?: SessionServiceTier;
     protected collaborationMode?: SessionCollaborationMode;
 
     constructor(opts: AgentSessionBaseOptions<Mode>) {
@@ -68,6 +71,7 @@ export class AgentSessionBase<Mode> {
         this.model = opts.model;
         this.modelReasoningEffort = opts.modelReasoningEffort;
         this.effort = opts.effort;
+        this.serviceTier = opts.serviceTier;
         this.collaborationMode = opts.collaborationMode;
 
         this.queue.onBatchConsumed = (localIds) => this.client.emitMessagesConsumed(localIds);
@@ -91,10 +95,11 @@ export class AgentSessionBase<Mode> {
         const modelLabel = this.model === undefined ? 'unset' : (this.model ?? 'auto');
         const modelReasoningEffortLabel = this.modelReasoningEffort === undefined ? 'unset' : (this.modelReasoningEffort ?? 'default');
         const effortLabel = this.effort === undefined ? 'unset' : (this.effort ?? 'auto');
+        const serviceTierLabel = this.serviceTier === undefined ? 'unset' : (this.serviceTier ?? 'default');
         const collaborationLabel = this.collaborationMode ?? 'unset';
         logger.debug(
             `[${this.sessionLabel}] Mode switched to ${mode} ` +
-            `(permissionMode=${permissionLabel}, model=${modelLabel}, modelReasoningEffort=${modelReasoningEffortLabel}, effort=${effortLabel}, collaborationMode=${collaborationLabel})`
+            `(permissionMode=${permissionLabel}, model=${modelLabel}, modelReasoningEffort=${modelReasoningEffortLabel}, effort=${effortLabel}, serviceTier=${serviceTierLabel}, collaborationMode=${collaborationLabel})`
         );
         this._onModeChange(mode);
     };
@@ -133,13 +138,15 @@ export class AgentSessionBase<Mode> {
             model?: SessionModel
             modelReasoningEffort?: SessionModelReasoningEffort
             effort?: SessionEffort
+            serviceTier?: SessionServiceTier
             collaborationMode?: SessionCollaborationMode
         } | undefined {
         if (
             this.permissionMode === undefined
             && this.model === undefined
             && this.modelReasoningEffort === undefined
             && this.effort === undefined
+            && this.serviceTier === undefined
             && this.collaborationMode === undefined
         ) {
             return undefined;
@@ -149,6 +156,7 @@ export class AgentSessionBase<Mode> {
             model: this.model,
             modelReasoningEffort: this.modelReasoningEffort,
             effort: this.effort,
+            serviceTier: this.serviceTier,
             collaborationMode: this.collaborationMode
         };
     }
@@ -169,6 +177,10 @@ export class AgentSessionBase<Mode> {
         return this.effort;
     }
 
+    getServiceTier(): SessionServiceTier | undefined {
+        return this.serviceTier;
+    }
+
     getCollaborationMode(): SessionCollaborationMode | undefined {
         return this.collaborationMode;
     }

cli/src/agent/sessionFactory.ts

@@ -25,6 +25,7 @@ export type SessionBootstrapOptions = {
     model?: string
     modelReasoningEffort?: string
     effort?: string
+    serviceTier?: string
     metadataOverrides?: Partial<Metadata>
 }
 
@@ -135,7 +136,8 @@ export async function bootstrapSession(options: SessionBootstrapOptions): Promis
         state: agentState,
         model: options.model,
         modelReasoningEffort: options.modelReasoningEffort,
-        effort: options.effort
+        effort: options.effort,
+        serviceTier: options.serviceTier
     })
 
     const session = api.sessionSyncClient(sessionInfo)

cli/src/api/api.extraHeaders.test.ts

@@ -137,6 +137,7 @@ describe('API extra headers integration', () => {
             model: null,
             modelReasoningEffort: null,
             effort: null,
+            serviceTier: null,
             permissionMode: undefined,
             collaborationMode: undefined
         })

cli/src/api/api.ts

@@ -22,6 +22,7 @@ export class ApiClient {
         model?: string
         modelReasoningEffort?: string
         effort?: string
+        serviceTier?: string
     }): Promise<Session> {
         const response = await axios.post<CreateSessionResponse>(
             `${configuration.apiUrl}/cli/sessions`,
@@ -31,7 +32,8 @@ export class ApiClient {
                 agentState: opts.state,
                 model: opts.model,
                 modelReasoningEffort: opts.modelReasoningEffort,
-                effort: opts.effort
+                effort: opts.effort,
+                serviceTier: opts.serviceTier
             },
             {
                 headers: buildHubRequestHeaders({
@@ -79,6 +81,7 @@ export class ApiClient {
             model: raw.model,
             modelReasoningEffort: raw.modelReasoningEffort,
             effort: raw.effort,
+            serviceTier: raw.serviceTier,
             permissionMode: raw.permissionMode,
             collaborationMode: raw.collaborationMode
         }

cli/src/api/apiMachine.test.ts

@@ -0,0 +1,177 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+type FakeSocket = {
+    handlers: Map<string, (...args: any[]) => void>
+    emitted: Array<{ event: string, payload: unknown }>
+    on: (event: string, handler: (...args: any[]) => void) => FakeSocket
+    emit: (event: string, payload: unknown) => void
+    emitWithAck: (event: string, payload: unknown) => Promise<unknown>
+    close: () => void
+}
+
+const listImportableCodexSessionsMock = vi.hoisted(() => vi.fn())
+const listImportableClaudeSessionsMock = vi.hoisted(() => vi.fn())
+const fakeSocket = vi.hoisted<FakeSocket>(() => ({
+    handlers: new Map(),
+    emitted: [],
+    on(event, handler) {
+        this.handlers.set(event, handler)
+        return this
+    },
+    emit(event, payload) {
+        this.emitted.push({ event, payload })
+    },
+    emitWithAck: vi.fn(async (event: string) => {
+        if (event === 'machine-update-state') {
+            return { result: 'success', version: 1, runnerState: null }
+        }
+
+        if (event === 'machine-update-metadata') {
+            return { result: 'success', version: 1, metadata: null }
+        }
+
+        return { result: 'success', version: 1 }
+    }),
+    close() {}
+}))
+
+const importableSessionsResponse = {
+    sessions: [
+        {
+            agent: 'codex',
+            externalSessionId: 'codex-session-1',
+            cwd: '/work/project',
+            timestamp: 1712131200000,
+            transcriptPath: '/sessions/codex-session-1.jsonl',
+            previewTitle: 'Project draft',
+            previewPrompt: 'Build the project'
+        }
+    ]
+}
+
+const importableClaudeSessionsResponse = {
+    sessions: [
+        {
+            agent: 'claude',
+            externalSessionId: 'claude-session-1',
+            cwd: '/work/project',
+            timestamp: 1712131200000,
+            transcriptPath: '/sessions/claude-session-1.jsonl',
+            previewTitle: 'Continue the refactor',
+            previewPrompt: 'Continue the refactor'
+        }
+    ]
+}
+
+vi.mock('socket.io-client', () => ({
+    io: vi.fn(() => fakeSocket)
+}))
+
+vi.mock('@/codex/utils/listImportableCodexSessions', () => ({
+    listImportableCodexSessions: listImportableCodexSessionsMock
+}))
+
+vi.mock('@/claude/utils/listImportableClaudeSessions', () => ({
+    listImportableClaudeSessions: listImportableClaudeSessionsMock
+}))
+
+vi.mock('@/modules/common/registerCommonHandlers', () => ({
+    registerCommonHandlers: vi.fn()
+}))
+
+vi.mock('@/utils/invokedCwd', () => ({
+    getInvokedCwd: vi.fn(() => '/workspace')
+}))
+
+vi.mock('@/ui/logger', () => ({
+    logger: {
+        debug: vi.fn()
+    }
+}))
+
+import { ApiMachineClient } from './apiMachine'
+
+describe('ApiMachineClient list-importable-sessions RPC', () => {
+    beforeEach(() => {
+        fakeSocket.handlers.clear()
+        fakeSocket.emitted.length = 0
+        vi.mocked(fakeSocket.emitWithAck).mockClear()
+        listImportableCodexSessionsMock.mockReset()
+        listImportableClaudeSessionsMock.mockReset()
+        listImportableCodexSessionsMock.mockResolvedValue(importableSessionsResponse)
+        listImportableClaudeSessionsMock.mockResolvedValue(importableClaudeSessionsResponse)
+    })
+
+    it('registers the RPC during connect and returns scanner results by agent', async () => {
+        const machine = {
+            id: 'machine-1',
+            metadata: null,
+            metadataVersion: 0,
+            runnerState: null,
+            runnerStateVersion: 0
+        } as never
+
+        const client = new ApiMachineClient('token', machine)
+        client.connect()
+
+        const connectHandler = fakeSocket.handlers.get('connect')
+        expect(connectHandler).toBeTypeOf('function')
+        connectHandler?.()
+
+        expect(fakeSocket.emitted).toEqual(
+            expect.arrayContaining([
+                expect.objectContaining({
+                    event: 'rpc-register',
+                    payload: { method: 'machine-1:path-exists' }
+                }),
+                expect.objectContaining({
+                    event: 'rpc-register',
+                    payload: { method: 'machine-1:list-importable-sessions' }
+                })
+            ])
+        )
+
+        const rpcRequestHandler = fakeSocket.handlers.get('rpc-request')
+        expect(rpcRequestHandler).toBeTypeOf('function')
+
+        const codexResponse = await new Promise<string>((resolve) => {
+            rpcRequestHandler?.(
+                {
+                    method: 'machine-1:list-importable-sessions',
+                    params: JSON.stringify({ agent: 'codex' })
+                },
+                resolve
+            )
+        })
+
+        expect(codexResponse).toBe(JSON.stringify(importableSessionsResponse))
+
+        const missingAgentResponse = await new Promise<string>((resolve) => {
+            rpcRequestHandler?.(
+                {
+                    method: 'machine-1:list-importable-sessions',
+                    params: JSON.stringify({})
+                },
+                resolve
+            )
+        })
+
+        expect(missingAgentResponse).toBe(JSON.stringify({ sessions: [] }))
+        expect(listImportableCodexSessionsMock).toHaveBeenCalledTimes(1)
+
+        const claudeResponse = await new Promise<string>((resolve) => {
+            rpcRequestHandler?.(
+                {
+                    method: 'machine-1:list-importable-sessions',
+                    params: JSON.stringify({ agent: 'claude' })
+                },
+                resolve
+            )
+        })
+
+        expect(JSON.parse(claudeResponse)).toEqual(importableClaudeSessionsResponse)
+        expect(listImportableClaudeSessionsMock).toHaveBeenCalledTimes(1)
+
+        client.shutdown()
+    })
+})