@atolis-hq/wake 0.1.0

package/dist/src/adapters/http/ui-server.js

@@ -0,0 +1,151 @@
+import { createServer } from 'node:http';
+import { configuredTicketSource } from '../../domain/sources.js';
+import { indexHtml } from './ui-assets.js';
+import { buildBoard, buildConfigView, buildEventsFeed, buildHealth, buildItemDetail, buildRuns, buildStatus, buildWorkspaces, } from './ui-data.js';
+function sendJson(res, status, body) {
+    const payload = JSON.stringify(body, null, 2);
+    res.writeHead(status, {
+        'content-type': 'application/json; charset=utf-8',
+        'content-length': Buffer.byteLength(payload),
+    });
+    res.end(payload);
+}
+function extractBearerToken(req) {
+    const header = req.headers.authorization;
+    if (typeof header === 'string' && header.startsWith('Bearer ')) {
+        return header.slice('Bearer '.length);
+    }
+    const cookie = req.headers.cookie;
+    if (typeof cookie === 'string') {
+        const match = cookie.split(';').map((part) => part.trim()).find((part) => part.startsWith('wake_ui_token='));
+        if (match !== undefined) {
+            return match.slice('wake_ui_token='.length);
+        }
+    }
+    return undefined;
+}
+/**
+ * Parses `/items/<repo-with-slashes>/<issueNumber>[/events]` where repo itself
+ * may contain a `/` (e.g. `owner/name`), so the split can't assume a fixed arity.
+ */
+function parseItemPath(segments) {
+    const trailingIsEvents = segments.at(-1) === 'events';
+    const numberIndex = trailingIsEvents ? segments.length - 2 : segments.length - 1;
+    const issueNumberRaw = segments[numberIndex];
+    const issueNumber = issueNumberRaw === undefined ? Number.NaN : Number(issueNumberRaw);
+    if (!Number.isInteger(issueNumber) || issueNumber <= 0 || numberIndex < 1) {
+        return null;
+    }
+    const repo = segments.slice(0, numberIndex).join('/');
+    return {
+        repo,
+        issueNumber,
+        ...(trailingIsEvents ? { suffix: 'events' } : {}),
+    };
+}
+export function createUiServer(options) {
+    const now = options.now ?? (() => new Date());
+    return createServer((req, res) => {
+        void handleRequest(req, res, options, now).catch((error) => {
+            sendJson(res, 500, { error: error instanceof Error ? error.message : String(error) });
+        });
+    });
+}
+async function handleRequest(req, res, options, now) {
+    const url = new URL(req.url ?? '/', 'http://internal');
+    // Whether a token is required is a bind-time decision — the caller (see
+    // ui-command.ts) only ever supplies a token when it configured a
+    // non-loopback --host, so once set it gates every request rather than
+    // trusting a per-connection remote-address check that docker's NAT/port
+    // publishing can make unreliable.
+    if (options.token !== undefined) {
+        const provided = extractBearerToken(req);
+        if (provided !== options.token) {
+            sendJson(res, 401, { error: 'missing or invalid token' });
+            return;
+        }
+    }
+    if (!url.pathname.startsWith('/api/v1/')) {
+        if (req.method === 'GET' && (url.pathname === '/' || url.pathname === '/index.html')) {
+            res.writeHead(200, { 'content-type': 'text/html; charset=utf-8' });
+            res.end(indexHtml);
+            return;
+        }
+        res.writeHead(404).end('not found');
+        return;
+    }
+    if (req.method !== 'GET') {
+        sendJson(res, 405, { error: 'this build only serves read endpoints; mutations are not implemented' });
+        return;
+    }
+    const { stateStore, resourceIndex, config } = options;
+    const segments = url.pathname.slice('/api/v1/'.length).split('/').filter((part) => part.length > 0).map((s) => decodeURIComponent(s));
+    const resource = segments[0];
+    if (resource === 'status' && segments.length === 1) {
+        sendJson(res, 200, await buildStatus({ stateStore, config, now: now() }));
+        return;
+    }
+    if (resource === 'board' && segments.length === 1) {
+        sendJson(res, 200, await buildBoard({ stateStore, config, now: now() }));
+        return;
+    }
+    if (resource === 'items' && segments.length >= 3) {
+        const parsed = parseItemPath(segments.slice(1));
+        if (parsed === null) {
+            sendJson(res, 400, { error: 'expected /items/<repo>/<issueNumber>' });
+            return;
+        }
+        const itemDetailInput = {
+            stateStore,
+            resourceIndex,
+            provider: configuredTicketSource(config),
+            repo: parsed.repo,
+            issueNumber: parsed.issueNumber,
+        };
+        if (parsed.suffix === 'events') {
+            const detail = await buildItemDetail(itemDetailInput);
+            sendJson(res, 200, detail?.events ?? []);
+            return;
+        }
+        const detail = await buildItemDetail(itemDetailInput);
+        if (detail === null) {
+            sendJson(res, 404, { error: 'item not found' });
+            return;
+        }
+        sendJson(res, 200, detail);
+        return;
+    }
+    if (resource === 'runs' && segments.length === 1) {
+        sendJson(res, 200, await buildRuns({
+            stateStore,
+            status: url.searchParams.get('status') ?? undefined,
+            action: url.searchParams.get('action') ?? undefined,
+            repo: url.searchParams.get('repo') ?? undefined,
+        }));
+        return;
+    }
+    if (resource === 'events' && segments.length === 1) {
+        const limitParam = url.searchParams.get('limit');
+        sendJson(res, 200, await buildEventsFeed({
+            stateStore,
+            workItemKey: url.searchParams.get('workItemKey') ?? undefined,
+            direction: url.searchParams.get('direction') ?? undefined,
+            type: url.searchParams.get('type') ?? undefined,
+            limit: limitParam === null ? undefined : Number(limitParam),
+        }));
+        return;
+    }
+    if (resource === 'config' && segments.length === 1) {
+        sendJson(res, 200, await buildConfigView({ config, stateStore, now: now() }));
+        return;
+    }
+    if (resource === 'health' && segments.length === 1) {
+        sendJson(res, 200, await buildHealth({ stateStore, config, now: now() }));
+        return;
+    }
+    if (resource === 'workspaces' && segments.length === 1) {
+        sendJson(res, 200, await buildWorkspaces({ stateStore }));
+        return;
+    }
+    sendJson(res, 404, { error: `unknown endpoint: ${url.pathname}` });
+}

package/dist/src/adapters/runner/cli-command.js

@@ -0,0 +1,43 @@
+import { spawn } from 'node:child_process';
+const TIMEOUT_KILL_GRACE_MS = 5_000;
+export function runAgentCliCommand(input) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(input.command, input.args, {
+            cwd: input.cwd,
+            env: process.env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stdout = '';
+        let stderr = '';
+        let timedOut = false;
+        let killTimer;
+        const timeoutTimer = input.timeoutMs === undefined
+            ? undefined
+            : setTimeout(() => {
+                timedOut = true;
+                child.kill('SIGTERM');
+                killTimer = setTimeout(() => child.kill('SIGKILL'), TIMEOUT_KILL_GRACE_MS);
+            }, input.timeoutMs);
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr.on('data', (chunk) => {
+            stderr += chunk.toString();
+        });
+        child.on('error', (error) => {
+            clearTimeout(timeoutTimer);
+            clearTimeout(killTimer);
+            reject(error);
+        });
+        child.on('close', (exitCode) => {
+            clearTimeout(timeoutTimer);
+            clearTimeout(killTimer);
+            resolve({
+                stdout,
+                stderr,
+                exitCode: exitCode ?? 1,
+                timedOut,
+            });
+        });
+    });
+}

package/dist/src/adapters/runner/prompt-templates.js

@@ -0,0 +1,76 @@
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import Handlebars from 'handlebars';
+function findProjectRoot(startDir) {
+    let dir = startDir;
+    for (let depth = 0; depth < 8; depth += 1) {
+        if (existsSync(join(dir, 'package.json'))) {
+            return dir;
+        }
+        const parent = dirname(dir);
+        if (parent === dir) {
+            break;
+        }
+        dir = parent;
+    }
+    throw new Error(`Could not locate project root above ${startDir}`);
+}
+function parseFrontmatter(raw) {
+    const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(raw);
+    if (match === null) {
+        return { frontmatter: {}, body: raw };
+    }
+    const [, frontmatterBlock, body] = match;
+    const frontmatter = {};
+    for (const line of (frontmatterBlock ?? '').split(/\r?\n/)) {
+        const lineMatch = /^([\w.-]+):\s*(.*)$/.exec(line);
+        if (lineMatch === null) {
+            continue;
+        }
+        const [, key, value] = lineMatch;
+        if (key !== undefined) {
+            frontmatter[key] = (value ?? '').trim();
+        }
+    }
+    return { frontmatter, body: body ?? '' };
+}
+export function promptsRoot(explicitRoot) {
+    return explicitRoot ?? join(findProjectRoot(dirname(fileURLToPath(import.meta.url))), 'prompts');
+}
+export async function loadPromptTemplate(stage, mode, options) {
+    const root = promptsRoot(options?.promptsRoot);
+    const combinedFilePath = join(root, `${stage}.md`);
+    const modeFilePath = join(root, `${stage}.${mode}.md`);
+    let raw;
+    try {
+        raw = await readFile(combinedFilePath, 'utf8');
+    }
+    catch (error) {
+        const code = error.code;
+        if (code !== 'ENOENT') {
+            throw error;
+        }
+        raw = await readFile(modeFilePath, 'utf8');
+    }
+    return parseFrontmatter(raw);
+}
+export function renderPromptTemplate(template, context) {
+    const renderContext = Object.fromEntries(Object.entries(context).map(([key, value]) => {
+        if (Array.isArray(value)) {
+            return [key, Object.assign([...value], { toString: () => JSON.stringify(value, null, 2) })];
+        }
+        if (value !== null && typeof value === 'object') {
+            return [
+                key,
+                Object.assign({ ...value }, { toString: () => JSON.stringify(value, null, 2) }),
+            ];
+        }
+        return [key, value];
+    }));
+    const compiled = Handlebars.compile(template.body, {
+        noEscape: true,
+    });
+    return compiled(renderContext);
+}

package/dist/src/adapters/runner/runner-cli-adapter.js

@@ -0,0 +1,112 @@
+import { createClaudeRunner } from '../claude/claude-runner.js';
+import { createCodexRunner } from '../codex/codex-runner.js';
+import { createCursorRunner } from '../cursor/cursor-runner.js';
+function withoutKind(entry) {
+    const { kind: _kind, ...settings } = entry;
+    return settings;
+}
+export function createRunnerCliAdapter(input) {
+    if (input.entry.kind === 'claude') {
+        const settings = withoutKind(input.entry);
+        const runner = createClaudeRunner({
+            command: settings.command,
+            cwd: input.cwd,
+            settings,
+        });
+        return {
+            mode: 'claude',
+            cliName: 'Claude',
+            runner,
+            async smoke(args) {
+                if (args.includes('--remote-control')) {
+                    const result = await runner.startRemoteControlSmoke();
+                    return {
+                        mode: 'remote-control',
+                        exitCode: result.exitCode,
+                        stdout: result.stdout.trim(),
+                        stderr: result.stderr.trim(),
+                        command: result.command,
+                        args: result.args,
+                    };
+                }
+                const result = await runner.smoke();
+                return {
+                    mode: 'print-json',
+                    exitCode: result.exitCode,
+                    text: result.text,
+                    sessionId: result.sessionId,
+                    stdout: result.stdout.trim(),
+                    stderr: result.stderr.trim(),
+                };
+            },
+            buildResumeCommand({ sessionId }) {
+                return ['claude', '--resume', sessionId];
+            },
+        };
+    }
+    if (input.entry.kind === 'cursor') {
+        const settings = withoutKind(input.entry);
+        const runner = createCursorRunner({
+            command: settings.command,
+            cwd: input.cwd,
+            settings,
+        });
+        return {
+            mode: 'cursor',
+            cliName: 'Cursor',
+            runner,
+            async smoke() {
+                const result = await runner.smoke();
+                return {
+                    mode: 'print-json',
+                    exitCode: result.exitCode,
+                    text: result.text,
+                    sessionId: result.sessionId,
+                    stdout: result.stdout.trim(),
+                    stderr: result.stderr.trim(),
+                };
+            },
+            buildResumeCommand({ sessionId }) {
+                return ['cursor', 'agent', `--resume=${sessionId}`];
+            },
+        };
+    }
+    const settings = withoutKind(input.entry);
+    const runner = createCodexRunner({
+        command: settings.command,
+        cwd: input.cwd,
+        settings,
+    });
+    return {
+        mode: 'codex',
+        cliName: 'Codex',
+        runner,
+        async smoke() {
+            const result = await runner.smoke();
+            return {
+                mode: 'jsonl',
+                exitCode: result.exitCode,
+                text: result.text,
+                sessionId: result.sessionId,
+                stdout: result.stdout.trim(),
+                stderr: result.stderr.trim(),
+            };
+        },
+        buildResumeCommand({ sessionId }) {
+            return ['codex', 'resume', sessionId];
+        },
+    };
+}
+export function buildResumeCommandForCli(input) {
+    const normalizedCli = input.cli.trim().toLowerCase();
+    if (normalizedCli === 'codex') {
+        return ['codex', 'resume', input.sessionId];
+    }
+    if (normalizedCli === 'claude') {
+        return ['claude', '--resume', input.sessionId];
+    }
+    if (normalizedCli === 'cursor') {
+        return ['cursor', 'agent', `--resume=${input.sessionId}`];
+    }
+    return null;
+}

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

@@ -0,0 +1,141 @@
+import { createClaudeRunner } from '../claude/claude-runner.js';
+import { createCodexRunner } from '../codex/codex-runner.js';
+import { createCursorRunner } from '../cursor/cursor-runner.js';
+import { createFakeRunner } from '../fake/fake-runner.js';
+import { resolveRunnerRouting } from '../../domain/runner-routing.js';
+import { chooseAction, workflowForProjection, workflowNameForProjection } from '../../domain/workflows.js';
+export { resolveRunnerRouting } from '../../domain/runner-routing.js';
+function withoutKind(entry) {
+    const { kind: _kind, ...settings } = entry;
+    return settings;
+}
+function createRunnerForEntry(input) {
+    if (input.entry.kind === 'fake') {
+        return createFakeRunner(undefined, { cli: input.entry.cli });
+    }
+    if (input.entry.kind === 'claude') {
+        const settings = withoutKind(input.entry);
+        return createClaudeRunner({
+            command: settings.command,
+            cwd: input.cwd,
+            settings,
+        });
+    }
+    if (input.entry.kind === 'cursor') {
+        const settings = withoutKind(input.entry);
+        return createCursorRunner({
+            command: settings.command,
+            cwd: input.cwd,
+            settings,
+        });
+    }
+    const settings = withoutKind(input.entry);
+    return createCodexRunner({
+        command: settings.command,
+        cwd: input.cwd,
+        settings,
+    });
+}
+async function runWithRouting(input) {
+    const result = await input.runner.run({
+        ...input.runInput,
+        routing: input.routing,
+    });
+    return {
+        ...result,
+        routing: input.routing,
+        metadata: {
+            ...result.metadata,
+            routing: input.routing,
+        },
+    };
+}
+export function createRegistryRunner(input) {
+    if (input.override === 'fake') {
+        const runner = createFakeRunner();
+        return {
+            run(runInput) {
+                return runWithRouting({
+                    runner,
+                    runInput,
+                    routing: {
+                        runnerName: 'fake',
+                        runnerKind: 'fake',
+                        reason: '--runner fake override',
+                    },
+                });
+            },
+        };
+    }
+    if (input.override !== undefined) {
+        const entry = input.config.runners[input.override];
+        if (entry === undefined) {
+            throw new Error(`Unsupported runner override: ${input.override}`);
+        }
+        const runner = createRunnerForEntry({
+            name: input.override,
+            entry,
+            config: input.config,
+            cwd: input.cwd,
+        });
+        return {
+            run(runInput) {
+                return runWithRouting({
+                    runner,
+                    runInput,
+                    routing: {
+                        runnerName: input.override,
+                        runnerKind: entry.kind,
+                        reason: `--runner ${input.override} override`,
+                    },
+                });
+            },
+        };
+    }
+    const cache = new Map();
+    return {
+        async run(runInput) {
+            // Callers that already resolved routing against the ledger (tick-runner,
+            // so it can skip claiming a run when every candidate is paused) pass it
+            // in; only fall back to a ledger-less resolve for direct callers (smoke
+            // tests, sandbox exec) that never see quota state.
+            const routing = runInput.routing ??
+                (() => {
+                    const workflow = workflowForProjection(runInput.projection, runInput.config);
+                    const workflowAction = workflow === null
+                        ? null
+                        : chooseAction(runInput.projection, workflow);
+                    return resolveRunnerRouting({
+                        config: runInput.config,
+                        stage: workflowAction?.stage ?? runInput.projection.wake.stage,
+                        action: runInput.action,
+                        workflowName: workflowNameForProjection(runInput.projection, runInput.config),
+                    });
+                })();
+            if (routing === null) {
+                throw new Error('No runner available: every candidate in the resolved tier is quota-paused.');
+            }
+            const cacheKey = `${routing.runnerKind}:${routing.runnerName}`;
+            const existing = cache.get(cacheKey);
+            const runner = existing ??
+                createRunnerForEntry({
+                    name: routing.runnerName,
+                    entry: runInput.config.runners[routing.runnerName],
+                    config: runInput.config,
+                    cwd: input.cwd,
+                });
+            cache.set(cacheKey, runner);
+            return runWithRouting({
+                runner,
+                routing,
+                runInput,
+            });
+        },
+    };
+}
+export function runnerKindForOverride(config, override) {
+    if (override === 'fake') {
+        return 'fake';
+    }
+    return config.runners[override]?.kind ?? null;
+}