@taskforcehq/taskforce 0.3.328 → 0.3.330

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;
+}

package/dist/services/codexDeviceCodeLoginManager.js

@@ -0,0 +1,265 @@
+import { randomBytes } from 'node:crypto';
+import { CodexAppServerJsonRpcClient, } from './codexAppServerModelGateway.js';
+import { classifyCodexModelProviderError } from './codexModelProviderConnectionLifecycle.js';
+import { ModelProviderConnectionError, } from '../storage/modelProviderConnectionStore.js';
+function opaqueSessionId() {
+    return `mpl_${randomBytes(24).toString('base64url')}`;
+}
+function publicSession(session) {
+    const { id, connectionId, status, userCode, verificationUrl, expiresAt, failureCode } = session;
+    return { id, connectionId, status, userCode, verificationUrl, expiresAt, ...(failureCode ? { failureCode } : {}) };
+}
+function safeVerificationUrl(value) {
+    try {
+        const url = new URL(value);
+        const serialized = url.toString();
+        if (url.protocol !== 'https:'
+            || url.username
+            || url.password
+            || url.search
+            || url.hash
+            || serialized.length > 2_048)
+            throw new Error('invalid device authorization URL');
+        return serialized;
+    }
+    catch {
+        throw new ModelProviderConnectionError('Codex returned an invalid device authorization URL.', 502, 'MODEL_CONNECTION_PROVIDER_FAILURE');
+    }
+}
+function safeUserCode(value) {
+    const userCode = String(value || '').trim();
+    if (!/^[A-Za-z0-9_-]{4,64}$/.test(userCode)) {
+        throw new ModelProviderConnectionError('Codex returned an invalid device authorization code.', 502, 'MODEL_CONNECTION_PROVIDER_FAILURE');
+    }
+    return userCode;
+}
+export class CodexDeviceCodeLoginManager {
+    connections;
+    store;
+    sessions = new Map();
+    sessionByConnection = new Map();
+    startingConnections = new Map();
+    clientFactory;
+    ttlMs;
+    now;
+    maxPendingPerOwner;
+    maxPendingTotal;
+    constructor(connections, store, options = {}) {
+        this.connections = connections;
+        this.store = store;
+        this.clientFactory = options.clientFactory || ((environment) => new CodexAppServerJsonRpcClient({
+            env: environment,
+            credentialPaths: [String(environment.CODEX_HOME || '')].filter(Boolean),
+        }));
+        this.ttlMs = Math.min(10 * 60_000, Math.max(30_000, options.ttlMs ?? 8 * 60_000));
+        this.now = options.now || (() => new Date());
+        this.maxPendingPerOwner = Math.min(8, Math.max(1, options.maxPendingPerOwner ?? 2));
+        this.maxPendingTotal = Math.min(64, Math.max(1, options.maxPendingTotal ?? 16));
+    }
+    async start(ownerUserId, connectionId) {
+        this.store.requireOwned(ownerUserId, connectionId);
+        const existingId = this.sessionByConnection.get(connectionId);
+        const existing = existingId ? this.sessions.get(existingId) : null;
+        if ((existing && !existing.settled) || this.startingConnections.has(connectionId)) {
+            throw new ModelProviderConnectionError('A device authorization is already pending for this connection.', 409, 'MODEL_CONNECTION_LOGIN_PENDING');
+        }
+        if (this.pendingCount(ownerUserId) >= this.maxPendingPerOwner) {
+            throw new ModelProviderConnectionError('Too many device authorizations are already pending for this account.', 429, 'MODEL_CONNECTION_LOGIN_LIMIT_REACHED');
+        }
+        if (this.pendingCount() >= this.maxPendingTotal) {
+            throw new ModelProviderConnectionError('Device authorization capacity is temporarily unavailable.', 503, 'MODEL_CONNECTION_LOGIN_CAPACITY_REACHED');
+        }
+        this.startingConnections.set(connectionId, ownerUserId);
+        let resolveStarted;
+        let rejectStarted;
+        let started = false;
+        const startedPromise = new Promise((resolve, reject) => {
+            resolveStarted = resolve;
+            rejectStarted = reject;
+        });
+        let session = null;
+        let lifecyclePromise;
+        lifecyclePromise = this.connections.withConnectionLease({
+            ownerUserId,
+            connectionId,
+            operation: 'login',
+            leaseDurationMs: this.ttlMs,
+        }, async (context) => {
+            if (context.connection.providerKey !== 'openai'
+                || context.connection.authenticationType !== 'chatgpt_device_code') {
+                throw new ModelProviderConnectionError('This model connection does not support ChatGPT device authorization.', 400, 'MODEL_CONNECTION_TYPE_UNAVAILABLE');
+            }
+            const client = this.clientFactory(context.environment);
+            const cancellation = new AbortController();
+            let leaseLost = false;
+            const abortForLeaseLoss = () => {
+                leaseLost = true;
+                cancellation.abort();
+            };
+            context.signal.addEventListener('abort', abortForLeaseLoss, { once: true });
+            try {
+                await client.initialize();
+                const provider = await client.startChatGptDeviceCodeLogin();
+                const expiresAt = new Date(this.now().getTime() + this.ttlMs).toISOString();
+                session = {
+                    id: opaqueSessionId(),
+                    ownerUserId,
+                    connectionId,
+                    providerLoginId: provider.loginId,
+                    status: 'pending',
+                    userCode: safeUserCode(provider.userCode),
+                    verificationUrl: safeVerificationUrl(provider.verificationUrl),
+                    expiresAt,
+                    client,
+                    cancellation,
+                    cancelRequested: false,
+                    completion: Promise.resolve(),
+                    settled: false,
+                };
+                this.startingConnections.delete(connectionId);
+                session.completion = lifecyclePromise;
+                this.sessions.set(session.id, session);
+                this.sessionByConnection.set(connectionId, session.id);
+                started = true;
+                resolveStarted(publicSession(session));
+                const completion = await client.waitForAccountLoginCompleted({
+                    loginId: provider.loginId,
+                    timeoutMs: this.ttlMs,
+                    signal: cancellation.signal,
+                });
+                if (!completion.success) {
+                    throw classifyCodexModelProviderError(completion.error || 'ChatGPT device authorization did not complete.');
+                }
+                if (session.cancelRequested || cancellation.signal.aborted) {
+                    throw new ModelProviderConnectionError('ChatGPT device authorization was cancelled.', 409, 'MODEL_CONNECTION_LOGIN_CANCELLED');
+                }
+                const account = await client.readAccount(false);
+                if (account?.type !== 'chatgpt') {
+                    throw new ModelProviderConnectionError('The authorized Codex account is not a ChatGPT subscription account.', 409, 'MODEL_CONNECTION_ACCOUNT_UNAVAILABLE');
+                }
+                if (session.cancelRequested || cancellation.signal.aborted) {
+                    throw new ModelProviderConnectionError('ChatGPT device authorization was cancelled.', 409, 'MODEL_CONNECTION_LOGIN_CANCELLED');
+                }
+                this.store.markVerified({
+                    ownerUserId,
+                    connectionId,
+                    leaseToken: context.lease.token,
+                    displayMetadata: {
+                        accountEmail: account.email,
+                        accountLabel: account.email,
+                        planLabel: account.planType,
+                    },
+                });
+            }
+            catch (error) {
+                const classifiedError = classifyCodexModelProviderError(error);
+                if (session) {
+                    session.terminalStatus = session.cancelRequested
+                        ? 'cancelled'
+                        : leaseLost
+                            ? 'failed'
+                            : (this.now().toISOString() >= session.expiresAt ? 'expired' : 'failed');
+                    session.terminalFailureCode = session.cancelRequested
+                        ? 'MODEL_CONNECTION_LOGIN_CANCELLED'
+                        : leaseLost
+                            ? 'MODEL_CONNECTION_LEASE_LOST'
+                            : session.terminalStatus === 'expired'
+                                ? 'MODEL_CONNECTION_LOGIN_EXPIRED'
+                                : classifiedError.code;
+                    try {
+                        this.store.markReconnectRequired({
+                            ownerUserId,
+                            connectionId,
+                            leaseToken: context.lease.token,
+                            failureCode: session.terminalFailureCode.toLowerCase(),
+                        });
+                    }
+                    catch {
+                        // Lease loss remains authoritative.
+                    }
+                }
+                throw classifiedError;
+            }
+            finally {
+                context.signal.removeEventListener('abort', abortForLeaseLoss);
+                await client.close();
+                if (session)
+                    this.scheduleRemoval(session);
+            }
+        }).then(() => {
+            if (session?.status === 'pending')
+                session.status = 'active';
+            if (session)
+                session.settled = true;
+        }, (error) => {
+            const classifiedError = classifyCodexModelProviderError(error);
+            this.startingConnections.delete(connectionId);
+            if (!started) {
+                rejectStarted(classifiedError);
+                return;
+            }
+            if (session?.status === 'pending') {
+                session.status = session.terminalStatus || 'failed';
+                session.failureCode = session.terminalFailureCode || classifiedError.code;
+            }
+            if (session)
+                session.settled = true;
+        });
+        return startedPromise;
+    }
+    get(ownerUserId, connectionId, sessionId) {
+        return publicSession(this.requireOwned(ownerUserId, connectionId, sessionId));
+    }
+    async cancel(ownerUserId, connectionId, sessionId) {
+        const session = this.requireOwned(ownerUserId, connectionId, sessionId);
+        if (session.status !== 'pending') {
+            await session.completion;
+            return publicSession(session);
+        }
+        if (session.cancelRequested) {
+            await session.completion;
+            return publicSession(session);
+        }
+        session.cancelRequested = true;
+        session.terminalStatus = 'cancelled';
+        session.terminalFailureCode = 'MODEL_CONNECTION_LOGIN_CANCELLED';
+        session.cancellation.abort();
+        try {
+            await session.client.cancelAccountLogin(session.providerLoginId);
+        }
+        catch {
+            // Closing the process-local client remains sufficient to end this ceremony.
+        }
+        await session.completion;
+        return publicSession(session);
+    }
+    requireOwned(ownerUserId, connectionId, sessionId) {
+        const session = this.sessions.get(String(sessionId || '').trim());
+        if (!session || session.ownerUserId !== ownerUserId || session.connectionId !== connectionId) {
+            throw new ModelProviderConnectionError('Device authorization session was not found or no longer exists. Start a new authorization.', 404, 'MODEL_CONNECTION_LOGIN_SESSION_NOT_FOUND');
+        }
+        return session;
+    }
+    pendingCount(ownerUserId) {
+        let count = 0;
+        for (const session of this.sessions.values()) {
+            if (!session.settled && (!ownerUserId || session.ownerUserId === ownerUserId))
+                count += 1;
+        }
+        for (const startingOwnerUserId of this.startingConnections.values()) {
+            if (!ownerUserId || startingOwnerUserId === ownerUserId)
+                count += 1;
+        }
+        return count;
+    }
+    scheduleRemoval(session) {
+        const timeout = setTimeout(() => {
+            if (this.sessions.get(session.id) === session)
+                this.sessions.delete(session.id);
+            if (this.sessionByConnection.get(session.connectionId) === session.id) {
+                this.sessionByConnection.delete(session.connectionId);
+            }
+        }, 5 * 60_000);
+        timeout.unref?.();
+    }
+}

package/dist/services/codexModelProviderConnectionLifecycle.d.ts

@@ -0,0 +1,8 @@
+import { type CodexAppServerClient } from './codexAppServerModelGateway.js';
+import type { ModelProviderConnectionLifecycleHandlers } from './modelProviderConnectionService.js';
+import { ModelProviderConnectionError } from '../storage/modelProviderConnectionStore.js';
+export interface CodexModelProviderConnectionLifecycleOptions {
+    clientFactory?: (environment: NodeJS.ProcessEnv) => CodexAppServerClient;
+}
+export declare function classifyCodexModelProviderError(error: unknown): ModelProviderConnectionError;
+export declare function createCodexModelProviderConnectionLifecycleHandlers(options?: CodexModelProviderConnectionLifecycleOptions): ModelProviderConnectionLifecycleHandlers;

package/dist/services/codexModelProviderConnectionLifecycle.js

@@ -0,0 +1,73 @@
+import { CodexAppServerCompatibilityError, CodexAppServerJsonRpcClient, } from './codexAppServerModelGateway.js';
+import { ModelProviderConnectionError } from '../storage/modelProviderConnectionStore.js';
+export function classifyCodexModelProviderError(error) {
+    if (error instanceof ModelProviderConnectionError)
+        return error;
+    if (error instanceof CodexAppServerCompatibilityError) {
+        return error.reason === 'version'
+            ? new ModelProviderConnectionError('The installed Codex app-server version is not supported.', 503, 'MODEL_CONNECTION_CODEX_VERSION_UNSUPPORTED')
+            : new ModelProviderConnectionError('Codex did not use the isolated credential home for this connection.', 502, 'MODEL_CONNECTION_CREDENTIAL_HOME_MISMATCH');
+    }
+    const message = String(error?.message || error || '').toLowerCase();
+    if (/\b429\b|rate.?limit|too many requests/.test(message)) {
+        return new ModelProviderConnectionError('The ChatGPT connection is temporarily rate limited.', 429, 'MODEL_CONNECTION_RATE_LIMITED');
+    }
+    if (/device.?code/.test(message) && /(disabled|not enabled|unavailable|unsupported)/.test(message)) {
+        return new ModelProviderConnectionError('ChatGPT device authorization is unavailable for this account.', 409, 'MODEL_CONNECTION_DEVICE_CODE_UNAVAILABLE');
+    }
+    if (/(unsupported|incompatible).*(codex|version)|(codex|version).*(unsupported|incompatible)/.test(message)) {
+        return new ModelProviderConnectionError('The installed Codex app-server version is not supported.', 503, 'MODEL_CONNECTION_CODEX_VERSION_UNSUPPORTED');
+    }
+    return new ModelProviderConnectionError('The model provider connection operation failed.', 502, 'MODEL_CONNECTION_PROVIDER_FAILURE');
+}
+function accountMetadata(account) {
+    return {
+        ...(account.email ? { accountEmail: account.email, accountLabel: account.email } : {}),
+        ...(account.planType ? { planLabel: account.planType } : {}),
+    };
+}
+async function withCodexClient(context, clientFactory, callback) {
+    let client = null;
+    let closeForLeaseLoss = null;
+    try {
+        client = clientFactory(context.environment);
+        const activeClient = client;
+        closeForLeaseLoss = () => { void activeClient.close(); };
+        context.signal.addEventListener('abort', closeForLeaseLoss, { once: true });
+        await client.initialize();
+        return await callback(client);
+    }
+    catch (error) {
+        throw classifyCodexModelProviderError(error);
+    }
+    finally {
+        if (closeForLeaseLoss)
+            context.signal.removeEventListener('abort', closeForLeaseLoss);
+        if (client)
+            await client.close();
+    }
+}
+async function requireChatGptAccount(client, refreshToken) {
+    const account = await client.readAccount(refreshToken);
+    if (account?.type !== 'chatgpt') {
+        throw new ModelProviderConnectionError('The Codex credential home is not authorized with a ChatGPT subscription account.', 409, 'MODEL_CONNECTION_ACCOUNT_UNAVAILABLE');
+    }
+    return account;
+}
+export function createCodexModelProviderConnectionLifecycleHandlers(options = {}) {
+    const clientFactory = options.clientFactory || ((environment) => new CodexAppServerJsonRpcClient({
+        env: environment,
+        credentialPaths: [String(environment.CODEX_HOME || '')].filter(Boolean),
+    }));
+    return {
+        verify: async (context) => withCodexClient(context, clientFactory, async (client) => ({
+            displayMetadata: accountMetadata(await requireChatGptAccount(client, false)),
+        })),
+        refresh: async (context) => withCodexClient(context, clientFactory, async (client) => ({
+            displayMetadata: accountMetadata(await requireChatGptAccount(client, true)),
+        })),
+        disconnect: async (context) => withCodexClient(context, clientFactory, async (client) => {
+            await client.logoutAccount();
+        }),
+    };
+}

package/dist/services/executorPhaseAApprovalRuntime.d.ts

@@ -0,0 +1,14 @@
+import type { TaskforceCore } from '../core/Taskforce.js';
+import type { ExecutorPhaseAApprovalTrustPolicy } from '../shared/executorPhaseAApprovalReceipt.js';
+import { ExecutorPhaseAApprovalReceiptStore } from '../storage/executorPhaseAApprovalReceiptStore.js';
+import { ExecutorPhaseAApprovalService, type ExecutorPhaseAApprovalSigningConfig } from './executorPhaseAApprovalService.js';
+export declare function createExecutorPhaseAApprovalRuntime(core: TaskforceCore, options?: {
+    policy?: ExecutorPhaseAApprovalTrustPolicy;
+    signing?: ExecutorPhaseAApprovalSigningConfig | null;
+    now?: () => Date;
+    randomId?: () => string;
+}): {
+    policy: ExecutorPhaseAApprovalTrustPolicy;
+    store: ExecutorPhaseAApprovalReceiptStore;
+    service: ExecutorPhaseAApprovalService | null;
+};

package/dist/services/executorPhaseAApprovalRuntime.js

@@ -0,0 +1,24 @@
+import trustPolicyJson from '../shared/executorPhaseAApprovalTrustPolicy.json' with { type: 'json' };
+import { ExecutorPhaseAApprovalReceiptStore } from '../storage/executorPhaseAApprovalReceiptStore.js';
+import { ExecutorPhaseARunAuthorizationStore } from '../storage/executorPhaseARunAuthorizationStore.js';
+import { ExecutorPhaseAApprovalService, resolveExecutorPhaseAApprovalSigningConfig, } from './executorPhaseAApprovalService.js';
+export function createExecutorPhaseAApprovalRuntime(core, options = {}) {
+    const policy = options.policy || trustPolicyJson;
+    const signing = options.signing === undefined
+        ? resolveExecutorPhaseAApprovalSigningConfig(process.env, policy)
+        : options.signing;
+    const store = new ExecutorPhaseAApprovalReceiptStore(core.getDatabaseAdapter(), core.getTenantId());
+    const runAuthorizationStore = new ExecutorPhaseARunAuthorizationStore(core.getDatabaseAdapter(), core.getTenantId());
+    return {
+        policy,
+        store,
+        service: signing ? new ExecutorPhaseAApprovalService({
+            store,
+            runAuthorizationStore,
+            signing,
+            policy,
+            now: options.now,
+            randomId: options.randomId,
+        }) : null,
+    };
+}

package/dist/services/executorPhaseAApprovalService.d.ts

@@ -0,0 +1,40 @@
+import { type KeyObject } from 'crypto';
+import { type ExecutorPhaseAApprovalTrustPolicy, type ExecutorPhaseAPreflight } from '../shared/executorPhaseAApprovalReceipt.js';
+import type { ExecutorPhaseAApprovalReceiptStore } from '../storage/executorPhaseAApprovalReceiptStore.js';
+import type { ExecutorPhaseARunAuthorizationStore } from '../storage/executorPhaseARunAuthorizationStore.js';
+export declare class ExecutorPhaseAApprovalError extends Error {
+    readonly statusCode: number;
+    readonly code: string;
+    constructor(message: string, statusCode?: number, code?: string);
+}
+export interface ExecutorPhaseAApprovalSigningConfig {
+    keyId: string;
+    privateKey: KeyObject;
+}
+export declare function assertExecutorPhaseAApprovalTrustPolicy(policy: ExecutorPhaseAApprovalTrustPolicy): void;
+export declare function resolveExecutorPhaseAApprovalTrustKey(policy: ExecutorPhaseAApprovalTrustPolicy, keyId: string, signedAt: string, usage: 'sign' | 'verify'): import("../shared/executorPhaseAApprovalReceipt.js").ExecutorPhaseAApprovalTrustKey | null;
+export declare function parseCanonicalExecutorPhaseAPreflight(bytes: Buffer, policy: ExecutorPhaseAApprovalTrustPolicy, now?: Date): ExecutorPhaseAPreflight;
+export declare function resolveExecutorPhaseAApprovalSigningConfig(env?: NodeJS.ProcessEnv, policy?: ExecutorPhaseAApprovalTrustPolicy): ExecutorPhaseAApprovalSigningConfig | null;
+export declare class ExecutorPhaseAApprovalService {
+    private readonly options;
+    constructor(options: {
+        store: ExecutorPhaseAApprovalReceiptStore;
+        runAuthorizationStore?: ExecutorPhaseARunAuthorizationStore;
+        signing: ExecutorPhaseAApprovalSigningConfig;
+        policy?: ExecutorPhaseAApprovalTrustPolicy;
+        now?: () => Date;
+        randomId?: () => string;
+    });
+    issue(canonicalPreflightBytes: Buffer, actorUserId: string): {
+        bytes: Buffer;
+        receiptId: string;
+        digest: string;
+        created: boolean;
+    };
+    issueCleanup(originalCapabilityId: string, residualInventorySha256: string, actorUserId: string): {
+        bytes: Buffer;
+        receiptId: string;
+        digest: string;
+        created: boolean;
+    };
+}