@atolis-hq/wake 0.1.22 → 0.2.0

package/dist/src/cli/sandbox-setup-command.js

@@ -0,0 +1,31 @@
+export async function runSandboxSetupCommand(deps) {
+    deps.log('Wake sandbox setup starting.');
+    await deps.prepareCodexHome();
+    await deps.ensureSshKey();
+    if (await deps.prompt('Configure GitHub auth? [y/N]')) {
+        deps.log('Optional best practice: sign in with a dedicated GitHub identity for Wake-managed agent work, rather than your main personal account. Make sure it has only the repository access Wake needs.');
+        await deps.runInteractive('gh', ['auth', 'login']);
+        await deps.runInteractive('gh', ['auth', 'setup-git']);
+    }
+    else {
+        deps.log('Skipping GitHub auth setup.');
+    }
+    if (await deps.prompt('Configure Claude auth? [y/N]')) {
+        await deps.runInteractive('claude', ['auth', 'login', '--claudeai']);
+    }
+    else {
+        deps.log('Skipping Claude auth setup.');
+    }
+    if (await deps.prompt('Configure Codex auth? [y/N]')) {
+        await deps.runInteractive('codex', ['login']);
+    }
+    else {
+        deps.log('Skipping Codex auth setup.');
+    }
+    if (await deps.prompt('Configure Cursor auth? [y/N]')) {
+        await deps.runInteractive('agent', ['login']);
+    }
+    else {
+        deps.log('Skipping Cursor auth setup.');
+    }
+}

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

@@ -1,19 +1,27 @@
-import { chmod, copyFile, mkdir, readFile, readdir, writeFile } from 'node:fs/promises';
-import { dirname, join, resolve } from 'node:path';
+import { access, chmod, copyFile, mkdir, readFile, readdir, writeFile } from 'node:fs/promises';
+import { basename, 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',
-];
+import { createWakePaths } from '../lib/paths.js';
 const promptFileNames = ['refine.md', 'implement.md'];
-const dockerAssetNames = ['Dockerfile', 'setup.sh', 'log-command.sh'];
+function sanitizeContainerName(name) {
+    const sanitized = name
+        .toLowerCase()
+        .replace(/[^a-z0-9_.-]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^[-._]+|[-._]+$/g, '');
+    return sanitized.length > 0 ? sanitized : 'wake';
+}
+export async function detectDevMode(repoRoot) {
+    try {
+        await access(join(repoRoot, 'src', 'main.ts'));
+        await access(join(repoRoot, 'tsconfig.json'));
+        return 'source';
+    }
+    catch {
+        return 'packaged';
+    }
+}
 export async function assertEmptyDirectory(targetDir) {
     try {
         const entries = await readdir(targetDir);
@@ -45,129 +53,40 @@ async function copyAssets(repoRoot, sourceDir, targetDir, fileNames) {
         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 devMode = input.devModeOverride ?? (await detectDevMode(repoRoot));
+    const defaults = createDefaultWakeConfig(wakeRoot);
     const config = {
-        ...createDefaultWakeConfig(wakeRoot),
+        ...defaults,
+        sandbox: {
+            ...defaults.sandbox,
+            containerName: `wake-sandbox-${sanitizeContainerName(basename(wakeRoot))}`,
+        },
         dev: {
             repoRoot,
+            mode: devMode,
         },
     };
-    await Promise.all(runtimeDirectoryNames.map((directoryName) => mkdir(join(wakeRoot, directoryName), { recursive: true })));
+    const paths = createWakePaths(wakeRoot);
+    const runtimeDirectories = [
+        paths.dataRoot,
+        join(paths.dataRoot, 'events'),
+        join(paths.dataRoot, 'state'),
+        join(paths.dataRoot, 'runs'),
+        join(paths.dataRoot, 'sources'),
+        join(paths.dataRoot, 'repos'),
+        join(paths.dataRoot, 'locks'),
+        join(paths.dataRoot, 'logs'),
+        join(paths.dataRoot, 'control'),
+        join(paths.dataRoot, 'container-home'),
+        join(paths.dataRoot, 'transcripts'),
+        paths.workspaceRoot,
+    ];
+    await Promise.all(runtimeDirectories.map((directoryPath) => mkdir(directoryPath, { 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

@@ -4,7 +4,7 @@ const START_PROCESS_CHECK = [
     'sh',
     '-lc',
     [
-        'pid="$(cat /wake/logs/start.pid)"',
+        'pid="$(cat /wake/.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',

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

@@ -61,7 +61,7 @@ async function assertPromptsRootAccessible(promptsRoot) {
     }
     await access(promptsRoot);
 }
-export async function runStartupPreflight(config, deps = {}) {
+export async function collectStartupPreflightFailures(config, deps = {}) {
     const failures = [];
     const loadPrompt = deps.loadPrompt ?? defaultLoadPrompt;
     const checkRunnerCommand = deps.checkRunnerCommand ?? defaultCheckRunnerCommand;
@@ -121,6 +121,10 @@ export async function runStartupPreflight(config, deps = {}) {
             }
         }
     }
+    return failures;
+}
+export async function runStartupPreflight(config, deps = {}) {
+    const failures = await collectStartupPreflightFailures(config, deps);
     if (failures.length > 0) {
         throw formatPreflightFailures(failures);
     }

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

@@ -15,12 +15,16 @@ export async function loadWakeConfig(options) {
             // no config file — schema defaults apply
         }
     }
+    // wakeRoot is always the live invocation's --wake-root/cwd, never a value
+    // to accept from a (possibly stale, possibly container-context) config
+    // file — spread rawPaths first so wakeRoot always wins. promptsRoot and
+    // any other paths key stay file-overridable.
     const rawPaths = raw.paths ?? {};
     return parseWakeConfig({
         ...raw,
         paths: {
-            wakeRoot,
             ...rawPaths,
+            wakeRoot,
         },
     });
 }

package/dist/src/domain/schema.js

@@ -433,6 +433,7 @@ export const wakeConfigSchema = z
     dev: z
         .object({
         repoRoot: z.string().optional(),
+        mode: z.enum(['source', 'packaged']).optional(),
     })
         .default({}),
     scheduler: z

package/dist/src/lib/paths.js

@@ -6,40 +6,43 @@ export function sanitizePathKey(value) {
     return value.replace(/[^A-Za-z0-9._-]/g, '__');
 }
 export function createWakePaths(wakeRoot) {
+    const dataRoot = join(wakeRoot, '.wake');
     return {
         wakeRoot,
-        containerHomeRoot: join(wakeRoot, 'container-home'),
+        dataRoot,
+        containerHomeRoot: join(dataRoot, 'container-home'),
         configFile: join(wakeRoot, 'config.json'),
-        ledgerFile: join(wakeRoot, 'ledger.json'),
-        pauseFile: join(wakeRoot, 'PAUSE'),
-        tickRequestFile: join(wakeRoot, 'control', 'tick-request.json'),
-        tickLockFile: join(wakeRoot, 'locks', 'tick.lock'),
-        runnerLockFile: join(wakeRoot, 'locks', 'runner.lock'),
-        issueFixtureFile: join(wakeRoot, 'fixtures', 'issues.json'),
+        ledgerFile: join(dataRoot, 'ledger.json'),
+        pauseFile: join(dataRoot, 'PAUSE'),
+        tickRequestFile: join(dataRoot, 'control', 'tick-request.json'),
+        tickLockFile: join(dataRoot, 'locks', 'tick.lock'),
+        runnerLockFile: join(dataRoot, 'locks', 'runner.lock'),
+        issueFixtureFile: join(dataRoot, 'fixtures', 'issues.json'),
         workspaceRoot: join(wakeRoot, 'workspaces'),
-        transcriptsRoot: join(wakeRoot, 'transcripts'),
-        reposRoot: join(wakeRoot, 'repos'),
-        repoRoot: (repo) => join(wakeRoot, 'repos', sanitizeRepo(repo)),
-        sourceStateRoot: join(wakeRoot, 'sources'),
+        transcriptsRoot: join(dataRoot, 'transcripts'),
+        reposRoot: join(dataRoot, 'repos'),
+        repoRoot: (repo) => join(dataRoot, 'repos', sanitizeRepo(repo)),
+        sourceStateRoot: join(dataRoot, 'sources'),
         // Keyed on the minted work id, which is filename-safe by construction
         // (src/lib/work-id.ts) — hence no sanitizePathKey here. No durable path
         // embeds a provider, repo, or issue segment (spec §3).
-        workItemStateFile: (workId) => join(wakeRoot, 'state', `${workId}.json`),
-        archivedWorkItemStateFile: (workId) => join(wakeRoot, 'state', 'archive', `${workId}.json`),
-        sourceStateFile: (source, key) => join(wakeRoot, 'sources', sanitizePathKey(source), `${sanitizePathKey(key)}.json`),
-        runFile: (runId) => join(wakeRoot, 'runs', `${runId}.json`),
-        runDateFile: (date, runId) => join(wakeRoot, 'runs', 'by-date', date, `${runId}.json`),
-        eventFile: (date) => join(wakeRoot, 'events', `${date}.jsonl`),
-        eventEnvelopeFile: (eventId) => join(wakeRoot, 'events-by-id', `${sanitizePathKey(eventId)}.json`),
-        logFile: (date) => join(wakeRoot, 'logs', `${date}.log`),
+        workItemStateFile: (workId) => join(dataRoot, 'state', `${workId}.json`),
+        archivedWorkItemStateFile: (workId) => join(dataRoot, 'state', 'archive', `${workId}.json`),
+        sourceStateFile: (source, key) => join(dataRoot, 'sources', sanitizePathKey(source), `${sanitizePathKey(key)}.json`),
+        runFile: (runId) => join(dataRoot, 'runs', `${runId}.json`),
+        runDateFile: (date, runId) => join(dataRoot, 'runs', 'by-date', date, `${runId}.json`),
+        eventFile: (date) => join(dataRoot, 'events', `${date}.jsonl`),
+        eventEnvelopeFile: (eventId) => join(dataRoot, 'events-by-id', `${sanitizePathKey(eventId)}.json`),
+        logFile: (date) => join(dataRoot, 'logs', `${date}.log`),
         // Workspaces and transcripts are ephemeral scratch rather than durable
         // state, but they re-key to the work id anyway: they are 1:1 with a work
         // item, not a ticket, and a ticket-shaped path here would preserve the
         // second ticket-shaped identity this change exists to remove (spec §3).
         workspaceDir: (workId) => join(wakeRoot, 'workspaces', workId),
-        transcriptWorkDir: (workId) => join(wakeRoot, 'transcripts', workId),
-        transcriptSessionDir: (workId, sessionKey) => join(wakeRoot, 'transcripts', workId, sanitizePathKey(sessionKey)),
-        resourceIndexRoot: join(wakeRoot, 'state', 'index'),
-        resourceIndexShardFile: (shard) => join(wakeRoot, 'state', 'index', `${shard}.json`),
+        transcriptWorkDir: (workId) => join(dataRoot, 'transcripts', workId),
+        transcriptSessionDir: (workId, sessionKey) => join(dataRoot, 'transcripts', workId, sanitizePathKey(sessionKey)),
+        resourceIndexRoot: join(dataRoot, 'state', 'index'),
+        resourceIndexShardFile: (shard) => join(dataRoot, 'state', 'index', `${shard}.json`),
+        controlPlaneUiUrlFile: join(dataRoot, 'control-plane-ui-url'),
     };
 }