@rozek/nanoclaw 1.2.17

package/src/cli.ts

@@ -0,0 +1,209 @@
+/**
+ * cli.ts — NanoClaw CLI entry point
+ *
+ * Usage:
+ *   node dist/cli.js [options]
+ *   npx nanoclaw [options]    (requires "bin" field in package.json)
+ *
+ * Parses arguments, validates them (fail-fast), then starts NanoClaw.
+ */
+
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+import { parseArgs } from 'util';
+
+// ─── Help text ───────────────────────────────────────────────────────────────
+
+const HELP = `
+Usage: nanoclaw [options]
+
+Options:
+  --host <address>      Bind address for the web channel  (default: 0.0.0.0)
+  --port <number>       Port for the web channel           (default: 3099)
+  --workspace <path>    Workspace directory                (default: current directory)
+  --key <api-key>       Anthropic API key
+                          Not required with a Claude Pro/Max subscription —
+                          NanoClaw uses Claude Code which is included in those plans.
+  --token <token>       Access token for the web interface (default: no protection)
+                          Clients must supply it via Authorization: Bearer <token>,
+                          as a ?token=<value> query parameter, or a session cookie.
+  --sandbox <type>      Container runtime: "docker" or "apple"
+                          apple = macOS Sequoia 15+ Apple Container Runtime
+                          Defaults to auto-detect (docker first, then apple).
+  -h, --help            Show this help and exit
+
+Environment variables (CLI flags take precedence):
+  NANOCLAW_HOST           Bind address          (same as --host)
+  NANOCLAW_PORT           Port                  (same as --port)
+  NANOCLAW_KEY            Anthropic API key     (same as --key)
+  NANOCLAW_TOKEN          Access token          (same as --token)
+  NANOCLAW_WORKSPACE      Workspace directory   (same as --workspace)
+  NANOCLAW_SANDBOX        Container runtime     (same as --sandbox)
+
+Examples:
+  nanoclaw
+  nanoclaw --port 8080 --workspace ~/my-workspace
+  nanoclaw --sandbox docker --host 127.0.0.1 --token s3cr3t
+  NANOCLAW_PORT=8080 NANOCLAW_TOKEN=s3cr3t nanoclaw
+`;
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function die(msg: string): never {
+  console.error(`Error: ${msg}`);
+  console.error('Run "nanoclaw --help" for usage.');
+  process.exit(1);
+}
+
+function checkBinary(cmd: string): boolean {
+  try {
+    execSync(cmd, { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function detectSandbox(): 'docker' | 'apple' | null {
+  if (checkBinary('docker info')) return 'docker';
+  if (checkBinary('container --version')) return 'apple';
+  return null;
+}
+
+// ─── Main ────────────────────────────────────────────────────────────────────
+
+async function cli(): Promise<void> {
+  // --- Parse arguments -------------------------------------------------------
+  let values: Record<string, string | boolean | undefined>;
+  try {
+    ({ values } = parseArgs({
+      args: process.argv.slice(2),
+      options: {
+        host: { type: 'string' },
+        port: { type: 'string' },
+        workspace: { type: 'string' },
+        key: { type: 'string' },
+        token: { type: 'string' },
+        sandbox: { type: 'string' },
+        help: { type: 'boolean', short: 'h' },
+      },
+      allowPositionals: false,
+      strict: true,
+    }));
+  } catch (err: any) {
+    // parseArgs throws ERR_PARSE_ARGS_UNKNOWN_OPTION for unrecognised flags
+    die(err?.message ?? String(err));
+  }
+
+  if (values.help) {
+    console.log(HELP);
+    process.exit(0);
+  }
+
+  // --- Merge: CLI flags override NANOCLAW_* env vars -------------------------
+  // Each setting resolves in priority order: CLI flag > NANOCLAW_* env var > default
+  const host = (values.host as string | undefined) ?? process.env.NANOCLAW_HOST;
+  const portStr =
+    (values.port as string | undefined) ?? process.env.NANOCLAW_PORT;
+  const key = (values.key as string | undefined) ?? process.env.NANOCLAW_KEY;
+  const token =
+    (values.token as string | undefined) ?? process.env.NANOCLAW_TOKEN;
+  const workspace =
+    (values.workspace as string | undefined) ?? process.env.NANOCLAW_WORKSPACE;
+  const sandboxRaw =
+    (values.sandbox as string | undefined) ?? process.env.NANOCLAW_SANDBOX;
+
+  // --- Validate --port -------------------------------------------------------
+  if (portStr !== undefined) {
+    const port = parseInt(portStr, 10);
+    if (Number.isNaN(port) || port < 1 || port > 65535) {
+      die(
+        `Invalid port value "${portStr}". Must be an integer between 1 and 65535.`,
+      );
+    }
+  }
+
+  // --- Validate --sandbox ----------------------------------------------------
+  let sandboxType: 'docker' | 'apple';
+
+  if (sandboxRaw) {
+    if (sandboxRaw !== 'docker' && sandboxRaw !== 'apple') {
+      die(
+        `Invalid sandbox value "${sandboxRaw}". Must be "docker" or "apple".`,
+      );
+    }
+    sandboxType = sandboxRaw as 'docker' | 'apple';
+  } else {
+    const detected = detectSandbox();
+    if (!detected) {
+      die(
+        'No container sandbox found.\n' +
+          '  • Install Docker Desktop (https://www.docker.com/products/docker-desktop)\n' +
+          '  • Or use macOS Sequoia 15+ with the Apple Container Runtime.',
+      );
+    }
+    sandboxType = detected;
+    console.log(`Auto-detected sandbox: ${sandboxType}`);
+  }
+
+  // --- Validate --workspace --------------------------------------------------
+  if (workspace !== undefined) {
+    const ws = resolve(workspace);
+    if (!existsSync(ws)) {
+      die(`Workspace directory not found: ${ws}`);
+    }
+    process.chdir(ws);
+    console.log(`Workspace: ${ws}`);
+  }
+
+  // --- Check "claude" binary -------------------------------------------------
+  if (!checkBinary('claude --version')) {
+    die(
+      '"claude" command not found.\n' +
+        '  Install Claude Code via: npm install -g @anthropic-ai/claude-code\n' +
+        '  or visit https://claude.ai/code',
+    );
+  }
+
+  // --- Check sandbox availability --------------------------------------------
+  if (sandboxType === 'docker') {
+    if (!checkBinary('docker info')) {
+      die(
+        'Docker is not running.\n' +
+          '  Please start Docker Desktop or the Docker Engine daemon.',
+      );
+    }
+  } else {
+    // apple
+    if (!checkBinary('container --version')) {
+      die(
+        'Apple Container Runtime not available.\n' +
+          '  Requires macOS Sequoia 15 or later.',
+      );
+    }
+  }
+
+  // --- Apply settings to process.env so downstream modules pick them up ------
+  // web.ts reads NANOCLAW_HOST / NANOCLAW_PORT / NANOCLAW_TOKEN;
+  // credential-proxy reads ANTHROPIC_API_KEY.
+  if (host) process.env.NANOCLAW_HOST = host;
+  if (portStr) process.env.NANOCLAW_PORT = portStr;
+  if (key) process.env.ANTHROPIC_API_KEY = key;
+  if (token) process.env.NANOCLAW_TOKEN = token;
+  process.env.NANOCLAW_SANDBOX = sandboxType;
+  process.env.CONTAINER_RUNTIME = sandboxType; // backward compat for container-runtime.ts
+
+  // --- Start NanoClaw --------------------------------------------------------
+  const tokenHint = token ? ' — token protection enabled' : '';
+  console.log(
+    `Starting NanoClaw (sandbox: ${sandboxType}, port: ${process.env.NANOCLAW_PORT ?? 3099}${tokenHint})…`,
+  );
+  const { main } = await import('./index.js');
+  await main();
+}
+
+cli().catch((err) => {
+  console.error('Fatal error:', err);
+  process.exit(1);
+});

package/src/config.ts

@@ -0,0 +1,73 @@
+import os from 'os';
+import path from 'path';
+
+import { readEnvFile } from './env.js';
+
+// Read config values from .env (falls back to process.env).
+// Secrets (API keys, tokens) are NOT read here — they are loaded only
+// by the credential proxy (credential-proxy.ts), never exposed to containers.
+const envConfig = readEnvFile(['ASSISTANT_NAME', 'ASSISTANT_HAS_OWN_NUMBER']);
+
+export const ASSISTANT_NAME =
+  process.env.ASSISTANT_NAME || envConfig.ASSISTANT_NAME || 'Andy';
+export const ASSISTANT_HAS_OWN_NUMBER =
+  (process.env.ASSISTANT_HAS_OWN_NUMBER ||
+    envConfig.ASSISTANT_HAS_OWN_NUMBER) === 'true';
+export const POLL_INTERVAL = 2000;
+export const SCHEDULER_POLL_INTERVAL = 60000;
+
+// Absolute paths needed for container mounts
+const PROJECT_ROOT = process.cwd();
+const HOME_DIR = process.env.HOME || os.homedir();
+
+// Mount security: allowlist stored OUTSIDE project root, never mounted into containers
+export const MOUNT_ALLOWLIST_PATH = path.join(
+  HOME_DIR,
+  '.config',
+  'nanoclaw',
+  'mount-allowlist.json',
+);
+export const SENDER_ALLOWLIST_PATH = path.join(
+  HOME_DIR,
+  '.config',
+  'nanoclaw',
+  'sender-allowlist.json',
+);
+export const STORE_DIR = path.resolve(PROJECT_ROOT, 'store');
+export const GROUPS_DIR = path.resolve(PROJECT_ROOT, 'groups');
+export const DATA_DIR = path.resolve(PROJECT_ROOT, 'data');
+
+export const CONTAINER_IMAGE =
+  process.env.CONTAINER_IMAGE || 'nanoclaw-agent:latest';
+export const CONTAINER_TIMEOUT = parseInt(
+  process.env.CONTAINER_TIMEOUT || '1800000',
+  10,
+);
+export const CONTAINER_MAX_OUTPUT_SIZE = parseInt(
+  process.env.CONTAINER_MAX_OUTPUT_SIZE || '10485760',
+  10,
+); // 10MB default
+export const CREDENTIAL_PROXY_PORT = parseInt(
+  process.env.CREDENTIAL_PROXY_PORT || '3001',
+  10,
+);
+export const IPC_POLL_INTERVAL = 1000;
+export const IDLE_TIMEOUT = parseInt(process.env.IDLE_TIMEOUT || '1800000', 10); // 30min default — how long to keep container alive after last result
+export const MAX_CONCURRENT_CONTAINERS = Math.max(
+  1,
+  parseInt(process.env.MAX_CONCURRENT_CONTAINERS || '5', 10) || 5,
+);
+
+function escapeRegex(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+export const TRIGGER_PATTERN = new RegExp(
+  `^@${escapeRegex(ASSISTANT_NAME)}\\b`,
+  'i',
+);
+
+// Timezone for scheduled tasks (cron expressions, etc.)
+// Uses system timezone by default
+export const TIMEZONE =
+  process.env.TZ || Intl.DateTimeFormat().resolvedOptions().timeZone;

package/src/container-runner.test.ts

@@ -0,0 +1,210 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
+import { EventEmitter } from 'events';
+import { PassThrough } from 'stream';
+
+// Sentinel markers must match container-runner.ts
+const OUTPUT_START_MARKER = '---NANOCLAW_OUTPUT_START---';
+const OUTPUT_END_MARKER = '---NANOCLAW_OUTPUT_END---';
+
+// Mock config
+vi.mock('./config.js', () => ({
+  CONTAINER_IMAGE: 'nanoclaw-agent:latest',
+  CONTAINER_MAX_OUTPUT_SIZE: 10485760,
+  CONTAINER_TIMEOUT: 1800000, // 30min
+  CREDENTIAL_PROXY_PORT: 3001,
+  DATA_DIR: '/tmp/nanoclaw-test-data',
+  GROUPS_DIR: '/tmp/nanoclaw-test-groups',
+  IDLE_TIMEOUT: 1800000, // 30min
+  TIMEZONE: 'America/Los_Angeles',
+}));
+
+// Mock logger
+vi.mock('./logger.js', () => ({
+  logger: {
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+  },
+}));
+
+// Mock fs
+vi.mock('fs', async () => {
+  const actual = await vi.importActual<typeof import('fs')>('fs');
+  return {
+    ...actual,
+    default: {
+      ...actual,
+      existsSync: vi.fn(() => false),
+      mkdirSync: vi.fn(),
+      writeFileSync: vi.fn(),
+      readFileSync: vi.fn(() => ''),
+      readdirSync: vi.fn(() => []),
+      statSync: vi.fn(() => ({ isDirectory: () => false })),
+      copyFileSync: vi.fn(),
+    },
+  };
+});
+
+// Mock mount-security
+vi.mock('./mount-security.js', () => ({
+  validateAdditionalMounts: vi.fn(() => []),
+}));
+
+// Create a controllable fake ChildProcess
+function createFakeProcess() {
+  const proc = new EventEmitter() as EventEmitter & {
+    stdin: PassThrough;
+    stdout: PassThrough;
+    stderr: PassThrough;
+    kill: ReturnType<typeof vi.fn>;
+    pid: number;
+  };
+  proc.stdin = new PassThrough();
+  proc.stdout = new PassThrough();
+  proc.stderr = new PassThrough();
+  proc.kill = vi.fn();
+  proc.pid = 12345;
+  return proc;
+}
+
+let fakeProc: ReturnType<typeof createFakeProcess>;
+
+// Mock child_process.spawn
+vi.mock('child_process', async () => {
+  const actual =
+    await vi.importActual<typeof import('child_process')>('child_process');
+  return {
+    ...actual,
+    spawn: vi.fn(() => fakeProc),
+    exec: vi.fn(
+      (_cmd: string, _opts: unknown, cb?: (err: Error | null) => void) => {
+        if (cb) cb(null);
+        return new EventEmitter();
+      },
+    ),
+  };
+});
+
+import { runContainerAgent, ContainerOutput } from './container-runner.js';
+import type { RegisteredGroup } from './types.js';
+
+const testGroup: RegisteredGroup = {
+  name: 'Test Group',
+  folder: 'test-group',
+  trigger: '@Andy',
+  added_at: new Date().toISOString(),
+};
+
+const testInput = {
+  prompt: 'Hello',
+  groupFolder: 'test-group',
+  chatJid: 'test@g.us',
+  isMain: false,
+};
+
+function emitOutputMarker(
+  proc: ReturnType<typeof createFakeProcess>,
+  output: ContainerOutput,
+) {
+  const json = JSON.stringify(output);
+  proc.stdout.push(`${OUTPUT_START_MARKER}\n${json}\n${OUTPUT_END_MARKER}\n`);
+}
+
+describe('container-runner timeout behavior', () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+    fakeProc = createFakeProcess();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('timeout after output resolves as success', async () => {
+    const onOutput = vi.fn(async () => {});
+    const resultPromise = runContainerAgent(
+      testGroup,
+      testInput,
+      () => {},
+      onOutput,
+    );
+
+    // Emit output with a result
+    emitOutputMarker(fakeProc, {
+      status: 'success',
+      result: 'Here is my response',
+      newSessionId: 'session-123',
+    });
+
+    // Let output processing settle
+    await vi.advanceTimersByTimeAsync(10);
+
+    // Fire the hard timeout (IDLE_TIMEOUT + 30s = 1830000ms)
+    await vi.advanceTimersByTimeAsync(1830000);
+
+    // Emit close event (as if container was stopped by the timeout)
+    fakeProc.emit('close', 137);
+
+    // Let the promise resolve
+    await vi.advanceTimersByTimeAsync(10);
+
+    const result = await resultPromise;
+    expect(result.status).toBe('success');
+    expect(result.newSessionId).toBe('session-123');
+    expect(onOutput).toHaveBeenCalledWith(
+      expect.objectContaining({ result: 'Here is my response' }),
+    );
+  });
+
+  it('timeout with no output resolves as error', async () => {
+    const onOutput = vi.fn(async () => {});
+    const resultPromise = runContainerAgent(
+      testGroup,
+      testInput,
+      () => {},
+      onOutput,
+    );
+
+    // No output emitted — fire the hard timeout
+    await vi.advanceTimersByTimeAsync(1830000);
+
+    // Emit close event
+    fakeProc.emit('close', 137);
+
+    await vi.advanceTimersByTimeAsync(10);
+
+    const result = await resultPromise;
+    expect(result.status).toBe('error');
+    expect(result.error).toContain('timed out');
+    expect(onOutput).not.toHaveBeenCalled();
+  });
+
+  it('normal exit after output resolves as success', async () => {
+    const onOutput = vi.fn(async () => {});
+    const resultPromise = runContainerAgent(
+      testGroup,
+      testInput,
+      () => {},
+      onOutput,
+    );
+
+    // Emit output
+    emitOutputMarker(fakeProc, {
+      status: 'success',
+      result: 'Done',
+      newSessionId: 'session-456',
+    });
+
+    await vi.advanceTimersByTimeAsync(10);
+
+    // Normal exit (no timeout)
+    fakeProc.emit('close', 0);
+
+    await vi.advanceTimersByTimeAsync(10);
+
+    const result = await resultPromise;
+    expect(result.status).toBe('success');
+    expect(result.newSessionId).toBe('session-456');
+  });
+});