@atolis-hq/wake 0.1.0

package/dist/src/adapters/cursor/cursor-runner.js

@@ -0,0 +1,352 @@
+import { parseRunnerResult } from '../../domain/schema.js';
+import { buildStagePrompt } from '../runner/stage-prompt.js';
+import { runAgentCliCommand } from '../runner/cli-command.js';
+import { writeRunnerTranscript } from '../runner/transcripts.js';
+const CURSOR_CLI_NAME = 'Cursor';
+export function buildCursorAgentArgs(input) {
+    const fullPrompt = buildCursorPromptText(input);
+    return [
+        'agent',
+        '-p',
+        '--output-format',
+        'json',
+        '--model',
+        input.model,
+        '--trust',
+        ...(input.mode !== undefined ? ['--mode', input.mode] : []),
+        ...(input.force === true ? ['--force'] : []),
+        ...(input.resumeSessionId !== undefined ? [`--resume=${input.resumeSessionId}`] : []),
+        fullPrompt,
+    ];
+}
+export function buildCursorPromptText(input) {
+    return input.harnessPrompt === undefined
+        ? input.prompt
+        : `${input.harnessPrompt}\n\n${input.prompt}`;
+}
+export function buildCursorResumeArgs(input) {
+    return ['agent', '--resume=' + input.sessionId];
+}
+function compactLogValue(value) {
+    return value.replace(/\s+/g, ' ').trim();
+}
+export function formatCursorRunLogLine(input) {
+    const parts = [
+        '[cursor-run]',
+        `phase=${input.phase}`,
+        `runId=${input.runId}`,
+        `cli=Cursor`,
+        ...(input.model === undefined ? [] : [`model=${input.model}`]),
+        `repo=${input.repo}`,
+        `issueNumber=${input.issueNumber}`,
+        `action=${input.action}`,
+        `recentEventIds=${input.recentEventIds.length > 0 ? input.recentEventIds.join(',') : '(none)'}`,
+        ...(input.workspacePath === undefined
+            ? []
+            : [`workspacePath=${compactLogValue(input.workspacePath)}`]),
+        ...(input.sessionId === undefined ? [] : [`sessionId=${input.sessionId}`]),
+        ...(input.exitCode === undefined ? [] : [`exitCode=${input.exitCode}`]),
+    ];
+    return parts.join(' ');
+}
+// Verified against a live `cursor-agent agent -p --output-format json` call
+// (run through the wake-sandbox container, since the host `cursor` binary
+// here is the desktop app, not the CLI). Cursor's usage keys are camelCase
+// and different names from both Claude's and Codex's snake_case fields, e.g.:
+// {"usage":{"inputTokens":5945,"outputTokens":32,"cacheReadTokens":6020,"cacheWriteTokens":0}}
+// No cost field was present in that response, so costUsd stays unset for Cursor.
+function extractCursorTokenUsage(parsed) {
+    const usage = parsed.usage;
+    if (usage === undefined) {
+        return undefined;
+    }
+    const inputTokens = typeof usage.inputTokens === 'number' ? usage.inputTokens : undefined;
+    const outputTokens = typeof usage.outputTokens === 'number' ? usage.outputTokens : undefined;
+    if (inputTokens === undefined || outputTokens === undefined) {
+        return undefined;
+    }
+    const cacheReadInputTokens = typeof usage.cacheReadTokens === 'number' ? usage.cacheReadTokens : undefined;
+    const cacheCreationInputTokens = typeof usage.cacheWriteTokens === 'number' ? usage.cacheWriteTokens : undefined;
+    return {
+        inputTokens,
+        outputTokens,
+        ...(cacheCreationInputTokens === undefined ? {} : { cacheCreationInputTokens }),
+        ...(cacheReadInputTokens === undefined ? {} : { cacheReadInputTokens }),
+    };
+}
+export function extractCursorAgentResult(stdout) {
+    const trimmed = stdout.trim();
+    if (trimmed.length === 0) {
+        throw new Error('Cursor agent produced no output.');
+    }
+    const parsed = JSON.parse(trimmed);
+    const result = typeof parsed.result === 'string' ? parsed.result : undefined;
+    if (result === undefined) {
+        throw new Error('Cursor agent JSON output did not include a result field.');
+    }
+    const sessionId = typeof parsed.session_id === 'string' ? parsed.session_id : undefined;
+    const isError = typeof parsed.is_error === 'boolean' ? parsed.is_error : undefined;
+    const tokenUsage = extractCursorTokenUsage(parsed);
+    return {
+        result,
+        ...(sessionId !== undefined ? { sessionId } : {}),
+        ...(isError !== undefined ? { isError } : {}),
+        ...(tokenUsage !== undefined ? { tokenUsage } : {}),
+    };
+}
+export function classifyCursorCliFailure(input) {
+    if (input.timedOut) {
+        return 'infra';
+    }
+    // Cursor JSON output signals a handled task-level error
+    if (input.isError === true) {
+        return 'task';
+    }
+    const text = `${input.stderr}\n${input.stdout}`.toLowerCase();
+    if (text.includes('rate limit') ||
+        text.includes('quota') ||
+        text.includes('billing') ||
+        text.includes('unauthorized') ||
+        text.includes('authentication') ||
+        text.includes('api key') ||
+        text.includes('too many requests')) {
+        return 'quota';
+    }
+    return 'infra';
+}
+// Cursor uses --mode ask for read-only stages, which already enforces
+// the constraint at the CLI boundary. The capability note explains to the agent
+// what tools are available in ask mode versus the default agent mode.
+export function buildCursorToolCapabilityNote(input) {
+    if (input.workspaceMode !== 'read-only') {
+        return undefined;
+    }
+    const note = 'You are running in read-only ask mode. You can read and explore the repository but cannot modify files. ' +
+        'Use your available file-reading and search tools to understand the codebase.';
+    return input.mode === 'resume' ? `Reminder: this is still a planning-only stage. ${note}` : note;
+}
+function resolveCursorMode(input) {
+    return input.workspaceMode === 'read-only' ? 'ask' : undefined;
+}
+function resolveModel(input) {
+    const { models, model } = input.settings;
+    const actionSpecificModel = models[input.action];
+    if (actionSpecificModel !== undefined) {
+        return actionSpecificModel;
+    }
+    if (models.default !== undefined) {
+        return models.default;
+    }
+    return model;
+}
+function readSandboxLogBreadcrumb() {
+    const containerName = process.env.WAKE_SANDBOX_CONTAINER_NAME;
+    if (containerName === undefined || containerName.length === 0) {
+        return null;
+    }
+    return {
+        text: `Sandbox logs: docker logs --tail 200 ${containerName}`,
+        metadata: {
+            sandboxContainerName: containerName,
+        },
+    };
+}
+export function createCursorRunner(options) {
+    return {
+        async run(input) {
+            const priorSessionId = input.projection.wake.sessionId;
+            const priorSessionCli = input.projection.wake.sessionCli;
+            const isResume = priorSessionId !== undefined && priorSessionCli === CURSOR_CLI_NAME;
+            const cursorMode = resolveCursorMode({
+                ...(input.workspaceMode === undefined ? {} : { workspaceMode: input.workspaceMode }),
+            });
+            const toolCapabilityNote = buildCursorToolCapabilityNote({
+                ...(input.workspaceMode === undefined ? {} : { workspaceMode: input.workspaceMode }),
+                mode: isResume ? 'resume' : 'start',
+            });
+            const stagePrompt = await buildStagePrompt({
+                action: input.action,
+                projection: input.projection,
+                mode: isResume ? 'resume' : 'start',
+                config: input.config,
+                ...(input.workspaceMode === undefined ? {} : { workspaceMode: input.workspaceMode }),
+                ...(input.mergeConflictDetected === true ? { mergeConflictDetected: true } : {}),
+                ...(input.upstreamChanges === undefined ? {} : { upstreamChanges: input.upstreamChanges }),
+                ...(toolCapabilityNote !== undefined ? { contextOverrides: { toolCapabilityNote } } : {}),
+            });
+            const model = resolveModel({ action: input.action, settings: options.settings });
+            const cwd = input.workspacePath ?? options.cwd;
+            const promptText = buildCursorPromptText({
+                prompt: stagePrompt.prompt,
+                harnessPrompt: stagePrompt.harnessPrompt,
+            });
+            const promptTranscriptPath = await writeRunnerTranscript({
+                config: input.config,
+                projection: input.projection,
+                runId: input.runId,
+                action: input.action,
+                cli: CURSOR_CLI_NAME,
+                kind: 'prompt',
+                text: promptText,
+            });
+            console.log(formatCursorRunLogLine({
+                phase: 'start',
+                runId: input.runId,
+                action: input.action,
+                issueNumber: input.projection.issue.number,
+                repo: input.projection.issue.repo,
+                recentEventIds: input.recentEvents.map((event) => event.eventId),
+                model,
+                ...(input.workspacePath === undefined ? {} : { workspacePath: input.workspacePath }),
+                ...(isResume ? { sessionId: priorSessionId } : {}),
+            }));
+            const result = await runAgentCliCommand({
+                command: options.command,
+                args: buildCursorAgentArgs({
+                    model,
+                    prompt: promptText,
+                    ...(cursorMode !== undefined ? { mode: cursorMode } : {}),
+                    force: cursorMode === undefined,
+                    ...(isResume ? { resumeSessionId: priorSessionId } : {}),
+                }),
+                cwd,
+                timeoutMs: options.settings.timeoutMs,
+            });
+            const responseTranscriptPath = await writeRunnerTranscript({
+                config: input.config,
+                projection: input.projection,
+                runId: input.runId,
+                action: input.action,
+                cli: CURSOR_CLI_NAME,
+                kind: 'response',
+                text: result.stdout,
+            });
+            if (result.exitCode !== 0 || result.timedOut || result.stdout.trim().length === 0) {
+                const sandboxLog = readSandboxLogBreadcrumb();
+                const failureClass = classifyCursorCliFailure({
+                    stdout: result.stdout,
+                    stderr: result.stderr,
+                    timedOut: result.timedOut,
+                });
+                console.error(formatCursorRunLogLine({
+                    phase: 'failure',
+                    runId: input.runId,
+                    action: input.action,
+                    issueNumber: input.projection.issue.number,
+                    repo: input.projection.issue.repo,
+                    recentEventIds: input.recentEvents.map((event) => event.eventId),
+                    model,
+                    ...(input.workspacePath === undefined ? {} : { workspacePath: input.workspacePath }),
+                    exitCode: result.exitCode,
+                }));
+                return {
+                    result: [
+                        result.timedOut
+                            ? `Cursor runner timed out after ${options.settings.timeoutMs}ms and was killed`
+                            : result.stdout.trim().length === 0
+                                ? 'Cursor runner produced no output'
+                                : 'Cursor runner failed',
+                        result.stderr,
+                        sandboxLog?.text,
+                        'FAILED',
+                    ]
+                        .filter((part) => part !== undefined && part.length > 0)
+                        .join('\n'),
+                    model,
+                    cli: CURSOR_CLI_NAME,
+                    failureClass,
+                    metadata: {
+                        stdout: result.stdout,
+                        stderr: result.stderr,
+                        exitCode: result.exitCode,
+                        failureClass,
+                        ...(promptTranscriptPath === undefined ? {} : { promptTranscriptPath }),
+                        ...(responseTranscriptPath === undefined ? {} : { responseTranscriptPath }),
+                        ...(sandboxLog?.metadata ?? {}),
+                    },
+                };
+            }
+            let parsed;
+            try {
+                parsed = extractCursorAgentResult(result.stdout);
+            }
+            catch (err) {
+                const sandboxLog = readSandboxLogBreadcrumb();
+                return {
+                    result: [`Cursor runner output could not be parsed: ${String(err)}`, 'FAILED']
+                        .filter((part) => part.length > 0)
+                        .join('\n'),
+                    model,
+                    cli: CURSOR_CLI_NAME,
+                    failureClass: 'infra',
+                    metadata: {
+                        stdout: result.stdout,
+                        stderr: result.stderr,
+                        parseError: String(err),
+                        ...(promptTranscriptPath === undefined ? {} : { promptTranscriptPath }),
+                        ...(responseTranscriptPath === undefined ? {} : { responseTranscriptPath }),
+                        ...(sandboxLog?.metadata ?? {}),
+                    },
+                };
+            }
+            const sandboxLog = readSandboxLogBreadcrumb();
+            console.log(formatCursorRunLogLine({
+                phase: 'success',
+                runId: input.runId,
+                action: input.action,
+                issueNumber: input.projection.issue.number,
+                repo: input.projection.issue.repo,
+                recentEventIds: input.recentEvents.map((event) => event.eventId),
+                model,
+                ...(input.workspacePath === undefined ? {} : { workspacePath: input.workspacePath }),
+                ...(parsed.sessionId === undefined ? {} : { sessionId: parsed.sessionId }),
+            }));
+            return {
+                result: parsed.result,
+                model,
+                cli: CURSOR_CLI_NAME,
+                ...(parseRunnerResult(parsed.result).status === 'FAILED'
+                    ? { failureClass: 'task' }
+                    : {}),
+                ...(parsed.sessionId === undefined ? {} : { session_id: parsed.sessionId }),
+                ...(parsed.tokenUsage === undefined ? {} : { tokenUsage: parsed.tokenUsage }),
+                metadata: {
+                    stdout: result.stdout,
+                    stderr: result.stderr,
+                    raw: parsed,
+                    skipApproval: stagePrompt.skipApproval,
+                    ...(promptTranscriptPath === undefined ? {} : { promptTranscriptPath }),
+                    ...(responseTranscriptPath === undefined ? {} : { responseTranscriptPath }),
+                    ...(sandboxLog?.metadata ?? {}),
+                },
+            };
+        },
+        async smoke() {
+            const result = await runAgentCliCommand({
+                command: options.command,
+                args: buildCursorAgentArgs({
+                    model: options.settings.smokeModel,
+                    prompt: options.settings.smokePrompt,
+                    force: true,
+                }),
+                cwd: options.cwd,
+            });
+            let parsed;
+            if (result.exitCode === 0 && result.stdout.trim().length > 0) {
+                try {
+                    parsed = extractCursorAgentResult(result.stdout);
+                }
+                catch {
+                    parsed = undefined;
+                }
+            }
+            return {
+                text: parsed?.result ?? '',
+                ...(parsed?.sessionId === undefined ? {} : { sessionId: parsed.sessionId }),
+                stdout: result.stdout,
+                stderr: result.stderr,
+                exitCode: result.exitCode,
+            };
+        },
+    };
+}

package/dist/src/adapters/docker/docker-cli.js

@@ -0,0 +1,97 @@
+function buildStopArgs(containerName, timeoutSeconds) {
+    return [
+        'stop',
+        ...(timeoutSeconds !== undefined ? ['--time', String(timeoutSeconds)] : []),
+        containerName,
+    ];
+}
+function buildRunArgs(input) {
+    return [
+        'run',
+        '-d',
+        '--name',
+        input.containerName,
+        '-v',
+        `${input.wakeRoot}:${input.containerMountPath}`,
+        '-v',
+        `${input.containerHomeRoot}:${input.containerHomeMountPath}`,
+        ...(input.extraMounts ?? []).flatMap((mount) => [
+            '-v',
+            `${mount.source}:${mount.target}${mount.readOnly === true ? ':ro' : ''}`,
+        ]),
+        // Auto-started by docker/entrypoint.sh; the UI binds 0.0.0.0 inside the
+        // container so this published port can reach it (127.0.0.1 inside the
+        // container would not be reachable via docker's port-forwarding NAT).
+        ...(input.ui?.enabled === true
+            ? [
+                '-p',
+                `127.0.0.1:${input.ui.port}:${input.ui.port}`,
+                '-e',
+                'WAKE_UI_ENABLED=true',
+                '-e',
+                `WAKE_UI_PORT=${input.ui.port}`,
+                ...(input.ui.token !== undefined ? ['-e', `WAKE_UI_TOKEN=${input.ui.token}`] : []),
+                ...(input.ui.tunnel?.enabled === true
+                    ? [
+                        '-e',
+                        'WAKE_UI_TUNNEL_ENABLED=true',
+                        '-e',
+                        input.ui.tunnel.authToken !== undefined
+                            ? `NGROK_AUTHTOKEN=${input.ui.tunnel.authToken}`
+                            : 'NGROK_AUTHTOKEN',
+                    ]
+                    : []),
+            ]
+            : []),
+        ...(input.start?.enabled === true ? ['-e', 'WAKE_START_ENABLED=true'] : []),
+        input.image,
+    ];
+}
+export function createDockerCli(deps) {
+    return {
+        async build(input) {
+            await deps.run(['build', '-t', input.image, '-f', input.dockerfile, input.contextDir]);
+        },
+        async up(input) {
+            const imageExists = await deps.inspectImage(input.image);
+            if (!imageExists) {
+                throw new Error('Sandbox image not found. Run `wake sandbox build` first.');
+            }
+            const containerState = await deps.inspectContainer(input.containerName);
+            if (containerState === 'running') {
+                return;
+            }
+            if (containerState === 'stopped') {
+                await deps.run(['start', input.containerName]);
+                return;
+            }
+            await deps.run(buildRunArgs(input));
+        },
+        async update(input) {
+            const imageExists = await deps.inspectImage(input.image);
+            if (!imageExists) {
+                throw new Error('Sandbox image not found. Run `wake sandbox build` first.');
+            }
+            const containerState = await deps.inspectContainer(input.containerName);
+            if (containerState === 'running' || containerState === 'stopped') {
+                if (containerState === 'running') {
+                    await deps.run(buildStopArgs(input.containerName, input.stopTimeoutSeconds));
+                }
+                await deps.run(['rm', input.containerName]);
+            }
+            await deps.run(buildRunArgs(input));
+        },
+        async down(containerName, options) {
+            await deps.run(buildStopArgs(containerName, options?.timeoutSeconds));
+        },
+        async exec(containerName, command, options) {
+            const interactive = options?.interactive ?? false;
+            await deps.run(command.length > 0
+                ? ['exec', interactive ? '-it' : '-i', containerName, ...command]
+                : ['exec', '-it', containerName, 'bash']);
+        },
+        async logs(containerName, tailLines) {
+            await deps.run(['logs', '--tail', String(tailLines), containerName]);
+        },
+    };
+}

package/dist/src/adapters/fake/fake-artifact-verifier.js

@@ -0,0 +1,14 @@
+/**
+ * Permanent test harness. `verifies` is the allowlist of URLs this fake
+ * treats as legitimate, mapped to the resourceUri they resolve to — anything
+ * not listed fails verification, exercising the "malformed claim" path.
+ */
+export function createFakeArtifactVerifier(options) {
+    const byUrl = new Map(options.verifies.map((entry) => [entry.url, entry.resourceUri]));
+    return {
+        async verify(artifact) {
+            const resourceUri = byUrl.get(artifact.url);
+            return resourceUri === undefined ? null : { resourceUri };
+        },
+    };
+}

package/dist/src/adapters/fake/fake-github-pull-request-activity-source.js

@@ -0,0 +1,73 @@
+import { createEventEnvelope, createUnkeyedEventEnvelope } from '../../lib/event-log.js';
+/** Permanent test harness — zero-token equivalent of the real GitHub PR activity source. */
+export function createFakeGitHubPullRequestActivitySource(options) {
+    const now = options.now ?? (() => new Date());
+    return {
+        async pollEvents(input) {
+            const nowIso = now().toISOString();
+            const watched = new Set((input?.watch ?? []).map((ref) => ref.resourceUri));
+            const events = [];
+            for (const pr of options.prs) {
+                const resourceUri = `github:pr:${pr.repo}#${pr.number}`;
+                if (!watched.has(resourceUri)) {
+                    events.push(createUnkeyedEventEnvelope({
+                        eventId: `fake-pr-seen-${pr.repo}-${pr.number}`,
+                        streamScope: 'global-intake',
+                        direction: 'inbound',
+                        sourceSystem: 'fake-github-pr',
+                        sourceEventType: 'pr.seen',
+                        sourceRefs: { repo: pr.repo, resourceUri },
+                        occurredAt: nowIso,
+                        ingestedAt: nowIso,
+                        trigger: 'context-only',
+                        payload: { pr: { number: pr.number, author: pr.author, headRef: pr.headRef } },
+                    }));
+                    continue;
+                }
+                for (const comment of pr.comments) {
+                    events.push(createUnkeyedEventEnvelope({
+                        eventId: `fake-pr-comment-${pr.repo}-${pr.number}-${comment.id}`,
+                        streamScope: 'work-item',
+                        direction: 'inbound',
+                        sourceSystem: 'fake-github-pr',
+                        sourceEventType: 'pr.comment.created',
+                        sourceRefs: { repo: pr.repo, commentId: comment.id, resourceUri },
+                        occurredAt: nowIso,
+                        ingestedAt: nowIso,
+                        trigger: 'context-only',
+                        payload: {
+                            comment: {
+                                id: comment.id,
+                                body: comment.body,
+                                author: { login: comment.author },
+                                createdAt: nowIso,
+                                updatedAt: nowIso,
+                                resourceUri,
+                            },
+                        },
+                        derivedHints: { botAuthoredComment: false },
+                    }));
+                }
+            }
+            return events;
+        },
+        async deliverIntent(input) {
+            const publishedAt = now().toISOString();
+            return [
+                createEventEnvelope({
+                    eventId: `${input.event.eventId}-published`,
+                    workItemKey: input.event.workItemKey,
+                    streamScope: 'work-item',
+                    direction: 'outbound',
+                    sourceSystem: 'fake-github-pr',
+                    sourceEventType: 'pr.comment.reply.published',
+                    sourceRefs: { ...input.event.sourceRefs, sink: 'fake-github-pr' },
+                    occurredAt: publishedAt,
+                    ingestedAt: publishedAt,
+                    trigger: 'context-only',
+                    payload: { intentEventId: input.event.eventId, kind: input.event.payload.kind, body: input.event.payload.body },
+                }),
+            ];
+        },
+    };
+}

package/dist/src/adapters/fake/fake-resource-index.js

@@ -0,0 +1,21 @@
+/**
+ * In-memory ResourceIndex test fake. Permanent test harness (per repo
+ * convention: fakes are passed on purpose, never a default that materializes
+ * when a caller forgets to wire one in), not a fallback baked into core/.
+ * Production always uses the disk-backed `createResourceIndex` from
+ * `src/adapters/fs/resource-index.ts`.
+ */
+export function createFakeResourceIndex() {
+    const entries = new Map();
+    return {
+        async resolve(resourceUri) {
+            return entries.get(resourceUri);
+        },
+        async register(resourceUri, workItemKey) {
+            entries.set(resourceUri, workItemKey);
+        },
+        async retract(resourceUri) {
+            entries.delete(resourceUri);
+        },
+    };
+}

package/dist/src/adapters/fake/fake-runner.js

@@ -0,0 +1,22 @@
+export function createFakeRunner(result, options) {
+    return {
+        async run(_) {
+            return result ?? {
+                result: [
+                    'Fake runner completed',
+                    '',
+                    '```wake-result',
+                    '{ "status": "DONE" }',
+                    '```',
+                    'DONE',
+                ].join('\n'),
+                model: 'fake',
+                cli: options?.cli ?? 'Fake',
+                session_id: 'fake-session-1',
+                metadata: {
+                    source: 'fake-runner',
+                },
+            };
+        },
+    };
+}