@playcraft/cli 0.1.29 → 0.1.31

package/dist/workspace-runtime/codex/model-broker.js

@@ -0,0 +1,263 @@
+import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
+import { createServer } from 'node:http';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { basename, dirname } from 'node:path';
+import { z } from 'zod';
+import { workspaceContextFromRoot } from '../workspaces/registry.js';
+import { PLATFORM_ROUTES, modelResponsesPath, platformEndpoint } from '@playcraft/common/cloud-workspace/runtime';
+const credentialSchema = z.object({
+    token: z.string().min(1), expiresAt: z.string().datetime(),
+    configId: z.string().uuid(), model: z.string().min(1).max(128),
+    supportsReasoning: z.boolean().optional(),
+    claims: z.object({
+        environment: z.string(), userId: z.string(), workspaceId: z.string(), runtimeId: z.string(),
+        generation: z.number().int(), runtimeEpoch: z.number().int(),
+    }),
+});
+/** Keeps renewable execution credentials in control memory, outside Codex and project files. */
+export class WorkspaceModelBroker {
+    state;
+    server;
+    baseUrl = '';
+    entries = new Map();
+    routes = new Map();
+    pending = new Map();
+    requests = new Set();
+    sessionRequests = new Map();
+    constructor(state) {
+        this.state = state;
+    }
+    async start() {
+        if (this.server)
+            return;
+        const server = createServer({ maxHeaderSize: 8192 }, (request, response) => {
+            void this.forward(request, response);
+        });
+        await new Promise((resolve, reject) => {
+            server.once('error', reject);
+            server.listen(0, '127.0.0.1', resolve);
+        });
+        this.server = server;
+        const address = server.address();
+        if (!address || typeof address === 'string')
+            throw new Error('model_broker_unavailable');
+        this.baseUrl = `http://127.0.0.1:${address.port}`;
+    }
+    async threadConfig(cwd, modelConfigId, sessionId, reasoningEffort) {
+        const { activate, ...settings } = await this.prepareThreadConfig(cwd, modelConfigId, sessionId, reasoningEffort);
+        activate();
+        return settings;
+    }
+    async prepareThreadConfig(cwd, modelConfigId, sessionId, reasoningEffort, clientRequestId) {
+        if (!this.server)
+            throw new Error('workspace_not_registered');
+        const { workspaceId } = await workspaceContextFromRoot(this.state, cwd);
+        if (modelConfigId !== undefined && !z.string().uuid().safeParse(modelConfigId).success)
+            throw new Error('model_config_denied');
+        const routeKey = sessionId ? `${workspaceId}/${createHash('sha256').update(sessionId).digest('hex').slice(0, 32)}` : workspaceId;
+        let route = this.routes.get(routeKey);
+        const selected = modelConfigId ?? (route?.epoch === this.state.runtimeEpoch ? route.selected?.entry.modelConfigId : undefined);
+        const cacheKey = `${workspaceId}:${selected ?? 'default'}:${reasoningEffort ?? 'default'}`;
+        let entry = this.entries.get(cacheKey) ?? [...this.entries.values()].find(item => item.workspaceId === workspaceId && item.epoch === this.state.runtimeEpoch && item.modelConfigId === selected
+            && item.reasoningEffort === reasoningEffort);
+        if (!entry || entry.epoch !== this.state.runtimeEpoch) {
+            entry = { workspaceId, epoch: this.state.runtimeEpoch, cacheKey, modelConfigId: selected, reasoningEffort };
+            this.entries.set(cacheKey, entry);
+        }
+        // Resolve current model metadata and permission at every native turn boundary.
+        const credential = await this.credential(entry, true);
+        if (!route || route.epoch !== this.state.runtimeEpoch) {
+            route = { workspaceId, epoch: this.state.runtimeEpoch, capability: randomBytes(32).toString('base64url') };
+            this.routes.set(routeKey, route);
+        }
+        // Each session pins its prepared model; shared credential renewal cannot change an active turn.
+        return {
+            activate: () => {
+                if (!this.valid(entry) || this.routes.get(routeKey) !== route)
+                    throw new Error('model_access_denied');
+                route.selected = { entry, model: credential.model,
+                    ...(sessionId && clientRequestId ? { feedback: { sessionId, clientRequestId } } : {}) };
+            },
+            model: credential.model,
+            modelConfigId: credential.configId,
+            modelProvider: 'playcraft_workspace',
+            config: {
+                'model_providers.playcraft_workspace': {
+                    name: 'PlayCraft Workspace', base_url: `${this.baseUrl}/${routeKey}`,
+                    wire_api: 'responses', requires_openai_auth: false,
+                    http_headers: { Authorization: `Bearer ${route.capability}` },
+                },
+            },
+        };
+    }
+    valid(entry) {
+        return Boolean(this.server && !this.state.journal.destroyed()
+            && this.state.runtimeEpoch === entry.epoch && this.state.journal.getWorkspace(entry.workspaceId)
+            && this.entries.get(entry.cacheKey) === entry);
+    }
+    async credential(entry, refresh = false) {
+        if (!this.valid(entry))
+            throw new Error('model_access_denied');
+        if (!refresh && entry.credential && Date.parse(entry.credential.expiresAt) > Date.now() + 60_000)
+            return entry.credential;
+        let pending = this.pending.get(entry);
+        if (!pending) {
+            pending = this.renew(entry).finally(() => this.pending.delete(entry));
+            this.pending.set(entry, pending);
+        }
+        return pending;
+    }
+    async renew(entry) {
+        const config = this.state.config;
+        const endpoint = platformEndpoint(config.publicBaseUrl, PLATFORM_ROUTES.modelCredentials);
+        const response = await fetch(endpoint, {
+            method: 'POST', redirect: 'error', signal: AbortSignal.timeout(10_000),
+            headers: { authorization: `Bearer ${config.controlToken}`, 'content-type': 'application/json', 'playcraft-env': config.environment },
+            body: JSON.stringify({ runtimeId: config.runtimeId, generation: config.generation,
+                runtimeEpoch: entry.epoch, workspaceId: entry.workspaceId,
+                ...(entry.modelConfigId ? { modelConfigId: entry.modelConfigId } : {}),
+                ...(entry.reasoningEffort ? { reasoningEffort: entry.reasoningEffort } : {}) }),
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({}));
+            throw new Error(['model_config_required', 'model_config_denied', 'reasoning_effort_denied', 'reasoning_effort_unsupported'].includes(error.reason ?? '') ? error.reason : 'model_credential_unavailable');
+        }
+        const credential = credentialSchema.parse(await response.json());
+        const claims = credential.claims;
+        if (!this.valid(entry) || claims.workspaceId !== entry.workspaceId || claims.runtimeId !== config.runtimeId
+            || claims.userId !== config.userId || claims.environment !== config.environment
+            || claims.generation !== config.generation || claims.runtimeEpoch !== entry.epoch
+            || (entry.modelConfigId !== undefined && credential.configId !== entry.modelConfigId)
+            || Date.parse(credential.expiresAt) <= Date.now() + 1000)
+            throw new Error('model_credential_scope_mismatch');
+        entry.modelConfigId = credential.configId;
+        entry.credential = credential;
+        return credential;
+    }
+    async forward(request, response) {
+        const abort = new AbortController();
+        this.requests.add(abort);
+        let activeRoute;
+        const cancel = () => abort.abort();
+        response.once('close', cancel);
+        try {
+            const match = /^\/([0-9a-f-]{36}(?:\/[0-9a-f]{32})?)\/responses$/.exec(request.url ?? '');
+            const route = match ? this.routes.get(match[1]) : undefined;
+            const selected = route?.selected;
+            const entry = selected?.entry;
+            const presented = Buffer.from(request.headers.authorization ?? '');
+            const expected = Buffer.from(route ? `Bearer ${route.capability}` : '');
+            if (request.method !== 'POST' || !entry || !expected.length || presented.length !== expected.length
+                || !timingSafeEqual(presented, expected) || !this.valid(entry)) {
+                response.writeHead(403);
+                response.end();
+                return;
+            }
+            activeRoute = route;
+            const active = this.sessionRequests.get(route) ?? new Set();
+            active.add(abort);
+            this.sessionRequests.set(route, active);
+            const credential = await this.credential(entry);
+            const chunks = [];
+            let size = 0;
+            for await (const chunk of request) {
+                size += chunk.length;
+                if (size > 16 * 1024 * 1024) {
+                    response.writeHead(413);
+                    response.end();
+                    return;
+                }
+                chunks.push(Buffer.from(chunk));
+            }
+            if (!this.valid(entry))
+                throw new Error('model_access_denied');
+            const body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+            if (!body || typeof body !== 'object' || Array.isArray(body)) {
+                response.writeHead(400);
+                response.end();
+                return;
+            }
+            // The browser selects a configuration, never an arbitrary billable upstream model.
+            body.model = selected.model;
+            if (credential.supportsReasoning === false) {
+                const reasoning = body.reasoning;
+                if (reasoning && typeof reasoning === 'object' && !Array.isArray(reasoning)) {
+                    delete reasoning.effort;
+                }
+            }
+            else if (entry.reasoningEffort) {
+                const reasoning = body.reasoning;
+                const modelName = selected.model.split('/').pop() ?? selected.model;
+                const effort = entry.reasoningEffort === 'max' && /^o\d|gpt-[5-9]/i.test(modelName)
+                    ? 'xhigh' : entry.reasoningEffort;
+                body.reasoning = {
+                    ...(reasoning && typeof reasoning === 'object' && !Array.isArray(reasoning) ? reasoning : {}),
+                    effort,
+                };
+            }
+            const expires = setTimeout(cancel, Math.max(0, Date.parse(credential.expiresAt) - Date.now()));
+            try {
+                const upstream = await fetch(platformEndpoint(this.state.config.publicBaseUrl, modelResponsesPath(credential.configId)), {
+                    method: 'POST', redirect: 'error', signal: abort.signal,
+                    headers: { authorization: `Bearer ${credential.token}`, 'content-type': 'application/json',
+                        ...(selected?.feedback ? {
+                            'x-playcraft-cloud-session-id': selected.feedback.sessionId,
+                            'x-playcraft-client-request-id': selected.feedback.clientRequestId,
+                        } : {}) },
+                    body: JSON.stringify(body),
+                });
+                if (upstream.status === 401 || upstream.status === 403)
+                    entry.credential = undefined;
+                response.writeHead(upstream.status, {
+                    'content-type': upstream.headers.get('content-type') ?? 'application/json', 'cache-control': 'no-store',
+                });
+                if (upstream.body)
+                    await pipeline(Readable.fromWeb(upstream.body), response);
+                else
+                    response.end();
+            }
+            finally {
+                clearTimeout(expires);
+            }
+        }
+        catch {
+            if (!response.headersSent) {
+                response.writeHead(503, { 'content-type': 'application/json', 'cache-control': 'no-store' });
+                response.end(JSON.stringify({ error: { message: 'model_credential_unavailable', type: 'server_error' } }));
+            }
+            else
+                response.destroy();
+        }
+        finally {
+            response.off('close', cancel);
+            this.requests.delete(abort);
+            if (activeRoute) {
+                const active = this.sessionRequests.get(activeRoute);
+                active?.delete(abort);
+                if (!active?.size)
+                    this.sessionRequests.delete(activeRoute);
+            }
+        }
+    }
+    cancelSession(cwd, sessionId) {
+        const routeKey = `${/^(basic|remix-)/.test(basename(cwd)) ? basename(dirname(cwd)) : basename(cwd)}/${createHash('sha256').update(sessionId).digest('hex').slice(0, 32)}`;
+        const route = this.routes.get(routeKey);
+        if (route)
+            for (const request of this.sessionRequests.get(route) ?? [])
+                request.abort();
+    }
+    async close() {
+        const server = this.server;
+        this.server = undefined;
+        this.entries.clear();
+        this.routes.clear();
+        this.sessionRequests.clear();
+        for (const request of this.requests)
+            request.abort();
+        if (server) {
+            server.closeAllConnections();
+            await new Promise(resolve => server.close(() => resolve()));
+        }
+    }
+}

package/dist/workspace-runtime/codex/native-adapter.js

@@ -0,0 +1,9 @@
+/** Failure before a native request was sent; safe to report as failed instead of uncertain. */
+export class NativePreparationError extends Error {
+}
+export function nativeEvent(type, payload) {
+    return { type, payload, occurredAt: new Date().toISOString() };
+}
+export function collectedEvent(kind, method, params) {
+    return { kind, method, params, occurredAt: new Date().toISOString() };
+}

package/dist/workspace-runtime/codex/permissions.js

@@ -0,0 +1,70 @@
+export const NATIVE_APPROVALS_REVIEWER = 'user';
+/** Fixed production/coordinator boundaries may only become narrower. */
+export function executionPolicy(cwd, mode, fixed) {
+    const directory = fixed?.cwd ?? cwd;
+    if (mode === 'read-only')
+        return { cwd: directory, approvalPolicy: 'never', sandboxPolicy: { type: 'readOnly', networkAccess: false } };
+    if (mode === 'auto')
+        return fixed ?? { cwd, approvalPolicy: 'never', sandboxPolicy: { type: 'dangerFullAccess' } };
+    if (fixed?.sandboxPolicy.type === 'readOnly')
+        return { ...fixed, sandboxPolicy: { type: 'readOnly', networkAccess: false } };
+    return { cwd: directory, approvalPolicy: fixed ? 'never' : 'on-request', sandboxPolicy: {
+            type: 'workspaceWrite', writableRoots: fixed?.sandboxPolicy.type === 'workspaceWrite' ? fixed.sandboxPolicy.writableRoots : [directory],
+            networkAccess: false, excludeTmpdirEnvVar: true, excludeSlashTmp: true,
+        } };
+}
+export function threadExecutionParams(execution) {
+    const sandbox = execution.sandboxPolicy.type === 'readOnly' ? 'read-only'
+        : execution.sandboxPolicy.type === 'workspaceWrite' ? 'workspace-write' : 'danger-full-access';
+    const policy = execution.sandboxPolicy;
+    return { cwd: execution.cwd, approvalPolicy: execution.approvalPolicy, approvalsReviewer: NATIVE_APPROVALS_REVIEWER, sandbox,
+        config: policy.type === 'workspaceWrite' ? {
+            'sandbox_workspace_write.writable_roots': policy.writableRoots,
+            'sandbox_workspace_write.network_access': policy.networkAccess,
+            'sandbox_workspace_write.exclude_tmpdir_env_var': policy.excludeTmpdirEnvVar,
+            'sandbox_workspace_write.exclude_slash_tmp': policy.excludeSlashTmp,
+        } : {} };
+}
+export const APPROVAL_METHODS = new Set([
+    'item/commandExecution/requestApproval', 'item/fileChange/requestApproval',
+    'item/permissions/requestApproval', 'item/tool/requestUserInput',
+]);
+function record(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+/** Returns only the native request's permissions; a browser cannot supply new paths or network access. */
+export function nativeApprovalResponse(method, request, response, canEscalate) {
+    if (method === 'item/commandExecution/requestApproval' || method === 'item/fileChange/requestApproval') {
+        if (response.kind !== 'decision' || (response.accepted && !canEscalate))
+            return undefined;
+        const decision = response.accepted ? 'accept' : Array.isArray(request.availableDecisions)
+            && !request.availableDecisions.includes('decline') && request.availableDecisions.includes('cancel') ? 'cancel' : 'decline';
+        if (Array.isArray(request.availableDecisions) && !request.availableDecisions.includes(decision))
+            return undefined;
+        return { decision };
+    }
+    if (method === 'item/permissions/requestApproval') {
+        if (response.kind !== 'permissions' || (response.accepted && !canEscalate))
+            return undefined;
+        const requested = record(request.permissions);
+        if (!request.permissions || Object.keys(requested).some(key => !['network', 'fileSystem'].includes(key)))
+            return undefined;
+        return { permissions: response.accepted ? Object.fromEntries(Object.entries(requested).filter(([, value]) => value != null)) : {}, scope: response.scope };
+    }
+    if (method !== 'item/tool/requestUserInput' || response.kind !== 'user-input' || !Array.isArray(request.questions) || !request.questions.length)
+        return undefined;
+    const questions = request.questions.map(record);
+    const ids = questions.map(question => question.id);
+    if (ids.some(id => typeof id !== 'string' || !id) || new Set(ids).size !== ids.length
+        || Object.keys(response.answers).length !== ids.length || Object.keys(response.answers).some(id => !ids.includes(id)))
+        return undefined;
+    for (const question of questions) {
+        const answers = response.answers[question.id]?.answers;
+        if (!answers || answers.length !== 1 || !answers[0]?.trim())
+            return undefined;
+        const options = Array.isArray(question.options) ? question.options.map(record) : [];
+        if (options.length && question.isOther !== true && !options.some(option => option.label === answers[0]))
+            return undefined;
+    }
+    return { answers: response.answers };
+}

package/dist/workspace-runtime/codex/work-mode.js

@@ -0,0 +1,15 @@
+export function workModeExecution(execution, workMode) {
+    return workMode === 'plan' ? {
+        ...execution, approvalPolicy: 'never', sandboxPolicy: { type: 'readOnly', networkAccess: false },
+    } : execution;
+}
+export function nativeCollaborationMode(model, effort, workMode) {
+    return {
+        mode: workMode === 'plan' ? 'plan' : 'default',
+        settings: {
+            model,
+            reasoning_effort: effort === 'max' ? 'xhigh' : effort ?? null,
+            developer_instructions: null,
+        },
+    };
+}

package/dist/workspace-runtime/main.js

@@ -0,0 +1,10 @@
+import { runWorkspaceRuntimeServe } from '../commands/workspace-runtime.js';
+const flag = process.argv.indexOf('--config');
+const configPath = flag >= 0 ? process.argv[flag + 1] : undefined;
+if (!configPath) {
+    console.error('workspace-runtime: missing --config');
+    process.exitCode = 2;
+}
+else {
+    await runWorkspaceRuntimeServe(configPath);
+}