@playcraft/cli 0.1.17 → 0.1.19

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

@@ -8,7 +8,6 @@ import { portableCodexConfig, writePortableCodexCatalog } from './config-toml.js
 import { createJsonRpcStdioClient } from './jsonrpc-stdio.js';
 import { projectNativeThread } from '@playcraft/common/cloud-workspace/runtime';
 import { collectedEvent, NativePreparationError } from './native-adapter.js';
-import { exportTranscript } from './transcripts.js';
 import { readProjectSkillsLockFile } from '@playcraft/common/project-skills';
 import { freezeWorkspaceSkills } from '../workspaces/skills.js';
 function asRecord(value) {
@@ -75,18 +74,6 @@ export function createCodexAppServerAdapter(options) {
             release();
         }
     }
-    function transcriptHome() {
-        if (!launcherSocket)
-            return { homeDir };
-        return {
-            homeDir,
-            launcher: {
-                socketPath: launcherSocket,
-                runtimeEpoch: executionEpoch,
-                cwd: options.config.workspaceMode === 'multi' ? '/home/playcraft-dev' : options.config.workspaceRoot,
-            },
-        };
-    }
     async function ensureStarted() {
         if (closed)
             throw new Error('codex_not_started');
@@ -382,44 +369,6 @@ export function createCodexAppServerAdapter(options) {
                 throw new Error('codex_not_started');
             return { pid: next.pid, startedAt: next.startedAt };
         },
-        async canContinueThread(input) {
-            return withPreparation(async () => {
-                await ensureStarted();
-                if (!rpc)
-                    return false;
-                try {
-                    const existing = threads.get(input.threadId);
-                    if (existing && existing.sessionId !== input.sessionId)
-                        return false;
-                    if (existing?.turnActive)
-                        return false;
-                    const prepared = await lockedThreadConfig(input.cwd ?? '', input.modelConfigId, input.sessionId);
-                    if (existing?.needsRecreate)
-                        return false;
-                    if (existing?.loaded) {
-                        if (existing.skillsHash !== prepared.skillsHash || existing.discoveryHash !== prepared.discoveryHash) {
-                            if (!existing.hasNativeHistory)
-                                return false;
-                            await restartForSkills(input.threadId, prepared.modelConfigId);
-                        }
-                        prepared.activate();
-                        return threads.get(input.threadId)?.sessionId === input.sessionId;
-                    }
-                    const result = await rpc.request('thread/resume', { threadId: input.threadId, cwd: input.cwd,
-                        ...prepared.params }, 30_000);
-                    const resumedId = result.thread?.id ?? result.threadId;
-                    if (resumedId !== input.threadId)
-                        return false;
-                    prepared.activate();
-                    threads.set(input.threadId, { sessionId: input.sessionId, cwd: input.cwd, skillsHash: prepared.skillsHash,
-                        discoveryHash: prepared.discoveryHash, modelConfigId: prepared.modelConfigId, hasNativeHistory: true, loaded: true });
-                    return true;
-                }
-                catch {
-                    return false;
-                }
-            });
-        },
         async readThread(input) {
             try {
                 await ensureStarted();
@@ -436,17 +385,6 @@ export function createCodexAppServerAdapter(options) {
                 return undefined;
             }
         },
-        exportThread(input) {
-            return exportTranscript(transcriptHome(), input.threadId);
-        },
-        async captureNativeCheckpoint(input) {
-            const thread = threads.get(input.threadId);
-            if (!thread || thread.sessionId !== input.sessionId)
-                return undefined;
-            if (!thread.lastTurnId)
-                return { threadId: input.threadId };
-            return { threadId: input.threadId, nativeDurableTurnId: thread.lastTurnId };
-        },
         async start() {
             await ensureStarted();
         },
@@ -470,6 +408,30 @@ export function createCodexAppServerAdapter(options) {
                 return { threadId, modelConfigId: prepared.modelConfigId };
             });
         },
+        async resumeThread(input) {
+            return withPreparation(async () => {
+                await ensureStarted();
+                if (!rpc)
+                    throw new Error('codex_not_started');
+                const prepared = await lockedThreadConfig(input.cwd, input.modelConfigId, input.sessionId);
+                let resumedId;
+                try {
+                    const resumed = await rpc.request('thread/resume', {
+                        threadId: input.threadId, cwd: input.cwd, ...prepared.params,
+                    }, 30_000);
+                    resumedId = resumed.thread?.id;
+                }
+                catch {
+                    return undefined;
+                }
+                if (resumedId !== input.threadId)
+                    return undefined;
+                prepared.activate();
+                threads.set(input.threadId, { sessionId: input.sessionId, cwd: input.cwd, skillsHash: prepared.skillsHash,
+                    discoveryHash: prepared.discoveryHash, modelConfigId: prepared.modelConfigId, hasNativeHistory: true, loaded: true });
+                return { modelConfigId: prepared.modelConfigId };
+            });
+        },
         async startTurn(input) {
             return withPreparation(async () => {
                 await ensureStarted();

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

@@ -26,6 +26,9 @@ export function createLoopbackNativeAdapter() {
             threads.set(threadId, { sessionId: input.sessionId, items: [] });
             return { threadId };
         },
+        async resumeThread(input) {
+            return threads.get(input.threadId)?.sessionId === input.sessionId ? {} : undefined;
+        },
         async startTurn(input) {
             const thread = threads.get(input.threadId);
             if (!thread || thread.sessionId !== input.sessionId)

package/dist/workspace-runtime/persistence/journal.js

@@ -1,7 +1,7 @@
 import { copyFile, mkdir, readFile, writeFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
 import { dirname, join } from 'node:path';
-import { workspaceRegistrationSchema, checkpointRecordSchema, operationRecordSchema, pendingSourceEventSchema, replayPinResultSchema, retainedRangeHasGap, sourceAckSchema, sourceEventKey, sourceEventReceiptSchema, terminalRecordSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { workspaceRegistrationSchema, operationRecordSchema, pendingSourceEventSchema, replayPinResultSchema, retainedRangeHasGap, sourceAckSchema, sourceEventKey, sourceEventReceiptSchema, terminalRecordSchema, } from '@playcraft/common/cloud-workspace/runtime';
 import { SqliteWorkerClient } from './sqlite-client.js';
 export const RUNTIME_STATE_FILE = 'runtime-state.sqlite';
 export const LEGACY_JOURNAL_FILE = 'journal.json';
@@ -116,21 +116,6 @@ export class RuntimeJournal {
     listTerminals(workspaceId) {
         return Object.values(this.snapshot.terminals).filter((item) => !workspaceId || item.workspaceId === workspaceId);
     }
-    getCheckpoint(checkpointId) {
-        return this.snapshot.checkpoints[checkpointId];
-    }
-    fileCheckpointId() {
-        return this.snapshot.fileCheckpointId;
-    }
-    consistentCheckpointId() {
-        return this.snapshot.consistentCheckpointId;
-    }
-    async setFileCheckpointId(checkpointId) {
-        await this.run('setCheckpointId', { field: 'file', id: checkpointId });
-    }
-    async setConsistentCheckpointId(checkpointId) {
-        await this.run('setCheckpointId', { field: 'consistent', id: checkpointId });
-    }
     listManagedWrites(workspaceId) {
         return Object.values(this.snapshot.managedWrites).filter((item) => !workspaceId || item.workspaceId === workspaceId);
     }
@@ -266,11 +251,6 @@ export class RuntimeJournal {
         await this.run('upsertRecord', { bucket: 'terminals', key: parsed.terminalId, body: parsed });
         return parsed;
     }
-    async putCheckpoint(checkpoint) {
-        const parsed = checkpointRecordSchema.parse(checkpoint);
-        await this.run('upsertRecord', { bucket: 'checkpoints', key: parsed.checkpointId, body: parsed });
-        return parsed;
-    }
     async putFileRevision(path, record, workspaceId) {
         if (workspaceId) {
             await this.run('upsertRecord', { bucket: `workspace_files:${workspaceId}`, key: path, body: record });
@@ -278,10 +258,6 @@ export class RuntimeJournal {
         }
         await this.run('upsertRecord', { bucket: 'file_revisions', key: path, body: record });
     }
-    async replaceFileRevisions(records, workspaceId) {
-        const entries = Object.entries(records).map(([key, body]) => ({ key, body }));
-        await this.run('replaceBucket', { bucket: workspaceId ? `workspace_files:${workspaceId}` : 'file_revisions', entries });
-    }
     async markDestroyed() {
         await this.run('setDestroyed', {});
     }
@@ -367,7 +343,6 @@ function emptySnapshot() {
         events: {},
         sessions: {},
         terminals: {},
-        checkpoints: {},
         fileRevisions: {},
         approvals: {},
         managedWrites: {},

package/dist/workspace-runtime/persistence/sqlite-worker.js

@@ -12,7 +12,7 @@ import { chmodSync, mkdirSync } from 'node:fs';
 import { dirname } from 'node:path';
 import { parentPort } from 'node:worker_threads';
 import Database from 'better-sqlite3-pinned';
-import { hashOperationPayload, operationRecordSchema, pendingSourceEventSchema, checkpointRecordSchema, terminalRecordSchema, workspaceRegistrationSchema, transitionOperation, canTransitionTurn, } from '@playcraft/common/cloud-workspace/runtime';
+import { hashOperationPayload, operationRecordSchema, pendingSourceEventSchema, terminalRecordSchema, workspaceRegistrationSchema, transitionOperation, canTransitionTurn, } from '@playcraft/common/cloud-workspace/runtime';
 const SCHEMA_VERSION = 1;
 const MIN_SQLITE = [3, 51, 3];
 const BINDING = 'better-sqlite3@13.0.3';
@@ -68,9 +68,6 @@ function dispatch(type, payload) {
             case 'setDestroyed':
                 setMeta(database, 'destroyed', '1');
                 return;
-            case 'setCheckpointId':
-                setMeta(database, body.field === 'consistent' ? 'consistent_checkpoint_id' : 'file_checkpoint_id', String(body.id));
-                return;
             case 'noteExecutionGroup':
                 setMeta(database, 'execution_group', JSON.stringify({ ...(executionGroup(database)), ...asRecord(body.group) }));
                 return;
@@ -298,7 +295,6 @@ function importLegacy(database, legacy) {
         return typeof session.sessionId === 'string' && typeof session.threadId === 'string';
     });
     importBucket(database, 'terminals', asRecord(snapshot.terminals), (value) => terminalRecordSchema.safeParse(value).success);
-    importBucket(database, 'checkpoints', asRecord(snapshot.checkpoints), (value) => checkpointRecordSchema.safeParse(value).success);
     importBucket(database, 'approvals', asRecord(snapshot.approvals), (value) => isApproval(value));
     importBucket(database, 'managed_writes', asRecord(snapshot.managedWrites), () => true);
     importBucket(database, 'file_revisions', asRecord(snapshot.fileRevisions), () => true);
@@ -307,11 +303,6 @@ function importLegacy(database, legacy) {
     for (const [workspaceId, files] of Object.entries(workspaceFiles)) {
         importBucket(database, `workspace_files:${workspaceId}`, asRecord(files), () => true);
     }
-    if (typeof snapshot.fileCheckpointId === 'string')
-        setMeta(database, 'file_checkpoint_id', snapshot.fileCheckpointId);
-    if (typeof snapshot.consistentCheckpointId === 'string') {
-        setMeta(database, 'consistent_checkpoint_id', snapshot.consistentCheckpointId);
-    }
     setMeta(database, 'accepted_lease_fence', String(Number(snapshot.acceptedLeaseFence) || 0));
     setMeta(database, 'destroyed', snapshot.destroyed === true ? '1' : '0');
     setMeta(database, 'runtime_epoch', String(runtimeEpoch));
@@ -441,6 +432,7 @@ function bindTurn(database, body) {
             turnBlock: undefined,
             activeTurnId: String(body.turnId),
             threadId: String(body.threadId),
+            recoveryContextPending: undefined,
         });
     }
     const threadId = String(body.threadId);
@@ -701,13 +693,10 @@ function dump(database) {
         events: eventsObject(database),
         sessions: bucketObject(database, 'sessions'),
         terminals: bucketObject(database, 'terminals'),
-        checkpoints: bucketObject(database, 'checkpoints'),
         fileRevisions: bucketObject(database, 'file_revisions'),
         approvals: bucketObject(database, 'approvals'),
         managedWrites: bucketObject(database, 'managed_writes'),
         workspaceDependencies: bucketObject(database, 'workspace_dependencies'),
-        fileCheckpointId: metaString(database, 'file_checkpoint_id') || undefined,
-        consistentCheckpointId: metaString(database, 'consistent_checkpoint_id') || undefined,
         executionGroup: executionGroup(database),
         runtimeEpoch: metaNumber(database, 'runtime_epoch'),
         lastSourceSequence: currentCounter(database),