volute 0.16.0 → 0.18.0

package/dist/chunk-J52CJCVI.js

@@ -1,447 +0,0 @@
-#!/usr/bin/env node
-import {
-  loadMergedEnv
-} from "./chunk-OYSZNX5I.js";
-import {
-  chownMindDir,
-  isIsolationEnabled,
-  wrapForIsolation
-} from "./chunk-ZCEYUUID.js";
-import {
-  findMind,
-  findVariant,
-  mindDir,
-  setMindRunning,
-  setVariantRunning,
-  stateDir,
-  voluteHome
-} from "./chunk-M77QBTEH.js";
-
-// src/lib/mind-manager.ts
-import { execFile, spawn } from "child_process";
-import { existsSync as existsSync3, mkdirSync, readFileSync as readFileSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
-import { resolve } from "path";
-import { promisify } from "util";
-
-// src/lib/json-state.ts
-import { existsSync, readFileSync, unlinkSync, writeFileSync } from "fs";
-function loadJsonMap(path) {
-  const map = /* @__PURE__ */ new Map();
-  try {
-    if (existsSync(path)) {
-      const data = JSON.parse(readFileSync(path, "utf-8"));
-      for (const [key, value] of Object.entries(data)) {
-        if (typeof value === "number") map.set(key, value);
-      }
-    }
-  } catch (err) {
-    console.warn(`[state] failed to load ${path}:`, err);
-  }
-  return map;
-}
-function saveJsonMap(path, map) {
-  const data = {};
-  for (const [key, value] of map) {
-    data[key] = value;
-  }
-  try {
-    writeFileSync(path, `${JSON.stringify(data)}
-`);
-  } catch (err) {
-    console.warn(`[state] failed to save ${path}:`, err);
-  }
-}
-function clearJsonMap(path, map) {
-  map.clear();
-  try {
-    if (existsSync(path)) unlinkSync(path);
-  } catch (err) {
-    console.warn(`[state] failed to clear ${path}:`, err);
-  }
-}
-
-// src/lib/rotating-log.ts
-import {
-  createWriteStream,
-  existsSync as existsSync2,
-  renameSync,
-  rmSync,
-  statSync
-} from "fs";
-import { Writable } from "stream";
-var MAX_SIZE = 10 * 1024 * 1024;
-var RotatingLog = class extends Writable {
-  constructor(path, maxSize = MAX_SIZE, maxFiles = 5) {
-    super();
-    this.path = path;
-    this.maxSize = maxSize;
-    this.maxFiles = maxFiles;
-    this.on("error", () => {
-    });
-    try {
-      this.size = existsSync2(path) ? statSync(path).size : 0;
-    } catch {
-      this.size = 0;
-    }
-    this.stream = createWriteStream(path, { flags: "a" });
-  }
-  stream;
-  size;
-  _write(chunk, _encoding, callback) {
-    this.size += chunk.length;
-    if (this.size > this.maxSize) {
-      try {
-        const oldest = `${this.path}.${this.maxFiles}`;
-        if (existsSync2(oldest)) rmSync(oldest);
-        for (let i = this.maxFiles - 1; i >= 1; i--) {
-          const from = `${this.path}.${i}`;
-          const to = `${this.path}.${i + 1}`;
-          if (existsSync2(from)) renameSync(from, to);
-        }
-        renameSync(this.path, `${this.path}.1`);
-        const oldStream = this.stream;
-        this.stream = createWriteStream(this.path);
-        this.size = chunk.length;
-        oldStream.end();
-      } catch {
-      }
-    }
-    this.stream.write(chunk, callback);
-  }
-  _final(callback) {
-    this.stream.end(callback);
-  }
-};
-
-// src/lib/mind-manager.ts
-var execFileAsync = promisify(execFile);
-function mindPidPath(name) {
-  return resolve(stateDir(name), "mind.pid");
-}
-var MAX_RESTART_ATTEMPTS = 5;
-var BASE_RESTART_DELAY = 3e3;
-var MAX_RESTART_DELAY = 6e4;
-var MindManager = class {
-  minds = /* @__PURE__ */ new Map();
-  stopping = /* @__PURE__ */ new Set();
-  shuttingDown = false;
-  restartAttempts = /* @__PURE__ */ new Map();
-  pendingContext = /* @__PURE__ */ new Map();
-  resolveTarget(name) {
-    const [baseName, variantName] = name.split("@", 2);
-    const entry = findMind(baseName);
-    if (!entry) throw new Error(`Unknown mind: ${baseName}`);
-    if (variantName) {
-      const variant = findVariant(baseName, variantName);
-      if (!variant) throw new Error(`Unknown variant: ${variantName} (mind: ${baseName})`);
-      return { dir: variant.path, port: variant.port, isVariant: true, baseName, variantName };
-    }
-    const dir = mindDir(baseName);
-    if (!existsSync3(dir)) throw new Error(`Mind directory missing: ${dir}`);
-    return { dir, port: entry.port, isVariant: false, baseName };
-  }
-  async startMind(name) {
-    if (this.minds.has(name)) {
-      throw new Error(`Mind ${name} is already running`);
-    }
-    const target = this.resolveTarget(name);
-    const { dir, isVariant, baseName, variantName } = target;
-    const port = target.port;
-    const pidFile = mindPidPath(name);
-    try {
-      if (existsSync3(pidFile)) {
-        const stalePid = parseInt(readFileSync2(pidFile, "utf-8").trim(), 10);
-        if (stalePid > 0) {
-          try {
-            process.kill(stalePid, 0);
-            const { stdout } = await execFileAsync("ps", ["-p", String(stalePid), "-o", "args="]);
-            if (stdout.includes("server.ts")) {
-              console.error(`[daemon] killing stale mind process ${stalePid} for ${name}`);
-              process.kill(-stalePid, "SIGTERM");
-              await new Promise((r) => setTimeout(r, 500));
-            } else {
-              console.error(
-                `[daemon] stale PID ${stalePid} for ${name} is not a mind process, skipping`
-              );
-            }
-          } catch (err) {
-            if (err.code !== "ESRCH") {
-              console.error(`[daemon] failed to check/kill stale process for ${name}:`, err);
-            }
-          }
-        }
-        rmSync2(pidFile, { force: true });
-      }
-    } catch (err) {
-      console.error(`[daemon] failed to read PID file for ${name}:`, err);
-    }
-    try {
-      const res = await fetch(`http://127.0.0.1:${port}/health`);
-      if (res.ok) {
-        console.error(`[daemon] killing orphan process on port ${port}`);
-        await killProcessOnPort(port);
-        await new Promise((r) => setTimeout(r, 500));
-      }
-    } catch {
-    }
-    const mindStateDir = stateDir(name);
-    const logsDir = resolve(mindStateDir, "logs");
-    mkdirSync(logsDir, { recursive: true });
-    if (isIsolationEnabled()) {
-      try {
-        chownMindDir(mindStateDir, baseName);
-      } catch (err) {
-        throw new Error(
-          `Cannot start mind ${name}: failed to set ownership on state directory ${mindStateDir}: ${err instanceof Error ? err.message : err}`
-        );
-      }
-    }
-    const logStream = new RotatingLog(resolve(logsDir, "mind.log"));
-    const mindEnv = loadMergedEnv(name);
-    const env = {
-      ...process.env,
-      ...mindEnv,
-      VOLUTE_MIND: name,
-      VOLUTE_STATE_DIR: stateDir(name),
-      VOLUTE_MIND_DIR: dir,
-      VOLUTE_MIND_PORT: String(port),
-      // Strip CLAUDECODE so the Agent SDK can spawn Claude Code subprocesses
-      CLAUDECODE: void 0
-    };
-    if (isIsolationEnabled()) {
-      env.HOME = resolve(dir, "home");
-    }
-    const tsxBin = resolve(dir, "node_modules", ".bin", "tsx");
-    const tsxArgs = ["src/server.ts", "--port", String(port)];
-    const [spawnCmd, spawnArgs] = wrapForIsolation(tsxBin, tsxArgs, name);
-    const spawnOpts = {
-      cwd: dir,
-      stdio: ["ignore", "pipe", "pipe"],
-      detached: true,
-      env
-    };
-    const child = spawn(spawnCmd, spawnArgs, spawnOpts);
-    this.minds.set(name, { child, port });
-    child.stdout?.pipe(logStream);
-    child.stderr?.pipe(logStream);
-    try {
-      await new Promise((resolve2, reject) => {
-        const timeout = setTimeout(() => {
-          reject(new Error(`Mind ${name} did not start within 30s`));
-        }, 3e4);
-        function checkOutput(data) {
-          if (data.toString().match(/listening on :\d+/)) {
-            clearTimeout(timeout);
-            resolve2();
-          }
-        }
-        child.stdout?.on("data", checkOutput);
-        child.stderr?.on("data", checkOutput);
-        child.on("error", (err) => {
-          clearTimeout(timeout);
-          reject(err);
-        });
-        child.on("exit", (code) => {
-          clearTimeout(timeout);
-          reject(new Error(`Mind ${name} exited with code ${code} during startup`));
-        });
-      });
-    } catch (err) {
-      this.minds.delete(name);
-      try {
-        child.kill();
-      } catch {
-      }
-      throw err;
-    }
-    if (child.pid) {
-      try {
-        writeFileSync2(pidFile, String(child.pid));
-      } catch (err) {
-        console.error(`[daemon] failed to write PID file for ${name}:`, err);
-      }
-    }
-    if (this.restartAttempts.delete(name)) this.saveCrashAttempts();
-    this.setupCrashRecovery(name, child);
-    if (isVariant) {
-      setVariantRunning(baseName, variantName, true);
-    } else {
-      setMindRunning(name, true);
-    }
-    console.error(`[daemon] started mind ${name} on port ${port}`);
-    await this.deliverPendingContext(name);
-  }
-  setPendingContext(name, context) {
-    this.pendingContext.set(name, context);
-  }
-  async deliverPendingContext(name) {
-    const context = this.pendingContext.get(name);
-    if (!context) return;
-    const tracked = this.minds.get(name);
-    if (!tracked) return;
-    this.pendingContext.delete(name);
-    const parts = [];
-    if (context.type === "merge" || context.type === "merged") {
-      parts.push(`[system] Variant "${context.name}" has been merged and you have been restarted.`);
-    } else if (context.type === "sprouted") {
-      parts.push(
-        "[system] You've sprouted. You now have full capabilities \u2014 connectors, schedules, variants, and the complete volute CLI. Check your new skills for details."
-      );
-    } else {
-      parts.push("[system] You have been restarted.");
-    }
-    if (context.summary) parts.push(`Changes: ${context.summary}`);
-    if (context.justification) parts.push(`Why: ${context.justification}`);
-    if (context.memory) parts.push(`Context: ${context.memory}`);
-    try {
-      await fetch(`http://127.0.0.1:${tracked.port}/message`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          content: [{ type: "text", text: parts.join("\n") }],
-          channel: "system"
-        })
-      });
-    } catch (err) {
-      console.error(`[daemon] failed to deliver pending context to ${name}:`, err);
-    }
-  }
-  setupCrashRecovery(name, child) {
-    child.on("exit", async (code) => {
-      this.minds.delete(name);
-      if (this.shuttingDown || this.stopping.has(name)) return;
-      console.error(`[daemon] mind ${name} exited with code ${code}`);
-      const attempts = this.restartAttempts.get(name) ?? 0;
-      if (attempts >= MAX_RESTART_ATTEMPTS) {
-        console.error(`[daemon] ${name} crashed ${attempts} times \u2014 giving up on restart`);
-        const [base, variant] = name.split("@", 2);
-        if (variant) {
-          setVariantRunning(base, variant, false);
-        } else {
-          setMindRunning(name, false);
-        }
-        return;
-      }
-      const delay = Math.min(BASE_RESTART_DELAY * 2 ** attempts, MAX_RESTART_DELAY);
-      this.restartAttempts.set(name, attempts + 1);
-      this.saveCrashAttempts();
-      console.error(
-        `[daemon] crash recovery for ${name} \u2014 attempt ${attempts + 1}/${MAX_RESTART_ATTEMPTS}, restarting in ${delay}ms`
-      );
-      setTimeout(() => {
-        if (this.shuttingDown) return;
-        this.startMind(name).catch((err) => {
-          console.error(`[daemon] failed to restart ${name}:`, err);
-        });
-      }, delay);
-    });
-  }
-  async stopMind(name) {
-    const tracked = this.minds.get(name);
-    if (!tracked) return;
-    this.stopping.add(name);
-    const { child } = tracked;
-    this.minds.delete(name);
-    await new Promise((resolve2) => {
-      child.on("exit", () => resolve2());
-      try {
-        process.kill(-child.pid, "SIGTERM");
-      } catch {
-        resolve2();
-      }
-      setTimeout(() => {
-        try {
-          process.kill(-child.pid, "SIGKILL");
-        } catch {
-        }
-        resolve2();
-      }, 5e3);
-    });
-    this.stopping.delete(name);
-    if (this.restartAttempts.delete(name)) this.saveCrashAttempts();
-    rmSync2(mindPidPath(name), { force: true });
-    if (!this.shuttingDown) {
-      const [baseName, variantName] = name.split("@", 2);
-      if (variantName) {
-        setVariantRunning(baseName, variantName, false);
-      } else {
-        setMindRunning(name, false);
-      }
-    }
-    console.error(`[daemon] stopped mind ${name}`);
-  }
-  async restartMind(name) {
-    await this.stopMind(name);
-    await this.startMind(name);
-  }
-  async stopAll() {
-    this.shuttingDown = true;
-    const names = [...this.minds.keys()];
-    await Promise.all(names.map((name) => this.stopMind(name)));
-  }
-  isRunning(name) {
-    return this.minds.has(name);
-  }
-  getRunningMinds() {
-    return [...this.minds.keys()];
-  }
-  get crashAttemptsPath() {
-    return resolve(voluteHome(), "crash-attempts.json");
-  }
-  loadCrashAttempts() {
-    this.restartAttempts = loadJsonMap(this.crashAttemptsPath);
-  }
-  saveCrashAttempts() {
-    saveJsonMap(this.crashAttemptsPath, this.restartAttempts);
-  }
-  clearCrashAttempts() {
-    clearJsonMap(this.crashAttemptsPath, this.restartAttempts);
-  }
-};
-async function killProcessOnPort(port) {
-  try {
-    const { stdout } = await execFileAsync("lsof", ["-ti", `:${port}`, "-sTCP:LISTEN"]);
-    const pids = /* @__PURE__ */ new Set();
-    for (const line of stdout.trim().split("\n").filter(Boolean)) {
-      const pid = parseInt(line, 10);
-      pids.add(pid);
-      try {
-        const { stdout: psOut } = await execFileAsync("ps", ["-p", String(pid), "-o", "pgid="]);
-        const pgid = parseInt(psOut.trim(), 10);
-        if (pgid > 1) pids.add(pgid);
-      } catch {
-      }
-    }
-    for (const pid of pids) {
-      try {
-        process.kill(-pid, "SIGTERM");
-      } catch {
-      }
-      try {
-        process.kill(pid, "SIGTERM");
-      } catch {
-      }
-    }
-  } catch {
-  }
-}
-var instance = null;
-function initMindManager() {
-  if (instance) throw new Error("MindManager already initialized");
-  instance = new MindManager();
-  return instance;
-}
-function getMindManager() {
-  if (!instance) instance = new MindManager();
-  return instance;
-}
-
-export {
-  RotatingLog,
-  loadJsonMap,
-  saveJsonMap,
-  clearJsonMap,
-  MindManager,
-  initMindManager,
-  getMindManager
-};

package/dist/history-LKCJJMUV.js

@@ -1,50 +0,0 @@
-#!/usr/bin/env node
-import {
-  resolveMindName
-} from "./chunk-NAOW2CLO.js";
-import {
-  parseArgs
-} from "./chunk-D424ZQGI.js";
-import {
-  daemonFetch
-} from "./chunk-OJQ47SCA.js";
-import "./chunk-M77QBTEH.js";
-import {
-  getClient,
-  urlOf
-} from "./chunk-4RQBJWQX.js";
-import "./chunk-K3NQKI34.js";
-
-// src/commands/history.ts
-async function run(args) {
-  const { flags } = parseArgs(args, {
-    mind: { type: "string" },
-    channel: { type: "string" },
-    limit: { type: "string" }
-  });
-  const name = resolveMindName(flags);
-  const client = getClient();
-  const url = client.api.minds[":name"].history.$url({ param: { name } });
-  if (flags.channel) url.searchParams.set("channel", flags.channel);
-  if (flags.limit) url.searchParams.set("limit", flags.limit);
-  const res = await daemonFetch(urlOf(url));
-  if (!res.ok) {
-    let errorMsg = `Failed to get history: ${res.status}`;
-    try {
-      const data = await res.json();
-      if (data.error) errorMsg = data.error;
-    } catch {
-    }
-    console.error(errorMsg);
-    process.exit(1);
-  }
-  const rows = await res.json();
-  for (const row of rows.reverse()) {
-    const time = new Date(row.created_at).toLocaleString();
-    const sender = row.sender ?? "assistant";
-    console.log(`[${time}] [${row.channel}] ${sender}: ${row.content}`);
-  }
-}
-export {
-  run
-};