ds-harness-remote 0.4.3 → 0.4.5

package/dist/codex/virtual-harness.js

@@ -1,4 +1,4 @@
-import { CodexRemoteClient, projectCodexThread, } from '@dsh-remote/client-core';
+import { CodexRemoteClient, deriveCodexCwdWorkspaces, projectCodexThread, } from '@dsh-remote/client-core';
 const CODEX_SESSION_PREFIX = 'codex:';
 const CODEX_WORKSPACE_PREFIX = 'codex-workspace:';
 const CODEX_PROVIDER = 'codex';
@@ -151,11 +151,14 @@ export class CodexVirtualHarness {
                     }));
                 }
                 case 'session/selectModel': return business(await this.selectModel(requestArg(args), signal));
-                case 'session/canOpenWorkspacePath': return business(false);
+                case 'session/canOpenWorkspacePath': return business(this.selectedWorkspaceId !== undefined);
                 case 'session/openWorkspacePath': return business(failure('bad-request', 'Opening Host paths is unavailable in CodeX mode.'));
+                case 'host/describe': return business(success(await this.describeHost(signal)));
+                case 'host/listDirectory': return business(await this.listDirectory(requestArg(args), signal));
+                case 'directoryPicker/list': return business(await this.listDirectory(requestArg(args), signal));
                 case 'skills/list': return business(success({ items: [] }));
                 case 'commands/list': return ok(this.commandList(args));
-                case 'commands/execute': return ok(this.executeCommand(args));
+                case 'commands/execute': return ok(await this.executeCommand(args, signal));
                 default: return fail('method-not-found', `CodeX virtual Harness does not implement ${endpoint}.`);
             }
         }
@@ -241,6 +244,10 @@ export class CodexVirtualHarness {
     permissionSelection(sessionId) {
         return this.selectedPermissions.get(sessionId) ?? CODEX_DEFAULT_PERMISSION;
     }
+    setPermissionSelection(sessionId, preset) {
+        this.selectedPermissions.set(sessionId, preset);
+        this.publishProjection(sessionId, 'permissions', codexPermissionsProjection(preset), this.nextProjectionSeq());
+    }
     commandList(args) {
         nativeThreadId(requiredString(args.agentId, 'agentId'));
         return [{
@@ -249,9 +256,9 @@ export class CodexVirtualHarness {
                 input: { hint: '<preset>' },
             }];
     }
-    executeCommand(args) {
+    async executeCommand(args, signal) {
         const sessionId = requiredString(args.agentId, 'agentId');
-        nativeThreadId(sessionId);
+        const threadId = nativeThreadId(sessionId);
         const line = requiredString(args.line, 'command line').trim();
         if (!Array.isArray(args.images))
             throw new Error('The CodeX command image list is required.');
@@ -275,9 +282,10 @@ export class CodexVirtualHarness {
                 commandId,
                 result: { kind: 'error', text: `unknown preset "${requested}" (available: workspace-write, danger-full-access)` },
             };
-        this.selectedPermissions.set(sessionId, requested);
-        this.publishProjection(sessionId, 'permissions', codexPermissionsProjection(requested), this.nextProjectionSeq());
-        return { commandId, result: { kind: 'success', text: `preset ${requested}` } };
+        const result = await this.client.request('thread/resume', { threadId, permissionPreset: requested }, signal);
+        const effective = codexPermissionPresetFromResponse(result) ?? requested;
+        this.setPermissionSelection(sessionId, effective);
+        return { commandId, result: { kind: 'success', text: `preset ${effective}` } };
     }
     sessionTitle(sessionId) {
         const session = this.catalog?.sessions.find(item => item.id === sessionId);
@@ -429,7 +437,7 @@ export class CodexVirtualHarness {
             queue,
             nextSeq: history.cursor + 1,
             turn: history.nextTurn,
-            stepOpen: false,
+            stepOpen: history.activeTurnId !== undefined,
             startedItems: new Set(),
             completedItems: new Set(),
             streamedBlocks: new Map(),
@@ -439,6 +447,7 @@ export class CodexVirtualHarness {
             liveToolOutput: new Map(),
             liveToolResultSeq: new Map(),
             requestId: this.pendingRequestIds.get(sessionId),
+            ...(history.activeTurnId === undefined ? {} : { activeTurnId: history.activeTurnId }),
         };
         this.follows.add(follow);
         queue.push({
@@ -484,6 +493,12 @@ export class CodexVirtualHarness {
             this.publishProjection(follow.sessionId, 'title', title, seq);
             return;
         }
+        if (frame.method === 'thread/settings/updated') {
+            const preset = codexPermissionPresetFromResponse(params);
+            if (preset !== undefined)
+                this.setPermissionSelection(follow.sessionId, preset);
+            return;
+        }
         if (frame.method === 'turn/started') {
             const turn = record(params.turn);
             this.resetLiveTurn(follow);
@@ -889,6 +904,49 @@ export class CodexVirtualHarness {
             ? failure('workspace-not-found', 'The CodeX virtual Workspace was not found.')
             : success({ workspace: nativeWorkspace(workspace) });
     }
+    selectedWorkspace(catalog) {
+        return this.selectedWorkspaceId === undefined
+            ? undefined
+            : catalog.workspaces.find(item => item.workspaceId === this.selectedWorkspaceId);
+    }
+    async describeHost(signal) {
+        const catalog = await this.currentCatalog(signal);
+        const workspace = this.selectedWorkspace(catalog);
+        const models = await this.models(signal).catch(() => undefined);
+        return {
+            version: 'CodeX Remote',
+            cwd: workspace?.path ?? '',
+            home: workspace?.path ?? '',
+            provider: 'CodeX',
+            ...(models === undefined ? {} : { model: models.default.model }),
+            attachedSessions: catalog.sessions.length,
+            canOpenPath: workspace !== undefined,
+        };
+    }
+    async listDirectory(request, signal) {
+        const catalog = await this.currentCatalog(signal);
+        const workspace = this.selectedWorkspace(catalog);
+        if (workspace === undefined)
+            return failure('workspace-not-found', 'The CodeX virtual Workspace was not found.');
+        const path = string(request.path) ?? workspace.path;
+        if (!containsPath(workspace.path, path)) {
+            return failure('workspace-not-found', 'The selected directory is outside the current CodeX virtual Workspace.');
+        }
+        const listing = record(await this.client.request('dsh/directoryList', { path }, signal));
+        if (!isCodexDirectoryListing(listing)) {
+            return failure('internal', 'CodeX Remote returned an invalid directory listing.');
+        }
+        const listedPaths = [
+            listing.path,
+            listing.home,
+            ...listing.crumbs.map(item => item.path),
+            ...listing.entries.map(item => item.path),
+        ];
+        if (listedPaths.some(path => !containsPath(workspace.path, path))) {
+            return failure('internal', 'CodeX Remote returned a directory outside the current Workspace.');
+        }
+        return success(listing);
+    }
     async archiveSession(request, signal) {
         const sessionId = requiredString(request.sessionId, 'sessionId');
         await this.client.request('thread/archive', { threadId: nativeThreadId(sessionId) }, signal);
@@ -899,18 +957,23 @@ export class CodexVirtualHarness {
     async createSession(request, signal) {
         const catalog = await this.currentCatalog(signal);
         const workspaceId = string(request.workspaceId) ?? this.selectedWorkspaceId;
+        const workspace = workspaceId === undefined ? undefined : catalog.workspaces.find(item => item.workspaceId === workspaceId);
         const cwd = string(request.cwd)
-            ?? (workspaceId === undefined ? undefined : catalog.workspaces.find(item => item.workspaceId === workspaceId)?.path);
+            ?? workspace?.path;
         if (cwd === undefined)
             return failure('workspace-not-found', 'The CodeX virtual Workspace was not found.');
+        if (workspace !== undefined && !containsPath(workspace.path, cwd)) {
+            return failure('workspace-not-found', 'The selected directory is outside the current CodeX virtual Workspace.');
+        }
         const directory = await this.models(signal);
         const selection = directory.default;
-        const permissionPreset = CODEX_DEFAULT_PERMISSION;
+        const requestedPreset = CODEX_DEFAULT_PERMISSION;
         const result = record(await this.client.request('thread/start', {
             cwd,
             model: selection.model,
-            permissionPreset,
+            permissionPreset: requestedPreset,
         }, signal));
+        const permissionPreset = codexPermissionPresetFromResponse(result) ?? requestedPreset;
         const thread = { ...record(result.thread), cwd, turns: array(record(result.thread).turns) };
         const projected = projectCodexThread(thread);
         if (projected === undefined)
@@ -932,11 +995,12 @@ export class CodexVirtualHarness {
     }
     async forkSession(request, signal) {
         const sessionId = requiredString(request.sessionId, 'sessionId');
-        const permissionPreset = this.permissionSelection(sessionId);
+        let permissionPreset = this.selectedPermissions.get(sessionId);
         const result = record(await this.client.request('thread/fork', {
             threadId: nativeThreadId(sessionId),
-            permissionPreset,
+            ...(permissionPreset === undefined ? {} : { permissionPreset }),
         }, signal));
+        permissionPreset = codexPermissionPresetFromResponse(result) ?? permissionPreset ?? CODEX_DEFAULT_PERMISSION;
         const projected = projectCodexThread(record(result.thread));
         if (projected === undefined)
             return failure('internal', 'CodeX returned an invalid forked Thread.');
@@ -955,15 +1019,20 @@ export class CodexVirtualHarness {
             return failure('attachment-error', 'CodeX virtual Sessions accept text and pasted PNG, JPEG, WebP, or GIF images only.');
         const threadId = nativeThreadId(sessionId);
         const selection = this.modelSelection(sessionId, await this.models(signal));
-        const permissionPreset = this.permissionSelection(sessionId);
+        let permissionPreset = this.selectedPermissions.get(sessionId);
         const isFreshBlankThread = this.blankThreads.has(threadId) || this.pendingThreads.has(threadId);
         await this.ensureRcFollow(sessionId);
-        if (!isFreshBlankThread)
-            await this.client.request('thread/resume', {
+        if (!isFreshBlankThread) {
+            const resumeResult = await this.client.request('thread/resume', {
                 threadId,
                 model: selection.model,
-                permissionPreset,
             }, signal);
+            const serverPreset = codexPermissionPresetFromResponse(resumeResult);
+            if (permissionPreset === undefined && serverPreset !== undefined) {
+                permissionPreset = serverPreset;
+                this.setPermissionSelection(sessionId, serverPreset);
+            }
+        }
         this.pendingRequestIds.set(sessionId, string(request.requestId) ?? '');
         const mode = request.mode === 'steer' ? 'turn/steer' : 'turn/start';
         if (mode === 'turn/steer') {
@@ -977,7 +1046,7 @@ export class CodexVirtualHarness {
                 threadId,
                 input,
                 ...codexModelParams(selection),
-                permissionPreset,
+                ...(permissionPreset === undefined ? {} : { permissionPreset }),
             }, signal);
         }
         this.blankThreads.delete(threadId);
@@ -1136,7 +1205,7 @@ export class CodexVirtualHarness {
             queue: new AsyncValueQueue(controller.signal),
             nextSeq: history.cursor + 1,
             turn: history.nextTurn,
-            stepOpen: false,
+            stepOpen: history.activeTurnId !== undefined,
             startedItems: new Set(),
             completedItems: new Set(),
             streamedBlocks: new Map(),
@@ -1147,6 +1216,7 @@ export class CodexVirtualHarness {
             liveToolResultSeq: new Map(),
             requestId: this.pendingRequestIds.get(sessionId),
             rcOnly: true,
+            ...(history.activeTurnId === undefined ? {} : { activeTurnId: history.activeTurnId }),
         };
         this.follows.add(follow);
         try {
@@ -1225,7 +1295,10 @@ export class CodexVirtualHarness {
                 archiveSession: call('workspace.archiveSession'),
             },
             subagents: {},
-            host: {},
+            host: {
+                describe: call('host.describe'),
+                listDirectory: call('host.listDirectory'),
+            },
             skills: { list: call('skills.list') },
             agentPresets: {},
             goals: {},
@@ -1289,7 +1362,7 @@ export class CodexVirtualHarness {
     }
 }
 async function loadCatalog(client, signal, pendingThreads) {
-    const projects = await loadCodexProjects(client, signal);
+    let projects = await loadCodexProjects(client, signal);
     const threads = [];
     let cursor;
     for (let page = 0; page < MAX_CODEX_PAGES; page += 1) {
@@ -1318,6 +1391,16 @@ async function loadCatalog(client, signal, pendingThreads) {
                 threads.unshift(thread);
         }
     }
+    if (projects.length === 0) {
+        projects = deriveCodexCwdWorkspaces(threads).map(workspace => ({
+            id: workspace.id,
+            name: workspace.name,
+            roots: [{ path: workspace.path }],
+            position: workspace.position,
+            createdAt: workspace.createdAt,
+            updatedAt: workspace.updatedAt,
+        }));
+    }
     const projected = threads.map(thread => {
         const session = projectCodexThread(thread);
         return session === undefined ? undefined : { thread, session };
@@ -1440,6 +1523,7 @@ export function projectCodexNativeHistory(thread, sessionId) {
     const entries = [];
     let seq = 0;
     let turnNumber = 0;
+    const active = activeTurnId(thread.turns);
     const append = (type, data, time = Date.now(), view, sourceEventSeqs) => {
         const eventSeq = seq++;
         entries.push({
@@ -1459,6 +1543,7 @@ export function projectCodexNativeHistory(thread, sessionId) {
     for (const rawTurn of array(thread.turns)) {
         const turn = record(rawTurn);
         turnNumber += 1;
+        const turnActive = isActiveCodexTurn(turn);
         const time = normalizeTime(turn.createdAt) || normalizeTime(turn.startedAt) || normalizeTime(thread.createdAt) || Date.now();
         append('turn/start', { turn: turnNumber }, time);
         append('step/start', { turn: turnNumber, step: 1 }, time);
@@ -1471,6 +1556,8 @@ export function projectCodexNativeHistory(thread, sessionId) {
                     toolCallSeq = eventSeq;
             }
         }
+        if (turnActive)
+            continue;
         append('step/end', { turn: turnNumber, step: 1 }, normalizeTime(turn.updatedAt) || normalizeTime(turn.completedAt) || time);
         append('turn/end', {
             turn: turnNumber,
@@ -1490,6 +1577,7 @@ export function projectCodexNativeHistory(thread, sessionId) {
         entries,
         lastSeq: seq - 1,
         nextTurn: turnNumber,
+        ...(active === undefined ? {} : { activeTurnId: active }),
     };
 }
 export function paginateCodexNativeHistory(history, request) {
@@ -1515,6 +1603,7 @@ export function paginateCodexNativeHistory(history, request) {
         nextTurn: history.nextTurn,
         records: window.filter(entry => entry.event.seq >= cut),
         hasMore: window.some(entry => entry.event.seq < cut),
+        ...(history.activeTurnId === undefined ? {} : { activeTurnId: history.activeTurnId }),
     };
 }
 function itemEvents(item, turn, step, requestId, selection = modelSelection(), sessionId = CODEX_SESSION_PREFIX) {
@@ -2155,6 +2244,25 @@ function codexImageLimitsProjection() {
 function isCodexPermissionPreset(value) {
     return value === 'workspace-write' || value === 'danger-full-access';
 }
+function codexPermissionPresetFromResponse(value) {
+    const root = record(value);
+    return codexPermissionPresetFromPolicyRecord(root)
+        ?? codexPermissionPresetFromPolicyRecord(record(root.threadSettings));
+}
+function codexPermissionPresetFromPolicyRecord(value) {
+    const sandbox = value.sandbox ?? value.sandboxPolicy;
+    if (value.approvalPolicy === 'never' && isDangerFullAccessSandbox(sandbox))
+        return 'danger-full-access';
+    if (value.approvalPolicy === 'on-request' && isWorkspaceWriteSandbox(sandbox))
+        return 'workspace-write';
+    return undefined;
+}
+function isDangerFullAccessSandbox(value) {
+    return value === 'danger-full-access' || record(value).type === 'dangerFullAccess';
+}
+function isWorkspaceWriteSandbox(value) {
+    return value === 'workspace-write' || record(value).type === 'workspaceWrite';
+}
 function modelCatalog(directory) {
     return {
         default: directory.default,
@@ -2318,6 +2426,19 @@ function nativeThreadId(sessionId) {
     }
     return sessionId.slice(CODEX_SESSION_PREFIX.length);
 }
+function activeTurnId(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    for (let index = value.length - 1; index >= 0; index -= 1) {
+        const turn = record(value[index]);
+        if (isActiveCodexTurn(turn) && typeof turn.id === 'string' && turn.id.length > 0)
+            return turn.id;
+    }
+    return undefined;
+}
+function isActiveCodexTurn(turn) {
+    return turn.status === 'inProgress' || turn.status === 'running';
+}
 function carrierArgs(payload) {
     return record(record(payload).args);
 }
@@ -2348,6 +2469,22 @@ function business(value) {
     }
     return ok(value);
 }
+function isCodexDirectoryListing(value) {
+    const listing = record(value);
+    return typeof listing.path === 'string'
+        && typeof listing.home === 'string'
+        && Array.isArray(listing.crumbs)
+        && listing.crumbs.every(isCodexDirectoryEntry)
+        && Array.isArray(listing.entries)
+        && listing.entries.every(isCodexDirectoryEntry)
+        && typeof listing.truncated === 'boolean';
+}
+function isCodexDirectoryEntry(value) {
+    const entry = record(value);
+    return typeof entry.name === 'string'
+        && typeof entry.path === 'string'
+        && typeof entry.hidden === 'boolean';
+}
 function fail(code, message, details = {}) {
     return { ok: false, error: { code, message, details } };
 }
@@ -2413,7 +2550,8 @@ function isCodexNativeHistoryPage(value, sessionId) {
         && integer(page.cursor) !== undefined
         && integer(page.nextTurn) !== undefined
         && Array.isArray(page.records)
-        && typeof page.hasMore === 'boolean';
+        && typeof page.hasMore === 'boolean'
+        && (page.activeTurnId === undefined || typeof page.activeTurnId === 'string');
 }
 function truncateCodePoints(value, maximum) {
     return [...value].slice(0, maximum).join('');