volute 0.1.0

package/dist/delete-JNGY7ZFH.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+import {
+  parseArgs
+} from "./chunk-D424ZQGI.js";
+import {
+  agentDir,
+  findAgent,
+  removeAgent,
+  removeAllVariants
+} from "./chunk-5YW4B7CG.js";
+
+// src/commands/delete.ts
+import { existsSync, rmSync } from "fs";
+async function run(args) {
+  const { positional, flags } = parseArgs(args, {
+    force: { type: "boolean" }
+  });
+  const name = positional[0];
+  if (!name) {
+    console.error("Usage: volute delete <name> [--force]");
+    process.exit(1);
+  }
+  const entry = findAgent(name);
+  if (!entry) {
+    console.error(`Unknown agent: ${name}`);
+    process.exit(1);
+  }
+  try {
+    const { daemonFetch } = await import("./daemon-client-ZTHW7ROS.js");
+    const res = await daemonFetch(`/api/agents/${encodeURIComponent(name)}/stop`, {
+      method: "POST"
+    });
+    if (res.ok) {
+      console.log(`Stopped ${name}.`);
+    }
+  } catch {
+  }
+  const dir = agentDir(name);
+  removeAllVariants(name);
+  removeAgent(name);
+  console.log(`Removed ${name} from registry.`);
+  if (existsSync(dir)) {
+    if (!flags.force) {
+      console.log(`Directory: ${dir}`);
+      console.log("Use --force to also delete the agent directory.");
+    } else {
+      rmSync(dir, { recursive: true, force: true });
+      console.log(`Deleted ${dir}`);
+    }
+  }
+}
+export {
+  run
+};

package/dist/disconnect-ACVTKTRE.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import {
+  daemonFetch
+} from "./chunk-H5XQARAP.js";
+import "./chunk-5YW4B7CG.js";
+
+// src/commands/disconnect.ts
+async function run(args) {
+  const type = args[0];
+  const name = args[1];
+  if (!type || !name) {
+    console.error("Usage: volute disconnect <type> <agent>");
+    process.exit(1);
+  }
+  const res = await daemonFetch(
+    `/api/agents/${encodeURIComponent(name)}/connectors/${encodeURIComponent(type)}`,
+    {
+      method: "DELETE"
+    }
+  );
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({ error: "Unknown error" }));
+    console.error(`Failed to stop ${type} connector: ${body.error}`);
+    process.exit(1);
+  }
+  console.log(`${type} connector for ${name} stopped.`);
+}
+export {
+  run
+};

package/dist/down-FYCUYC5H.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+import {
+  VOLUTE_HOME
+} from "./chunk-5YW4B7CG.js";
+
+// src/commands/down.ts
+import { existsSync, readFileSync, unlinkSync } from "fs";
+import { resolve } from "path";
+async function run(_args) {
+  const pidPath = resolve(VOLUTE_HOME, "daemon.pid");
+  if (!existsSync(pidPath)) {
+    const configPath = resolve(VOLUTE_HOME, "daemon.json");
+    let port = 4200;
+    if (existsSync(configPath)) {
+      try {
+        port = JSON.parse(readFileSync(configPath, "utf-8")).port ?? 4200;
+      } catch {
+      }
+    }
+    try {
+      const res = await fetch(`http://localhost:${port}/api/health`);
+      if (res.ok) {
+        console.error(`Daemon appears to be running on port ${port} but PID file is missing.`);
+        console.error(`Kill the process manually: lsof -ti :${port} | xargs kill`);
+        process.exit(1);
+      }
+    } catch {
+    }
+    console.error("Daemon is not running (no PID file found).");
+    process.exit(1);
+  }
+  const pid = parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
+  try {
+    process.kill(pid, 0);
+  } catch {
+    try {
+      unlinkSync(pidPath);
+    } catch {
+    }
+    console.log("Daemon was not running (cleaned up stale PID file).");
+    return;
+  }
+  try {
+    process.kill(-pid, "SIGTERM");
+    console.log(`Sent SIGTERM to daemon group (pid ${pid})`);
+  } catch {
+    process.kill(pid, "SIGTERM");
+    console.log(`Sent SIGTERM to daemon (pid ${pid})`);
+  }
+  const maxWait = 1e4;
+  const start = Date.now();
+  while (Date.now() - start < maxWait) {
+    if (!existsSync(pidPath)) {
+      console.log("Daemon stopped.");
+      return;
+    }
+    await new Promise((r) => setTimeout(r, 200));
+  }
+  try {
+    process.kill(-pid, "SIGKILL");
+  } catch {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+    }
+  }
+  console.error("Daemon did not exit cleanly, sent SIGKILL.");
+}
+export {
+  run
+};

package/dist/env-7SLRN3MG.js

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+import {
+  agentEnvPath,
+  loadMergedEnv,
+  readEnv,
+  sharedEnvPath,
+  writeEnv
+} from "./chunk-A5ZJEMHT.js";
+import {
+  parseArgs
+} from "./chunk-D424ZQGI.js";
+import {
+  resolveAgent
+} from "./chunk-5YW4B7CG.js";
+
+// src/commands/env.ts
+function getEnvPath(agentName) {
+  if (agentName) {
+    const { dir } = resolveAgent(agentName);
+    return agentEnvPath(dir);
+  }
+  return sharedEnvPath();
+}
+async function promptValue(key) {
+  process.stderr.write(`Enter value for ${key}: `);
+  if (process.stdin.isTTY) process.stdin.setRawMode(true);
+  return new Promise((resolve) => {
+    let value = "";
+    const onData = (buf) => {
+      for (const byte of buf) {
+        if (byte === 3) {
+          process.stderr.write("\n");
+          process.exit(1);
+        }
+        if (byte === 13 || byte === 10) {
+          process.stderr.write("\n");
+          if (process.stdin.isTTY) process.stdin.setRawMode(false);
+          process.stdin.removeListener("data", onData);
+          process.stdin.pause();
+          resolve(value);
+          return;
+        }
+        if (byte === 127 || byte === 8) {
+          value = value.slice(0, -1);
+        } else {
+          value += String.fromCharCode(byte);
+        }
+      }
+    };
+    process.stdin.resume();
+    process.stdin.on("data", onData);
+  });
+}
+async function run(args) {
+  const { positional, flags } = parseArgs(args, {
+    agent: { type: "string" }
+  });
+  const subcommand = positional[0];
+  switch (subcommand) {
+    case "set": {
+      const key = positional[1];
+      if (!key) {
+        console.error("Usage: volute env set <KEY> [<VALUE>] [--agent <name>]");
+        process.exit(1);
+      }
+      const value = positional[2] ?? await promptValue(key);
+      const path = getEnvPath(flags.agent);
+      const env = readEnv(path);
+      env[key] = value;
+      writeEnv(path, env);
+      const scope = flags.agent ? `agent:${flags.agent}` : "shared";
+      console.log(`Set ${key} [${scope}]`);
+      break;
+    }
+    case "get": {
+      const key = positional[1];
+      if (!key) {
+        console.error("Usage: volute env get <KEY> [--agent <name>]");
+        process.exit(1);
+      }
+      if (flags.agent) {
+        const { dir } = resolveAgent(flags.agent);
+        const merged = loadMergedEnv(dir);
+        if (key in merged) {
+          console.log(merged[key]);
+        } else {
+          console.error(`${key} not set`);
+          process.exit(1);
+        }
+      } else {
+        const env = readEnv(sharedEnvPath());
+        if (key in env) {
+          console.log(env[key]);
+        } else {
+          console.error(`${key} not set`);
+          process.exit(1);
+        }
+      }
+      break;
+    }
+    case "list": {
+      if (flags.agent) {
+        const { dir } = resolveAgent(flags.agent);
+        const shared = readEnv(sharedEnvPath());
+        const agent = readEnv(agentEnvPath(dir));
+        const allKeys = /* @__PURE__ */ new Set([...Object.keys(shared), ...Object.keys(agent)]);
+        if (allKeys.size === 0) {
+          console.log("No environment variables set.");
+          return;
+        }
+        for (const key of [...allKeys].sort()) {
+          const scope = key in agent ? "agent" : "shared";
+          const value = key in agent ? agent[key] : shared[key];
+          console.log(`${key}=${value} [${scope}]`);
+        }
+      } else {
+        const env = readEnv(sharedEnvPath());
+        const keys = Object.keys(env);
+        if (keys.length === 0) {
+          console.log("No shared environment variables set.");
+          return;
+        }
+        for (const key of keys.sort()) {
+          console.log(`${key}=${env[key]} [shared]`);
+        }
+      }
+      break;
+    }
+    case "remove": {
+      const key = positional[1];
+      if (!key) {
+        console.error("Usage: volute env remove <KEY> [--agent <name>]");
+        process.exit(1);
+      }
+      const path = getEnvPath(flags.agent);
+      const env = readEnv(path);
+      if (!(key in env)) {
+        const scope2 = flags.agent ? `agent:${flags.agent}` : "shared";
+        console.error(`${key} not set in ${scope2} scope`);
+        process.exit(1);
+      }
+      delete env[key];
+      writeEnv(path, env);
+      const scope = flags.agent ? `agent:${flags.agent}` : "shared";
+      console.log(`Removed ${key} [${scope}]`);
+      break;
+    }
+    default:
+      console.error(`Usage: volute env <set|get|list|remove> [--agent <name>]`);
+      if (subcommand) {
+        console.error(`
+Unknown subcommand: ${subcommand}`);
+      }
+      process.exit(1);
+  }
+}
+export {
+  run
+};

package/dist/fork-BB3DZ426.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+import {
+  spawnServer
+} from "./chunk-N4QN44LC.js";
+import {
+  exec,
+  execInherit
+} from "./chunk-XZN4WPNC.js";
+import {
+  parseArgs
+} from "./chunk-D424ZQGI.js";
+import {
+  addVariant,
+  resolveAgent,
+  validateBranchName
+} from "./chunk-5YW4B7CG.js";
+
+// src/commands/fork.ts
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { resolve } from "path";
+async function run(args) {
+  const { positional, flags } = parseArgs(args, {
+    soul: { type: "string" },
+    port: { type: "number" },
+    "no-start": { type: "boolean" },
+    json: { type: "boolean" }
+  });
+  const agentName = positional[0];
+  const variantName = positional[1];
+  const { soul, port, json } = flags;
+  const noStart = flags["no-start"];
+  if (!agentName || !variantName) {
+    console.error(
+      'Usage: volute fork <agent> <variant> [--soul "..."] [--port N] [--no-start] [--json]'
+    );
+    process.exit(1);
+  }
+  const err = validateBranchName(variantName);
+  if (err) {
+    console.error(err);
+    process.exit(1);
+  }
+  const { dir: projectRoot } = resolveAgent(agentName);
+  const worktreeDir = resolve(projectRoot, ".worktrees", variantName);
+  if (existsSync(worktreeDir)) {
+    console.error(`Worktree already exists: ${worktreeDir}`);
+    process.exit(1);
+  }
+  const parentDir = resolve(projectRoot, ".worktrees");
+  if (!existsSync(parentDir)) {
+    mkdirSync(parentDir, { recursive: true });
+  }
+  try {
+    await exec("git", ["worktree", "add", "-b", variantName, worktreeDir], { cwd: projectRoot });
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    console.error(`Failed to create worktree: ${msg}`);
+    process.exit(1);
+  }
+  if (!json) console.log("Installing dependencies...");
+  try {
+    if (json) {
+      await exec("npm", ["install"], { cwd: worktreeDir });
+    } else {
+      await execInherit("npm", ["install"], { cwd: worktreeDir });
+    }
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    console.error(`npm install failed: ${msg}`);
+    process.exit(1);
+  }
+  if (soul) {
+    writeFileSync(resolve(worktreeDir, "home/SOUL.md"), soul);
+  }
+  let actualPort = null;
+  let pid = null;
+  if (!noStart) {
+    const requestedPort = port ?? 0;
+    if (!json) console.log("Starting server...");
+    const result = await spawnServer(worktreeDir, requestedPort, { detached: true });
+    if (!result) {
+      console.error("Server failed to start within timeout");
+      process.exit(1);
+    }
+    actualPort = result.actualPort;
+    pid = result.child.pid ?? null;
+  }
+  const variant = {
+    name: variantName,
+    branch: variantName,
+    path: worktreeDir,
+    port: actualPort ?? port ?? 0,
+    pid,
+    created: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  addVariant(agentName, variant);
+  if (json) {
+    console.log(JSON.stringify(variant, null, 2));
+  } else {
+    console.log(`
+Variant created: ${variantName}`);
+    console.log(`  Branch: ${variant.branch}`);
+    console.log(`  Path:   ${variant.path}`);
+    if (actualPort) {
+      console.log(`  Port:   ${actualPort}`);
+      console.log(`  PID:    ${pid}`);
+    }
+  }
+}
+export {
+  run
+};