lazyclaw 4.3.0 → 5.0.1

package/sandbox/modal.mjs

@@ -0,0 +1,53 @@
+// sandbox/modal.mjs — Modal CLI + idle-hibernation wake hook.
+
+import { spawn, spawnSync } from 'node:child_process';
+import { Sandbox, SandboxSession, SandboxError } from './base.mjs';
+
+export function buildModalArgv(spec, argv) {
+  if (!spec || !spec.app) {
+    throw new SandboxError('modal sandbox requires app name', 'SANDBOX_BAD_SPEC');
+  }
+  const out = ['modal', 'run', '--detach=false'];
+  if (spec.region) out.push('--region', spec.region);
+  out.push(spec.app, '--', ...argv);
+  return out;
+}
+
+export function idleWakeUrl(spec) {
+  const app = encodeURIComponent(spec.app || '');
+  const tok = encodeURIComponent(spec.token || '');
+  const host = spec.host || 'lazyclaw-edge.modal.run';
+  return `https://${host}/wake?app=${app}&token=${tok}`;
+}
+
+async function maybeWake(spec) {
+  if (!spec.idleWake || !spec.token) return;
+  try {
+    await fetch(idleWakeUrl(spec), { method: 'POST' });
+  } catch { /* best effort; modal cold-start handles rest */ }
+}
+
+class ModalSession extends SandboxSession {
+  constructor(spec) { super(); this.spec = spec; }
+  async exec(argv, opts = {}) {
+    await maybeWake(this.spec);
+    const a = buildModalArgv(this.spec, argv);
+    const r = spawnSync(a[0], a.slice(1), {
+      input: opts.input, env: { ...process.env, ...(opts.env || {}) },
+      stdio: opts.stdio || 'pipe', encoding: 'utf8',
+    });
+    return { code: r.status ?? -1, stdout: r.stdout || '', stderr: r.stderr || '' };
+  }
+  async spawn(argv, opts = {}) {
+    await maybeWake(this.spec);
+    const a = buildModalArgv(this.spec, argv);
+    return spawn(a[0], a.slice(1), opts);
+  }
+  async close() {}
+}
+
+export class ModalSandbox extends Sandbox {
+  constructor(spec) { super(spec); }
+  async open() { return new ModalSession(this.spec); }
+  describe() { return `modal · app=${this.spec.app}`; }
+}

package/sandbox/singularity.mjs

@@ -0,0 +1,39 @@
+// sandbox/singularity.mjs — apptainer / singularity exec wrapper.
+
+import { spawn, spawnSync } from 'node:child_process';
+import { Sandbox, SandboxSession, SandboxError } from './base.mjs';
+
+export function buildSingularityArgv(spec, argv) {
+  if (!spec || !spec.image) {
+    throw new SandboxError('singularity sandbox requires image', 'SANDBOX_BAD_SPEC');
+  }
+  const bin = spec.useApptainer === false ? 'singularity' : 'apptainer';
+  const out = [bin, 'exec'];
+  for (const b of spec.bind || []) out.push('--bind', b);
+  if (!spec.net) out.push('--net', '--network=none');
+  out.push(spec.image, ...argv);
+  return out;
+}
+
+class SingularitySession extends SandboxSession {
+  constructor(spec) { super(); this.spec = spec; }
+  async exec(argv, opts = {}) {
+    const a = buildSingularityArgv(this.spec, argv);
+    const r = spawnSync(a[0], a.slice(1), {
+      input: opts.input, env: { ...process.env, ...(opts.env || {}) },
+      stdio: opts.stdio || 'pipe', encoding: 'utf8',
+    });
+    return { code: r.status ?? -1, stdout: r.stdout || '', stderr: r.stderr || '' };
+  }
+  async spawn(argv, opts = {}) {
+    const a = buildSingularityArgv(this.spec, argv);
+    return spawn(a[0], a.slice(1), opts);
+  }
+  async close() {}
+}
+
+export class SingularitySandbox extends Sandbox {
+  constructor(spec) { super(spec); }
+  async open() { return new SingularitySession(this.spec); }
+  describe() { return `singularity · ${this.spec.image}`; }
+}

package/sandbox/ssh.mjs

@@ -0,0 +1,56 @@
+// sandbox/ssh.mjs — Remote exec via OpenSSH with ControlMaster reuse.
+//
+// The wrapper deliberately avoids node-ssh's reconnect logic — we
+// rely on OpenSSH's ControlMaster/ControlPersist so multiple exec()
+// calls share one TCP connection. node-ssh is imported lazily and
+// only used for streaming spawn() because spawnSync over Control-
+// Master is enough for short tool calls.
+
+import { spawn, spawnSync } from 'node:child_process';
+import { Sandbox, SandboxSession, SandboxError } from './base.mjs';
+
+export function buildSshArgv(spec, argv) {
+  if (!spec || !spec.host) throw new SandboxError('ssh sandbox requires host', 'SANDBOX_BAD_SPEC');
+  const userHost = spec.user ? `${spec.user}@${spec.host}` : spec.host;
+  const out = ['ssh',
+    '-o', 'ControlMaster=auto',
+    '-o', 'ControlPath=~/.ssh/cm-%h-%p-%r',
+    '-o', 'ControlPersist=10m',
+    '-o', 'StrictHostKeyChecking=accept-new',
+  ];
+  if (spec.identityFile) out.push('-i', spec.identityFile);
+  if (spec.port) out.push('-p', String(spec.port));
+  out.push(userHost, argv.join(' '));
+  return out;
+}
+
+class SshSession extends SandboxSession {
+  constructor(spec) { super(); this.spec = spec; }
+
+  async exec(argv, opts = {}) {
+    const sshArgv = buildSshArgv(this.spec, argv);
+    const r = spawnSync(sshArgv[0], sshArgv.slice(1), {
+      input: opts.input,
+      env: { ...process.env, ...(opts.env || {}) },
+      stdio: opts.stdio || 'pipe',
+      encoding: 'utf8',
+    });
+    return { code: r.status ?? -1, stdout: r.stdout || '', stderr: r.stderr || '' };
+  }
+
+  async spawn(argv, opts = {}) {
+    const sshArgv = buildSshArgv(this.spec, argv);
+    return spawn(sshArgv[0], sshArgv.slice(1), opts);
+  }
+
+  async close() { /* ControlPersist handles socket lifecycle */ }
+}
+
+export class SshSandbox extends Sandbox {
+  constructor(spec) { super(spec); }
+  async open() { return new SshSession(this.spec); }
+  describe() {
+    const u = this.spec.user ? `${this.spec.user}@${this.spec.host}` : this.spec.host;
+    return `ssh · ${u}`;
+  }
+}

package/sandbox.mjs

@@ -1,127 +1,11 @@
-// Sandbox — wrap a child process in a Docker container.
-//
-// `lazyclaw chat --sandbox docker:<image>` (or the equivalent on
-// `agent`) routes the underlying `claude` CLI invocation through
-//
-//   docker run --rm -i --network=<net> \
-//              -v <cwd>:<cwd> -w <cwd> \
-//              -e <pass-through env vars> \
-//              <image> claude -p ...
-//
-// instead of running `claude` directly on the host. Two reasons:
-//
-// 1. Filesystem confinement. The default --workdir mount only
-//    exposes the current working directory; tools that try to
-//    chdir into $HOME or read /etc see an empty container fs.
-// 2. Network policy. By default we set --network=none so the
-//    sandboxed agent cannot reach the public internet — useful
-//    when handing it untrusted prompts. Pass `--network host` /
-//    `bridge` via flags when the workflow needs outbound access
-//    (e.g. it has to call an API).
-//
-// Caveats — call out so users aren't surprised:
-//
-// - The user's `claude` login lives in $HOME/.claude/. The sandbox
-//   doesn't expose $HOME by default, so the wrapped CLI can't see
-//   that auth and will prompt for login. To run sandboxed under
-//   the user's existing subscription, mount $HOME/.claude:
-//
-//     lazyclaw chat --sandbox docker:node:20 \
-//                   --sandbox-mount "$HOME/.claude:/root/.claude:ro"
-//
-// - Sandboxing only applies when the picked provider goes through
-//   a subprocess (currently `claude-cli`). API providers
-//   (anthropic / openai / gemini) hit the network from
-//   *lazyclaw's* process, not a child — sandboxing them is a
-//   no-op and we surface a warning.
-
-import { spawn } from 'node:child_process';
-
-class SandboxError extends Error {
-  constructor(message, code) {
-    super(message);
-    this.name = 'SandboxError';
-    this.code = code || 'SANDBOX_ERR';
-  }
-}
-
-/**
- * Parse a `--sandbox` flag. Accepts:
- *   docker:<image>           — Docker with default policy
- *   docker:<image>?<args>     — query-string-style overrides
- *   off | none | -            — explicit "no sandbox"
- *
- * Returns null when sandboxing is off, or
- * { kind: 'docker', image, network, mounts: string[], envPassthrough: string[] }.
- */
-export function parseSandboxSpec(spec, flags = {}) {
-  if (!spec || /^(off|none|-)$/i.test(String(spec))) return null;
-  const m = String(spec).match(/^([a-z]+):(.+)$/i);
-  if (!m) throw new SandboxError(`bad sandbox spec "${spec}" — expected "docker:<image>"`, 'SANDBOX_BAD_SPEC');
-  const [, kind, rest] = m;
-  if (kind.toLowerCase() !== 'docker') {
-    throw new SandboxError(`unsupported sandbox kind "${kind}" — only "docker" is implemented`, 'SANDBOX_UNSUPPORTED');
-  }
-  return {
-    kind: 'docker',
-    image: rest.trim(),
-    // Default to --network=none for safety. Override via:
-    //   --sandbox-network host   (or bridge / a named network)
-    network: flags['sandbox-network'] || 'none',
-    // --sandbox-mount can repeat; cli.parseArgs collects repeats
-    // into an array.
-    mounts: arrayify(flags['sandbox-mount']),
-    envPassthrough: arrayify(flags['sandbox-env']),
-  };
-}
-
-function arrayify(v) {
-  if (v === undefined || v === null) return [];
-  return Array.isArray(v) ? v : [String(v)];
-}
-
-/**
- * Build the docker run argv that wraps a child invocation. The
- * caller hands us the original [bin, ...args] they were going to
- * spawn; we return [docker, ...dockerArgs] that puts the same
- * thing inside the container.
- */
-export function buildDockerArgs(spec, [bin, ...binArgs], opts = {}) {
-  if (!spec || spec.kind !== 'docker') {
-    throw new SandboxError('buildDockerArgs requires a docker spec', 'SANDBOX_BAD_SPEC');
-  }
-  const cwd = opts.cwd || process.cwd();
-  const args = [
-    'run', '--rm', '-i',
-    '--network', spec.network || 'none',
-    '-v', `${cwd}:${cwd}`,
-    '-w', cwd,
-  ];
-  for (const mount of spec.mounts) {
-    if (!mount.includes(':')) {
-      throw new SandboxError(`bad mount "${mount}" — expected host:container[:mode]`, 'SANDBOX_BAD_MOUNT');
-    }
-    args.push('-v', mount);
-  }
-  for (const envName of spec.envPassthrough) {
-    args.push('-e', envName);
-  }
-  args.push(spec.image, bin, ...binArgs);
-  return args;
-}
-
-/**
- * Spawn `bin` with `args` either bare (no sandbox) or under the
- * docker wrapper. Returns the child process; the caller drives
- * stdio and handles exit. Mirrors `child_process.spawn`'s shape.
- */
-export function spawnSandboxed(spec, bin, args, spawnOpts = {}) {
-  if (!spec) return spawn(bin, args, spawnOpts);
-  if (spec.kind !== 'docker') {
-    throw new SandboxError(`unsupported kind "${spec.kind}"`, 'SANDBOX_UNSUPPORTED');
-  }
-  const dockerArgs = buildDockerArgs(spec, [bin, ...args], { cwd: spawnOpts.cwd });
-  return spawn('docker', dockerArgs, spawnOpts);
-}
-
-export { SandboxError };
+// sandbox.mjs — v4 compat shim. Real implementations live under
+// sandbox/. Kept so providers/{claude_cli,codex_cli,gemini_cli}.mjs
+// can keep their `import { spawnSandboxed } from '../sandbox.mjs'`
+// statements unchanged during the v5 phase rollout.
+
+export {
+  parseSandboxSpec,
+  buildDockerArgs,
+  spawnSandboxed,
+} from './sandbox/docker.mjs';
+export { SandboxError } from './sandbox/base.mjs';

package/scripts/hermes-import.mjs

@@ -0,0 +1,111 @@
+// scripts/hermes-import.mjs
+// Detect ~/.hermes (or --from <dir>) and import into lazyclaw.
+//   skills/*.md       → <cfgDir>/skills/*.md with trained_by: hermes-import (C4)
+//   USER.md           → <cfgDir>/memory/USER.md          (C6)
+//   MEMORY.md         → <cfgDir>/memory/core.md          (merged, append)
+//   channels.json     → cfg.channels.* (best-effort)
+//   skins/<slug>.yaml → <cfgDir>/personalities/hermes-<slug>.md (C7)
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+export function defaultHermesDir() { return path.join(os.homedir(), '.hermes'); }
+export function defaultCfgDir() {
+  return process.env.LAZYCLAW_CONFIG_DIR || path.join(os.homedir(), '.lazyclaw');
+}
+
+function injectTrainedBy(content, value) {
+  if (!content.startsWith('---')) {
+    return `---\ntrained_by: ${value}\n---\n${content}`;
+  }
+  // Replace existing trained_by or insert before closing fence
+  const closeRe = /\r?\n---[ \t]*(?:\r?\n|$)/;
+  const m = closeRe.exec(content.slice(3));
+  if (!m) return content;
+  const block = content.slice(4, 3 + m.index);
+  const rest = content.slice(3 + m.index + m[0].length);
+  if (/^trained_by:/m.test(block)) {
+    return `---\n${block.replace(/^trained_by:.*$/m, `trained_by: ${value}`)}\n---\n${rest}`;
+  }
+  return `---\n${block}\ntrained_by: ${value}\n---\n${rest}`;
+}
+
+function importSkills(srcDir, dstDir) {
+  const src = path.join(srcDir, 'skills');
+  if (!fs.existsSync(src)) return 0;
+  const dst = path.join(dstDir, 'skills');
+  fs.mkdirSync(dst, { recursive: true });
+  let n = 0;
+  for (const f of fs.readdirSync(src)) {
+    if (!f.endsWith('.md')) continue;
+    const content = fs.readFileSync(path.join(src, f), 'utf8');
+    fs.writeFileSync(path.join(dst, f), injectTrainedBy(content, 'hermes-import'));
+    n++;
+  }
+  return n;
+}
+
+function importMemory(srcDir, dstDir) {
+  const memDir = path.join(dstDir, 'memory');
+  fs.mkdirSync(memDir, { recursive: true });
+  const userSrc = path.join(srcDir, 'USER.md');
+  if (fs.existsSync(userSrc)) {
+    const incoming = fs.readFileSync(userSrc, 'utf8');
+    const dst = path.join(memDir, 'USER.md');
+    const existing = fs.existsSync(dst) ? fs.readFileSync(dst, 'utf8') : '';
+    fs.writeFileSync(dst, existing ? `${existing}\n\n<!-- hermes-import -->\n${incoming}` : incoming);
+  }
+  const memSrc = path.join(srcDir, 'MEMORY.md');
+  if (fs.existsSync(memSrc)) {
+    const incoming = fs.readFileSync(memSrc, 'utf8');
+    const dst = path.join(memDir, 'core.md');
+    const existing = fs.existsSync(dst) ? fs.readFileSync(dst, 'utf8') : '';
+    fs.writeFileSync(dst, existing ? `${existing}\n\n<!-- hermes-import -->\n${incoming}` : incoming);
+  }
+}
+
+function importChannels(srcDir, cfgDir) {
+  const src = path.join(srcDir, 'channels.json');
+  if (!fs.existsSync(src)) return;
+  let incoming;
+  try { incoming = JSON.parse(fs.readFileSync(src, 'utf8')); } catch { return; }
+  const cfgPath = path.join(cfgDir, 'config.json');
+  let cfg = {};
+  try { cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8')); } catch {}
+  cfg.channels = { ...(cfg.channels || {}), ...incoming };
+  fs.mkdirSync(cfgDir, { recursive: true });
+  fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2));
+}
+
+function importSkins(srcDir, dstDir) {
+  const src = path.join(srcDir, 'skins');
+  if (!fs.existsSync(src)) return 0;
+  const dst = path.join(dstDir, 'personalities');
+  fs.mkdirSync(dst, { recursive: true });
+  let n = 0;
+  for (const f of fs.readdirSync(src)) {
+    if (!/\.ya?ml$/.test(f)) continue;
+    const slug = f.replace(/\.ya?ml$/, '');
+    const raw = fs.readFileSync(path.join(src, f), 'utf8');
+    // Best-effort: extract `prompt:` flat YAML; else dump raw.
+    const m = /^prompt:\s*"?(.*?)"?\s*$/m.exec(raw);
+    const body = m ? m[1] : raw;
+    fs.writeFileSync(path.join(dst, `hermes-${slug}.md`), `# ${slug} (imported from Hermes)\n\n${body}\n`);
+    n++;
+  }
+  return n;
+}
+
+export function importHermes({ from, cfgDir } = {}) {
+  const src = from || defaultHermesDir();
+  const dst = cfgDir || defaultCfgDir();
+  if (!fs.existsSync(src)) throw new Error(`hermes source not found: ${src}`);
+  fs.mkdirSync(dst, { recursive: true });
+  const counts = {
+    skills: importSkills(src, dst),
+    memory: (importMemory(src, dst), 1),
+    channels: (importChannels(src, dst), 1),
+    skins: importSkins(src, dst),
+  };
+  return { src, dst, counts };
+}