@taskforcehq/taskforce 0.3.329 → 0.3.332

package/dist/services/codexAppServerModelGateway.js

@@ -1,9 +1,85 @@
 import { spawn } from 'child_process';
+import { existsSync, realpathSync } from 'fs';
 import { tmpdir } from 'os';
+import { dirname, isAbsolute, join, resolve } from 'path';
+import { createRequire } from 'module';
 import readline from 'readline';
 import { ModelGatewayConfigurationError } from './modelGateway.js';
 import { TASKFORCE_AGENT_MODEL_OPTIONS, isTaskforceAgentSubscriptionDevModelsEnabled } from '../shared/taskforceAgentModels.js';
 const CODEX_APP_SERVER_STDERR_LIMIT = 4_096;
+export const PINNED_CODEX_APP_SERVER_VERSION = '0.148.0-alpha.9';
+const require = createRequire(import.meta.url);
+export class CodexAppServerCompatibilityError extends Error {
+    reason;
+    constructor(reason, message) {
+        super(message);
+        this.reason = reason;
+        this.name = 'CodexAppServerCompatibilityError';
+    }
+}
+export function resolveBundledCodexCommand() {
+    try {
+        const packageVersion = String(require('@openai/codex/package.json')?.version || '');
+        if (packageVersion !== PINNED_CODEX_APP_SERVER_VERSION)
+            throw new Error('version mismatch');
+        const target = (() => {
+            if (process.platform === 'linux' && process.arch === 'x64') {
+                return ['@openai/codex-linux-x64', 'x86_64-unknown-linux-musl'];
+            }
+            if (process.platform === 'linux' && process.arch === 'arm64') {
+                return ['@openai/codex-linux-arm64', 'aarch64-unknown-linux-musl'];
+            }
+            if (process.platform === 'darwin' && process.arch === 'x64') {
+                return ['@openai/codex-darwin-x64', 'x86_64-apple-darwin'];
+            }
+            if (process.platform === 'darwin' && process.arch === 'arm64') {
+                return ['@openai/codex-darwin-arm64', 'aarch64-apple-darwin'];
+            }
+            if (process.platform === 'win32' && process.arch === 'x64') {
+                return ['@openai/codex-win32-x64', 'x86_64-pc-windows-msvc'];
+            }
+            if (process.platform === 'win32' && process.arch === 'arm64') {
+                return ['@openai/codex-win32-arm64', 'aarch64-pc-windows-msvc'];
+            }
+            throw new Error('unsupported platform');
+        })();
+        const platformPackageJson = require.resolve(`${target[0]}/package.json`);
+        const platformVersion = String(require(platformPackageJson)?.version || '');
+        const expectedPlatformVersion = `${PINNED_CODEX_APP_SERVER_VERSION}-${target[0].slice('@openai/codex-'.length)}`;
+        if (platformVersion !== expectedPlatformVersion)
+            throw new Error('platform version mismatch');
+        const executable = join(dirname(platformPackageJson), 'vendor', target[1], 'bin', process.platform === 'win32' ? 'codex.exe' : 'codex');
+        if (!existsSync(executable))
+            throw new Error('binary missing');
+        return executable;
+    }
+    catch {
+        throw new CodexAppServerCompatibilityError('version', `Unsupported Codex app-server version; Taskforce requires ${PINNED_CODEX_APP_SERVER_VERSION}.`);
+    }
+}
+function normalizedPath(value) {
+    try {
+        return realpathSync(value);
+    }
+    catch {
+        return resolve(value);
+    }
+}
+export function assertCodexAppServerCompatibility(result, expectedCodexHome) {
+    const userAgent = readStringPath(result, ['userAgent']);
+    const codexHome = readStringPath(result, ['codexHome']);
+    const version = userAgent.match(/\/([0-9]+\.[0-9]+\.[0-9]+(?:-[A-Za-z0-9.-]+)?)(?:\s|\()/)?.[1];
+    if (version !== PINNED_CODEX_APP_SERVER_VERSION) {
+        throw new CodexAppServerCompatibilityError('version', `Unsupported Codex app-server version; Taskforce requires ${PINNED_CODEX_APP_SERVER_VERSION}.`);
+    }
+    if (!codexHome || !isAbsolute(codexHome)) {
+        throw new CodexAppServerCompatibilityError('credential_home', 'Unsupported Codex app-server credential home response.');
+    }
+    const expected = String(expectedCodexHome || '').trim();
+    if (expected && normalizedPath(codexHome) !== normalizedPath(expected)) {
+        throw new CodexAppServerCompatibilityError('credential_home', 'Unsupported Codex app-server credential home response.');
+    }
+}
 export const DEFAULT_CODEX_APP_SERVER_MODEL_KEY_IDS = {
     ...Object.fromEntries(TASKFORCE_AGENT_MODEL_OPTIONS
         .filter((model) => model.runtime === 'subscription-dev' && model.providerKey === 'openai')
@@ -38,12 +114,21 @@ export function buildCodexAppServerEnv(source = process.env) {
     }
     return env;
 }
-export function sanitizeCodexAppServerStderr(value) {
-    return String(value || '')
-        .replace(/((?:api[_-]?key|access[_-]?token|refresh[_-]?token|client[_-]?secret)\s*[:=]\s*)[^\s]+/gi, '$1[redacted]')
+export function sanitizeCodexAppServerStderr(value, credentialPaths = []) {
+    let sanitized = String(value || '')
+        .replace(/\\+(?=["'])/g, '')
+        .replace(/(["']?(?:api[_-]?key|access[_-]?token|refresh[_-]?token|id[_-]?token|client[_-]?secret)["']?\s*[:=]\s*)(["'])[^"'\r\n]*\2/gi, '$1$2[redacted]$2')
+        .replace(/((?:api[_-]?key|access[_-]?token|refresh[_-]?token|id[_-]?token|client[_-]?secret)\s*[:=]\s*)[^\s,}\]]+/gi, '$1[redacted]')
         .replace(/sk-[A-Za-z0-9_-]{8,}/g, '[redacted OpenAI credential]')
         .replace(/(Bearer\s+)[^\s]+/gi, '$1[redacted]')
+        .replace(/\beyJ[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]{5,}\.[A-Za-z0-9_-]{5,}\b/g, '[redacted JWT]')
         .replace(/[^\x09\x0A\x0D\x20-\x7E]/g, '?');
+    for (const credentialPath of credentialPaths) {
+        const normalized = String(credentialPath || '').trim();
+        if (normalized)
+            sanitized = sanitized.split(normalized).join('[redacted credential path]');
+    }
+    return sanitized.slice(0, CODEX_APP_SERVER_STDERR_LIMIT);
 }
 export function collectCodexAppServerStderr(current, chunk) {
     return (current + String(chunk || '')).slice(-CODEX_APP_SERVER_STDERR_LIMIT);
@@ -54,6 +139,24 @@ export function assertCodexChatGptSubscriptionAccount(result) {
         throw new ModelGatewayConfigurationError('Codex is not signed in with a ChatGPT subscription. Run codex login on this machine and choose Sign in with ChatGPT.', 'MODEL_SOURCE_UNAVAILABLE');
     }
 }
+export function extractCodexAccountLoginCompletion(messages, loginId, credentialPaths = []) {
+    for (const message of messages) {
+        if (message.method !== 'account/login/completed')
+            continue;
+        const completedLoginId = readStringPath(message.params, ['loginId']);
+        if (completedLoginId !== loginId)
+            continue;
+        const params = message.params;
+        const success = params?.success === true;
+        const error = sanitizeCodexAppServerStderr(params?.error, credentialPaths).trim();
+        return {
+            loginId,
+            success,
+            ...(error ? { error } : {}),
+        };
+    }
+    return null;
+}
 export function isCodexSubscriptionDevRuntimeAllowed(source = process.env) {
     const runtimeMode = String(source.TASKFORCE_RUNTIME_MODE || '').trim().toLowerCase();
     return runtimeMode === 'local';
@@ -72,7 +175,7 @@ function buildCodexAppServerRuntimePolicy(cwd) {
         },
     };
 }
-export function extractCodexTurnCompletion(messages) {
+export function extractCodexTurnCompletion(messages, credentialPaths = []) {
     const jsonMessages = messages;
     const completed = jsonMessages.find((message) => message.method === 'turn/completed');
     if (!completed)
@@ -84,7 +187,7 @@ export function extractCodexTurnCompletion(messages) {
         const errorMessage = readStringPath(completed.params, ['turn', 'error', 'message'])
             || readStringPath(completed.params, ['error', 'message'])
             || `Codex app-server turn ended with status ${stopReason}.`;
-        throw new Error(errorMessage);
+        throw new Error(sanitizeCodexAppServerStderr(errorMessage, credentialPaths));
     }
     return {
         text: extractAgentText(jsonMessages),
@@ -99,19 +202,40 @@ export class CodexAppServerJsonRpcClient {
     initialized = false;
     lineReader;
     requestTimeoutMs;
-    turnRejectors = new Set();
+    terminalRejectors = new Set();
+    loginNotificationStart = new Map();
     terminalError = null;
     stderrTail = '';
+    credentialPaths;
+    expectedCodexHome;
+    processExited;
+    closePromise = null;
     constructor(options = {}) {
-        const command = options.command || process.env.TASKFORCE_CODEX_APP_SERVER_COMMAND || 'codex';
+        const command = options.command
+            || process.env.TASKFORCE_CODEX_APP_SERVER_COMMAND
+            || resolveBundledCodexCommand();
         const args = options.args || ['app-server', '--listen', 'stdio://'];
         const cwd = resolveCodexAppServerCwd(options.cwd);
         this.requestTimeoutMs = options.requestTimeoutMs ?? 30_000;
+        this.credentialPaths = options.credentialPaths || [];
+        const childEnvironment = options.env || buildCodexAppServerEnv();
+        this.expectedCodexHome = String(childEnvironment.CODEX_HOME || '').trim();
         this.process = spawn(command, args, {
             stdio: ['pipe', 'pipe', 'pipe'],
-            env: options.env || buildCodexAppServerEnv(),
+            env: childEnvironment,
             cwd,
         });
+        this.processExited = new Promise((resolveExit) => {
+            let settled = false;
+            const finish = () => {
+                if (settled)
+                    return;
+                settled = true;
+                resolveExit();
+            };
+            this.process.once('exit', finish);
+            this.process.once('error', finish);
+        });
         this.lineReader = readline.createInterface({ input: this.process.stdout });
         this.lineReader.on('line', (line) => this.handleLine(line));
         this.process.on('error', (error) => {
@@ -119,7 +243,7 @@ export class CodexAppServerJsonRpcClient {
         });
         this.process.on('exit', (code, signal) => {
             const reason = signal ? `signal ${signal}` : `exit code ${code ?? 'unknown'}`;
-            const details = sanitizeCodexAppServerStderr(this.stderrTail).trim();
+            const details = sanitizeCodexAppServerStderr(this.stderrTail, this.credentialPaths).trim();
             this.fail(new Error(`Codex app-server stopped before completing the request (${reason}).${details ? ` ${details}` : ''}`));
         });
         this.process.stderr.on('data', (chunk) => {
@@ -129,13 +253,18 @@ export class CodexAppServerJsonRpcClient {
     async initialize() {
         if (this.initialized)
             return;
-        await this.request('initialize', {
+        const result = await this.request('initialize', {
             clientInfo: {
                 name: 'taskforce_dev',
                 title: 'Taskforce Dev',
                 version: '0.1.0',
             },
+            capabilities: {
+                experimentalApi: true,
+                requestAttestation: false,
+            },
         });
+        assertCodexAppServerCompatibility(result, this.expectedCodexHome);
         this.sendNotification('initialized', {});
         this.initialized = true;
     }
@@ -143,6 +272,45 @@ export class CodexAppServerJsonRpcClient {
         const result = await this.request('account/read', { refreshToken: false });
         assertCodexChatGptSubscriptionAccount(result);
     }
+    async startChatGptDeviceCodeLogin() {
+        const notificationStart = this.notifications.length;
+        const result = await this.request('account/login/start', { type: 'chatgptDeviceCode' });
+        const type = readStringPath(result, ['type']);
+        const loginId = readStringPath(result, ['loginId']);
+        const userCode = readStringPath(result, ['userCode']);
+        const verificationUrl = readStringPath(result, ['verificationUrl']);
+        if (type !== 'chatgptDeviceCode' || !loginId || !userCode || !verificationUrl) {
+            throw new Error('Codex app-server returned an invalid device-code login response.');
+        }
+        this.loginNotificationStart.set(loginId, notificationStart);
+        return { loginId, userCode, verificationUrl };
+    }
+    async waitForAccountLoginCompleted(input) {
+        const startIndex = this.loginNotificationStart.get(input.loginId) ?? 0;
+        try {
+            return await this.waitForNotification(() => extractCodexAccountLoginCompletion(this.notifications.slice(startIndex), input.loginId, this.credentialPaths), input.timeoutMs, 'Timed out waiting for Codex device-code authorization.', input.signal);
+        }
+        finally {
+            this.loginNotificationStart.delete(input.loginId);
+        }
+    }
+    async cancelAccountLogin(loginId) {
+        const result = await this.request('account/login/cancel', { loginId });
+        const status = readStringPath(result, ['status']);
+        return status === 'canceled' ? 'canceled' : 'notFound';
+    }
+    async readAccount(refreshToken = false) {
+        const result = await this.request('account/read', { refreshToken });
+        const type = readStringPath(result, ['account', 'type']);
+        if (!type)
+            return null;
+        const email = readStringPath(result, ['account', 'email']);
+        const planType = readStringPath(result, ['account', 'planType']);
+        return { type, ...(email ? { email } : {}), ...(planType ? { planType } : {}) };
+    }
+    async logoutAccount() {
+        await this.request('account/logout', {});
+    }
     async startThread(input) {
         const result = await this.request('thread/start', {
             model: input.model,
@@ -171,9 +339,32 @@ export class CodexAppServerJsonRpcClient {
         });
         return this.waitForTurnCompletion(startedAt, input.timeoutMs);
     }
-    close() {
-        this.lineReader.close();
-        this.process.kill();
+    async close() {
+        if (this.closePromise)
+            return this.closePromise;
+        this.closePromise = (async () => {
+            this.lineReader.close();
+            if (this.process.exitCode !== null || this.process.signalCode !== null) {
+                await this.processExited;
+                return;
+            }
+            this.process.kill('SIGTERM');
+            let timeout;
+            const exitedGracefully = await Promise.race([
+                this.processExited.then(() => true),
+                new Promise((resolveTimeout) => {
+                    timeout = setTimeout(() => resolveTimeout(false), 2_000);
+                    timeout.unref?.();
+                }),
+            ]);
+            if (timeout)
+                clearTimeout(timeout);
+            if (!exitedGracefully && this.process.exitCode === null && this.process.signalCode === null) {
+                this.process.kill('SIGKILL');
+                await this.processExited;
+            }
+        })();
+        return this.closePromise;
     }
     request(method, params) {
         const id = this.nextId++;
@@ -228,7 +419,7 @@ export class CodexAppServerJsonRpcClient {
             }
             this.pending.delete(message.id);
             if (message.error) {
-                pending.reject(new Error(message.error.message || 'Codex app-server request failed.'));
+                pending.reject(new Error(sanitizeCodexAppServerStderr(message.error.message || 'Codex app-server request failed.', this.credentialPaths)));
             }
             else {
                 pending.resolve(message.result);
@@ -253,17 +444,17 @@ export class CodexAppServerJsonRpcClient {
                 if (settled)
                     return;
                 settled = true;
-                this.turnRejectors.delete(rejectTurn);
+                this.terminalRejectors.delete(rejectTurn);
                 reject(error);
             };
             const resolveTurn = (value) => {
                 if (settled)
                     return;
                 settled = true;
-                this.turnRejectors.delete(rejectTurn);
+                this.terminalRejectors.delete(rejectTurn);
                 resolve(value);
             };
-            this.turnRejectors.add(rejectTurn);
+            this.terminalRejectors.add(rejectTurn);
             if (this.terminalError) {
                 rejectTurn(this.terminalError);
                 return;
@@ -273,7 +464,7 @@ export class CodexAppServerJsonRpcClient {
                     return;
                 const messages = this.notifications.slice(startIndex);
                 try {
-                    const completion = extractCodexTurnCompletion(messages);
+                    const completion = extractCodexTurnCompletion(messages, this.credentialPaths);
                     if (completion) {
                         resolveTurn(completion);
                         return;
@@ -292,6 +483,39 @@ export class CodexAppServerJsonRpcClient {
             poll();
         });
     }
+    waitForNotification(readValue, timeoutMs, timeoutMessage, signal) {
+        const startedAt = Date.now();
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const finish = (callback) => {
+                if (settled)
+                    return;
+                settled = true;
+                this.terminalRejectors.delete(rejectWaiter);
+                signal?.removeEventListener('abort', abortWaiter);
+                callback();
+            };
+            const rejectWaiter = (error) => finish(() => reject(error));
+            const abortWaiter = () => rejectWaiter(new Error('Codex device-code authorization was cancelled.'));
+            this.terminalRejectors.add(rejectWaiter);
+            signal?.addEventListener('abort', abortWaiter, { once: true });
+            if (signal?.aborted)
+                return abortWaiter();
+            if (this.terminalError)
+                return rejectWaiter(this.terminalError);
+            const poll = () => {
+                if (settled)
+                    return;
+                const value = readValue();
+                if (value !== null)
+                    return finish(() => resolve(value));
+                if (Date.now() - startedAt > timeoutMs)
+                    return rejectWaiter(new Error(timeoutMessage));
+                setTimeout(poll, 50);
+            };
+            poll();
+        });
+    }
     rejectAll(error) {
         for (const pending of this.pending.values())
             pending.reject(error);
@@ -301,8 +525,8 @@ export class CodexAppServerJsonRpcClient {
         if (!this.terminalError)
             this.terminalError = error;
         this.rejectAll(this.terminalError);
-        for (const rejectTurn of [...this.turnRejectors])
-            rejectTurn(this.terminalError);
+        for (const rejectWaiter of [...this.terminalRejectors])
+            rejectWaiter(this.terminalError);
     }
 }
 export class CodexAppServerModelGateway {
@@ -320,6 +544,7 @@ export class CodexAppServerModelGateway {
             cwd: this.cwd,
             env: options.env,
             requestTimeoutMs: options.requestTimeoutMs,
+            credentialPaths: options.credentialPaths,
         }));
         this.modelKeyIds = {
             ...DEFAULT_CODEX_APP_SERVER_MODEL_KEY_IDS,
@@ -364,7 +589,7 @@ export class CodexAppServerModelGateway {
         }
         finally {
             if (shouldClose)
-                client.close();
+                await client.close();
         }
     }
     resolveModelId(input) {

package/dist/services/codexDeviceCodeLoginManager.d.ts

@@ -0,0 +1,39 @@
+import { type CodexAppServerClient } from './codexAppServerModelGateway.js';
+import { ModelProviderConnectionService } from './modelProviderConnectionService.js';
+import { ModelProviderConnectionStore } from '../storage/modelProviderConnectionStore.js';
+export type CodexDeviceCodeLoginStatus = 'pending' | 'active' | 'failed' | 'cancelled' | 'expired';
+export interface PublicCodexDeviceCodeLoginSession {
+    id: string;
+    connectionId: string;
+    status: CodexDeviceCodeLoginStatus;
+    userCode: string;
+    verificationUrl: string;
+    expiresAt: string;
+    failureCode?: string;
+}
+export interface CodexDeviceCodeLoginManagerOptions {
+    clientFactory?: (environment: NodeJS.ProcessEnv) => CodexAppServerClient;
+    ttlMs?: number;
+    now?: () => Date;
+    maxPendingPerOwner?: number;
+    maxPendingTotal?: number;
+}
+export declare class CodexDeviceCodeLoginManager {
+    private readonly connections;
+    private readonly store;
+    private readonly sessions;
+    private readonly sessionByConnection;
+    private readonly startingConnections;
+    private readonly clientFactory;
+    private readonly ttlMs;
+    private readonly now;
+    private readonly maxPendingPerOwner;
+    private readonly maxPendingTotal;
+    constructor(connections: ModelProviderConnectionService, store: ModelProviderConnectionStore, options?: CodexDeviceCodeLoginManagerOptions);
+    start(ownerUserId: string, connectionId: string): Promise<PublicCodexDeviceCodeLoginSession>;
+    get(ownerUserId: string, connectionId: string, sessionId: string): PublicCodexDeviceCodeLoginSession;
+    cancel(ownerUserId: string, connectionId: string, sessionId: string): Promise<PublicCodexDeviceCodeLoginSession>;
+    private requireOwned;
+    private pendingCount;
+    private scheduleRemoval;
+}