@atolis-hq/wake 0.2.4 → 0.2.6

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/adapters/github/github-issues-work-source.js

@@ -180,6 +180,22 @@ export async function readControlPlaneUiUrl(wakeRoot) {
         return undefined;
     }
 }
+export function formatGitHubError(error) {
+    if (error instanceof Error) {
+        const octokit = error;
+        if (octokit.status !== undefined) {
+            const headers = octokit.response?.headers ?? {};
+            const parts = [`status=${octokit.status}`];
+            if (headers['x-ratelimit-remaining'] !== undefined)
+                parts.push(`ratelimit-remaining=${headers['x-ratelimit-remaining']}`);
+            if (headers['retry-after'] !== undefined)
+                parts.push(`retry-after=${headers['retry-after']}`);
+            return parts.join(' ');
+        }
+        return error.message.slice(0, 300);
+    }
+    return String(error).slice(0, 300);
+}
 export function formatWakeComment(payload, controlPlaneUrl) {
     const body = typeof payload.body === 'string' ? payload.body : '';
     const kind = typeof payload.kind === 'string' ? payload.kind : undefined;
@@ -314,7 +330,7 @@ export function createGitHubIssuesWorkSource(deps) {
                     });
                 }
                 catch (error) {
-                    console.error(`[github-work-source] poll failed for ${repoRef}, skipping this tick: ${error instanceof Error ? error.message : String(error)}`);
+                    console.error(`[github-work-source] poll failed for ${repoRef}, skipping this tick: ${formatGitHubError(error)}`);
                 }
             }
             return events;

package/dist/src/adapters/github/github-pull-request-activity-source.js

@@ -1,6 +1,6 @@
 import { buildResourceUri } from '../../domain/resource-uri.js';
 import { createUnkeyedEventEnvelope, createEventEnvelope } from '../../lib/event-log.js';
-import { formatWakeComment, readControlPlaneUiUrl } from './github-issues-work-source.js';
+import { formatGitHubError, formatWakeComment, readControlPlaneUiUrl, } from './github-issues-work-source.js';
 const githubPrSource = 'github-pr';
 const wakeCommentMarker = '<!-- wake:agent -->';
 function prResourceUri(repo, number) {
@@ -122,7 +122,7 @@ export function createGitHubPullRequestActivitySource(deps) {
                 }
             }
             catch (error) {
-                console.error(`[github-pr-activity-source] discovery failed for ${repoRef}, skipping this tick: ${error instanceof Error ? error.message : String(error)}`);
+                console.error(`[github-pr-activity-source] discovery failed for ${repoRef}, skipping this tick: ${formatGitHubError(error)}`);
             }
         }
         return { events, seenPrData, confirmedOpenRepos };
@@ -247,7 +247,7 @@ export function createGitHubPullRequestActivitySource(deps) {
             }
         }
         catch (error) {
-            console.error(`[github-pr-activity-source] activity poll failed for ${resourceUri}, skipping this tick: ${error instanceof Error ? error.message : String(error)}`);
+            console.error(`[github-pr-activity-source] activity poll failed for ${resourceUri}, skipping this tick: ${formatGitHubError(error)}`);
         }
         return events;
     }
@@ -391,7 +391,7 @@ export function createGitHubPullRequestActivitySource(deps) {
                     return await pollRequiredCheckFailures(ref, watchRef.resourceUri, ingestedAt, seenPrData.get(watchRef.resourceUri));
                 }
                 catch (error) {
-                    console.error(`[github-pr-activity-source] check poll failed for ${watchRef.resourceUri}, skipping this tick: ${error instanceof Error ? error.message : String(error)}`);
+                    console.error(`[github-pr-activity-source] check poll failed for ${watchRef.resourceUri}, skipping this tick: ${formatGitHubError(error)}`);
                     return [];
                 }
             }));

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.4+g59df9f2";
+export const wakeVersion = "0.2.6+g29d62c6";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atolis-hq/wake",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "Local autonomous agent control plane for software development",
   "license": "Apache-2.0",
   "repository": {