@exaudeus/workrail 3.73.2 → 3.74.1

package/dist/cli-worktrain.js

@@ -965,7 +965,7 @@ runCommand
         joinPath: path_1.default.join,
     }, options.port);
     const deps = {
-        spawnSession: async (workflowId, goal, workspace, context) => {
+        spawnSession: async (workflowId, goal, workspace, context, _agentConfig, parentSessionId) => {
             const url = `http://127.0.0.1:${port}/api/v2/auto/dispatch`;
             try {
                 const response = await globalThis.fetch(url, {
@@ -976,6 +976,7 @@ runCommand
                         goal,
                         workspacePath: workspace,
                         ...(context !== undefined ? { context } : {}),
+                        ...(parentSessionId !== undefined ? { parentSessionId } : {}),
                     }),
                     signal: AbortSignal.timeout(30000),
                 });
@@ -1147,6 +1148,130 @@ runCommand
                 return emptyResult;
             }
         },
+        getChildSessionResult: async (handle, _coordinatorSessionId) => {
+            const sessionUrl = `http://127.0.0.1:${port}/api/v2/sessions/${encodeURIComponent(handle)}`;
+            try {
+                const sessionRes = await globalThis.fetch(sessionUrl, { signal: AbortSignal.timeout(30000) });
+                if (!sessionRes.ok) {
+                    return { kind: 'failed', reason: 'error', message: `Session fetch HTTP ${sessionRes.status}` };
+                }
+                const sessionBody = await sessionRes.json();
+                const data = sessionBody['data'];
+                const runs = (data?.['runs'] ?? sessionBody['runs']);
+                const runStatus = runs?.[0]?.['status'];
+                if (runStatus === 'complete' || runStatus === 'complete_with_gaps') {
+                    const agentResult = await (async () => {
+                        const empty = { recapMarkdown: null, artifacts: [] };
+                        try {
+                            const tipNodeId = runs?.[0]?.['preferredTipNodeId'] ?? null;
+                            if (!tipNodeId)
+                                return empty;
+                            const allNodes = runs?.[0]?.['nodes'] ?? [];
+                            const allNodeIds = allNodes
+                                .map((n) => n['nodeId'])
+                                .filter((id) => typeof id === 'string' && id !== '');
+                            const nodeIdsToFetch = allNodeIds.length > 0 ? allNodeIds : [tipNodeId];
+                            let recap = null;
+                            const collectedArtifacts = [];
+                            for (const nodeId of nodeIdsToFetch) {
+                                try {
+                                    const nodeUrl = `http://127.0.0.1:${port}/api/v2/sessions/${encodeURIComponent(handle)}/nodes/${encodeURIComponent(nodeId)}`;
+                                    const nodeRes = await globalThis.fetch(nodeUrl, { signal: AbortSignal.timeout(30000) });
+                                    if (!nodeRes.ok)
+                                        continue;
+                                    const nodeBody = await nodeRes.json();
+                                    const nodeData = nodeBody['data'];
+                                    if (nodeId === tipNodeId)
+                                        recap = nodeData?.['recapMarkdown'] ?? null;
+                                    const artifacts = nodeData?.['artifacts'] ?? [];
+                                    if (artifacts.length > 0)
+                                        collectedArtifacts.push(...artifacts);
+                                }
+                                catch {
+                                    continue;
+                                }
+                            }
+                            return { recapMarkdown: recap, artifacts: collectedArtifacts };
+                        }
+                        catch {
+                            return empty;
+                        }
+                    })();
+                    return { kind: 'success', notes: agentResult.recapMarkdown, artifacts: agentResult.artifacts };
+                }
+                if (runStatus === 'blocked') {
+                    return { kind: 'failed', reason: 'stuck', message: `Child session ${handle.slice(0, 16)} reached blocked state` };
+                }
+                if (runStatus === null || runStatus === undefined) {
+                    return { kind: 'timed_out', message: `Child session ${handle.slice(0, 16)} has no terminal run status` };
+                }
+                return { kind: 'timed_out', message: `Child session ${handle.slice(0, 16)} is in state '${runStatus}'` };
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                return { kind: 'failed', reason: 'error', message: `Exception in getChildSessionResult: ${msg}` };
+            }
+        },
+        spawnAndAwait: async (workflowId, goal, workspace, opts) => {
+            const spawnUrl = `http://127.0.0.1:${port}/api/v2/auto/dispatch`;
+            let handle;
+            try {
+                const response = await globalThis.fetch(spawnUrl, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        workflowId,
+                        goal,
+                        workspacePath: workspace,
+                        ...(opts?.coordinatorSessionId !== undefined ? { parentSessionId: opts.coordinatorSessionId } : {}),
+                    }),
+                    signal: AbortSignal.timeout(30000),
+                });
+                const body = await response.json();
+                if (!response.ok) {
+                    const errMsg = typeof body['error'] === 'string' ? body['error'] : `HTTP ${response.status}`;
+                    return { kind: 'failed', reason: 'error', message: `Spawn HTTP error: ${errMsg}` };
+                }
+                const sessionId = body['data']?.['sessionId']
+                    ?? body['sessionId'];
+                if (!sessionId) {
+                    return { kind: 'failed', reason: 'error', message: 'Spawn response missing sessionId' };
+                }
+                handle = sessionId;
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                return { kind: 'failed', reason: 'error', message: `Exception spawning session: ${msg}` };
+            }
+            const DEFAULT_TIMEOUT_MS = 15 * 60 * 1000;
+            const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+            const POLL_INTERVAL_MS = 5000;
+            const deadline = Date.now() + timeoutMs;
+            let timedOut = false;
+            while (Date.now() < deadline) {
+                try {
+                    const sessionUrl = `http://127.0.0.1:${port}/api/v2/sessions/${encodeURIComponent(handle)}`;
+                    const sessionRes = await globalThis.fetch(sessionUrl, { signal: AbortSignal.timeout(10000) });
+                    if (sessionRes.ok) {
+                        const body = await sessionRes.json();
+                        const data = body['data'];
+                        const runs = (data?.['runs'] ?? body['runs']);
+                        const status = runs?.[0]?.['status'];
+                        if (status === 'complete' || status === 'complete_with_gaps' || status === 'blocked') {
+                            break;
+                        }
+                    }
+                }
+                catch { }
+                await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
+            }
+            if (Date.now() >= deadline)
+                timedOut = true;
+            if (timedOut) {
+                return { kind: 'timed_out', message: `Session ${handle.slice(0, 16)} timed out after ${timeoutMs}ms` };
+            }
+            return deps.getChildSessionResult(handle, opts?.coordinatorSessionId);
+        },
         listOpenPRs: async (workspace) => {
             try {
                 const { stdout } = await execFilePromise('gh', ['pr', 'list', '--json', 'number,title,headRefName'], {