@atolis-hq/wake 0.1.0

package/dist/src/cli/scaffold-assets.js

@@ -0,0 +1,173 @@
+import { chmod, copyFile, mkdir, readFile, readdir, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { createDefaultWakeConfig } from '../config/defaults.js';
+import { writeJsonFile } from '../lib/json-file.js';
+const runtimeDirectoryNames = [
+    'events',
+    'state',
+    'runs',
+    'workspaces',
+    'repos',
+    'sources',
+    'locks',
+    'logs',
+];
+const promptFileNames = ['refine.md', 'implement.md'];
+const dockerAssetNames = ['Dockerfile', 'setup.sh', 'log-command.sh'];
+export async function assertEmptyDirectory(targetDir) {
+    try {
+        const entries = await readdir(targetDir);
+        if (entries.length > 0) {
+            throw new Error(`wake init requires an empty directory: ${targetDir}`);
+        }
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'ENOENT') {
+            await mkdir(targetDir, { recursive: true });
+            return;
+        }
+        throw error;
+    }
+}
+async function copyAssets(repoRoot, sourceDir, targetDir, fileNames) {
+    await mkdir(targetDir, { recursive: true });
+    await Promise.all(fileNames.map(async (fileName) => {
+        const sourceFile = join(repoRoot, sourceDir, fileName);
+        const targetFile = join(targetDir, fileName);
+        await mkdir(dirname(targetFile), { recursive: true });
+        if (fileName.endsWith('.sh')) {
+            const script = await readFile(sourceFile, 'utf8');
+            await writeFile(targetFile, script.replaceAll('\r\n', '\n'), 'utf8');
+            await chmod(targetFile, 0o755);
+            return;
+        }
+        await copyFile(sourceFile, targetFile);
+    }));
+}
+async function writeLaunchers(wakeRoot, repoRoot) {
+    const posixRepoRoot = repoRoot.replaceAll('\\', '/');
+    const shellLauncher = [
+        '#!/usr/bin/env bash',
+        'set -euo pipefail',
+        '',
+        `WAKE_REPO="${posixRepoRoot}"`,
+        'DIST_MAIN="$WAKE_REPO/dist/src/main.js"',
+        'SOURCE_MAIN="$WAKE_REPO/src/main.ts"',
+        'CONTAINER_MAIN="/app/dist/src/main.js"',
+        '',
+        'run_local_wake() {',
+        '  if [[ -f "$DIST_MAIN" ]]; then',
+        '    exec env MSYS_NO_PATHCONV=1 MSYS2_ARG_CONV_EXCL=\'*\' node "$DIST_MAIN" "$@"',
+        '  fi',
+        '  exec env MSYS_NO_PATHCONV=1 MSYS2_ARG_CONV_EXCL=\'*\' npx tsx "$SOURCE_MAIN" "$@"',
+        '}',
+        '',
+        'rewrite_runtime_args() {',
+        '  local rewritten_args=()',
+        '  local saw_wake_root=0',
+        '  while (($# > 0)); do',
+        '    if [[ "$1" == "--wake-root" ]]; then',
+        '      saw_wake_root=1',
+        '      shift',
+        '      if (($# > 0)); then',
+        '        shift',
+        '      fi',
+        '      rewritten_args+=("--wake-root" "/wake")',
+        '      continue',
+        '    fi',
+        '    rewritten_args+=("$1")',
+        '    shift',
+        '  done',
+        '  if [[ $saw_wake_root -eq 0 ]]; then',
+        '    rewritten_args+=("--wake-root" "/wake")',
+        '  fi',
+        '  printf \'%s\\0\' "${rewritten_args[@]}"',
+        '}',
+        '',
+        'case "${1:-}" in',
+        '  init|sandbox|stop)',
+        '    run_local_wake "$@"',
+        '    ;;',
+        '  *)',
+        '    mapfile -d \'\' -t rewritten_args < <(rewrite_runtime_args "$@")',
+        '    run_local_wake sandbox exec -- node "$CONTAINER_MAIN" "${rewritten_args[@]}"',
+        '    ;;',
+        'esac',
+        '',
+    ].join('\n');
+    const powerShellLauncher = [
+        '$ErrorActionPreference = "Stop"',
+        '',
+        `$wakeRepo = "${repoRoot.replaceAll('"', '""')}"`,
+        '$distMain = Join-Path $wakeRepo "dist/src/main.js"',
+        '$sourceMain = Join-Path $wakeRepo "src/main.ts"',
+        '$containerMain = "/app/dist/src/main.js"',
+        '$command = if ($Args.Count -gt 0) { [string] $Args[0] } else { "" }',
+        '',
+        'function Invoke-WakeLocal {',
+        '  param([string[]] $WakeArgs)',
+        '  if (Test-Path $distMain) {',
+        '    & node $distMain @WakeArgs',
+        '    exit $LASTEXITCODE',
+        '  }',
+        '  & npx tsx $sourceMain @WakeArgs',
+        '  exit $LASTEXITCODE',
+        '}',
+        '',
+        'switch ($command) {',
+        '  "init" {',
+        '    Invoke-WakeLocal -WakeArgs $Args',
+        '  }',
+        '  "sandbox" {',
+        '    Invoke-WakeLocal -WakeArgs $Args',
+        '  }',
+        '  "stop" {',
+        '    Invoke-WakeLocal -WakeArgs $Args',
+        '  }',
+        '  default {',
+        '    $rewrittenArgs = New-Object System.Collections.Generic.List[string]',
+        '    $sawWakeRoot = $false',
+        '    for ($index = 0; $index -lt $Args.Count; $index++) {',
+        '      $arg = [string] $Args[$index]',
+        '      if ($arg -eq "--wake-root") {',
+        '        $sawWakeRoot = $true',
+        '        if ($index + 1 -lt $Args.Count) {',
+        '          $index++',
+        '        }',
+        "        $rewrittenArgs.Add('--wake-root')",
+        "        $rewrittenArgs.Add('/wake')",
+        '        continue',
+        '      }',
+        '      $rewrittenArgs.Add($arg)',
+        '    }',
+        '    if (-not $sawWakeRoot) {',
+        "      $rewrittenArgs.Add('--wake-root')",
+        "      $rewrittenArgs.Add('/wake')",
+        '    }',
+        "    Invoke-WakeLocal -WakeArgs (@('sandbox', 'exec', '--', 'node', $containerMain) + $rewrittenArgs.ToArray())",
+        '  }',
+        '}',
+        '',
+    ].join('\n');
+    await writeFile(join(wakeRoot, 'wake.sh'), shellLauncher, 'utf8');
+    await writeFile(join(wakeRoot, 'wake.ps1'), powerShellLauncher, 'utf8');
+    await chmod(join(wakeRoot, 'wake.sh'), 0o755);
+}
+export async function scaffoldWakeHome(input) {
+    const wakeRoot = resolve(input.wakeRoot);
+    const repoRoot = resolve(input.repoRoot);
+    const config = {
+        ...createDefaultWakeConfig(wakeRoot),
+        dev: {
+            repoRoot,
+        },
+    };
+    await Promise.all(runtimeDirectoryNames.map((directoryName) => mkdir(join(wakeRoot, directoryName), { recursive: true })));
+    await Promise.all([
+        copyAssets(repoRoot, 'prompts', join(wakeRoot, 'prompts'), promptFileNames),
+        copyAssets(repoRoot, 'docker', join(wakeRoot, 'docker'), dockerAssetNames),
+        writeJsonFile(join(wakeRoot, 'config.json'), config),
+        writeLaunchers(wakeRoot, repoRoot),
+    ]);
+}

package/dist/src/cli/self-update-command.js

@@ -0,0 +1,158 @@
+import { waitForActiveRuns } from './stop-command.js';
+const HEALTHCHECK_WAKE_ROOT = '/tmp/wake-self-update-healthcheck';
+const START_PROCESS_CHECK = [
+    'sh',
+    '-lc',
+    [
+        'pid="$(cat /wake/logs/start.pid)"',
+        'test -n "$pid"',
+        'kill -0 "$pid"',
+        'tr "\\0" " " < "/proc/$pid/cmdline" | grep -F "node /app/dist/src/main.js start --wake-root /wake" >/dev/null',
+    ].join(' && '),
+];
+function readFlag(name, args) {
+    const index = args.indexOf(name);
+    return index === -1 ? undefined : args[index + 1];
+}
+function hasFlag(name, args) {
+    return args.includes(name);
+}
+function readNumberFlag(name, args) {
+    const raw = readFlag(name, args);
+    const parsed = raw === undefined ? Number.NaN : Number(raw);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+const DEFAULT_LOOP_INTERVAL_MS = 5 * 60 * 1000;
+async function verifyResidentStart(input) {
+    if (input.start?.enabled !== true) {
+        input.logger.error(`[self-update] wake start auto-start is disabled; resident loop will not be running after ${input.context}`);
+        return;
+    }
+    await input.docker.exec(input.containerName, START_PROCESS_CHECK);
+    input.logger.info(`[self-update] verified wake start is running after ${input.context}`);
+}
+export async function runSelfUpdateCommand(input) {
+    const force = hasFlag('--force', input.args);
+    const explicitTag = readFlag('--tag', input.args);
+    const ledger = await input.readLedger();
+    const tag = explicitTag ?? (await input.git.latestTag());
+    if (!force && tag === ledger.lastAppliedTag) {
+        input.logger.info(`[self-update] already on ${tag}; nothing to do`);
+        return;
+    }
+    if (!force && ledger.badTags.some((bad) => bad.tag === tag)) {
+        input.logger.info(`[self-update] ${tag} is recorded as a bad tag; skipping (use --force to retry)`);
+        return;
+    }
+    if (!(await input.git.isWorkingTreeClean())) {
+        throw new Error(`[self-update] repo working tree has local changes; refusing to update to ${tag}`);
+    }
+    await waitForActiveRuns({
+        listRunRecords: input.stateStore.listRunRecords,
+        sleep: input.sleep,
+        logger: input.logger,
+    });
+    const newImage = `${input.imageRepository}:${tag}`;
+    const updateInput = {
+        containerName: input.containerName,
+        wakeRoot: input.wakeRoot,
+        containerHomeRoot: input.containerHomeRoot,
+        containerMountPath: input.containerMountPath,
+        containerHomeMountPath: input.containerHomeMountPath,
+        ui: input.ui,
+        start: input.start,
+    };
+    try {
+        await input.git.checkoutTag(tag);
+        await input.docker.build({
+            image: newImage,
+            dockerfile: input.dockerfilePath,
+            contextDir: input.repoRoot,
+        });
+        await input.docker.update({ ...updateInput, image: newImage });
+        input.logger.info('[self-update] recreated container; entrypoint will keep wake start running');
+        await verifyResidentStart({
+            docker: input.docker,
+            containerName: input.containerName,
+            start: input.start,
+            logger: input.logger,
+            context: 'rollout',
+        });
+        await input.docker.exec(input.containerName, [
+            'node',
+            '/app/dist/src/main.js',
+            'tick',
+            '--wake-root',
+            HEALTHCHECK_WAKE_ROOT,
+        ]);
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        input.logger.error(`[self-update] rollout of ${tag} failed: ${reason}`);
+        if (ledger.lastKnownGoodTag !== null) {
+            const rollbackImage = `${input.imageRepository}:${ledger.lastKnownGoodTag}`;
+            await input.git.checkoutTag(ledger.lastKnownGoodTag);
+            await input.docker.update({ ...updateInput, image: rollbackImage });
+            input.logger.info('[self-update] recreated rollback container; entrypoint will keep wake start running');
+            await verifyResidentStart({
+                docker: input.docker,
+                containerName: input.containerName,
+                start: input.start,
+                logger: input.logger,
+                context: 'rollback',
+            });
+            input.logger.info(`[self-update] rolled back to ${ledger.lastKnownGoodTag}`);
+        }
+        else {
+            input.logger.error('[self-update] no previous known-good tag to roll back to');
+        }
+        await input.writeLedger({
+            lastAppliedTag: ledger.lastKnownGoodTag,
+            lastKnownGoodTag: ledger.lastKnownGoodTag,
+            badTags: [...ledger.badTags, { tag, reason, recordedAt: new Date().toISOString() }],
+        });
+        try {
+            await input.issueReporter.createIssue({
+                title: `Self-update to ${tag} failed and was rolled back`,
+                body: [
+                    `Automated update to \`${tag}\` failed during rollout and was rolled back to \`${ledger.lastKnownGoodTag ?? 'unknown'}\`.`,
+                    '',
+                    '```',
+                    reason,
+                    '```',
+                ].join('\n'),
+            });
+        }
+        catch (issueError) {
+            // Rollback already succeeded above; a failure to file the notification
+            // issue must not be reported as an overall self-update failure.
+            input.logger.error(`[self-update] rolled back successfully, but failed to file a GitHub issue: ${issueError instanceof Error ? issueError.message : String(issueError)}`);
+        }
+        return;
+    }
+    await input.writeLedger({
+        lastAppliedTag: tag,
+        lastKnownGoodTag: tag,
+        badTags: ledger.badTags,
+    });
+    input.logger.info(`[self-update] ${tag} is live and healthy`);
+}
+// Runs runSelfUpdateCommand forever, polling for a new tag every
+// --loop-interval-ms (default 5 minutes). One failed iteration (e.g. a
+// transient git/docker error) is logged and does not stop the loop — the
+// next iteration retries. Exits only if `sleep` itself rejects (e.g. the
+// process is being torn down), matching the resident-loop shape in
+// core/control-plane.ts.
+export async function runSelfUpdateLoop(input) {
+    const loopIntervalMs = readNumberFlag('--loop-interval-ms', input.args) ?? DEFAULT_LOOP_INTERVAL_MS;
+    for (;;) {
+        try {
+            await runSelfUpdateCommand(input);
+        }
+        catch (error) {
+            input.logger.error(`[self-update] loop iteration failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        input.logger.info(`[self-update] next check in ${loopIntervalMs}ms`);
+        await input.sleep(loopIntervalMs);
+    }
+}

package/dist/src/cli/startup-preflight.js

@@ -0,0 +1,127 @@
+import { execFile as nodeExecFile } from 'node:child_process';
+import { access } from 'node:fs/promises';
+import { promisify } from 'node:util';
+import { loadPromptTemplate } from '../adapters/runner/prompt-templates.js';
+const execFile = promisify(nodeExecFile);
+// Some CLIs (observed with Cursor's `agent --version`) take 5-6s to exit
+// when stdout isn't a TTY, likely due to a background update/telemetry
+// check — keep this comfortably above that or the probe kills a CLI that
+// is actually fine.
+const runnerVersionProbeTimeoutMs = 20_000;
+function activeRunnerNames(config, runnerOverride) {
+    const names = new Set();
+    if (runnerOverride !== undefined) {
+        names.add(runnerOverride);
+        return names;
+    }
+    for (const candidates of Object.values(config.tiers)) {
+        for (const candidate of candidates) {
+            names.add(candidate);
+        }
+    }
+    for (const workflow of Object.values(config.workflows)) {
+        for (const route of Object.values(workflow.stages)) {
+            if (route.runner !== undefined) {
+                names.add(route.runner);
+            }
+        }
+    }
+    return names;
+}
+function formatPreflightFailures(failures) {
+    return new Error([
+        'Wake startup preflight failed:',
+        ...failures.map((failure) => `- ${failure}`),
+        '',
+        'Fix the configuration or environment, then run `wake start` again.',
+    ].join('\n'));
+}
+async function defaultLoadPrompt(action, mode, promptsRoot) {
+    await loadPromptTemplate(action, mode, {
+        ...(promptsRoot === undefined ? {} : { promptsRoot }),
+    });
+}
+async function defaultCheckRunnerCommand(runnerName, entry) {
+    try {
+        await execFile(entry.command, ['--version'], {
+            env: process.env,
+            timeout: runnerVersionProbeTimeoutMs,
+            windowsHide: true,
+            maxBuffer: 1024 * 1024,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`runner "${runnerName}" (${entry.kind}) command "${entry.command}" is not invocable: ${message}`);
+    }
+}
+async function assertPromptsRootAccessible(promptsRoot) {
+    if (promptsRoot === undefined) {
+        return;
+    }
+    await access(promptsRoot);
+}
+export async function runStartupPreflight(config, deps = {}) {
+    const failures = [];
+    const loadPrompt = deps.loadPrompt ?? defaultLoadPrompt;
+    const checkRunnerCommand = deps.checkRunnerCommand ?? defaultCheckRunnerCommand;
+    try {
+        await assertPromptsRootAccessible(config.paths.promptsRoot);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        failures.push(`promptsRoot "${config.paths.promptsRoot}" is not readable: ${message}`);
+    }
+    const actions = new Set(Object.values(config.workflows).flatMap((workflow) => Object.entries(workflow.stages).map(([stageName, stage]) => stage.action ?? stageName)));
+    for (const action of actions) {
+        for (const mode of ['start', 'resume']) {
+            try {
+                await loadPrompt(action, mode, config.paths.promptsRoot);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                const root = config.paths.promptsRoot ?? '(bundled prompts)';
+                failures.push(`prompt template ${action}.md or ${action}.${mode}.md under ${root} is not readable: ${message}`);
+            }
+        }
+    }
+    const activeRunners = activeRunnerNames(config, deps.runnerOverride);
+    let usesRealRunner = false;
+    for (const runnerName of activeRunners) {
+        const entry = config.runners[runnerName];
+        if (entry === undefined) {
+            failures.push(`routing references unknown runner "${runnerName}"`);
+            continue;
+        }
+        if (entry.kind === 'fake') {
+            continue;
+        }
+        usesRealRunner = true;
+        try {
+            await checkRunnerCommand(runnerName, entry);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            failures.push(message);
+        }
+    }
+    if (usesRealRunner && config.sources.github.enabled && config.sources.github.repos.length > 0) {
+        if (deps.workspaceManager === undefined) {
+            failures.push('canonical clone health could not be checked: no workspace manager was provided');
+        }
+        else {
+            for (const repo of config.sources.github.repos) {
+                try {
+                    await deps.workspaceManager.prepareReadOnlyClone({ repo });
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    failures.push(`canonical clone for ${repo} is not healthy or clone-able: ${message}`);
+                }
+            }
+        }
+    }
+    if (failures.length > 0) {
+        throw formatPreflightFailures(failures);
+    }
+}

package/dist/src/cli/stop-command.js

@@ -0,0 +1,42 @@
+const DEFAULT_POLL_INTERVAL_MS = 5_000;
+const STOP_GRACE_PERIOD_SECONDS = 60;
+export async function waitForActiveRuns(input) {
+    const pollIntervalMs = input.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    const startedAt = Date.now();
+    for (;;) {
+        const records = await input.listRunRecords();
+        const activeRuns = records.filter((record) => record.status === 'running');
+        if (activeRuns.length === 0) {
+            return;
+        }
+        if (input.timeoutMs !== undefined && Date.now() - startedAt >= input.timeoutMs) {
+            throw new Error(`Timed out after ${input.timeoutMs}ms waiting for active runs to finish: ${activeRuns
+                .map((record) => record.runId)
+                .join(', ')}`);
+        }
+        input.logger.info(`[wake stop] waiting for ${activeRuns.length} active run(s) to finish: ${activeRuns
+            .map((record) => record.runId)
+            .join(', ')}`);
+        await input.sleep(pollIntervalMs);
+    }
+}
+function readNumberFlag(name, args) {
+    const index = args.indexOf(name);
+    if (index === -1) {
+        return undefined;
+    }
+    const raw = args[index + 1];
+    const parsed = raw === undefined ? Number.NaN : Number(raw);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+export async function runStopCommand(input) {
+    await waitForActiveRuns({
+        listRunRecords: input.stateStore.listRunRecords,
+        sleep: input.sleep,
+        pollIntervalMs: readNumberFlag('--poll-interval-ms', input.args),
+        timeoutMs: readNumberFlag('--timeout-ms', input.args),
+        logger: input.logger,
+    });
+    input.logger.info(`[wake stop] no active runs; stopping ${input.containerName}`);
+    await input.docker.down(input.containerName, { timeoutSeconds: STOP_GRACE_PERIOD_SECONDS });
+}

package/dist/src/cli/ui-command.js

@@ -0,0 +1,27 @@
+import { createUiServer } from '../adapters/http/ui-server.js';
+export async function runUiCommand(input) {
+    const log = input.log ?? console.log;
+    const portFlag = input.readFlag('--port', input.args);
+    const port = portFlag !== undefined ? Number(portFlag) : input.config.ui.port;
+    if (!Number.isInteger(port) || port <= 0) {
+        throw new Error(`Invalid --port: ${portFlag}`);
+    }
+    const host = input.readFlag('--host', input.args) ?? '127.0.0.1';
+    const token = input.readFlag('--token', input.args) ?? input.config.ui.token ?? process.env.WAKE_UI_TOKEN;
+    const server = createUiServer({
+        stateStore: input.stateStore,
+        resourceIndex: input.resourceIndex,
+        config: input.config,
+        ...(token === undefined ? {} : { token }),
+    });
+    await new Promise((resolveListen, reject) => {
+        server.once('error', reject);
+        server.listen(port, host, () => resolveListen());
+    });
+    log(`Wake UI listening on http://${host}:${port}`);
+    return {
+        close: () => new Promise((resolveClose) => {
+            server.close(() => resolveClose());
+        }),
+    };
+}

package/dist/src/config/defaults.js

@@ -0,0 +1,11 @@
+import { resolve } from 'node:path';
+import { defaultAgentIdentity, defaultSmokePrompt, parseWakeConfig } from '../domain/schema.js';
+export { defaultAgentIdentity, defaultSmokePrompt };
+export function createDefaultWakeConfig(wakeRoot = resolve(process.cwd(), '.wake')) {
+    return parseWakeConfig({
+        paths: {
+            wakeRoot,
+            promptsRoot: resolve(wakeRoot, 'prompts'),
+        },
+    });
+}

package/dist/src/config/load-config.js

@@ -0,0 +1,26 @@
+import { resolve } from 'node:path';
+import { access } from 'node:fs/promises';
+import { readJsonFile } from '../lib/json-file.js';
+import { parseWakeConfig } from '../domain/schema.js';
+export async function loadWakeConfig(options) {
+    const wakeRoot = options?.wakeRoot ?? resolve(process.cwd(), '.wake');
+    const configFile = options?.configFile;
+    let raw = {};
+    if (configFile !== undefined) {
+        try {
+            await access(configFile);
+            raw = await readJsonFile(configFile);
+        }
+        catch {
+            // no config file — schema defaults apply
+        }
+    }
+    const rawPaths = raw.paths ?? {};
+    return parseWakeConfig({
+        ...raw,
+        paths: {
+            wakeRoot,
+            ...rawPaths,
+        },
+    });
+}

package/dist/src/core/contracts.js

@@ -0,0 +1 @@
+export {};