@playcraft/cli 0.1.53-beta → 0.1.54

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

@@ -1,162 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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);
-    } });
-  `)}`;
-}