ds-harness-remote 0.4.3 → 0.4.5

package/dist/codex/domain.js

@@ -1,6 +1,8 @@
 import { randomUUID } from 'node:crypto';
+import { readdir, realpath, stat } from 'node:fs/promises';
 import { homedir } from 'node:os';
-import { isAbsolute, join } from 'node:path';
+import { basename, isAbsolute, join, relative, resolve } from 'node:path';
+import { deriveCodexCwdWorkspaces } from '@dsh-remote/client-core';
 import { RpcError } from '../safe-error.js';
 import { CodexAppServerClient, CodexAppServerError, } from './app-server.js';
 import { isThreadMutation, parseCodexCall, threadIdFromParams, } from './method-policy.js';
@@ -9,8 +11,10 @@ import { paginateCodexNativeHistory, projectCodexNativeHistory } from './virtual
 const APPROVAL_TTL_MS = 5 * 60_000;
 const DEFAULT_RESTART_DELAYS_MS = [1_000, 2_000, 4_000, 8_000, 15_000];
 const CODEX_PAGE_LIMIT = 100;
+const MAX_CODEX_PAGES = 32;
 const CODEX_HISTORY_PAGE_LIMIT = 25;
 const MAX_CODEX_HISTORY_PAGES = 64;
+const CODEX_DIRECTORY_ENTRY_LIMIT = 500;
 /**
  * Optional Codex business domain inside the existing Remote Plugin. It shares
  * Remote identity/transport with Harness, but owns its App Server process,
@@ -25,6 +29,7 @@ export class CodexRemoteDomain {
     unsubscribeInbound;
     unsubscribeUnavailable;
     peers = new Map();
+    peerDeviceIds = new Map();
     turnOwners = new Map();
     approvals = new Map();
     approvalExpiryTimer;
@@ -72,6 +77,7 @@ export class CodexRemoteDomain {
             return undefined;
         const bridge = new CodexPeerBridge(this, context, publish, this.logger);
         this.peers.set(context.connectionId, bridge);
+        this.peerDeviceIds.set(context.connectionId, context.peerDeviceId);
         return bridge;
     }
     async call(connectionId, input) {
@@ -85,16 +91,16 @@ export class CodexRemoteDomain {
             return sanitizeProjectList(await this.callUpstream(call.method, call.params));
         }
         if (call.method === 'thread/list') {
-            return filterThreadListByProjectAuthority(sanitizeThreadList(await this.callUpstream(call.method, call.params)), await this.readProjectAuthority());
+            const result = sanitizeThreadList(await this.callUpstream(call.method, call.params));
+            return filterThreadListByWorkspaceAuthority(result, await this.readWorkspaceAuthority(result.data));
         }
         if (call.method === 'thread/start') {
             const cwd = await this.requireCodexWorkspacePath(call.params.cwd);
-            const permission = codexPermission(call.params);
+            const permission = codexPermission(call.params, 'workspace-write');
             const result = await this.callUpstream(call.method, {
                 ...permission.params,
                 cwd,
-                approvalPolicy: permission.approvalPolicy,
-                sandbox: permission.sandbox,
+                ...codexThreadPermissionParams(permission),
                 serviceName: 'deepseek_harness_remote',
             });
             if (extractThread(result)?.id === undefined) {
@@ -105,11 +111,18 @@ export class CodexRemoteDomain {
         const threadId = threadIdFromParams(call.params);
         if (call.method === 'dsh/sessionHistory') {
             const thread = await this.readThreadForHistory(connectionId, threadId);
-            return paginateCodexNativeHistory(projectCodexNativeHistory(thread, `codex:${threadId}`), {
+            const page = paginateCodexNativeHistory(projectCodexNativeHistory(thread, `codex:${threadId}`), {
                 beforeSeq: optionalInteger(call.params.beforeSeq),
                 throughSeq: optionalInteger(call.params.throughSeq),
                 maxMessages: optionalInteger(call.params.maxMessages),
             });
+            const activeTurnId = typeof page.activeTurnId === 'string'
+                ? page.activeTurnId
+                : this.turnOwners.get(threadId)?.turnId;
+            return activeTurnId === undefined ? page : { ...page, activeTurnId };
+        }
+        if (call.method === 'dsh/directoryList') {
+            return this.listCodexDirectory(call.params.path);
         }
         const allowedThread = threadId === undefined ? undefined : await this.readKnownThread(threadId);
         if (call.method === 'thread/read') {
@@ -125,8 +138,11 @@ export class CodexRemoteDomain {
             return this.callUpstream(call.method, call.params);
         }
         let claimed = false;
+        let previousOwner;
         if (isThreadMutation(call.method) && threadId !== undefined) {
-            claimed = this.claimTurn(threadId, connectionId, call.method);
+            const claim = this.claimTurn(threadId, connectionId, call.method, typeof call.params.turnId === 'string' ? call.params.turnId : undefined);
+            claimed = claim.claimed;
+            previousOwner = claim.previous;
         }
         try {
             const permission = codexPermission(call.params);
@@ -134,31 +150,20 @@ export class CodexRemoteDomain {
                 ? {
                     ...permission.params,
                     ...(allowedThread.cwd === undefined ? {} : { cwd: allowedThread.cwd }),
-                    approvalPolicy: permission.approvalPolicy,
-                    sandbox: permission.sandbox,
+                    ...codexThreadPermissionParams(permission),
                     excludeTurns: true,
                 }
                 : call.method === 'thread/fork' && allowedThread !== undefined
                     ? {
                         ...permission.params,
                         ...(allowedThread.cwd === undefined ? {} : { cwd: allowedThread.cwd }),
-                        approvalPolicy: permission.approvalPolicy,
-                        sandbox: permission.sandbox,
+                        ...codexThreadPermissionParams(permission),
                     }
                     : call.method === 'turn/start'
                         ? {
                             ...permission.params,
                             ...(allowedThread?.cwd === undefined ? {} : { cwd: allowedThread.cwd }),
-                            approvalPolicy: permission.approvalPolicy,
-                            sandboxPolicy: permission.sandbox === 'danger-full-access'
-                                ? { type: 'dangerFullAccess' }
-                                : {
-                                    type: 'workspaceWrite',
-                                    writableRoots: allowedThread?.cwd === undefined ? [] : [allowedThread.cwd],
-                                    networkAccess: false,
-                                    excludeTmpdirEnvVar: false,
-                                    excludeSlashTmp: false,
-                                },
+                            ...codexTurnPermissionParams(permission, allowedThread?.cwd),
                         }
                         : permission.params;
             let result;
@@ -172,7 +177,8 @@ export class CodexRemoteDomain {
                 if (call.method === 'thread/resume'
                     && allowedThread !== undefined
                     && error instanceof RpcError
-                    && error.code === 'CODEX_UPSTREAM_ERROR') {
+                    && error.code === 'CODEX_UPSTREAM_ERROR'
+                    && call.params.permissionPreset === undefined) {
                     return { thread: allowedThread.thread };
                 }
                 throw error;
@@ -180,11 +186,18 @@ export class CodexRemoteDomain {
             if (call.method === 'thread/resume' || call.method === 'thread/fork' || call.method === 'thread/unarchive') {
                 await this.assertResultThreadAllowed(result);
             }
+            if (call.method === 'turn/start' && threadId !== undefined) {
+                this.rememberTurnId(threadId, connectionId, extractTurnId(result));
+            }
             return result;
         }
         catch (error) {
-            if (claimed && threadId !== undefined)
-                this.turnOwners.delete(threadId);
+            if (claimed && threadId !== undefined) {
+                if (previousOwner === undefined)
+                    this.turnOwners.delete(threadId);
+                else
+                    this.turnOwners.set(threadId, previousOwner);
+            }
             throw mapAppServerError(error);
         }
     }
@@ -204,8 +217,9 @@ export class CodexRemoteDomain {
         const bridge = this.peers.get(connectionId);
         if (bridge !== undefined)
             this.peers.delete(connectionId);
+        this.peerDeviceIds.delete(connectionId);
         for (const [threadId, owner] of this.turnOwners) {
-            if (owner === connectionId)
+            if (owner.connectionId === connectionId)
                 this.turnOwners.delete(threadId);
         }
         const appServer = this.appServer;
@@ -228,6 +242,7 @@ export class CodexRemoteDomain {
         for (const bridge of [...this.peers.values()])
             await bridge.closeAll();
         this.peers.clear();
+        this.peerDeviceIds.clear();
         this.turnOwners.clear();
         if (this.approvalExpiryTimer !== undefined)
             clearTimeout(this.approvalExpiryTimer);
@@ -359,6 +374,13 @@ export class CodexRemoteDomain {
         const threadId = extractThreadId(message.params);
         if (message.method === 'turn/completed' && threadId !== undefined)
             this.turnOwners.delete(threadId);
+        if (message.method === 'turn/started' && threadId !== undefined) {
+            const owner = this.turnOwners.get(threadId);
+            const turnId = extractTurnId(message.params);
+            if (owner !== undefined) {
+                this.turnOwners.set(threadId, { ...owner, ...(turnId === undefined ? {} : { turnId }) });
+            }
+        }
         if (message.method === 'serverRequest/resolved')
             this.resolveUpstreamApproval(message.params);
         if (threadId === undefined)
@@ -378,7 +400,7 @@ export class CodexRemoteDomain {
         }
         const threadId = extractThreadId(message.params);
         const owner = threadId === undefined ? undefined : this.turnOwners.get(threadId);
-        const peer = owner === undefined ? undefined : this.peers.get(owner);
+        const peer = owner === undefined ? undefined : this.peers.get(owner.connectionId);
         if (threadId === undefined || owner === undefined || peer === undefined || !peer.hasThreadSubscription(threadId)) {
             await appServer.respond(message.id, { decision: 'decline' });
             return;
@@ -386,7 +408,7 @@ export class CodexRemoteDomain {
         const requestHandle = randomUUID();
         this.approvals.set(requestHandle, {
             upstreamId: message.id,
-            connectionId: owner,
+            connectionId: owner.connectionId,
             threadId,
             method: message.method,
             expiresAt: Date.now() + APPROVAL_TTL_MS,
@@ -406,7 +428,7 @@ export class CodexRemoteDomain {
         }
     }
     async readKnownThread(threadId) {
-        const authority = await this.readProjectAuthority();
+        const authority = await this.readWorkspaceAuthority();
         let result;
         try {
             result = await this.callUpstream('thread/read', { threadId, includeTurns: false });
@@ -421,7 +443,7 @@ export class CodexRemoteDomain {
             return { thread: listed, ...(typeof listed.cwd === 'string' && listed.cwd.length > 0 ? { cwd: listed.cwd } : {}) };
         }
         const thread = extractThread(result);
-        if (thread === undefined || thread.id !== threadId || !isThreadAllowedByProjectAuthority(thread, authority)) {
+        if (thread === undefined || thread.id !== threadId || !isThreadAllowedByWorkspaceAuthority(thread, authority)) {
             throw new RpcError('CODEX_THREAD_NOT_ALLOWED', 'The Codex thread is not available through this Remote Host.');
         }
         return { thread, ...(typeof thread.cwd === 'string' && thread.cwd.length > 0 ? { cwd: thread.cwd } : {}) };
@@ -532,31 +554,48 @@ export class CodexRemoteDomain {
         if (thread === undefined || typeof thread.id !== 'string') {
             throw new RpcError('CODEX_INVALID_RESPONSE', 'Codex App Server returned an invalid thread.');
         }
-        if (!isThreadAllowedByProjectAuthority(thread, await this.readProjectAuthority())) {
+        if (!isThreadAllowedByWorkspaceAuthority(thread, await this.readWorkspaceAuthority())) {
             throw new RpcError('CODEX_THREAD_NOT_ALLOWED', 'The Codex thread is not available through this Remote Host.');
         }
     }
-    claimTurn(threadId, connectionId, method) {
+    claimTurn(threadId, connectionId, method, turnId) {
         const owner = this.turnOwners.get(threadId);
+        const peerDeviceId = this.peerDeviceIds.get(connectionId) ?? connectionId;
+        const nextOwner = { connectionId, peerDeviceId, ...(turnId === undefined ? {} : { turnId }) };
         if (method === 'turn/interrupt') {
             if (owner === undefined) {
                 // A replacement connection may recover an already-running persisted
                 // turn. Claim only for this explicit mutation; passive viewers still
                 // remain observers and cannot steal a live connection's lease.
-                this.turnOwners.set(threadId, connectionId);
-                return true;
+                this.turnOwners.set(threadId, nextOwner);
+                return { claimed: true };
             }
-            if (owner !== connectionId)
+            if (owner.connectionId !== connectionId && owner.peerDeviceId !== peerDeviceId) {
                 throw new RpcError('CODEX_TURN_OWNED', 'Only the connection that started this Codex turn can interrupt it.');
-            return false;
+            }
+            if (owner.connectionId !== connectionId) {
+                this.turnOwners.set(threadId, { ...owner, connectionId, peerDeviceId, ...(turnId === undefined ? {} : { turnId }) });
+                return { claimed: true, previous: owner };
+            }
+            if (turnId !== undefined && owner.turnId === undefined)
+                this.turnOwners.set(threadId, { ...owner, turnId });
+            return { claimed: false };
         }
-        if (owner !== undefined && owner !== connectionId) {
+        if (owner !== undefined && owner.connectionId !== connectionId && owner.peerDeviceId !== peerDeviceId) {
             throw new RpcError('CODEX_TURN_OWNED', 'Another Remote connection owns the active Codex turn.');
         }
-        if (owner === connectionId)
-            return false;
-        this.turnOwners.set(threadId, connectionId);
-        return true;
+        if (owner?.connectionId === connectionId)
+            return { claimed: false };
+        this.turnOwners.set(threadId, owner === undefined ? nextOwner : { ...owner, connectionId, peerDeviceId });
+        return { claimed: true, previous: owner };
+    }
+    rememberTurnId(threadId, connectionId, turnId) {
+        if (turnId === undefined)
+            return;
+        const owner = this.turnOwners.get(threadId);
+        if (owner === undefined || owner.connectionId !== connectionId)
+            return;
+        this.turnOwners.set(threadId, { ...owner, turnId });
     }
     hasSubscriber(threadId) {
         return [...this.peers.values()].some(peer => peer.hasThreadSubscription(threadId));
@@ -609,31 +648,60 @@ export class CodexRemoteDomain {
             throw mapAppServerError(error);
         }
     }
-    async readProjectAuthority() {
+    async readWorkspaceAuthority(listedThreads) {
         const projectIds = new Set();
         const roots = [];
         let cursor;
-        for (let page = 0; page < 32; page += 1) {
-            const result = sanitizeProjectList(await this.callUpstream('project/list', {
-                limit: 100,
-                ...(cursor === undefined ? {} : { cursor }),
-            }));
-            for (const project of result.data) {
-                const projectRoots = project.roots.map(root => root.path).filter(path => isAbsolute(path));
-                if (projectRoots.length === 0)
-                    continue;
-                projectIds.add(project.id);
-                roots.push(...projectRoots);
+        try {
+            for (let page = 0; page < MAX_CODEX_PAGES; page += 1) {
+                const result = sanitizeProjectList(await this.callUpstream('project/list', {
+                    limit: CODEX_PAGE_LIMIT,
+                    ...(cursor === undefined ? {} : { cursor }),
+                }));
+                for (const project of result.data) {
+                    const projectRoots = project.roots.map(root => root.path).filter(path => isAbsolute(path));
+                    if (projectRoots.length === 0)
+                        continue;
+                    projectIds.add(project.id);
+                    roots.push(...projectRoots);
+                }
+                cursor = typeof result.nextCursor === 'string' && result.nextCursor.length > 0 ? result.nextCursor : undefined;
+                if (cursor === undefined)
+                    break;
             }
-            cursor = typeof result.nextCursor === 'string' && result.nextCursor.length > 0 ? result.nextCursor : undefined;
-            if (cursor === undefined)
-                break;
+        }
+        catch (error) {
+            if (!isProjectListFallbackError(error))
+                throw error;
+        }
+        if (roots.length > 0)
+            return { projectIds, roots };
+        const threads = listedThreads === undefined ? [] : [...listedThreads];
+        if (listedThreads === undefined) {
+            cursor = undefined;
+            for (let page = 0; page < MAX_CODEX_PAGES; page += 1) {
+                const result = sanitizeThreadList(await this.callUpstream('thread/list', {
+                    limit: CODEX_PAGE_LIMIT,
+                    sortKey: 'updated_at',
+                    sortDirection: 'desc',
+                    archived: false,
+                    ...(cursor === undefined ? {} : { cursor }),
+                }));
+                threads.push(...result.data);
+                cursor = typeof result.nextCursor === 'string' && result.nextCursor.length > 0 ? result.nextCursor : undefined;
+                if (cursor === undefined)
+                    break;
+            }
+        }
+        for (const workspace of deriveCodexCwdWorkspaces(threads)) {
+            if (isAbsolute(workspace.path))
+                roots.push(workspace.path);
         }
         return { projectIds, roots };
     }
     async findKnownThreadInList(threadId, authority) {
         let cursor;
-        for (let page = 0; page < 32; page += 1) {
+        for (let page = 0; page < MAX_CODEX_PAGES; page += 1) {
             const result = sanitizeThreadList(await this.callUpstream('thread/list', {
                 limit: 100,
                 sortKey: 'updated_at',
@@ -643,7 +711,7 @@ export class CodexRemoteDomain {
             }));
             const thread = result.data.find(item => item.id === threadId);
             if (thread !== undefined) {
-                return isThreadAllowedByProjectAuthority(thread, authority) ? thread : undefined;
+                return isThreadAllowedByWorkspaceAuthority(thread, authority) ? thread : undefined;
             }
             cursor = typeof result.nextCursor === 'string' && result.nextCursor.length > 0 ? result.nextCursor : undefined;
             if (cursor === undefined)
@@ -655,16 +723,105 @@ export class CodexRemoteDomain {
         if (!isAbsolute(path)) {
             throw new RpcError('CODEX_PATH_NOT_ALLOWED', 'The CodeX working directory is not available as a Workspace.');
         }
-        const paths = await this.listCodexProjectWorkspacePaths();
-        const canonical = paths.get(normalizeCodexPathForCompare(path));
-        if (canonical === undefined) {
+        const paths = await this.listCodexWorkspacePaths();
+        const lexicalCandidate = resolve(path);
+        let candidate;
+        try {
+            candidate = await realpath(path);
+            if (!(await stat(candidate)).isDirectory())
+                throw new Error('not a directory');
+        }
+        catch {
+            throw new RpcError('CODEX_PATH_NOT_ALLOWED', 'The CodeX working directory is not available as a Workspace.');
+        }
+        for (const root of paths.values()) {
+            try {
+                if (!containsCodexPath(resolve(root), lexicalCandidate))
+                    continue;
+                const canonicalRoot = await realpath(root);
+                if (containsCodexPath(canonicalRoot, candidate))
+                    return lexicalCandidate;
+            }
+            catch {
+                // A stale project or Thread cwd is not authority for a new Thread.
+            }
+        }
+        throw new RpcError('CODEX_PATH_NOT_ALLOWED', 'The CodeX working directory is not available as a Workspace.');
+    }
+    async listCodexDirectory(path) {
+        const target = await this.resolveCodexDirectory(path);
+        const rows = await readdir(target.path, { withFileTypes: true }).catch(() => undefined);
+        if (rows === undefined) {
+            throw new RpcError('CODEX_PATH_NOT_ALLOWED', 'The CodeX working directory is not available as a Workspace.');
+        }
+        const entries = [];
+        for (const row of rows) {
+            const child = resolve(target.path, row.name);
+            let directory = row.isDirectory();
+            if (!directory && row.isSymbolicLink()) {
+                directory = await stat(child).then(value => value.isDirectory()).catch(() => false);
+            }
+            if (!directory)
+                continue;
+            try {
+                const canonicalChild = await realpath(child);
+                if (!(await stat(canonicalChild)).isDirectory())
+                    continue;
+                if (!containsCodexPath(target.canonicalRoot, canonicalChild))
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            entries.push({
+                name: row.name,
+                path: child,
+                hidden: process.platform !== 'win32' && row.name.startsWith('.'),
+            });
+        }
+        entries.sort((left, right) => left.name.localeCompare(right.name, undefined, { sensitivity: 'base' }));
+        return {
+            path: target.path,
+            home: target.root,
+            crumbs: codexDirectoryCrumbs(target.root, target.path),
+            entries: entries.slice(0, CODEX_DIRECTORY_ENTRY_LIMIT),
+            truncated: entries.length > CODEX_DIRECTORY_ENTRY_LIMIT,
+        };
+    }
+    async resolveCodexDirectory(path) {
+        if (!isAbsolute(path)) {
+            throw new RpcError('CODEX_PATH_NOT_ALLOWED', 'The CodeX working directory is not available as a Workspace.');
+        }
+        const authority = await this.readWorkspaceAuthority();
+        const lexicalCandidate = resolve(path);
+        let canonicalCandidate;
+        try {
+            canonicalCandidate = await realpath(path);
+            if (!(await stat(canonicalCandidate)).isDirectory())
+                throw new Error('not a directory');
+        }
+        catch {
             throw new RpcError('CODEX_PATH_NOT_ALLOWED', 'The CodeX working directory is not available as a Workspace.');
         }
-        return canonical;
+        for (const root of authority.roots) {
+            try {
+                const lexicalRoot = resolve(root);
+                if (!containsCodexPath(lexicalRoot, lexicalCandidate))
+                    continue;
+                const canonicalRoot = await realpath(root);
+                if (containsCodexPath(canonicalRoot, canonicalCandidate)) {
+                    return { path: lexicalCandidate, root: lexicalRoot, canonicalRoot };
+                }
+            }
+            catch {
+                // A stale project or Thread cwd is not authority for directory browsing.
+            }
+        }
+        throw new RpcError('CODEX_PATH_NOT_ALLOWED', 'The CodeX working directory is not available as a Workspace.');
     }
-    async listCodexProjectWorkspacePaths() {
+    async listCodexWorkspacePaths() {
         const paths = new Map();
-        const authority = await this.readProjectAuthority();
+        const authority = await this.readWorkspaceAuthority();
         for (const root of authority.roots)
             paths.set(normalizeCodexPathForCompare(root), root);
         return paths;
@@ -749,7 +906,7 @@ function sanitizeThreadList(result) {
             : {}),
     };
 }
-function filterThreadListByProjectAuthority(result, authority) {
+function filterThreadListByWorkspaceAuthority(result, authority) {
     if (!isRecord(result) || !Array.isArray(result.data)) {
         throw new RpcError('CODEX_INVALID_RESPONSE', 'Codex App Server returned an invalid thread list.');
     }
@@ -757,7 +914,7 @@ function filterThreadListByProjectAuthority(result, authority) {
         ...result,
         data: result.data
             .map(record => isRecord(record) ? record : undefined)
-            .filter((thread) => (thread !== undefined && isThreadAllowedByProjectAuthority(thread, authority))),
+            .filter((thread) => (thread !== undefined && isThreadAllowedByWorkspaceAuthority(thread, authority))),
     };
 }
 function sanitizeProjectList(result) {
@@ -789,7 +946,7 @@ function sanitizeProjectList(result) {
         ...(typeof result.nextCursor === 'string' && result.nextCursor.length > 0 ? { nextCursor: result.nextCursor } : { nextCursor: null }),
     };
 }
-function isThreadAllowedByProjectAuthority(thread, authority) {
+function isThreadAllowedByWorkspaceAuthority(thread, authority) {
     const projectId = typeof thread.projectId === 'string' ? thread.projectId : undefined;
     if (projectId !== undefined && authority.projectIds.has(projectId))
         return true;
@@ -806,9 +963,30 @@ function containsCodexPath(root, candidate) {
 function normalizeCodexPathForCompare(path) {
     return path.replace(/[\\/]+$/u, '') || path;
 }
+function codexDirectoryCrumbs(root, path) {
+    const crumbs = [{ name: basename(root) || root, path: root, hidden: false }];
+    const remainder = relative(root, path);
+    if (remainder === '')
+        return crumbs;
+    let current = root;
+    for (const segment of remainder.split(/[\\/]+/u).filter(Boolean)) {
+        current = resolve(current, segment);
+        crumbs.push({ name: segment, path: current, hidden: false });
+    }
+    return crumbs;
+}
 function extractThread(result) {
     return isRecord(result) && isRecord(result.thread) ? result.thread : undefined;
 }
+function extractTurnId(result) {
+    if (!isRecord(result))
+        return undefined;
+    if (typeof result.turnId === 'string' && result.turnId.length > 0)
+        return result.turnId;
+    if (isRecord(result.turn) && typeof result.turn.id === 'string' && result.turn.id.length > 0)
+        return result.turn.id;
+    return undefined;
+}
 function extractThreadId(params) {
     if (!isRecord(params))
         return undefined;
@@ -823,15 +1001,44 @@ function extractThreadId(params) {
 function optionalInteger(value) {
     return typeof value === 'number' && Number.isSafeInteger(value) ? value : undefined;
 }
-function codexPermission(params) {
+function codexPermission(params, fallbackPreset) {
     const { permissionPreset, ...rest } = params;
-    const fullAccess = permissionPreset === 'danger-full-access';
+    const preset = permissionPreset === 'workspace-write' || permissionPreset === 'danger-full-access'
+        ? permissionPreset
+        : fallbackPreset;
+    if (preset === undefined)
+        return { params: mapCodexImageInputs(rest) };
+    const fullAccess = preset === 'danger-full-access';
     return {
         params: mapCodexImageInputs(rest),
         approvalPolicy: fullAccess ? 'never' : 'on-request',
         sandbox: fullAccess ? 'danger-full-access' : 'workspace-write',
     };
 }
+function codexThreadPermissionParams(permission) {
+    if (permission.approvalPolicy === undefined || permission.sandbox === undefined)
+        return {};
+    return {
+        approvalPolicy: permission.approvalPolicy,
+        sandbox: permission.sandbox,
+    };
+}
+function codexTurnPermissionParams(permission, cwd) {
+    if (permission.approvalPolicy === undefined || permission.sandbox === undefined)
+        return {};
+    return {
+        approvalPolicy: permission.approvalPolicy,
+        sandboxPolicy: permission.sandbox === 'danger-full-access'
+            ? { type: 'dangerFullAccess' }
+            : {
+                type: 'workspaceWrite',
+                writableRoots: cwd === undefined ? [] : [cwd],
+                networkAccess: false,
+                excludeTmpdirEnvVar: false,
+                excludeSlashTmp: false,
+            },
+    };
+}
 function mapCodexImageInputs(params) {
     if (!Array.isArray(params.input))
         return params;
@@ -875,6 +1082,10 @@ function isHistoryReadRecoverable(error) {
     return error instanceof RpcError
         && ['METHOD_NOT_ALLOWED', 'METHOD_NOT_FOUND', 'CODEX_UPSTREAM_ERROR', 'CODEX_REQUEST_TIMEOUT', 'CODEX_THREAD_BUSY'].includes(error.code);
 }
+function isProjectListFallbackError(error) {
+    return error instanceof RpcError
+        && ['METHOD_NOT_ALLOWED', 'METHOD_NOT_FOUND', 'CODEX_UPSTREAM_ERROR'].includes(error.code);
+}
 function canTryNextBinary(error) {
     return !(error instanceof RpcError) || !['CODEX_AUTH_REQUIRED', 'CODEX_CLOSED'].includes(error.code);
 }