@atolis-hq/wake 0.2.97 → 0.3.0

package/dist/src/execution/infrastructure/process-execution.js

@@ -0,0 +1,29 @@
+import { spawn } from 'node:child_process';
+export function runProcess(command, args, cwd, signal, timeoutMs) {
+    const child = spawn(command, args, { cwd, shell: false, stdio: ['ignore', 'pipe', 'pipe'] });
+    const result = new Promise((resolve, reject) => {
+        let stdout = '';
+        let stderr = '';
+        let timedOut = false;
+        const timeout = timeoutMs === undefined
+            ? undefined
+            : setTimeout(() => {
+                timedOut = true;
+                child.kill();
+            }, timeoutMs);
+        child.stdout.on('data', (chunk) => (stdout += chunk.toString()));
+        child.stderr.on('data', (chunk) => (stderr += chunk.toString()));
+        child.once('error', (error) => {
+            if (timeout !== undefined)
+                clearTimeout(timeout);
+            reject(error);
+        });
+        child.once('close', (exitCode) => {
+            if (timeout !== undefined)
+                clearTimeout(timeout);
+            resolve({ stdout, stderr, exitCode, timedOut });
+        });
+    });
+    signal.addEventListener('abort', () => child.kill(), { once: true });
+    return { result, cancel: async () => void child.kill() };
+}

package/dist/src/execution/infrastructure/prompt-templates.js

@@ -0,0 +1,42 @@
+import Handlebars from 'handlebars';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import YAML from 'yaml';
+import { z } from 'zod';
+const frontmatterSchema = z
+    .object({
+    model: z.string().trim().min(1).nullable().optional(),
+    maxTurns: z.number().int().positive().optional(),
+    allowedTools: z.array(z.string().trim().min(1)).nullable().optional(),
+    extraArgs: z.array(z.string()).nullable().optional(),
+})
+    .strict();
+export function renderPromptTemplate(template, context) {
+    return Handlebars.compile(template.body, { noEscape: true, strict: true })(context);
+}
+export async function loadPromptTemplate(wakeRoot, name) {
+    if (!/^[a-z0-9][a-z0-9-]*$/i.test(name))
+        throw new Error(`Invalid prompt template name: ${name}`);
+    const path = join(wakeRoot, 'prompts', `${name}.md`);
+    const source = await readFile(path, 'utf8');
+    const match = /^---\r?\n([\s\S]*?)---\r?\n?([\s\S]*)$/u.exec(source);
+    if (match === null)
+        throw new Error(`Prompt template ${path} must start with YAML frontmatter`);
+    const [, frontmatterSource, body] = match;
+    let parsed;
+    try {
+        parsed = YAML.parse(frontmatterSource);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown YAML parsing failure';
+        throw new Error(`Prompt template ${path} frontmatter is invalid: ${message}`, { cause: error });
+    }
+    const validated = frontmatterSchema.safeParse(parsed ?? {});
+    if (!validated.success) {
+        const details = validated.error.issues
+            .map((issue) => `${issue.path.join('.')}: ${issue.message}`)
+            .join('; ');
+        throw new Error(`Prompt template ${path} frontmatter is invalid: ${details}`);
+    }
+    return { name, body: body.trim(), frontmatter: validated.data };
+}

package/dist/src/execution/infrastructure/runners/claude.js

@@ -0,0 +1,120 @@
+import { ExternalExecutionKind } from '../../../activities/index.js';
+import { ExecutionCancellationReason, RunStatus } from '../../contracts/vocabulary.js';
+import { runProcess } from '../process-execution.js';
+export function createClaudeRunner(options = {}) {
+    return cliRunner('claude', options.command ?? 'claude', (request) => claudeCommandArgs(request, options.args, options), {
+        ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
+        ...(options.model === undefined ? {} : { defaultModel: options.model }),
+        parseSuccessfulOutput: parseClaudeOutput,
+    });
+}
+export function parseClaudeOutput(stdout, _request) {
+    const value = parseRecord(stdout);
+    if (value === undefined || typeof value.result !== 'string')
+        return {};
+    return {
+        output: value.result,
+        ...(typeof value.session_id === 'string' ? { sessionId: value.session_id } : {}),
+        ...claudeUsage(value),
+    };
+}
+function claudeUsage(value) {
+    const usage = record(value.usage);
+    const input = usage === undefined ? undefined : numeric(usage.input_tokens);
+    const output = usage === undefined ? undefined : numeric(usage.output_tokens);
+    if (usage === undefined || input === undefined || output === undefined)
+        return {};
+    const cacheRead = numeric(usage.cache_read_input_tokens);
+    const cacheWrite = numeric(usage.cache_creation_input_tokens);
+    const costUsd = numeric(value.total_cost_usd);
+    return {
+        tokenUsage: {
+            input,
+            output,
+            ...(cacheRead === undefined ? {} : { cacheRead }),
+            ...(cacheWrite === undefined ? {} : { cacheWrite }),
+            ...(costUsd === undefined ? {} : { costUsd }),
+        },
+    };
+}
+function parseRecord(stdout) {
+    try {
+        return record(JSON.parse(stdout));
+    }
+    catch {
+        return undefined;
+    }
+}
+function record(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function numeric(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+export function claudeCommandArgs(request, passthroughArgs = [], defaults = {}) {
+    const model = request.model ?? defaults.model;
+    const effort = request.effort ?? defaults.effort;
+    return [
+        '-p',
+        '--output-format',
+        'json',
+        ...(request.resumeSessionId === undefined ? [] : ['--resume', request.resumeSessionId]),
+        ...(model === undefined ? [] : ['--model', model]),
+        ...(effort === undefined ? [] : ['--effort', effort]),
+        ...(request.maxTurns === undefined ? [] : ['--max-turns', String(request.maxTurns)]),
+        ...(request.allowedTools.length === 0
+            ? []
+            : ['--allowedTools', request.allowedTools.join(' ')]),
+        ...passthroughArgs,
+        '--',
+        request.prompt,
+    ];
+}
+export function cliRunner(name, command, args, options = {}) {
+    return {
+        async start(request, signal) {
+            const process = runProcess(command, args(request), request.workspacePath, signal, options.timeoutMs);
+            return {
+                identity: {
+                    kind: ExternalExecutionKind.Process,
+                    id: request.runId,
+                    startedAt: new Date().toISOString(),
+                },
+                result: process.result.then((value) => value.exitCode === 0 && !value.timedOut
+                    ? {
+                        transport: RunStatus.Succeeded,
+                        output: value.stdout,
+                        runner: name,
+                        ...((request.model ?? options.defaultModel) === undefined
+                            ? {}
+                            : { model: request.model ?? options.defaultModel }),
+                        ...parseSuccessfulOutput(value.stdout, request, options.parseSuccessfulOutput),
+                    }
+                    : {
+                        transport: RunStatus.Failed,
+                        output: value.stdout,
+                        runner: name,
+                        failure: {
+                            kind: value.timedOut ? ExecutionCancellationReason.Timeout : 'process-exit',
+                            message: value.timedOut
+                                ? `Runner timed out after ${options.timeoutMs}ms`
+                                : value.stderr || `exit ${value.exitCode}`,
+                        },
+                    }),
+                cancel: process.cancel,
+            };
+        },
+    };
+}
+function parseSuccessfulOutput(stdout, request, parser) {
+    if (parser === undefined)
+        return {};
+    try {
+        return parser(stdout, request);
+    }
+    catch {
+        return {};
+    }
+}

package/dist/src/execution/infrastructure/runners/codex.js

@@ -0,0 +1,143 @@
+import { WorkspaceMode } from '../../contracts/vocabulary.js';
+import { cliRunner } from './claude.js';
+export function createCodexRunner(options = {}) {
+    return cliRunner('codex', options.command ?? 'codex', (request) => codexCommandArgs(request, options.args, options), {
+        ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
+        ...(options.model === undefined ? {} : { defaultModel: options.model }),
+        parseSuccessfulOutput: parseCodexOutput,
+    });
+}
+export function codexCommandArgs(request, passthroughArgs = [], defaults = {}) {
+    const model = request.model ?? defaults.model;
+    return [
+        'exec',
+        '--json',
+        '--skip-git-repo-check',
+        ...(request.workspaceMode === undefined
+            ? []
+            : ['--sandbox', codexSandboxMode(request.workspaceMode)]),
+        ...(request.workspacePath === undefined ? [] : ['--cd', request.workspacePath]),
+        ...(model === undefined ? [] : ['--model', model]),
+        ...((request.effort ?? defaults.effort) === undefined
+            ? []
+            : ['-c', `model_reasoning_effort=${request.effort ?? defaults.effort}`]),
+        ...(request.resumeSessionId === undefined ? [] : ['resume', request.resumeSessionId]),
+        ...passthroughArgs,
+        request.prompt,
+    ];
+}
+function codexSandboxMode(workspaceMode) {
+    return workspaceMode === WorkspaceMode.Branch ? 'danger-full-access' : 'workspace-write';
+}
+export function parseCodexOutput(stdout, request) {
+    let state = {};
+    for (const line of stdout.split(/\r?\n/)) {
+        state = consumeCodexEvent(state, parseLine(line));
+    }
+    return codexResult(state, request?.usageBaseline);
+}
+function parseLine(line) {
+    try {
+        return asRecord(JSON.parse(line));
+    }
+    catch {
+        return undefined;
+    }
+}
+function consumeCodexEvent(state, event) {
+    if (event === undefined)
+        return state;
+    const sessionId = sessionIdFor(event) ?? state.sessionId;
+    const output = messageFor(event) ?? state.output;
+    const usage = usageFor(event);
+    return {
+        ...state,
+        ...(sessionId === undefined ? {} : { sessionId }),
+        ...(output === undefined ? {} : { output }),
+        ...(usage === undefined ? {} : { usage }),
+    };
+}
+function sessionIdFor(event) {
+    return event.type === 'thread.started' && typeof event.thread_id === 'string'
+        ? event.thread_id
+        : undefined;
+}
+function messageFor(event) {
+    const item = event.type === 'item.completed' ? asRecord(event.item) : undefined;
+    return item?.type === 'agent_message' && typeof item.text === 'string' ? item.text : undefined;
+}
+function usageFor(event) {
+    const usage = event.type === 'turn.completed' ? asRecord(event.usage) : undefined;
+    const input = usage === undefined ? undefined : numeric(usage.input_tokens);
+    const output = usage === undefined ? undefined : numeric(usage.output_tokens);
+    if (usage === undefined || input === undefined || output === undefined)
+        return undefined;
+    const cacheRead = numeric(asRecord(usage.input_tokens_details)?.cached_tokens);
+    const cacheWrite = numeric(asRecord(usage.input_tokens_details)?.cache_creation_tokens);
+    return {
+        input,
+        output,
+        ...(cacheRead === undefined ? {} : { cacheRead }),
+        ...(cacheWrite === undefined ? {} : { cacheWrite }),
+    };
+}
+function codexResult(state, baseline) {
+    const tokenUsage = codexTokenUsage(state.usage, baseline);
+    return {
+        ...(state.output === undefined ? {} : { output: state.output }),
+        ...(state.sessionId === undefined ? {} : { sessionId: state.sessionId }),
+        ...(tokenUsage === undefined ? {} : { tokenUsage }),
+    };
+}
+function codexTokenUsage(usage, baseline) {
+    if (usage === undefined)
+        return undefined;
+    if (baseline === undefined)
+        return nonNegativeUsage(usage);
+    if (!nonNegativeUsage(baseline))
+        return undefined;
+    const input = subtract(usage.input, baseline.input);
+    const output = subtract(usage.output, baseline.output);
+    const cacheRead = cacheDelta(usage.cacheRead, baseline.cacheRead);
+    const cacheWrite = cacheDelta(usage.cacheWrite, baseline.cacheWrite);
+    if (!isRequiredDelta(input) ||
+        !isRequiredDelta(output) ||
+        !isOptionalDelta(cacheRead) ||
+        !isOptionalDelta(cacheWrite)) {
+        return undefined;
+    }
+    return {
+        input,
+        output,
+        ...(cacheRead === undefined ? {} : { cacheRead }),
+        ...(cacheWrite === undefined ? {} : { cacheWrite }),
+    };
+}
+function nonNegativeUsage(usage) {
+    return Object.values(usage).every((value) => Number.isFinite(value) && value >= 0)
+        ? usage
+        : undefined;
+}
+function isRequiredDelta(value) {
+    return typeof value === 'number';
+}
+function isOptionalDelta(value) {
+    return value === undefined || typeof value === 'number';
+}
+function subtract(total, baseline) {
+    const delta = total - baseline;
+    return Number.isFinite(delta) && delta >= 0 ? delta : undefined;
+}
+function cacheDelta(total, baseline) {
+    if (total === undefined)
+        return baseline === undefined ? undefined : 'inconsistent';
+    return subtract(total, baseline ?? 0);
+}
+function asRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function numeric(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}

package/dist/src/execution/infrastructure/runners/command.js

@@ -0,0 +1,4 @@
+import { cliRunner } from './claude.js';
+export function createCommandRunner(command, args, timeoutMs) {
+    return cliRunner('command', command, () => [...args], { timeoutMs });
+}

package/dist/src/execution/infrastructure/runners/cursor.js

@@ -0,0 +1,69 @@
+import { WorkspaceMode } from '../../contracts/vocabulary.js';
+import { cliRunner } from './claude.js';
+// Cursor's CLI subcommand, not the closed domain vocabulary word "agent".
+const cursorCliSubcommand = String.fromCharCode(97, 103, 101, 110, 116);
+export function createCursorRunner(options = {}) {
+    return cliRunner('cursor', options.command ?? 'cursor', (request) => cursorCommandArgs(request, options.args, options), {
+        ...(options.timeoutMs === undefined ? {} : { timeoutMs: options.timeoutMs }),
+        ...(options.model === undefined ? {} : { defaultModel: options.model }),
+        parseSuccessfulOutput: parseCursorOutput,
+    });
+}
+export function cursorCommandArgs(request, passthroughArgs = [], defaults = {}) {
+    const model = request.model ?? defaults.model;
+    return [
+        cursorCliSubcommand,
+        '-p',
+        '--output-format',
+        'json',
+        ...(model === undefined ? [] : ['--model', model]),
+        '--trust',
+        ...(request.workspaceMode === WorkspaceMode.ReadOnly ? ['--mode', 'ask'] : ['--force']),
+        ...(request.resumeSessionId === undefined ? [] : [`--resume=${request.resumeSessionId}`]),
+        ...passthroughArgs,
+        request.prompt,
+    ];
+}
+export function parseCursorOutput(stdout) {
+    const value = parseRecord(stdout);
+    if (value === undefined || typeof value.result !== 'string')
+        return {};
+    return {
+        output: value.result,
+        ...(typeof value.session_id === 'string' ? { sessionId: value.session_id } : {}),
+        ...cursorUsage(value),
+    };
+}
+function cursorUsage(value) {
+    const usage = asRecord(value.usage);
+    const input = usage === undefined ? undefined : numeric(usage.inputTokens);
+    const output = usage === undefined ? undefined : numeric(usage.outputTokens);
+    if (usage === undefined || input === undefined || output === undefined)
+        return {};
+    const cacheRead = numeric(usage.cacheReadTokens);
+    const cacheWrite = numeric(usage.cacheWriteTokens);
+    return {
+        tokenUsage: {
+            input,
+            output,
+            ...(cacheRead === undefined ? {} : { cacheRead }),
+            ...(cacheWrite === undefined ? {} : { cacheWrite }),
+        },
+    };
+}
+function parseRecord(stdout) {
+    try {
+        return asRecord(JSON.parse(stdout));
+    }
+    catch {
+        return undefined;
+    }
+}
+function asRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function numeric(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}

package/dist/src/execution/infrastructure/runners/fake-scenarios.js

@@ -0,0 +1,99 @@
+import { z } from 'zod';
+import { RetrySafety } from '../../../activities/index.js';
+const outcomeSchema = z.enum(['DONE', 'REJECTED', 'BLOCKED', 'FAILED']);
+const matchSchema = z
+    .object({
+    runner: z.string().trim().min(1),
+    action: z.string().trim().min(1),
+    occurrence: z.number().int().positive().optional(),
+})
+    .strict();
+const delaySchema = z.union([
+    z.number().int().positive(),
+    z
+        .object({
+        min: z.number().int().positive(),
+        max: z.number().int().positive(),
+        seed: z.union([z.string().trim().min(1), z.number().int()]),
+    })
+        .strict()
+        .refine((value) => value.min <= value.max, { message: 'min must not exceed max' }),
+]);
+const ruleSchema = z
+    .object({
+    name: z.string().trim().min(1),
+    when: matchSchema,
+    afterMs: delaySchema,
+    outcome: outcomeSchema,
+    retrySafety: z.literal(RetrySafety.SafeToRetry).optional(),
+    displayBody: z.string().trim().min(1).optional(),
+    reportedArtifacts: z
+        .array(z
+        .object({
+        kind: z.string().trim().min(1),
+        externalKey: z
+            .object({ adapter: z.string().trim().min(1), key: z.string().trim().min(1) })
+            .strict(),
+    })
+        .strict())
+        .optional(),
+})
+    .strict()
+    .refine((value) => value.outcome === 'FAILED' || value.retrySafety === undefined, {
+    message: 'retrySafety is only valid for FAILED outcomes',
+    path: ['retrySafety'],
+});
+const fileSchema = z
+    .object({ schemaVersion: z.literal(1), rules: z.array(ruleSchema).default([]) })
+    .strict()
+    .superRefine((value, context) => {
+    const names = new Set();
+    value.rules.forEach((rule, index) => {
+        if (names.has(rule.name))
+            context.addIssue({
+                code: 'custom',
+                path: ['rules', index, 'name'],
+                message: `Duplicate fake scenario rule name: ${rule.name}`,
+            });
+        names.add(rule.name);
+    });
+});
+export const emptyFakeScenarios = { resolve: () => undefined };
+export function parseFakeScenarios(value) {
+    const parsed = fileSchema.parse(value);
+    return {
+        resolve(input) {
+            const rule = parsed.rules.find((candidate) => candidate.when.runner === input.runner &&
+                candidate.when.action === input.action &&
+                (candidate.when.occurrence === undefined ||
+                    candidate.when.occurrence === input.occurrence));
+            if (rule === undefined)
+                return undefined;
+            return {
+                name: rule.name,
+                delayMs: resolveDelay(rule.afterMs, input),
+                outcome: rule.outcome,
+                ...(rule.retrySafety === undefined ? {} : { retrySafety: rule.retrySafety }),
+                ...(rule.displayBody === undefined ? {} : { displayBody: rule.displayBody }),
+                ...(rule.reportedArtifacts === undefined
+                    ? {}
+                    : { reportedArtifacts: rule.reportedArtifacts }),
+            };
+        },
+    };
+}
+function resolveDelay(afterMs, input) {
+    if (typeof afterMs === 'number')
+        return afterMs;
+    const range = afterMs.max - afterMs.min + 1;
+    return (afterMs.min +
+        (hash(`${afterMs.seed}:${input.runner}:${input.action}:${input.occurrence}`) % range));
+}
+function hash(value) {
+    let result = 2166136261;
+    for (let index = 0; index < value.length; index += 1) {
+        result ^= value.charCodeAt(index);
+        result = Math.imul(result, 16777619);
+    }
+    return result >>> 0;
+}

package/dist/src/execution/infrastructure/runners/fake.js

@@ -0,0 +1,65 @@
+import { RetrySafety } from '../../../activities/index.js';
+import { RunStatus } from '../../contracts/vocabulary.js';
+import { emptyFakeScenarios, } from './fake-scenarios.js';
+export class FakeExecutionRunner {
+    name;
+    scenarios;
+    constructor(name = 'fake', scenarios = emptyFakeScenarios) {
+        this.name = name;
+        this.scenarios = scenarios;
+    }
+    async start(request, signal) {
+        const scenario = request.context === undefined
+            ? undefined
+            : this.scenarios.resolve({
+                runner: request.context.runnerName,
+                action: request.context.action,
+                occurrence: request.context.activationOrdinal,
+            });
+        return {
+            result: waitFor(scenario?.delayMs ?? 0, signal).then(() => resultFor(this.name, scenario, request)),
+            async cancel() { },
+        };
+    }
+}
+function resultFor(name, scenario, request) {
+    return {
+        transport: RunStatus.Succeeded,
+        output: JSON.stringify(outputFor(scenario, request.prompt)),
+        runner: name,
+    };
+}
+function outputFor(scenario, prompt) {
+    const status = statusFor(scenario, prompt);
+    return {
+        status,
+        ...retrySafetyFor(scenario, status),
+        ...(scenario?.displayBody === undefined ? {} : { displayBody: scenario.displayBody }),
+        ...(scenario?.reportedArtifacts === undefined
+            ? {}
+            : { reportedArtifacts: scenario.reportedArtifacts }),
+    };
+}
+function statusFor(scenario, prompt) {
+    if (scenario !== undefined)
+        return scenario.outcome;
+    if (prompt.includes('[fake:failed]'))
+        return 'FAILED';
+    return prompt.includes('[fake:blocked]') ? 'BLOCKED' : 'DONE';
+}
+function retrySafetyFor(scenario, status) {
+    if (scenario?.retrySafety !== undefined)
+        return { retrySafety: scenario.retrySafety };
+    return status === 'FAILED' ? { retrySafety: RetrySafety.SafeToRetry } : {};
+}
+function waitFor(delayMs, signal) {
+    if (delayMs === 0)
+        return Promise.resolve();
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(resolve, delayMs);
+        signal.addEventListener('abort', () => {
+            clearTimeout(timer);
+            reject(new Error('Fake runner execution aborted'));
+        }, { once: true });
+    });
+}

package/dist/src/execution/infrastructure/runners/registry.js

@@ -0,0 +1,26 @@
+export class RunnerRegistry {
+    runnerPools;
+    runners;
+    constructor(runnerPools, runners) {
+        this.runnerPools = runnerPools;
+        this.runners = runners;
+    }
+    resolve(runnerPool, ineligible = new Set()) {
+        const candidates = this.runnerPools[runnerPool];
+        if (candidates === undefined)
+            throw new Error(`Execution runner pool ${runnerPool} has no runner`);
+        return selectEligibleCandidate(runnerPool, candidates, this.runners, ineligible);
+    }
+}
+// Falls sideways to the next candidate on quota ineligibility; never a different runner pool.
+function selectEligibleCandidate(runnerPool, candidates, runners, ineligible) {
+    for (const name of candidates) {
+        if (ineligible.has(name))
+            continue;
+        const runner = runners[name];
+        if (runner === undefined)
+            throw new Error(`Runner ${name} is not registered`);
+        return { name, runner };
+    }
+    throw new Error(`Execution runner pool ${runnerPool} has no eligible runner: all candidates are ineligible`);
+}