@atolis-hq/wake 0.2.97 → 0.3.0

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

@@ -1,48 +0,0 @@
-export async function runDoctorCommand(config, deps) {
-    const failures = [...(await deps.collectPreflightFailures(config))];
-    const notices = [];
-    if (config.sources.github.enabled) {
-        try {
-            await deps.resolveGitHubToken();
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            failures.push(`GitHub token could not be resolved: ${message}`);
-        }
-    }
-    if (await deps.hasDockerfile(deps.wakeRoot)) {
-        const reachable = await deps.dockerReachable();
-        if (!reachable) {
-            failures.push('Docker daemon is not reachable');
-        }
-        else {
-            const imageExists = await deps.inspectImage(deps.image);
-            if (!imageExists) {
-                failures.push(`sandbox image "${deps.image}" not found — run \`wake sandbox build\``);
-            }
-        }
-    }
-    try {
-        if (await deps.containerRunning()) {
-            const sandboxVersion = await deps.execVersionInContainer();
-            if (sandboxVersion !== '' && sandboxVersion !== deps.installedVersion) {
-                notices.push(`sandbox is running version ${sandboxVersion}, installed CLI is ${deps.installedVersion} — run \`wake sandbox build && wake sandbox update\` to sync`);
-            }
-        }
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        notices.push(`could not check sandbox version: ${message}`);
-    }
-    try {
-        const driftedFiles = await deps.diffPromptsAndDockerfile();
-        for (const file of driftedFiles) {
-            notices.push(`${file} differs from the currently-shipped default (not auto-overwritten)`);
-        }
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        notices.push(`could not check prompt/Dockerfile drift: ${message}`);
-    }
-    return { failures, notices };
-}

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

@@ -1,18 +0,0 @@
-import { resolve } from 'node:path';
-import { assertEmptyDirectory, scaffoldWakeHome } from './scaffold-assets.js';
-export async function runInitCommand(input) {
-    const positionalArgs = input.args.filter((arg) => arg !== '--dev' && arg !== '--packaged');
-    const wakeRoot = resolve(input.cwd, positionalArgs[0] ?? '.');
-    const devModeOverride = input.args.includes('--dev')
-        ? 'source'
-        : input.args.includes('--packaged')
-            ? 'packaged'
-            : undefined;
-    await assertEmptyDirectory(wakeRoot);
-    await scaffoldWakeHome({
-        wakeRoot,
-        repoRoot: input.repoRoot,
-        ...(devModeOverride === undefined ? {} : { devModeOverride }),
-    });
-    return { wakeRoot };
-}

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

@@ -1,258 +0,0 @@
-import { access, mkdir, readFile, writeFile } from 'node:fs/promises';
-import { posix, resolve } from 'node:path';
-import { createRunnerCliAdapter } from '../adapters/runner/runner-cli-adapter.js';
-import { runSandboxResumeCommand } from './sandbox-resume.js';
-import { runSelfUpdateCommand, runSelfUpdateLoop } from './self-update-command.js';
-import { runStopCommand } from './stop-command.js';
-import { resolveWakeVersion, wakeVersion } from '../version.js';
-async function ensureDockerfile(input) {
-    const targetPath = resolve(input.wakeRoot, 'docker', 'Dockerfile');
-    try {
-        await access(targetPath);
-        return; // already present — user-owned, never overwritten
-    }
-    catch {
-        // fall through to write it
-    }
-    const mode = input.devMode ?? 'packaged';
-    const templatePath = resolve(input.packagedTemplatesRoot, mode === 'source' ? 'Dockerfile' : 'Dockerfile.packaged');
-    const content = await readFile(templatePath, 'utf8');
-    await mkdir(resolve(input.wakeRoot, 'docker'), { recursive: true });
-    await writeFile(targetPath, content, 'utf8');
-}
-async function ensureContainerHomeMountParents(input) {
-    for (const mount of input.extraMounts) {
-        const relativeTarget = posix.relative(input.containerHomeMountPath, mount.target);
-        if (relativeTarget.length === 0 || relativeTarget === '.' || relativeTarget.startsWith('..')) {
-            continue;
-        }
-        const parentRelativeTarget = posix.dirname(relativeTarget);
-        await mkdir(resolve(input.containerHomeRoot, parentRelativeTarget), {
-            recursive: true,
-        });
-    }
-}
-const sandboxSubcommands = [
-    ['build', 'Generate docker/Dockerfile (if missing) and build the sandbox image'],
-    ['up', 'Start the sandbox container'],
-    ['update', 'Recreate the sandbox container from the current image'],
-    ['down', 'Stop and remove the sandbox container'],
-    ['stop', 'Stop the resident loop gracefully, then the container'],
-    ['self-update', 'Pull the latest tag and rebuild (source dev.mode only)'],
-    ['setup', 'Run interactive first-time setup inside the container'],
-    ['exec', 'Run a command inside the sandbox container'],
-    ['logs', 'Print sandbox container logs'],
-    ['resume', 'Resume a previous agent session inside the sandbox'],
-];
-export function printSandboxUsage(stream) {
-    const width = Math.max(...sandboxSubcommands.map(([name]) => name.length));
-    stream.write([
-        'Usage: wake sandbox <subcommand>',
-        '',
-        'Subcommands:',
-        ...sandboxSubcommands.map(([name, description]) => `  ${name.padEnd(width)}  ${description}`),
-        '',
-    ].join('\n'));
-}
-function readFlag(name, args) {
-    const index = args.indexOf(name);
-    if (index === -1) {
-        return undefined;
-    }
-    return args[index + 1];
-}
-function uiDockerInput(config) {
-    return {
-        enabled: config.ui.enabled,
-        port: config.ui.port,
-        token: config.ui.token,
-        tunnel: config.ui.tunnel,
-    };
-}
-function startDockerInput(config) {
-    return {
-        enabled: config.sandbox.start.enabled,
-    };
-}
-export async function runSandboxCommand(input) {
-    const subcommand = input.args[0];
-    if (subcommand === undefined ||
-        subcommand === '--help' ||
-        subcommand === '-h' ||
-        subcommand === 'help') {
-        printSandboxUsage(process.stdout);
-        return;
-    }
-    if (subcommand === 'build') {
-        const repoRoot = input.config.dev?.repoRoot;
-        if (repoRoot === undefined || repoRoot.length === 0) {
-            throw new Error('Sandbox build requires config.dev.repoRoot');
-        }
-        const effectiveDevMode = input.config.dev?.mode ?? 'packaged';
-        const buildVersion = effectiveDevMode === 'source' ? resolveWakeVersion({ repoRoot }) : wakeVersion;
-        await ensureDockerfile({
-            wakeRoot: input.wakeRoot,
-            devMode: effectiveDevMode,
-            packagedTemplatesRoot: input.packagedTemplatesRoot,
-        });
-        await input.docker.build({
-            image: input.config.sandbox.image,
-            dockerfile: resolve(input.wakeRoot, 'docker', 'Dockerfile'),
-            contextDir: repoRoot,
-            buildArgs: effectiveDevMode === 'packaged'
-                ? { WAKE_VERSION: buildVersion }
-                : { WAKE_BUILD_TAG: buildVersion },
-        });
-        return;
-    }
-    if (subcommand === 'up') {
-        await ensureContainerHomeMountParents({
-            containerHomeRoot: input.containerHomeRoot,
-            containerHomeMountPath: input.config.sandbox.containerHomeMountPath,
-            extraMounts: input.config.sandbox.extraMounts,
-        });
-        await input.docker.up({
-            image: input.config.sandbox.image,
-            containerName: input.config.sandbox.containerName,
-            wakeRoot: input.wakeRoot,
-            containerHomeRoot: input.containerHomeRoot,
-            containerMountPath: input.config.sandbox.containerMountPath,
-            containerHomeMountPath: input.config.sandbox.containerHomeMountPath,
-            extraMounts: input.config.sandbox.extraMounts,
-            ui: uiDockerInput(input.config),
-            start: startDockerInput(input.config),
-        });
-        return;
-    }
-    if (subcommand === 'update') {
-        await ensureContainerHomeMountParents({
-            containerHomeRoot: input.containerHomeRoot,
-            containerHomeMountPath: input.config.sandbox.containerHomeMountPath,
-            extraMounts: input.config.sandbox.extraMounts,
-        });
-        await input.docker.update({
-            image: input.config.sandbox.image,
-            containerName: input.config.sandbox.containerName,
-            wakeRoot: input.wakeRoot,
-            containerHomeRoot: input.containerHomeRoot,
-            containerMountPath: input.config.sandbox.containerMountPath,
-            containerHomeMountPath: input.config.sandbox.containerHomeMountPath,
-            extraMounts: input.config.sandbox.extraMounts,
-            ui: uiDockerInput(input.config),
-            start: startDockerInput(input.config),
-        });
-        return;
-    }
-    if (subcommand === 'down') {
-        await input.docker.down(input.config.sandbox.containerName);
-        return;
-    }
-    if (subcommand === 'stop') {
-        await runStopCommand({
-            args: input.args.slice(1),
-            stateStore: input.stateStore,
-            ...(input.recoverActiveRuns === undefined
-                ? {}
-                : { recoverActiveRuns: input.recoverActiveRuns }),
-            docker: input.docker,
-            containerName: input.config.sandbox.containerName,
-            sleep: input.sleep,
-            logger: input.logger,
-        });
-        return;
-    }
-    if (subcommand === 'self-update') {
-        const repoRoot = input.config.dev?.repoRoot;
-        if (repoRoot === undefined || repoRoot.length === 0) {
-            throw new Error('Sandbox self-update requires config.dev.repoRoot');
-        }
-        if (input.selfUpdate === undefined) {
-            throw new Error('Sandbox self-update requires dev.mode: "source". For a packaged install, update instead with:\n' +
-                '  npm install -g @atolis-hq/wake@latest && wake sandbox build && wake sandbox update');
-        }
-        const selfUpdateArgs = input.args.slice(1);
-        const runSelfUpdate = selfUpdateArgs.includes('--loop')
-            ? runSelfUpdateLoop
-            : runSelfUpdateCommand;
-        await runSelfUpdate({
-            args: selfUpdateArgs,
-            repoRoot,
-            imageRepository: input.config.sandbox.imageRepository,
-            containerName: input.config.sandbox.containerName,
-            stateStore: input.stateStore,
-            ...(input.recoverActiveRuns === undefined
-                ? {}
-                : { recoverActiveRuns: input.recoverActiveRuns }),
-            docker: input.docker,
-            git: input.selfUpdate.git,
-            issueReporter: input.selfUpdate.issueReporter,
-            readLedger: input.selfUpdate.readLedger,
-            writeLedger: input.selfUpdate.writeLedger,
-            sleep: input.sleep,
-            logger: {
-                info: input.logger.info,
-                error: input.logger.error ?? input.logger.info,
-            },
-            wakeRoot: input.wakeRoot,
-            containerHomeRoot: input.containerHomeRoot,
-            containerMountPath: input.config.sandbox.containerMountPath,
-            containerHomeMountPath: input.config.sandbox.containerHomeMountPath,
-            dockerfilePath: resolve(repoRoot, 'docker', 'Dockerfile'),
-            ui: uiDockerInput(input.config),
-            start: startDockerInput(input.config),
-        });
-        return;
-    }
-    if (subcommand === 'setup') {
-        const setupCommand = input.config.dev?.mode === 'source'
-            ? ['node', '/app/dist/src/main.js', 'sandbox-setup']
-            : ['wake', 'sandbox-setup'];
-        await input.docker.exec(input.config.sandbox.containerName, setupCommand, {
-            interactive: true,
-        });
-        return;
-    }
-    if (subcommand === 'exec') {
-        const commandArgs = input.args.slice(1);
-        const wrappedCommand = commandArgs[0] === '--' ? commandArgs.slice(1) : commandArgs;
-        if (wrappedCommand.length === 0) {
-            // No command given: drop into an interactive shell with a real TTY,
-            // same as `docker exec -it ... bash`. That's a genuine interactive
-            // use case, so it stays on the inherited-stdio path rather than the
-            // piped/scrubbed one below (which would break TTY behavior).
-            await input.docker.exec(input.config.sandbox.containerName, []);
-            return;
-        }
-        await input.docker.execCaptured(input.config.sandbox.containerName, wrappedCommand, {
-            onStdout: (line) => input.logger.info(line),
-            onStderr: (line) => (input.logger.error ?? input.logger.info)(line),
-        });
-        return;
-    }
-    if (subcommand === 'logs') {
-        const tailLines = Number.parseInt(readFlag('--tail', input.args) ?? '200', 10);
-        await input.docker.logs(input.config.sandbox.containerName, Number.isFinite(tailLines) && tailLines > 0 ? tailLines : 200);
-        return;
-    }
-    if (subcommand === 'resume') {
-        const realEntry = Object.values(input.config.runners).find((e) => e.kind !== 'fake');
-        if (realEntry === undefined) {
-            throw new Error('Sandbox resume requires a real runner entry (`claude` or `codex`) in config.runners.');
-        }
-        const runnerAdapter = createRunnerCliAdapter({
-            entry: realEntry,
-            cwd: process.cwd(),
-        });
-        await runSandboxResumeCommand({
-            args: input.args.slice(1),
-            config: input.config,
-            docker: input.docker,
-            wakeRoot: input.wakeRoot,
-            containerHomeRoot: input.containerHomeRoot,
-            buildResumeCommand: runnerAdapter.buildResumeCommand,
-            logger: input.logger,
-        });
-        return;
-    }
-    throw new Error(`Unknown sandbox command: ${subcommand}`.trimEnd());
-}

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

@@ -1,88 +0,0 @@
-import { createWakePaths } from '../lib/paths.js';
-// The entrypoint always runs against the fixed in-container mount point
-// (/wake), so a literal wakeRoot here is safe.
-const CONTROL_PLANE_UI_URL_FILE = createWakePaths('/wake').controlPlaneUiUrlFile;
-const DEFAULT_UI_PORT = '4317';
-const DEFAULT_START_RESTART_DELAY_SECONDS = 10;
-/**
- * Resolves how to invoke the wake CLI from inside the container.
- *
- * Source-mode images (docker/Dockerfile) bake `WAKE_MAIN_JS` at build time,
- * pointing at the compiled entrypoint under /app. Packaged-mode images
- * (docker/Dockerfile.packaged) have no /app directory at all — the CLI is
- * installed globally via npm and exposed as a `wake` binary on PATH, so the
- * absence of WAKE_MAIN_JS is the signal to invoke it bare.
- */
-function resolveWakeInvocation(env) {
-    const mainJs = env.WAKE_MAIN_JS;
-    return mainJs !== undefined
-        ? { command: 'node', argsPrefix: [mainJs] }
-        : { command: 'wake', argsPrefix: [] };
-}
-async function discoverAndWriteNgrokUrl(deps) {
-    await deps.removeFile(CONTROL_PLANE_UI_URL_FILE);
-    const publicUrl = await deps.discoverNgrokUrl();
-    if (publicUrl !== undefined) {
-        await deps.writeFile(CONTROL_PLANE_UI_URL_FILE, `${publicUrl}\n`);
-        deps.log(`wake ui: ngrok tunnel available at ${publicUrl}`);
-        return;
-    }
-    deps.log('wake ui: ngrok tunnel started but public URL was not discovered; see /wake/.wake/logs/ngrok.log');
-}
-async function superviseWakeStart(deps, restartDelaySeconds) {
-    for (;;) {
-        deps.log('wake start: starting resident loop');
-        const { command, argsPrefix } = resolveWakeInvocation(deps.env);
-        // --no-sandbox: this already IS the sandbox — docker/Dockerfile is
-        // bind-mounted at /wake, so without this the process's own
-        // dispatchMainCommand would see it and try to auto-delegate into
-        // `docker exec`, which doesn't exist inside the container itself.
-        const { pid } = deps.spawnDetached(command, [...argsPrefix, 'start', '--wake-root', '/wake', '--no-sandbox'], { logFile: '/wake/.wake/logs/start.log' });
-        await deps.writeFile('/wake/.wake/logs/start.pid', String(pid));
-        const exitCode = await deps.waitForExit(pid);
-        deps.log(`wake start: resident loop exited with status ${exitCode}; restarting in ${restartDelaySeconds}s`);
-        await deps.sleep(restartDelaySeconds * 1000);
-    }
-}
-export async function runSandboxEntrypointCommand(deps) {
-    const { env } = deps;
-    await deps.ensureDir('/wake/.wake/logs');
-    if (env.WAKE_UI_ENABLED === 'true') {
-        const port = env.WAKE_UI_PORT ?? DEFAULT_UI_PORT;
-        deps.log(`wake ui: starting on 0.0.0.0:${port}`);
-        const { command, argsPrefix } = resolveWakeInvocation(env);
-        // --no-sandbox: same reason as the `wake start` spawn below — without
-        // it, this process would try to `docker exec` itself from inside the
-        // container it's already running in.
-        const uiArgs = [
-            ...argsPrefix,
-            'ui',
-            '--wake-root',
-            '/wake',
-            '--host',
-            '0.0.0.0',
-            '--port',
-            port,
-            '--no-sandbox',
-        ];
-        if (env.WAKE_UI_TOKEN) {
-            uiArgs.push('--token', env.WAKE_UI_TOKEN);
-        }
-        deps.spawnDetached(command, uiArgs, { logFile: '/wake/.wake/logs/ui.log' });
-        if (env.WAKE_UI_TUNNEL_ENABLED === 'true') {
-            if (env.NGROK_AUTHTOKEN) {
-                const { pid } = deps.spawnDetached('ngrok', ['config', 'add-authtoken', env.NGROK_AUTHTOKEN], { logFile: '/wake/.wake/logs/ngrok.log' });
-                await deps.waitForExit(pid);
-            }
-            deps.log(`wake ui: starting ngrok tunnel for 127.0.0.1:${port}`);
-            deps.spawnDetached('ngrok', ['http', `127.0.0.1:${port}`, '--log=stdout'], {
-                logFile: '/wake/.wake/logs/ngrok.log',
-            });
-            void discoverAndWriteNgrokUrl(deps);
-        }
-    }
-    if (env.WAKE_START_ENABLED === 'true') {
-        const restartDelaySeconds = Number(env.WAKE_START_RESTART_DELAY_SECONDS ?? DEFAULT_START_RESTART_DELAY_SECONDS);
-        void superviseWakeStart(deps, restartDelaySeconds);
-    }
-}

package/dist/src/cli/sandbox-exec-logging.js

@@ -1,7 +0,0 @@
-const ENV_SECRET_PATTERN = /([A-Za-z0-9_]*(?:TOKEN|SECRET|PASSWORD|PASS|KEY)[A-Za-z0-9_]*=)[^\s]+/gi;
-const GITHUB_TOKEN_PATTERN = /(?:gho|ghp|github_pat)_[A-Za-z0-9_]+/g;
-export function scrubSecrets(line) {
-    return line
-        .replace(ENV_SECRET_PATTERN, '$1[REDACTED]')
-        .replace(GITHUB_TOKEN_PATTERN, '[REDACTED]');
-}

package/dist/src/cli/sandbox-resume.js

@@ -1,79 +0,0 @@
-import { stdin as input, stdout as output } from 'node:process';
-import { createInterface } from 'node:readline/promises';
-import { join } from 'node:path';
-import { listRunRecords } from '../adapters/fs/state-store.js';
-function shellQuote(value) {
-    return `'${value.replaceAll("'", `'\\''`)}'`;
-}
-function buildCwdWrappedShellCommand(cwd, command) {
-    const shellCommand = `cd ${shellQuote(cwd)} && ${command.map(shellQuote).join(' ')}`;
-    return ['sh', '-c', shellCommand];
-}
-function readFlag(name, args) {
-    const index = args.indexOf(name);
-    if (index === -1) {
-        return undefined;
-    }
-    return args[index + 1];
-}
-function compareRunRecordsDescending(left, right) {
-    const leftTimestamp = left.finishedAt ?? left.startedAt;
-    const rightTimestamp = right.finishedAt ?? right.startedAt;
-    return rightTimestamp.localeCompare(leftTimestamp);
-}
-export async function promptResumeSelection(options) {
-    if (options.length === 0) {
-        return null;
-    }
-    for (const [index, option] of options.entries()) {
-        output.write(`${index + 1}. ${option.label}\n`);
-    }
-    const rl = createInterface({ input, output });
-    try {
-        const answer = (await rl.question('Select a resume target: ')).trim();
-        const selection = Number.parseInt(answer, 10);
-        if (!Number.isInteger(selection) || selection < 1 || selection > options.length) {
-            return null;
-        }
-        return options[selection - 1] ?? null;
-    }
-    finally {
-        rl.close();
-    }
-}
-export async function chooseResumeTarget(input) {
-    const options = (await listRunRecords(input.wakeRoot))
-        .filter((record) => record.sessionId !== undefined)
-        .sort(compareRunRecordsDescending)
-        .map((record) => ({
-        label: `${record.repo}#${record.issueNumber} · ${record.action} · ${record.finishedAt ?? record.startedAt}`,
-        value: {
-            sessionId: record.sessionId,
-            workspacePath: join(input.wakeRoot, 'workspaces', record.repo.replace(/[\\/]/g, '__'), String(record.issueNumber)),
-        },
-    }));
-    const selected = await input.select(options);
-    return selected?.value ?? null;
-}
-export async function runSandboxResumeCommand(input) {
-    const sessionId = input.args[0];
-    const explicitCwd = readFlag('--cwd', input.args);
-    const target = sessionId !== undefined
-        ? explicitCwd === undefined
-            ? null
-            : { sessionId, workspacePath: explicitCwd }
-        : await chooseResumeTarget({
-            wakeRoot: input.wakeRoot,
-            select: input.select ?? promptResumeSelection,
-        });
-    if (target === null) {
-        if (sessionId !== undefined && explicitCwd === undefined) {
-            throw new Error('Sandbox resume requires --cwd when a session ID is provided.');
-        }
-        throw new Error('No resumable sandbox session selected.');
-    }
-    await input.docker.execCaptured(input.config.sandbox.containerName, buildCwdWrappedShellCommand(target.workspacePath, input.buildResumeCommand({ sessionId: target.sessionId })), {
-        onStdout: (line) => input.logger.info(line),
-        onStderr: (line) => (input.logger.error ?? input.logger.info)(line),
-    });
-}

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

@@ -1,31 +0,0 @@
-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', '--device-auth']);
-    }
-    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,100 +0,0 @@
-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 { splitWakeConfig } from '../config/split-config.js';
-import { writeYamlFile } from '../lib/yaml-file.js';
-import { createWakePaths } from '../lib/paths.js';
-async function listPromptFileNames(repoRoot) {
-    const entries = await readdir(join(repoRoot, 'prompts'));
-    return entries.filter((name) => name.endsWith('.md')).sort();
-}
-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);
-        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);
-    }));
-}
-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 = {
-        ...defaults,
-        sandbox: {
-            ...defaults.sandbox,
-            containerName: `wake-sandbox-${sanitizeContainerName(basename(wakeRoot))}`,
-        },
-        dev: {
-            repoRoot,
-            mode: devMode,
-        },
-    };
-    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 })));
-    const { infra, workflow } = splitWakeConfig(config);
-    const promptFileNames = await listPromptFileNames(repoRoot);
-    await Promise.all([
-        copyAssets(repoRoot, 'prompts', join(wakeRoot, 'prompts'), promptFileNames),
-        copyFile(join(repoRoot, 'templates', 'SETUP.md'), join(wakeRoot, 'SETUP.md')),
-        writeYamlFile(join(wakeRoot, 'config.yaml'), infra),
-        writeYamlFile(join(wakeRoot, 'config.workflows.yaml'), workflow),
-    ]);
-}