@atolis-hq/wake 0.2.5 → 0.2.7

package/README.md

@@ -97,7 +97,8 @@ For more detail, see [docs/vision.md](docs/vision.md) and
   log; projections can be rebuilt, and the loop can crash and resume without
   losing its place.
 - **Local and inspectable.** Everything lives in a plain-file Wake home
-  directory: `config.yaml`, `config.workflows.yaml`, `prompts/`, and `workspaces/` at the top level for
+  directory: `config.yaml`, `config.workflows.yaml`, `prompts/`, `SETUP.md`, and
+  `workspaces/` at the top level for
   what you edit or browse day-to-day, with durable/internal state (events,
   projections, runs, logs, sandbox auth) nested under a hidden `.wake/`.
 - **Sandbox-oriented execution.** Wake can run from a persistent Docker sandbox
@@ -150,6 +151,8 @@ npm install -g @atolis-hq/wake
 cd ~/
 wake init ./wake-home
 cd ./wake-home
+# point your agent CLI at the scaffolded SETUP.md to finish configuring
+# (e.g. "read SETUP.md and help me configure this")
 wake sandbox build
 wake sandbox up
 wake sandbox setup

package/dist/src/adapters/docker/docker-cli.js

@@ -7,10 +7,16 @@ function buildStopArgs(containerName, timeoutSeconds) {
         containerName,
     ];
 }
+const DOCKER_LOG_MAX_SIZE = '10m';
+const DOCKER_LOG_MAX_FILE = '3';
 function buildRunArgs(input) {
     return [
         'run',
         '-d',
+        '--log-opt',
+        `max-size=${DOCKER_LOG_MAX_SIZE}`,
+        '--log-opt',
+        `max-file=${DOCKER_LOG_MAX_FILE}`,
         '--name',
         input.containerName,
         '-v',
@@ -21,7 +27,7 @@ function buildRunArgs(input) {
             '-v',
             `${mount.source}:${mount.target}${mount.readOnly === true ? ':ro' : ''}`,
         ]),
-        // Auto-started by docker/entrypoint.sh; the UI binds 0.0.0.0 inside the
+        // Auto-started by wake sandbox-entrypoint; the UI binds 0.0.0.0 inside the
         // container so this published port can reach it (127.0.0.1 inside the
         // container would not be reachable via docker's port-forwarding NAT).
         ...(input.ui?.enabled === true

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

@@ -93,6 +93,7 @@ export async function scaffoldWakeHome(input) {
     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),
     ]);

package/dist/src/lib/detached-process-logging.js

@@ -0,0 +1,46 @@
+import { createWriteStream } from 'node:fs';
+import { DEFAULT_LOG_MAX_BYTES, DEFAULT_LOG_ROTATE_CHECK_INTERVAL_MS, rotateLogFileIfNeeded, } from './log-rotation.js';
+export function createDetachedProcessLogSink(logFile, options) {
+    const maxBytes = options?.maxBytes ?? DEFAULT_LOG_MAX_BYTES;
+    const rotateCheckIntervalMs = options?.rotateCheckIntervalMs ?? DEFAULT_LOG_ROTATE_CHECK_INTERVAL_MS;
+    const stdout = options?.stdout ?? process.stdout;
+    let closed = false;
+    let fileStream = openLogFile(logFile, maxBytes);
+    const rotateInterval = setInterval(() => {
+        if (closed) {
+            return;
+        }
+        const stream = fileStream;
+        stream.end(() => {
+            if (closed) {
+                return;
+            }
+            rotateLogFileIfNeeded(logFile, maxBytes);
+            fileStream = openLogFile(logFile, maxBytes);
+        });
+    }, rotateCheckIntervalMs);
+    rotateInterval.unref();
+    return {
+        write: (chunk) => {
+            if (closed) {
+                return;
+            }
+            fileStream.write(chunk);
+            stdout.write(chunk);
+        },
+        close: () => {
+            if (closed) {
+                return Promise.resolve();
+            }
+            closed = true;
+            clearInterval(rotateInterval);
+            return new Promise((resolve) => {
+                fileStream.end(resolve);
+            });
+        },
+    };
+}
+function openLogFile(logFile, maxBytes) {
+    rotateLogFileIfNeeded(logFile, maxBytes);
+    return createWriteStream(logFile, { flags: 'a' });
+}

package/dist/src/lib/log-rotation.js

@@ -0,0 +1,42 @@
+import { renameSync, rmSync, statSync } from 'node:fs';
+export const DEFAULT_LOG_MAX_BYTES = 20 * 1024 * 1024;
+export const DEFAULT_LOG_ROTATE_CHECK_INTERVAL_MS = 5 * 60 * 1000;
+export function resolveLogMaxBytes(env = process.env) {
+    const raw = env.WAKE_LOG_MAX_BYTES;
+    if (raw === undefined || raw.trim() === '') {
+        return DEFAULT_LOG_MAX_BYTES;
+    }
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        return DEFAULT_LOG_MAX_BYTES;
+    }
+    return Math.floor(parsed);
+}
+export function resolveLogRotateCheckIntervalMs(env = process.env) {
+    const raw = env.WAKE_LOG_ROTATE_CHECK_INTERVAL_MS;
+    if (raw === undefined || raw.trim() === '') {
+        return DEFAULT_LOG_ROTATE_CHECK_INTERVAL_MS;
+    }
+    const parsed = Number(raw);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+        return DEFAULT_LOG_ROTATE_CHECK_INTERVAL_MS;
+    }
+    return Math.floor(parsed);
+}
+export function rotateLogFileIfNeeded(logFile, maxBytes = DEFAULT_LOG_MAX_BYTES) {
+    try {
+        if (statSync(logFile).size < maxBytes) {
+            return false;
+        }
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return false;
+        }
+        throw error;
+    }
+    const backupFile = `${logFile}.1`;
+    rmSync(backupFile, { force: true });
+    renameSync(logFile, backupFile);
+    return true;
+}

package/dist/src/main.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { spawn } from 'node:child_process';
-import { closeSync, existsSync, openSync } from 'node:fs';
+import { existsSync } from 'node:fs';
 import { access, chmod, copyFile, mkdir, readdir, readFile, rm, writeFile } from 'node:fs/promises';
 import { dirname, join, resolve } from 'node:path';
 import { createInterface } from 'node:readline/promises';
@@ -32,7 +32,9 @@ import { createControlPlane } from './core/control-plane.js';
 import { createOutboundSinkRouter, createWorkSourceFanIn } from './core/sink-router.js';
 import { createTickRunner } from './core/tick-runner.js';
 import { systemClock } from './lib/clock.js';
+import { createDetachedProcessLogSink } from './lib/detached-process-logging.js';
 import { readJsonFile } from './lib/json-file.js';
+import { resolveLogMaxBytes, resolveLogRotateCheckIntervalMs } from './lib/log-rotation.js';
 import { configuredTicketSource } from './domain/sources.js';
 import { wakeVersion } from './version.js';
 function commandArgsBeforeTerminator(args) {
@@ -243,16 +245,26 @@ function createSandboxEntrypointDeps() {
     return {
         env: process.env,
         spawnDetached: (command, args, options) => {
-            const logFd = options?.logFile !== undefined ? openSync(options.logFile, 'a') : 'ignore';
+            const logSink = options?.logFile !== undefined
+                ? createDetachedProcessLogSink(options.logFile, {
+                    maxBytes: resolveLogMaxBytes(process.env),
+                    rotateCheckIntervalMs: resolveLogRotateCheckIntervalMs(process.env),
+                })
+                : undefined;
             const child = spawn(command, args, {
                 cwd: process.cwd(),
                 env: process.env,
-                stdio: ['ignore', logFd, logFd],
+                stdio: ['ignore', 'pipe', 'pipe'],
                 detached: true,
             });
             if (typeof child.pid === 'number') {
                 children.set(child.pid, child);
             }
+            const forwardOutput = (chunk) => {
+                logSink?.write(chunk);
+            };
+            child.stdout?.on('data', forwardOutput);
+            child.stderr?.on('data', forwardOutput);
             // Registered here (at spawn time) so it runs before any exit listener
             // waitForExit attaches later — though it wouldn't matter either way:
             // waitForExit captures the ChildProcess reference synchronously from
@@ -264,9 +276,7 @@ function createSandboxEntrypointDeps() {
                 if (typeof child.pid === 'number') {
                     children.delete(child.pid);
                 }
-                if (logFd !== 'ignore') {
-                    closeSync(logFd);
-                }
+                logSink?.close().catch(() => { });
             });
             return { pid: child.pid ?? -1 };
         },

package/dist/src/version.js

@@ -1 +1 @@
-export const wakeVersion = "0.2.5+ga2cf757";
+export const wakeVersion = "0.2.7+gd91da24";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atolis-hq/wake",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "Local autonomous agent control plane for software development",
   "license": "Apache-2.0",
   "repository": {
@@ -17,6 +17,7 @@
     "dist/src",
     "docker",
     "prompts",
+    "templates",
     "README.md",
     "LICENSE"
   ],

package/templates/SETUP.md

@@ -0,0 +1,115 @@
+# Wake Setup Guide (for the assisting agent)
+
+You are reading this because a human just ran `wake init` and asked you to
+help finish configuring this Wake home. This file is written as instructions
+to you, the assisting agent — not as prose for a human to read top to bottom.
+
+Read `config.yaml` and `config.workflows.yaml` in this directory now — both
+already exist with working defaults from `wake init`. Everything below tells
+you which fields in those two files to change. Edit them directly; don't
+create a new `config.<label>.yaml` split unless the user asks for one.
+
+Work through the three sections below in order, asking the user only what's
+asked in each section. Each section links the relevant part of the hosted
+`docs/configuration.md` for full field-by-field reference beyond what's
+summarized here.
+
+## 1. GitHub source
+
+Ask the user:
+
+- Which GitHub repo(s) should Wake monitor for issues? (`owner/repo` format)
+- Should polling start immediately, or stay off until they're ready?
+
+Edit in `config.yaml`:
+
+```yaml
+sources:
+  github:
+    enabled: true # or leave false to configure now, enable later
+    repos: [owner/repo] # one or more, owner/repo format
+```
+
+Tell the user: once enabled, Wake adds/removes a
+`wake:status.pending|working|failed|completed` label on issues it works, and
+preserves any other labels already on the issue.
+
+Full reference:
+https://github.com/atolis-hq/wake/blob/main/docs/configuration.md#sourcesgithub
+
+## 2. Runner and tier
+
+Ask the user which agent CLI(s) they have authenticated on this host:
+Claude, Codex, and/or Cursor.
+
+`config.workflows.yaml` already has example `runners` entries for
+`claude-haiku`, `claude-opus`, `codex-mini`, `codex-flagship`, and
+`cursor-composer`, but every tier (`light`/`standard`/`deep`, with
+`defaultTier: standard`) still points at the placeholder `fake` runner — none
+of them route to a real runner yet. Don't rewrite this from scratch — pick
+which runner(s) the user actually has access to, and either:
+
+- repoint `tiers` so each tier lists the real named runner(s) the user can
+  actually use instead of `fake`, or
+- if the user has a runner not already listed (a different model, a
+  different CLI), add a new named entry under `runners` following the
+  existing pattern, then reference it from `tiers`.
+- remove entries which are not needed.
+
+Full reference:
+https://github.com/atolis-hq/wake/blob/main/docs/configuration.md#runners
+and
+https://github.com/atolis-hq/wake/blob/main/docs/configuration.md#tiers
+
+## 3. Credential mounts (check before asking)
+
+Do not start by asking the user where their credentials are. First check the
+host filesystem yourself for the files below, matching whichever runner(s)
+were chosen in step 2:
+
+- Claude: `~/.claude/.credentials.json` and `~/.claude/settings.json`
+- Codex: `~/.codex/config.toml` and `~/.codex/auth.json`
+- Cursor: `~/.config/cursor/auth.json`
+
+For each file that exists, propose adding it to `sandbox.extraMounts` in
+`config.yaml`, for example:
+
+```yaml
+sandbox:
+  extraMounts:
+    - source: /home/alice/.claude/.credentials.json
+      target: /home/wake/.claude/.credentials.json
+      readOnly: true
+    - source: /home/alice/.claude/settings.json
+      target: /home/wake/.claude/settings.json
+      readOnly: false
+```
+
+`.credentials.json`/`auth.json` should be `readOnly: true` unless the user
+wants the sandbox able to refresh tokens on the host's behalf. `settings.json`
+must stay `readOnly: false` — Claude plugin commands write to it. Use the
+actual host home directory path (resolve `~` yourself; don't write a literal
+tilde into YAML).
+
+Never mount the whole `~/.claude`, `~/.codex`, or `~/.cursor` directory —
+only the specific files listed above. Mounting the whole directory leaks
+OS-specific absolute paths (e.g. Windows plugin cache paths) into the Linux
+sandbox and can cause the sandbox to overwrite the host's plugin bookkeeping.
+
+Only if none of the expected files exist for the runner the user chose, ask
+them directly where their credentials live (e.g. a custom `CODEX_HOME`).
+
+Full reference:
+https://github.com/atolis-hq/wake/blob/main/docs/configuration.md#sandbox
+
+## After config looks right
+
+Don't try to explain the sandbox lifecycle yourself — point the user at (or
+fetch, if you have web access):
+
+- https://github.com/atolis-hq/wake/blob/main/docs/getting-started.md —
+  `wake sandbox build` / `up` / `setup` / `exec` / `down`
+- https://github.com/atolis-hq/wake/blob/main/docs/runner-comparison.md —
+  deeper comparison of runner tradeoffs if the user asks which to pick
+- https://github.com/atolis-hq/wake/blob/main/docs/configuration.md — every
+  config field, if something here doesn't cover their situation