@playcraft/cli 0.0.59 → 0.1.0

package/dist/agent/local-backend.js

@@ -2,7 +2,7 @@ import express from 'express';
 import crypto from 'node:crypto';
 import path from 'node:path';
 import fs from 'node:fs/promises';
-import { eq, inArray } from 'drizzle-orm';
+import { eq, inArray } from '@playcraft/common/database/operators';
 import pc from 'picocolors';
 import { createSqliteAdapter } from '@playcraft/common/database';
 import { AssetModel, ProjectModel, SceneModel } from '@playcraft/common/models';

package/dist/workspace-runtime/codex/app-server.js

@@ -3,17 +3,12 @@ import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { writePlaycraftCodexConfig } from './config-toml.js';
 import { createJsonRpcStdioClient } from './jsonrpc-stdio.js';
-import { nativeEvent } from './native-adapter.js';
+import { collectedEvent } from './native-adapter.js';
 function asRecord(value) {
     return value && typeof value === 'object' && !Array.isArray(value)
         ? value
         : {};
 }
-function nestedId(value, key) {
-    const record = asRecord(value);
-    const nested = asRecord(record[key]);
-    return typeof nested.id === 'string' ? nested.id : undefined;
-}
 function waitForChildExit(child) {
     if (child.exitCode !== null || child.signalCode !== null)
         return Promise.resolve();
@@ -62,14 +57,10 @@ export function createCodexAppServerAdapter(options) {
     let startPromise;
     let live;
     const exitListeners = new Set();
-    const unmatchedTurns = new Map();
-    const turnWaiters = new Map();
-    function finishTurn(turnId, params, waiter) {
-        turnWaiters.delete(turnId);
-        unmatchedTurns.delete(turnId);
-        const status = String(asRecord(asRecord(params).turn).status ?? 'completed');
-        const outcome = status === 'interrupted' ? 'interrupted' : status === 'failed' ? 'failed' : 'completed';
-        waiter.resolve({ outcome, turnId, events: waiter.events });
+    const collected = new Set();
+    function emitCollected(event) {
+        for (const listener of collected)
+            listener(event);
     }
     async function ensureStarted() {
         if (readyFlag && rpc)
@@ -103,20 +94,7 @@ export function createCodexAppServerAdapter(options) {
         });
         rpc = createJsonRpcStdioClient(child);
         rpc.onNotification((method, params) => {
-            const turnId = nestedId(params, 'turn') ?? String(asRecord(params).turnId ?? '');
-            const event = nativeEvent(method, params);
-            if (!turnId)
-                return;
-            const waiter = turnWaiters.get(turnId);
-            if (waiter) {
-                waiter.events.push(event);
-                if (method === 'turn/completed')
-                    finishTurn(turnId, params, waiter);
-                return;
-            }
-            const queued = unmatchedTurns.get(turnId) ?? [];
-            queued.push(event);
-            unmatchedTurns.set(turnId, queued);
+            emitCollected(collectedEvent('notification', method, params));
         });
         rpc.onServerRequest((id, method, params) => {
             const payload = asRecord(params);
@@ -127,19 +105,7 @@ export function createCodexAppServerAdapter(options) {
                 threadId: String(payload.threadId ?? ''),
                 turnId: turnId || undefined,
             });
-            const event = nativeEvent(method, params);
-            const waiter = turnId ? turnWaiters.get(turnId) : undefined;
-            if (waiter) {
-                waiter.events.push(event);
-                turnWaiters.delete(turnId);
-                waiter.resolve({ outcome: 'completed', turnId, approvalId, events: waiter.events });
-                return;
-            }
-            if (turnId) {
-                const queued = unmatchedTurns.get(turnId) ?? [];
-                queued.push(event);
-                unmatchedTurns.set(turnId, queued);
-            }
+            emitCollected(collectedEvent('approval_request', method, { ...payload, itemId: approvalId }));
         });
         const pid = child.pid;
         if (!pid)
@@ -158,10 +124,7 @@ export function createCodexAppServerAdapter(options) {
                 live = undefined;
                 rpc = undefined;
                 child = undefined;
-                for (const [turnId, waiter] of turnWaiters) {
-                    turnWaiters.delete(turnId);
-                    waiter.resolve({ outcome: 'uncertain', turnId, events: waiter.events });
-                }
+                emitCollected(collectedEvent('process_exit', 'process.exited', { pid: current.pid }));
             }
             if (!current.superseded && !closed) {
                 for (const listener of exitListeners)
@@ -189,6 +152,13 @@ export function createCodexAppServerAdapter(options) {
         onUnexpectedExit(listener) {
             exitListeners.add(listener);
         },
+        onCollected(listener) {
+            collected.add(listener);
+            return () => collected.delete(listener);
+        },
+        turnStartSends() {
+            return rpc?.turnStartSends() ?? 0;
+        },
         async replaceProcess() {
             const previous = live;
             if (previous)
@@ -197,8 +167,6 @@ export function createCodexAppServerAdapter(options) {
             startPromise = undefined;
             threads.clear();
             approvals.clear();
-            turnWaiters.clear();
-            unmatchedTurns.clear();
             if (previous && previous.child.exitCode === null && previous.child.signalCode === null) {
                 previous.child.kill('SIGTERM');
             }
@@ -265,104 +233,61 @@ export function createCodexAppServerAdapter(options) {
             await ensureStarted();
             if (!rpc)
                 throw new Error('codex_not_started');
-            if (input.simulateLostReceipt) {
-                return { outcome: 'uncertain', events: [] };
-            }
             if (threads.get(input.threadId)?.sessionId !== input.sessionId) {
-                return {
-                    outcome: 'failed',
-                    events: [nativeEvent('turn.failed', { reason: 'unknown_thread' })],
-                };
+                return { outcome: 'failed', error: 'unknown_thread' };
             }
-            const started = await rpc.request('turn/start', {
-                threadId: input.threadId,
-                input: [{ type: 'text', text: input.text }],
-            });
-            const turnId = started.turn?.id;
-            if (!turnId)
-                return { outcome: 'uncertain', events: [] };
-            const thread = threads.get(input.threadId);
-            if (thread)
-                thread.lastTurnId = turnId;
-            const queued = unmatchedTurns.get(turnId) ?? [];
-            unmatchedTurns.delete(turnId);
-            const events = [nativeEvent('turn/started', started), ...queued];
-            const alreadyDone = queued.find((event) => event.type === 'turn/completed');
-            if (alreadyDone) {
-                const status = String(asRecord(asRecord(alreadyDone.payload).turn).status ?? 'completed');
-                const outcome = status === 'interrupted' ? 'interrupted' : status === 'failed' ? 'failed' : 'completed';
-                return { outcome, turnId, events };
+            const requestId = rpc.reserveRequest();
+            await input.persistReservation({ nativeRequestId: String(requestId) });
+            if (input.simulateLostReceipt)
+                return { outcome: 'uncertain', threadId: input.threadId };
+            try {
+                const started = await rpc.sendReserved(requestId, 'turn/start', { threadId: input.threadId, input: [{ type: 'text', text: input.text }] }, turnTimeoutMs);
+                const turnId = started.turn?.id;
+                if (!turnId)
+                    return { outcome: 'uncertain', threadId: input.threadId };
+                const thread = threads.get(input.threadId);
+                if (thread)
+                    thread.lastTurnId = turnId;
+                return { outcome: 'accepted', threadId: input.threadId, turnId };
             }
-            const approvalEvent = queued.find((event) => event.type.includes('requestApproval') || event.type.includes('requestUserInput'));
-            if (approvalEvent) {
-                const approvalId = String(asRecord(approvalEvent.payload).itemId ?? '');
-                return { outcome: 'completed', turnId, approvalId, events };
+            catch {
+                return { outcome: 'uncertain', threadId: input.threadId };
             }
-            return await new Promise((resolve) => {
-                let timer;
-                const waiter = {
-                    events,
-                    resolve: (result) => {
-                        clearTimeout(timer);
-                        resolve(result);
-                    },
-                };
-                timer = setTimeout(() => {
-                    turnWaiters.delete(turnId);
-                    resolve({ outcome: 'uncertain', turnId, events: waiter.events });
-                }, turnTimeoutMs);
-                turnWaiters.set(turnId, waiter);
-            });
         },
         async interrupt(input) {
             await ensureStarted();
             if (!rpc)
-                return { outcome: 'uncertain', events: [] };
+                return { outcome: 'uncertain' };
             if (threads.get(input.threadId)?.sessionId !== input.sessionId)
-                return { outcome: 'uncertain', events: [] };
+                return { outcome: 'uncertain' };
             const turnId = threads.get(input.threadId)?.lastTurnId;
             if (!turnId)
-                return { outcome: 'uncertain', events: [] };
+                return { outcome: 'uncertain' };
             try {
                 await rpc.request('turn/interrupt', { threadId: input.threadId, turnId });
             }
             catch {
-                return { outcome: 'uncertain', events: [nativeEvent('turn.interrupted', { threadId: input.threadId })] };
+                return { outcome: 'uncertain', turnId };
             }
-            return {
-                outcome: 'interrupted',
-                turnId,
-                events: [nativeEvent('turn.interrupted', { threadId: input.threadId, turnId })],
-            };
+            return { outcome: 'accepted', turnId };
         },
         async respondApproval(input) {
-            if (!rpc) {
-                return {
-                    outcome: 'failed',
-                    events: [nativeEvent('approval.unknown', { approvalId: input.approvalId })],
-                };
-            }
+            if (!rpc)
+                return { outcome: 'failed', approvalId: input.approvalId };
             const threadId = [...threads].find(([, thread]) => thread.sessionId === input.sessionId)?.[0];
             const key = JSON.stringify([threadId, input.approvalId]);
             const pending = approvals.get(key);
-            if (!pending) {
-                return {
-                    outcome: 'failed',
-                    events: [nativeEvent('approval.unknown', { approvalId: input.approvalId })],
-                };
-            }
+            if (!pending)
+                return { outcome: 'failed', approvalId: input.approvalId };
             approvals.delete(key);
             rpc.respond(pending.rpcId, { decision: input.accepted ? 'accept' : 'decline' });
-            return {
-                outcome: 'completed',
+            emitCollected(collectedEvent('notification', 'approval.resolved', {
                 approvalId: input.approvalId,
-                events: [
-                    nativeEvent('approval.resolved', {
-                        approvalId: input.approvalId,
-                        accepted: input.accepted,
-                    }),
-                ],
-            };
+                accepted: input.accepted,
+                threadId,
+                turnId: pending.turnId,
+            }));
+            return { outcome: 'accepted', approvalId: input.approvalId, turnId: pending.turnId };
         },
         async close() {
             if (closed)

package/dist/workspace-runtime/codex/jsonrpc-stdio.js

@@ -7,6 +7,7 @@ export function createJsonRpcStdioClient(child) {
     const emitter = new EventEmitter();
     const pending = new Map();
     let nextId = 1;
+    let turnStarts = 0;
     let buffer = '';
     let closed = false;
     const onData = (chunk) => {
@@ -60,8 +61,16 @@ export function createJsonRpcStdioClient(child) {
         notify(method, params) {
             send({ method, params: params ?? {} });
         },
-        request(method, params, timeoutMs = 20_000) {
-            const id = nextId++;
+        reserveRequest() {
+            const id = nextId;
+            nextId += 1;
+            return id;
+        },
+        sendReserved(id, method, params, timeoutMs = 20_000) {
+            if (pending.has(id))
+                throw new Error('jsonrpc_request_in_use');
+            if (method === 'turn/start')
+                turnStarts += 1;
             return new Promise((resolve, reject) => {
                 const timer = setTimeout(() => {
                     pending.delete(id);
@@ -78,6 +87,14 @@ export function createJsonRpcStdioClient(child) {
                 }
             });
         },
+        request(method, params, timeoutMs = 20_000) {
+            const id = nextId;
+            nextId += 1;
+            return this.sendReserved(id, method, params, timeoutMs);
+        },
+        turnStartSends() {
+            return turnStarts;
+        },
         onNotification(listener) {
             emitter.on('notification', listener);
             return () => emitter.off('notification', listener);

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

@@ -1,59 +1,110 @@
-import { nativeEvent } from './native-adapter.js';
+import { collectedEvent } from './native-adapter.js';
 /** In-process Codex stand-in. Not the App Server; used to prove the operation/event loop. */
 export function createLoopbackNativeAdapter() {
     const threads = new Map();
     const approvals = new Set();
+    const collected = new Set();
+    const sent = new Set();
+    let turnStarts = 0;
+    function emit(event) {
+        for (const listener of collected)
+            listener(event);
+    }
     return {
         name: 'loopback',
         ready: () => true,
+        onCollected(listener) {
+            collected.add(listener);
+            return () => collected.delete(listener);
+        },
+        turnStartSends() {
+            return turnStarts;
+        },
         async startThread(input) {
             const threadId = `thread_${input.sessionId}`;
-            threads.set(threadId, input.sessionId);
+            threads.set(threadId, { sessionId: input.sessionId });
             return { threadId };
         },
         async startTurn(input) {
-            if (threads.get(input.threadId) !== input.sessionId) {
-                return {
-                    outcome: 'failed',
-                    events: [nativeEvent('turn.failed', { reason: 'unknown_thread' })],
-                };
-            }
-            if (input.simulateLostReceipt) {
-                return { outcome: 'uncertain', events: [] };
+            const thread = threads.get(input.threadId);
+            if (!thread || thread.sessionId !== input.sessionId)
+                return { outcome: 'failed', error: 'unknown_thread' };
+            const nativeRequestId = `loopback:${input.sessionId}:${input.clientRequestId}`;
+            const sentKey = `${input.sessionId}:${input.clientRequestId}`;
+            await input.persistReservation({ nativeRequestId });
+            if (input.simulateLostReceipt || sent.has(sentKey)) {
+                sent.add(sentKey);
+                return { outcome: 'uncertain', threadId: input.threadId };
             }
-            const turnId = `turn_${input.clientRequestId}`;
-            const events = [
-                nativeEvent('item/agentMessage/delta', { text: `loopback:${input.text}` }),
-                nativeEvent('turn.completed', { turnId, threadId: input.threadId }),
-            ];
-            if (input.text.includes('[approval]')) {
-                const approvalId = `approval_${input.clientRequestId}`;
-                approvals.add(JSON.stringify([input.sessionId, approvalId]));
-                events.splice(1, 0, nativeEvent('item/tool/requestUserInput', { approvalId }));
-                return { outcome: 'completed', turnId, approvalId, events };
-            }
-            return { outcome: 'completed', turnId, events };
+            sent.add(sentKey);
+            turnStarts += 1;
+            const turnId = `turn_${input.sessionId}_${input.clientRequestId}`;
+            thread.turnId = turnId;
+            queueMicrotask(() => {
+                emit(collectedEvent('notification', 'item/agentMessage/delta', {
+                    threadId: input.threadId,
+                    turnId,
+                    text: `loopback:${input.text}`,
+                    delta: `loopback:${input.text}`,
+                }));
+                if (input.text.includes('[approval]')) {
+                    const approvalId = `approval_${input.clientRequestId}`;
+                    approvals.add(JSON.stringify([input.sessionId, approvalId]));
+                    emit(collectedEvent('approval_request', 'item/tool/requestUserInput', {
+                        threadId: input.threadId,
+                        turnId,
+                        approvalId,
+                        itemId: approvalId,
+                    }));
+                    return;
+                }
+                emit(collectedEvent('notification', 'turn/completed', {
+                    threadId: input.threadId,
+                    turnId,
+                    turn: { id: turnId, status: 'completed' },
+                }));
+            });
+            return { outcome: 'accepted', threadId: input.threadId, turnId };
         },
         async interrupt(input) {
-            if (threads.get(input.threadId) !== input.sessionId) {
-                return { outcome: 'uncertain', events: [] };
-            }
-            return {
-                outcome: 'interrupted',
-                events: [nativeEvent('turn.interrupted', { threadId: input.threadId })],
-            };
+            const thread = threads.get(input.threadId);
+            if (!thread || thread.sessionId !== input.sessionId)
+                return { outcome: 'uncertain' };
+            const turnId = thread.turnId;
+            queueMicrotask(() => {
+                emit(collectedEvent('notification', 'turn/completed', {
+                    threadId: input.threadId,
+                    turnId,
+                    turn: { id: turnId, status: 'interrupted' },
+                }));
+            });
+            return { outcome: 'accepted', turnId };
         },
         async respondApproval(input) {
-            if (!approvals.has(JSON.stringify([input.sessionId, input.approvalId]))) {
-                return { outcome: 'failed', events: [nativeEvent('approval.unknown', { approvalId: input.approvalId })] };
-            }
-            approvals.delete(JSON.stringify([input.sessionId, input.approvalId]));
-            const result = {
-                outcome: 'completed',
-                approvalId: input.approvalId,
-                events: [nativeEvent('approval.resolved', { approvalId: input.approvalId, accepted: input.accepted })],
-            };
-            return result;
+            const key = JSON.stringify([input.sessionId, input.approvalId]);
+            if (!approvals.has(key))
+                return { outcome: 'failed', approvalId: input.approvalId };
+            approvals.delete(key);
+            const thread = [...threads].find(([, value]) => value.sessionId === input.sessionId);
+            queueMicrotask(() => {
+                emit(collectedEvent('notification', 'approval.resolved', {
+                    approvalId: input.approvalId,
+                    accepted: input.accepted,
+                    threadId: thread?.[0],
+                    turnId: thread?.[1].turnId,
+                }));
+                emit(collectedEvent('notification', 'item/agentMessage/delta', {
+                    threadId: thread?.[0],
+                    turnId: thread?.[1].turnId,
+                    delta: 'after-approval',
+                }));
+                emit(collectedEvent('notification', 'turn/completed', {
+                    threadId: thread?.[0],
+                    turnId: thread?.[1].turnId,
+                    turn: { id: thread?.[1].turnId, status: 'completed' },
+                }));
+            });
+            return { outcome: 'accepted', approvalId: input.approvalId, turnId: thread?.[1].turnId };
         },
     };
 }

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

@@ -1,3 +1,6 @@
 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() };
+}