volute 0.1.0

package/dist/schedule-KKSOVUDF.js

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+import {
+  daemonFetch
+} from "./chunk-H5XQARAP.js";
+import "./chunk-5YW4B7CG.js";
+
+// src/commands/schedule.ts
+async function run(args) {
+  const subcommand = args[0];
+  const agentName = args[1];
+  if (!subcommand || !agentName) {
+    printUsage();
+    process.exit(1);
+  }
+  switch (subcommand) {
+    case "list":
+      await listSchedules(agentName);
+      break;
+    case "add":
+      await addSchedule(agentName, args.slice(2));
+      break;
+    case "remove":
+      await removeSchedule(agentName, args.slice(2));
+      break;
+    default:
+      printUsage();
+      process.exit(1);
+  }
+}
+function printUsage() {
+  console.error(`Usage:
+  volute schedule list <agent>
+  volute schedule add <agent> --cron "..." --message "..." [--id name]
+  volute schedule remove <agent> --id <id>`);
+}
+async function listSchedules(agent) {
+  const res = await daemonFetch(`/api/agents/${encodeURIComponent(agent)}/schedules`);
+  if (!res.ok) {
+    const data = await res.json();
+    console.error(data.error ?? `Failed to list schedules: ${res.status}`);
+    process.exit(1);
+  }
+  const schedules = await res.json();
+  if (schedules.length === 0) {
+    console.log("No schedules configured.");
+    return;
+  }
+  const idW = Math.max(2, ...schedules.map((s) => s.id.length));
+  const cronW = Math.max(4, ...schedules.map((s) => s.cron.length));
+  console.log(`${"ID".padEnd(idW)}  ${"CRON".padEnd(cronW)}  ENABLED  MESSAGE`);
+  for (const s of schedules) {
+    console.log(
+      `${s.id.padEnd(idW)}  ${s.cron.padEnd(cronW)}  ${String(s.enabled).padEnd(7)}  ${s.message}`
+    );
+  }
+}
+async function addSchedule(agent, args) {
+  let cron = "";
+  let message = "";
+  let id = "";
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--cron" && args[i + 1]) {
+      cron = args[++i];
+    } else if (args[i] === "--message" && args[i + 1]) {
+      message = args[++i];
+    } else if (args[i] === "--id" && args[i + 1]) {
+      id = args[++i];
+    }
+  }
+  if (!cron || !message) {
+    console.error("--cron and --message are required");
+    process.exit(1);
+  }
+  const body = { cron, message };
+  if (id) body.id = id;
+  const res = await daemonFetch(`/api/agents/${encodeURIComponent(agent)}/schedules`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) {
+    const data2 = await res.json();
+    console.error(data2.error ?? `Failed to add schedule: ${res.status}`);
+    process.exit(1);
+  }
+  const data = await res.json();
+  console.log(`Schedule added: ${data.id}`);
+}
+async function removeSchedule(agent, args) {
+  let id = "";
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--id" && args[i + 1]) {
+      id = args[++i];
+    }
+  }
+  if (!id) {
+    console.error("--id is required");
+    process.exit(1);
+  }
+  const res = await daemonFetch(
+    `/api/agents/${encodeURIComponent(agent)}/schedules/${encodeURIComponent(id)}`,
+    { method: "DELETE" }
+  );
+  if (!res.ok) {
+    const data = await res.json();
+    console.error(data.error ?? `Failed to remove schedule: ${res.status}`);
+    process.exit(1);
+  }
+  console.log(`Schedule removed: ${id}`);
+}
+export {
+  run
+};

package/dist/send-WQSVSRDD.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import {
+  readNdjson
+} from "./chunk-KSMIWOCN.js";
+import {
+  daemonFetch
+} from "./chunk-H5XQARAP.js";
+import "./chunk-5YW4B7CG.js";
+
+// src/commands/send.ts
+import { userInfo } from "os";
+async function run(args) {
+  const name = args[0];
+  const message = args[1];
+  if (!name || !message) {
+    console.error('Usage: volute send <name> "<message>"');
+    process.exit(1);
+  }
+  const sender = userInfo().username;
+  const res = await daemonFetch(`/api/agents/${encodeURIComponent(name)}/message`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      content: [{ type: "text", text: message }],
+      channel: "cli",
+      sender
+    })
+  });
+  if (!res.ok) {
+    const data = await res.json();
+    console.error(data.error ?? `Failed to send message: ${res.status}`);
+    process.exit(1);
+  }
+  if (!res.body) {
+    console.error("No response body");
+    process.exit(1);
+  }
+  for await (const event of readNdjson(res.body)) {
+    if (event.type === "text") {
+      process.stdout.write(event.content);
+    }
+    if (event.type === "done") {
+      break;
+    }
+  }
+  process.stdout.write("\n");
+}
+export {
+  run
+};

package/dist/start-LKMWS6ZE.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+import {
+  daemonFetch
+} from "./chunk-H5XQARAP.js";
+import {
+  resolveAgent
+} from "./chunk-5YW4B7CG.js";
+
+// src/commands/start.ts
+async function run(args) {
+  const name = args[0];
+  if (!name) {
+    console.error("Usage: volute start <name>");
+    process.exit(1);
+  }
+  const { entry } = resolveAgent(name);
+  const res = await daemonFetch(`/api/agents/${encodeURIComponent(name)}/start`, {
+    method: "POST"
+  });
+  const data = await res.json();
+  if (!res.ok) {
+    console.error(data.error || "Failed to start agent");
+    process.exit(1);
+  }
+  console.log(`${name} started on port ${entry.port}`);
+}
+export {
+  run
+};

package/dist/status-CIEKUI3V.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import {
+  daemonFetch
+} from "./chunk-H5XQARAP.js";
+import "./chunk-5YW4B7CG.js";
+
+// src/commands/status.ts
+async function run(args) {
+  const name = args[0];
+  if (!name) {
+    const res2 = await daemonFetch("/api/agents");
+    if (!res2.ok) {
+      const data = await res2.json();
+      console.error(data.error ?? `Failed to get status: ${res2.status}`);
+      process.exit(1);
+    }
+    const agents = await res2.json();
+    if (agents.length === 0) {
+      console.log("No agents registered. Create one with: volute create <name>");
+      return;
+    }
+    const nameW = Math.max(4, ...agents.map((a) => a.name.length));
+    const portW = Math.max(4, ...agents.map((a) => String(a.port).length));
+    console.log(`${"NAME".padEnd(nameW)}  ${"PORT".padEnd(portW)}  STATUS    CONNECTORS`);
+    for (const agent2 of agents) {
+      const connected = agent2.channels.filter((ch) => ch.status === "connected").map((ch) => ch.name);
+      const connectors = connected.length > 0 ? connected.join(", ") : "-";
+      console.log(
+        `${agent2.name.padEnd(nameW)}  ${String(agent2.port).padEnd(portW)}  ${agent2.status.padEnd(8)}  ${connectors}`
+      );
+    }
+    return;
+  }
+  const res = await daemonFetch(`/api/agents/${encodeURIComponent(name)}`);
+  if (!res.ok) {
+    const data = await res.json();
+    console.error(data.error || `Failed to get status for ${name}`);
+    process.exit(1);
+  }
+  const agent = await res.json();
+  console.log(`Agent: ${agent.name}`);
+  console.log(`Port: ${agent.port}`);
+  console.log(`Status: ${agent.status}`);
+  for (const ch of agent.channels) {
+    console.log(`${ch.name}: ${ch.status}`);
+  }
+}
+export {
+  run
+};

package/dist/stop-YTOAGYE4.js

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

package/dist/up-AJJ4GCXY.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+import {
+  parseArgs
+} from "./chunk-D424ZQGI.js";
+import {
+  VOLUTE_HOME
+} from "./chunk-5YW4B7CG.js";
+
+// src/commands/up.ts
+import { spawn } from "child_process";
+import { existsSync, mkdirSync, openSync, readFileSync } from "fs";
+import { dirname, resolve } from "path";
+async function run(args) {
+  const { flags } = parseArgs(args, {
+    port: { type: "number" },
+    foreground: { type: "boolean" }
+  });
+  const port = flags.port ?? 4200;
+  const pidPath = resolve(VOLUTE_HOME, "daemon.pid");
+  if (existsSync(pidPath)) {
+    try {
+      const pid = parseInt(readFileSync(pidPath, "utf-8").trim(), 10);
+      process.kill(pid, 0);
+      console.error(`Daemon already running (pid ${pid}). Use 'volute down' first.`);
+      process.exit(1);
+    } catch {
+    }
+  }
+  try {
+    const res = await fetch(`http://localhost:${port}/api/health`);
+    if (res.ok) {
+      console.error(
+        `Port ${port} is already in use by a Volute daemon. Use 'volute down' first, or kill the process on that port.`
+      );
+      process.exit(1);
+    }
+  } catch {
+  }
+  if (flags.foreground) {
+    const { startDaemon } = await import("./daemon.js");
+    await startDaemon({ port, foreground: true });
+    return;
+  }
+  let tsxBin = "";
+  let searchDir = dirname(new URL(import.meta.url).pathname);
+  for (let i = 0; i < 5; i++) {
+    const candidate = resolve(searchDir, "node_modules", ".bin", "tsx");
+    if (existsSync(candidate)) {
+      tsxBin = candidate;
+      break;
+    }
+    searchDir = dirname(searchDir);
+  }
+  if (!tsxBin) {
+    console.error("Could not find tsx binary.");
+    process.exit(1);
+  }
+  let daemonModule = "";
+  searchDir = dirname(new URL(import.meta.url).pathname);
+  for (let i = 0; i < 5; i++) {
+    const candidate = resolve(searchDir, "src", "daemon.ts");
+    if (existsSync(candidate)) {
+      daemonModule = candidate;
+      break;
+    }
+    searchDir = dirname(searchDir);
+  }
+  if (!daemonModule) {
+    console.error("Could not find daemon module.");
+    process.exit(1);
+  }
+  mkdirSync(VOLUTE_HOME, { recursive: true });
+  const logFile = resolve(VOLUTE_HOME, "daemon.log");
+  const logFd = openSync(logFile, "a");
+  const child = spawn(tsxBin, [daemonModule, "--port", String(port)], {
+    stdio: ["ignore", logFd, logFd],
+    detached: true
+  });
+  child.unref();
+  const url = `http://localhost:${port}/api/health`;
+  const maxWait = 3e4;
+  const start = Date.now();
+  while (Date.now() - start < maxWait) {
+    try {
+      const res = await fetch(url);
+      if (res.ok) {
+        console.log(`Volute daemon running on port ${port} (pid ${child.pid})`);
+        console.log(`Logs: ${logFile}`);
+        return;
+      }
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  if (child.pid) {
+    try {
+      process.kill(-child.pid, "SIGTERM");
+    } catch {
+      try {
+        process.kill(child.pid, "SIGTERM");
+      } catch {
+      }
+    }
+  }
+  console.error("Daemon started but did not become healthy within 30s.");
+  console.error(`Check logs: ${logFile}`);
+  process.exit(1);
+}
+export {
+  run
+};

package/dist/upgrade-JACA6YMO.js

@@ -0,0 +1,211 @@
+#!/usr/bin/env node
+import {
+  spawnServer
+} from "./chunk-N4QN44LC.js";
+import {
+  composeTemplate,
+  copyTemplateToDir,
+  findTemplatesRoot
+} from "./chunk-GSPKUPKU.js";
+import {
+  exec,
+  execInherit
+} from "./chunk-XZN4WPNC.js";
+import {
+  parseArgs
+} from "./chunk-D424ZQGI.js";
+import {
+  addVariant,
+  resolveAgent
+} from "./chunk-5YW4B7CG.js";
+
+// src/commands/upgrade.ts
+import { existsSync, mkdirSync, rmSync } from "fs";
+import { resolve } from "path";
+var TEMPLATE_BRANCH = "volute/template";
+var VARIANT_NAME = "upgrade";
+async function run(args) {
+  const { positional, flags } = parseArgs(args, {
+    template: { type: "string" },
+    continue: { type: "boolean" }
+  });
+  const agentName = positional[0];
+  if (!agentName) {
+    console.error("Usage: volute upgrade <name> [--template <name>] [--continue]");
+    process.exit(1);
+  }
+  const { dir: projectRoot } = resolveAgent(agentName);
+  const template = flags.template ?? "agent-sdk";
+  if (flags.continue) {
+    await continueUpgrade(agentName, projectRoot);
+    return;
+  }
+  const worktreeDir = resolve(projectRoot, ".worktrees", VARIANT_NAME);
+  if (existsSync(worktreeDir)) {
+    console.error(
+      `Upgrade worktree already exists: ${worktreeDir}
+If a previous upgrade is in progress, use --continue to finish it.
+Otherwise, remove it with: git -C ${projectRoot} worktree remove .worktrees/${VARIANT_NAME}`
+    );
+    process.exit(1);
+  }
+  await exec("git", ["worktree", "prune"], { cwd: projectRoot });
+  try {
+    await exec("git", ["branch", "-D", VARIANT_NAME], { cwd: projectRoot });
+  } catch {
+  }
+  console.log("Updating template branch...");
+  await updateTemplateBranch(projectRoot, template, agentName);
+  console.log("Creating upgrade variant...");
+  const parentDir = resolve(projectRoot, ".worktrees");
+  if (!existsSync(parentDir)) {
+    mkdirSync(parentDir, { recursive: true });
+  }
+  await exec("git", ["worktree", "add", "-b", VARIANT_NAME, worktreeDir], {
+    cwd: projectRoot
+  });
+  console.log("Merging template changes...");
+  const hasConflicts = await mergeTemplateBranch(worktreeDir);
+  if (hasConflicts) {
+    console.log("\nMerge conflicts detected. Resolve them in:");
+    console.log(`  ${worktreeDir}`);
+    console.log(`
+Then run:`);
+    console.log(`  volute upgrade ${agentName} --continue`);
+    return;
+  }
+  await installAndVerify(agentName, worktreeDir);
+}
+async function updateTemplateBranch(projectRoot, template, agentName) {
+  const tempWorktree = resolve(projectRoot, ".worktrees", "_template_update");
+  let branchExists = false;
+  try {
+    await exec("git", ["rev-parse", "--verify", TEMPLATE_BRANCH], {
+      cwd: projectRoot
+    });
+    branchExists = true;
+  } catch {
+  }
+  try {
+    await exec("git", ["worktree", "remove", "--force", tempWorktree], { cwd: projectRoot });
+  } catch {
+  }
+  if (existsSync(tempWorktree)) {
+    rmSync(tempWorktree, { recursive: true, force: true });
+  }
+  const templatesRoot = findTemplatesRoot();
+  const { composedDir, manifest } = composeTemplate(templatesRoot, template);
+  try {
+    if (branchExists) {
+      await exec("git", ["worktree", "add", tempWorktree, TEMPLATE_BRANCH], {
+        cwd: projectRoot
+      });
+    } else {
+      await exec("git", ["worktree", "add", "--detach", tempWorktree], {
+        cwd: projectRoot
+      });
+      await exec("git", ["checkout", "--orphan", TEMPLATE_BRANCH], {
+        cwd: tempWorktree
+      });
+      await exec("git", ["rm", "-rf", "--cached", "."], { cwd: tempWorktree });
+      await exec("git", ["clean", "-fd"], { cwd: tempWorktree });
+    }
+    if (branchExists) {
+      await exec("git", ["rm", "-rf", "."], { cwd: tempWorktree }).catch(() => {
+      });
+    }
+    copyTemplateToDir(composedDir, tempWorktree, agentName, manifest);
+    const initDir = resolve(tempWorktree, ".init");
+    if (existsSync(initDir)) {
+      rmSync(initDir, { recursive: true, force: true });
+    }
+    await exec("git", ["add", "-A"], { cwd: tempWorktree });
+    try {
+      await exec("git", ["diff", "--cached", "--quiet"], { cwd: tempWorktree });
+      console.log("Template branch is already up to date.");
+    } catch {
+      await exec("git", ["commit", "-m", "template update"], {
+        cwd: tempWorktree
+      });
+    }
+  } finally {
+    try {
+      await exec("git", ["worktree", "remove", "--force", tempWorktree], { cwd: projectRoot });
+    } catch {
+    }
+    if (existsSync(tempWorktree)) {
+      rmSync(tempWorktree, { recursive: true, force: true });
+    }
+    rmSync(composedDir, { recursive: true, force: true });
+  }
+}
+async function mergeTemplateBranch(worktreeDir) {
+  try {
+    await exec(
+      "git",
+      ["merge", TEMPLATE_BRANCH, "--allow-unrelated-histories", "-m", "merge template update"],
+      { cwd: worktreeDir }
+    );
+    return false;
+  } catch (e) {
+    try {
+      const status = await exec("git", ["status", "--porcelain"], {
+        cwd: worktreeDir
+      });
+      const hasConflictMarkers = status.split("\n").some((line) => line.startsWith("UU") || line.startsWith("AA"));
+      if (hasConflictMarkers) return true;
+    } catch {
+    }
+    throw e;
+  }
+}
+async function continueUpgrade(agentName, projectRoot) {
+  const worktreeDir = resolve(projectRoot, ".worktrees", VARIANT_NAME);
+  if (!existsSync(worktreeDir)) {
+    console.error("No upgrade in progress. Run `volute upgrade` first.");
+    process.exit(1);
+  }
+  const status = await exec("git", ["status", "--porcelain"], {
+    cwd: worktreeDir
+  });
+  const hasConflicts = status.split("\n").some((line) => line.startsWith("UU") || line.startsWith("AA"));
+  if (hasConflicts) {
+    console.error("There are still unresolved conflicts. Resolve them first.");
+    process.exit(1);
+  }
+  try {
+    await exec("git", ["add", "-A"], { cwd: worktreeDir });
+    await exec("git", ["commit", "--no-edit"], { cwd: worktreeDir });
+  } catch {
+  }
+  await installAndVerify(agentName, worktreeDir);
+}
+async function installAndVerify(agentName, worktreeDir) {
+  console.log("Installing dependencies...");
+  await execInherit("npm", ["install"], { cwd: worktreeDir });
+  console.log("Starting upgrade variant...");
+  const result = await spawnServer(worktreeDir, 0, { detached: true });
+  if (!result) {
+    console.error("Server failed to start within timeout");
+    process.exit(1);
+  }
+  const { actualPort, child } = result;
+  const pid = child.pid ?? null;
+  addVariant(agentName, {
+    name: VARIANT_NAME,
+    branch: VARIANT_NAME,
+    path: worktreeDir,
+    port: actualPort,
+    pid,
+    created: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  console.log(`
+Upgrade variant running on port ${actualPort}`);
+  console.log(`
+Next steps:`);
+  console.log(`  volute send ${agentName}@${VARIANT_NAME} "hello"    # chat with upgraded variant`);
+  console.log(`  volute merge ${agentName} ${VARIANT_NAME}           # merge back when satisfied`);
+}
+export {
+  run
+};

package/dist/variants-HPY4DEWU.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+import {
+  parseArgs
+} from "./chunk-D424ZQGI.js";
+import {
+  checkHealth,
+  readVariants,
+  resolveAgent,
+  writeVariants
+} from "./chunk-5YW4B7CG.js";
+
+// src/commands/variants.ts
+async function run(args) {
+  const { positional, flags } = parseArgs(args, {
+    json: { type: "boolean" }
+  });
+  const name = positional[0];
+  if (!name) {
+    console.error("Usage: volute variants <name>");
+    process.exit(1);
+  }
+  const { json } = flags;
+  resolveAgent(name);
+  const variants = readVariants(name);
+  if (variants.length === 0) {
+    if (json) {
+      console.log("[]");
+    } else {
+      console.log("No variants.");
+    }
+    return;
+  }
+  const results = await Promise.all(
+    variants.map(async (v) => {
+      if (!v.port) return { ...v, status: "no-server" };
+      const health = await checkHealth(v.port);
+      return { ...v, status: health.ok ? "running" : "dead" };
+    })
+  );
+  const updated = results.map(({ status, ...v }) => ({
+    ...v,
+    pid: status === "dead" ? null : v.pid
+  }));
+  writeVariants(name, updated);
+  if (json) {
+    console.log(JSON.stringify(results, null, 2));
+    return;
+  }
+  const nameW = Math.max(4, ...results.map((r) => r.name.length));
+  const portW = Math.max(4, ...results.map((r) => String(r.port || "-").length));
+  console.log(`${"NAME".padEnd(nameW)}  ${"PORT".padEnd(portW)}  ${"STATUS".padEnd(10)}  BRANCH`);
+  for (const r of results) {
+    console.log(
+      `${r.name.padEnd(nameW)}  ${String(r.port || "-").padEnd(portW)}  ${r.status.padEnd(10)}  ${r.branch}`
+    );
+  }
+}
+export {
+  run
+};