@playcraft/cli 0.1.51 → 0.1.53-beta

package/dist/workspace-runtime/persistence/native-subagents.js

@@ -0,0 +1,162 @@
+import { operationRecordSchema } from '@playcraft/common/cloud-workspace/runtime';
+/** Native ancestry is durable platform metadata, never inferred from an arbitrary turn identifier. */
+export function nativeEventOwner(database, threadId, turnId) {
+    if (!threadId)
+        return undefined;
+    const direct = sessionsForThread(database, threadId);
+    if (direct.length) {
+        if (direct.length !== 1)
+            return undefined;
+        const session = direct[0];
+        const operation = readOperation(database, 'turn_id', turnId ?? text(session.activeTurnId), threadId);
+        if (turnId && !ownsOperation(session, threadId, operation))
+            return undefined;
+        return { session, operation: ownsOperation(session, threadId, operation) ? operation : undefined };
+    }
+    const link = readRecord(database, 'native_subagent_threads', threadId);
+    if (!link || link.operationConfirmed === false)
+        return undefined;
+    const roots = sessionsForThread(database, link.rootThreadId);
+    if (roots.length !== 1)
+        return undefined;
+    const session = roots[0];
+    if (session.sessionId !== link.sessionId || session.workspaceId !== link.workspaceId)
+        return undefined;
+    const turnKey = turnId ? JSON.stringify([threadId, turnId]) : undefined;
+    const pinned = turnKey ? readRecord(database, 'native_subagent_turns', turnKey) : undefined;
+    const pending = turnKey && !pinned ? readRecord(database, 'native_subagent_pending_followups', threadId) : undefined;
+    if (pending) {
+        const followup = readOperation(database, 'scope_key', text(pending.operationScopeKey));
+        if (followup?.operation.status === 'accepted' && followup.operation.nativeTurnId === session.activeTurnId)
+            return undefined;
+        database.prepare('DELETE FROM records WHERE bucket = ? AND record_key = ?').run('native_subagent_pending_followups', threadId);
+    }
+    const scopeKey = text(pinned?.operationScopeKey) ?? link.operationScopeKey;
+    const operation = scopeKey
+        ? readOperation(database, 'scope_key', scopeKey)
+        : readOperation(database, 'turn_id', text(session.activeTurnId), link.rootThreadId);
+    if (!ownsOperation(session, link.rootThreadId, operation))
+        return undefined;
+    if (turnKey && !pinned)
+        writeRecord(database, 'native_subagent_turns', turnKey, { operationScopeKey: operation.scopeKey });
+    const { sessionId: _, workspaceId: __, operationScopeKey: ___, operationConfirmed: ____, ...subAgent } = link;
+    return { session, operation, subAgent };
+}
+/** Only native thread ancestry or a spawn from an already owned thread can introduce a child. */
+export function learnNativeSubagents(database, method, params, threadId, turnId) {
+    const payload = record(params);
+    if (method === 'thread/started') {
+        const thread = record(payload.thread);
+        const spawn = record(record(record(thread.source).subAgent).thread_spawn);
+        const childId = text(thread.id);
+        const parentId = text(thread.parentThreadId) ?? text(spawn.parent_thread_id);
+        if (!childId || !parentId || (text(thread.parentThreadId) && text(spawn.parent_thread_id) && thread.parentThreadId !== spawn.parent_thread_id))
+            return [];
+        const owner = nativeEventOwner(database, parentId);
+        if (!owner)
+            return [];
+        const changed = remember(database, childId, parentId, owner, {
+            agentNickname: text(thread.agentNickname) ?? text(spawn.agent_nickname),
+            agentRole: text(thread.agentRole) ?? text(spawn.agent_role),
+            agentPath: text(spawn.agent_path),
+        }, false);
+        return changed ? [childId] : [];
+    }
+    if (method !== 'item/started' && method !== 'item/completed')
+        return [];
+    const item = record(payload.item);
+    if (item.type !== 'collabAgentToolCall' || item.senderThreadId !== threadId)
+        return [];
+    const owner = nativeEventOwner(database, threadId, turnId);
+    if (!owner || !owner.operation)
+        return [];
+    const receivers = Array.isArray(item.receiverThreadIds) ? item.receiverThreadIds.filter((id) => typeof id === 'string' && id.length > 0) : [];
+    const changed = [];
+    for (const childId of receivers) {
+        if (item.tool === 'spawnAgent') {
+            if (remember(database, childId, threadId, owner, {}))
+                changed.push(childId);
+        }
+        else if (['sendInput', 'resumeAgent', 'sendMessage', 'followupTask'].includes(String(item.tool))) {
+            const existing = readRecord(database, 'native_subagent_threads', childId);
+            if (!existing || existing.sessionId !== owner.session.sessionId || existing.rootThreadId !== (owner.subAgent?.rootThreadId ?? threadId))
+                continue;
+            if (method === 'item/started' && item.status === 'inProgress' && existing.operationScopeKey !== owner.operation.scopeKey) {
+                writeRecord(database, 'native_subagent_pending_followups', childId, { itemId: item.id, operationScopeKey: owner.operation.scopeKey });
+                continue;
+            }
+            if (method !== 'item/completed')
+                continue;
+            const pending = readRecord(database, 'native_subagent_pending_followups', childId);
+            if (pending?.itemId === item.id)
+                database.prepare('DELETE FROM records WHERE bucket = ? AND record_key = ?').run('native_subagent_pending_followups', childId);
+            if (item.status === 'completed' && existing.operationScopeKey !== owner.operation.scopeKey)
+                writeRecord(database, 'native_subagent_threads', childId, { ...existing, operationScopeKey: owner.operation.scopeKey });
+            if (pending?.itemId === item.id || item.status === 'completed')
+                changed.push(childId);
+        }
+    }
+    return changed;
+}
+export function nativeSubagentThreads(database, rootThreadId) {
+    const rows = database.prepare("SELECT record_key FROM records WHERE bucket = 'native_subagent_threads' AND json_extract(body_json, '$.rootThreadId') = ?")
+        .all(rootThreadId);
+    return rows.map(row => row.record_key);
+}
+export function clearPendingNativeFollowups(database) {
+    const rows = database.prepare("SELECT record_key FROM records WHERE bucket = 'native_subagent_pending_followups'")
+        .all();
+    database.prepare("DELETE FROM records WHERE bucket = 'native_subagent_pending_followups'").run();
+    return rows.map(row => row.record_key);
+}
+function remember(database, childId, parentId, owner, metadata, confirmed = true) {
+    if (childId === parentId || sessionsForThread(database, childId).length)
+        return false;
+    const rootThreadId = owner.subAgent?.rootThreadId ?? text(owner.session.threadId);
+    if (childId === rootThreadId)
+        return false;
+    const previous = readRecord(database, 'native_subagent_threads', childId);
+    if (previous && (previous.parentThreadId !== parentId || previous.rootThreadId !== rootThreadId || previous.sessionId !== owner.session.sessionId))
+        return false;
+    const defined = Object.fromEntries(Object.entries(metadata).filter(([, value]) => value !== undefined));
+    // Thread ancestry contains no parent turn. Wait for its spawn item before archiving events
+    // against an operation: a parent agent may still be running an older, pinned turn.
+    const wasConfirmed = previous && previous.operationConfirmed !== false;
+    const next = { ...previous, ...defined, threadId: childId, parentThreadId: parentId, rootThreadId,
+        sessionId: String(owner.session.sessionId), workspaceId: text(owner.session.workspaceId),
+        operationConfirmed: Boolean(wasConfirmed || confirmed),
+        operationScopeKey: wasConfirmed ? previous.operationScopeKey : confirmed ? owner.operation?.scopeKey : undefined };
+    if (JSON.stringify(previous) === JSON.stringify(next))
+        return false;
+    writeRecord(database, 'native_subagent_threads', childId, next);
+    return true;
+}
+function ownsOperation(session, rootThreadId, found) {
+    return Boolean(found && ['session.turn', 'session.review', 'session.compact'].includes(found.operation.kind) && found.operation.sessionId === session.sessionId &&
+        (found.operation.workspaceId === undefined || found.operation.workspaceId === session.workspaceId) && found.operation.nativeThreadId === rootThreadId);
+}
+function readOperation(database, column, value, threadId) {
+    if (!value)
+        return undefined;
+    const row = database.prepare(`SELECT scope_key, operation_json FROM operation_intents WHERE ${column} = ?${threadId ? ' AND thread_id = ?' : ''}${column === 'turn_id' ? " AND json_extract(operation_json, '$.kind') IN ('session.turn', 'session.review', 'session.compact')" : ''}`)
+        .get(...(threadId ? [value, threadId] : [value]));
+    if (!row)
+        return undefined;
+    const parsed = operationRecordSchema.safeParse(JSON.parse(row.operation_json));
+    return parsed.success ? { scopeKey: row.scope_key, operation: parsed.data } : undefined;
+}
+function sessionsForThread(database, threadId) {
+    const rows = database.prepare("SELECT body_json FROM records WHERE bucket = 'sessions' AND json_extract(body_json, '$.threadId') = ?")
+        .all(threadId);
+    return rows.map(row => record(JSON.parse(row.body_json)));
+}
+function readRecord(database, bucket, key) {
+    const row = database.prepare('SELECT body_json FROM records WHERE bucket = ? AND record_key = ?').get(bucket, key);
+    return row ? record(JSON.parse(row.body_json)) : undefined;
+}
+function writeRecord(database, bucket, key, value) {
+    database.prepare('INSERT INTO records (bucket, record_key, body_json) VALUES (?, ?, ?) ON CONFLICT(bucket, record_key) DO UPDATE SET body_json = excluded.body_json')
+        .run(bucket, key, JSON.stringify(value));
+}
+function text(value) { return typeof value === 'string' && value.length > 0 ? value : undefined; }
+function record(value) { return value && typeof value === 'object' && !Array.isArray(value) ? value : {}; }

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

@@ -0,0 +1,77 @@
+import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { Worker } from 'node:worker_threads';
+export class SqliteWorkerClient {
+    nextId = 1;
+    pending = new Map();
+    chain = Promise.resolve();
+    worker;
+    constructor(worker) {
+        this.worker = worker;
+        worker.on('message', (message) => {
+            const waiter = this.pending.get(message.id);
+            if (!waiter)
+                return;
+            this.pending.delete(message.id);
+            if (message.ok)
+                waiter.resolve(message.result);
+            else
+                waiter.reject(new Error(message.error || 'sqlite_worker_failed'));
+        });
+        worker.on('error', (error) => {
+            for (const waiter of this.pending.values())
+                waiter.reject(error);
+            this.pending.clear();
+        });
+    }
+    static async open(filePath, legacy) {
+        const url = workerUrl();
+        const execArgv = url.pathname.endsWith('.ts') ? ['--import', sourceResolver()] : [];
+        const client = new SqliteWorkerClient(new Worker(url, { execArgv, env: { ...process.env, NODE_OPTIONS: '' } }));
+        try {
+            const opened = await client.request('open', { filePath, legacy });
+            return { client, opened };
+        }
+        catch (error) {
+            await client.close().catch(() => undefined);
+            throw error;
+        }
+    }
+    request(type, payload) {
+        const run = this.chain.then(() => this.send(type, payload));
+        this.chain = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    async close() {
+        await this.request('close', {}).catch(() => undefined);
+        await this.worker.terminate();
+    }
+    send(type, payload) {
+        const id = this.nextId;
+        this.nextId += 1;
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve: (value) => resolve(value), reject });
+            this.worker.postMessage({ id, type, payload });
+        });
+    }
+}
+function workerUrl() {
+    const compiled = new URL('./sqlite-worker.js', import.meta.url);
+    if (existsSync(fileURLToPath(compiled)))
+        return compiled;
+    return new URL('./sqlite-worker.ts', import.meta.url);
+}
+/** Source tests use Node's type stripping, with relative emitted imports resolved to their sources. */
+function sourceResolver() {
+    return `data:text/javascript,${encodeURIComponent(`
+    import { registerHooks } from 'node:module';
+    import { existsSync } from 'node:fs';
+    registerHooks({ resolve(specifier, context, next) {
+      if (context.parentURL?.endsWith('.ts') && specifier.startsWith('./') && specifier.endsWith('.js')) {
+        const source = new URL(specifier.slice(0, -3) + '.ts', context.parentURL);
+        if (existsSync(source)) return next(source.href, context);
+      }
+      return next(specifier, context);
+    } });
+  `)}`;
+}