volute 0.8.2 → 0.9.0

package/dist/{agent-YORVRB6I.js → agent-MB3OTRRK.js}

@@ -9,36 +9,36 @@ async function run(args) {
       await import("./create-HGJHLABX.js").then((m) => m.run(args.slice(1)));
       break;
     case "start":
-      await import("./start-QU73YTJW.js").then((m) => m.run(args.slice(1)));
+      await import("./start-6YRS6FF6.js").then((m) => m.run(args.slice(1)));
       break;
     case "stop":
-      await import("./stop-N7U5N6A7.js").then((m) => m.run(args.slice(1)));
+      await import("./stop-UQSNF4CG.js").then((m) => m.run(args.slice(1)));
       break;
     case "restart":
-      await import("./restart-KVH3TK5N.js").then((m) => m.run(args.slice(1)));
+      await import("./restart-CCYM3MEC.js").then((m) => m.run(args.slice(1)));
       break;
     case "delete":
-      await import("./delete-45TGQC4N.js").then((m) => m.run(args.slice(1)));
+      await import("./delete-WKQKE3FT.js").then((m) => m.run(args.slice(1)));
       break;
     case "list":
-      await import("./status-Q6ZQJXNI.js").then((m) => m.run(args.slice(1)));
+      await import("./status-SIMKH3ZE.js").then((m) => m.run(args.slice(1)));
       break;
     case "status": {
       const rest = args.slice(1);
       if (!rest[0] && process.env.VOLUTE_AGENT) {
         rest.unshift(process.env.VOLUTE_AGENT);
       }
-      await import("./status-Q6ZQJXNI.js").then((m) => m.run(rest));
+      await import("./status-SIMKH3ZE.js").then((m) => m.run(rest));
       break;
     }
     case "logs": {
       const rest = args.slice(1);
       const logsArgs = transformAgentFlag(rest);
-      await import("./logs-TZB3MTLZ.js").then((m) => m.run(logsArgs));
+      await import("./logs-V54B6QSG.js").then((m) => m.run(logsArgs));
       break;
     }
     case "upgrade":
-      await import("./upgrade-CZF6PN7Y.js").then((m) => m.run(args.slice(1)));
+      await import("./upgrade-BRNMSQBX.js").then((m) => m.run(args.slice(1)));
       break;
     case "import":
       await import("./import-CNEDF3TD.js").then((m) => m.run(args.slice(1)));

package/dist/api-client-YPKOZP2O.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import {
+  getClient,
+  urlOf
+} from "./chunk-4RQBJWQX.js";
+import "./chunk-K3NQKI34.js";
+export {
+  getClient,
+  urlOf
+};

package/dist/{channel-RDGHBFSI.js → channel-G5D4VBXY.js}

@@ -3,24 +3,16 @@ import {
   resolveAgentName
 } from "./chunk-AZEL2IEK.js";
 import {
-  CHANNELS,
-  getChannelDriver
-} from "./chunk-LIPPXNIE.js";
-import {
-  loadMergedEnv
-} from "./chunk-QF22MYDJ.js";
-import {
-  writeChannelEntry
-} from "./chunk-N6MLQ26B.js";
+  daemonFetch
+} from "./chunk-STOEJOJO.js";
 import {
   parseArgs
 } from "./chunk-D424ZQGI.js";
+import "./chunk-DP2DX4WV.js";
 import {
-  daemonFetch
-} from "./chunk-23L3MKEV.js";
-import {
-  agentDir
-} from "./chunk-DP2DX4WV.js";
+  getClient,
+  urlOf
+} from "./chunk-4RQBJWQX.js";
 import "./chunk-K3NQKI34.js";
 
 // src/commands/channel.ts
@@ -72,17 +64,20 @@ async function readChannel(args) {
   }
   const agentName = resolveAgentName(flags);
   const { platform } = parseUri(uri);
-  const driver = requireDriver(platform);
-  const dir = agentDir(agentName);
-  const env = { ...loadMergedEnv(agentName), VOLUTE_AGENT: agentName, VOLUTE_AGENT_DIR: dir };
-  try {
-    const limit = flags.limit ?? 20;
-    const output = await driver.read(env, uri, limit);
-    console.log(output);
-  } catch (err) {
-    console.error(err instanceof Error ? err.message : String(err));
+  const limit = flags.limit ?? 20;
+  const client = getClient();
+  const url = client.api.agents[":name"].channels.read.$url({ param: { name: agentName } });
+  url.searchParams.set("platform", platform);
+  url.searchParams.set("uri", uri);
+  url.searchParams.set("limit", String(limit));
+  const res = await daemonFetch(urlOf(url));
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    console.error(body.error ?? `Server responded with ${res.status}`);
     process.exit(1);
   }
+  const output = await res.text();
+  console.log(output);
 }
 async function listChannels(args) {
   const { positional, flags } = parseArgs(args, {
@@ -90,29 +85,27 @@ async function listChannels(args) {
   });
   const platform = positional[0];
   const agentName = resolveAgentName(flags);
-  const dir = agentDir(agentName);
-  const env = { ...loadMergedEnv(agentName), VOLUTE_AGENT: agentName, VOLUTE_AGENT_DIR: dir };
-  const platforms = platform ? [platform] : Object.keys(CHANNELS);
-  for (const p of platforms) {
-    const driver = getChannelDriver(p);
-    if (!driver?.listConversations) continue;
-    try {
-      const convs = await driver.listConversations(env);
-      for (const conv of convs) {
-        writeChannelEntry(agentName, conv.id, {
-          platformId: conv.platformId,
-          platform: p,
-          name: conv.name,
-          type: conv.type
-        });
-        const parts = [conv.id.padEnd(24), conv.name.padEnd(28), conv.type];
-        if (conv.participantCount != null) {
-          parts.push(String(conv.participantCount));
-        }
-        console.log(parts.join("  "));
+  const client = getClient();
+  const url = client.api.agents[":name"].channels.list.$url({ param: { name: agentName } });
+  if (platform) url.searchParams.set("platform", platform);
+  const res = await daemonFetch(urlOf(url));
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    console.error(body.error ?? `Server responded with ${res.status}`);
+    process.exit(1);
+  }
+  const results = await res.json();
+  for (const [p, convs] of Object.entries(results)) {
+    for (const conv of convs) {
+      if (conv.error) {
+        console.error(`${p}: ${conv.error}`);
+        continue;
+      }
+      const parts = [conv.id.padEnd(24), conv.name.padEnd(28), conv.type];
+      if (conv.participantCount != null) {
+        parts.push(String(conv.participantCount));
       }
-    } catch (err) {
-      console.error(`${p}: ${err instanceof Error ? err.message : String(err)}`);
+      console.log(parts.join("  "));
     }
   }
 }
@@ -125,23 +118,20 @@ async function listUsers(args) {
     console.error("Usage: volute channel users <platform> [--agent <name>]");
     process.exit(1);
   }
-  const driver = requireDriver(platform);
-  if (!driver.listUsers) {
-    console.error(`Platform ${platform} does not support listing users`);
-    process.exit(1);
-  }
   const agentName = resolveAgentName(flags);
-  const dir = agentDir(agentName);
-  const env = { ...loadMergedEnv(agentName), VOLUTE_AGENT: agentName, VOLUTE_AGENT_DIR: dir };
-  try {
-    const users = await driver.listUsers(env);
-    for (const user of users) {
-      console.log(`${user.username.padEnd(20)}  ${user.id.padEnd(20)}  ${user.type ?? ""}`);
-    }
-  } catch (err) {
-    console.error(err instanceof Error ? err.message : String(err));
+  const client = getClient();
+  const url = client.api.agents[":name"].channels.users.$url({ param: { name: agentName } });
+  url.searchParams.set("platform", platform);
+  const res = await daemonFetch(urlOf(url));
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    console.error(body.error ?? `Server responded with ${res.status}`);
     process.exit(1);
   }
+  const users = await res.json();
+  for (const user of users) {
+    console.log(`${user.username.padEnd(20)}  ${user.id.padEnd(20)}  ${user.type ?? ""}`);
+  }
 }
 async function createChannel(args) {
   const { positional, flags } = parseArgs(args, {
@@ -156,22 +146,24 @@ async function createChannel(args) {
     );
     process.exit(1);
   }
-  const driver = requireDriver(platform);
-  if (!driver.createConversation) {
-    console.error(`Platform ${platform} does not support creating conversations`);
-    process.exit(1);
-  }
   const agentName = resolveAgentName(flags);
-  const dir = agentDir(agentName);
-  const env = { ...loadMergedEnv(agentName), VOLUTE_AGENT: agentName, VOLUTE_AGENT_DIR: dir };
   const participants = flags.participants.split(",").map((s) => s.trim());
-  try {
-    const slug = await driver.createConversation(env, participants, flags.name);
-    console.log(slug);
-  } catch (err) {
-    console.error(err instanceof Error ? err.message : String(err));
+  const client = getClient();
+  const res = await daemonFetch(
+    urlOf(client.api.agents[":name"].channels.create.$url({ param: { name: agentName } })),
+    {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ platform, participants, name: flags.name })
+    }
+  );
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    console.error(body.error ?? `Server responded with ${res.status}`);
     process.exit(1);
   }
+  const data = await res.json();
+  console.log(data.slug);
 }
 async function typingChannel(args) {
   const { positional, flags } = parseArgs(args, {
@@ -184,9 +176,10 @@ async function typingChannel(args) {
   }
   const agentName = resolveAgentName(flags);
   try {
-    const res = await daemonFetch(
-      `/api/agents/${encodeURIComponent(agentName)}/typing?channel=${encodeURIComponent(uri)}`
-    );
+    const client = getClient();
+    const url = client.api.agents[":name"].typing.$url({ param: { name: agentName } });
+    url.searchParams.set("channel", uri);
+    const res = await daemonFetch(urlOf(url));
     if (!res.ok) {
       const body = await res.json().catch(() => ({}));
       console.error(body.error ?? `Server responded with ${res.status}`);
@@ -209,14 +202,6 @@ function parseUri(uri) {
   }
   return { platform: uri.slice(0, colonIdx), channelId: uri.slice(colonIdx + 1) };
 }
-function requireDriver(platform) {
-  const driver = getChannelDriver(platform);
-  if (!driver) {
-    console.error(`No channel driver for platform: ${platform}`);
-    process.exit(1);
-  }
-  return driver;
-}
 export {
   run
 };

package/dist/chunk-4RQBJWQX.js

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+
+// src/lib/api-client.ts
+import { hc } from "hono/client";
+var _client;
+function getClient() {
+  _client ??= hc("http://localhost");
+  return _client;
+}
+function urlOf(url) {
+  return url.pathname + url.search;
+}
+
+export {
+  getClient,
+  urlOf
+};

package/dist/{chunk-XSJ27WEM.js → chunk-AWHQZDB4.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-DP2DX4WV.js";
 
 // src/commands/up.ts
-import { spawn } from "child_process";
+import { execFileSync, spawn } from "child_process";
 import { existsSync, mkdirSync, openSync, readFileSync } from "fs";
 import { dirname, resolve } from "path";
 function readGlobalConfig() {
@@ -20,12 +20,27 @@ function readGlobalConfig() {
     process.exit(1);
   }
 }
+function isSystemdServiceEnabled() {
+  try {
+    execFileSync("systemctl", ["is-enabled", "--quiet", "volute"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function run(args) {
   const { flags } = parseArgs(args, {
     port: { type: "number" },
     host: { type: "string" },
     foreground: { type: "boolean" }
   });
+  if (!flags.foreground && isSystemdServiceEnabled()) {
+    console.error("Volute is managed by a systemd service.");
+    console.error("Use: sudo systemctl start volute");
+    console.error("     sudo systemctl restart volute");
+    console.error("     systemctl status volute");
+    process.exit(1);
+  }
   const config = readGlobalConfig();
   const port = flags.port ?? config.port ?? 4200;
   const hostname = flags.host ?? config.hostname ?? "127.0.0.1";

package/dist/{chunk-23L3MKEV.js → chunk-STOEJOJO.js}

@@ -9,19 +9,33 @@ import { resolve } from "path";
 function readDaemonConfig() {
   const configPath = resolve(voluteHome(), "daemon.json");
   if (!existsSync(configPath)) {
-    console.error("Volute is not running. Start with: volute up");
+    if (existsSync("/etc/systemd/system/volute.service") && !process.env.VOLUTE_HOME) {
+      console.error("Volute is running as a system service but VOLUTE_HOME is not set.");
+      console.error("Re-run setup to update the CLI wrapper: sudo volute setup");
+      console.error("Then start a new shell or run: source /etc/profile.d/volute.sh");
+    } else {
+      console.error("Volute is not running. Start with: volute up");
+    }
     process.exit(1);
   }
   try {
     return JSON.parse(readFileSync(configPath, "utf-8"));
-  } catch {
-    console.error("Volute is not running. Start with: volute up");
+  } catch (err) {
+    const code = err.code;
+    if (code === "EACCES") {
+      console.error(`Permission denied reading ${configPath}. Try: sudo volute ...`);
+    } else {
+      console.error("Volute is not running. Start with: volute up");
+    }
     process.exit(1);
   }
 }
 function buildUrl(config) {
   const url = new URL("http://localhost");
-  url.hostname = config.hostname || "localhost";
+  let hostname = config.hostname || "localhost";
+  if (hostname === "0.0.0.0") hostname = "127.0.0.1";
+  if (hostname === "::") hostname = "[::1]";
+  url.hostname = hostname;
   url.port = String(config.port);
   return url.origin;
 }

package/dist/{chunk-HZ5LTOEJ.js → chunk-YNNK4QN2.js}

@@ -4,9 +4,21 @@ import {
 } from "./chunk-DP2DX4WV.js";
 
 // src/commands/down.ts
+import { execFileSync } from "child_process";
 import { existsSync, readFileSync, unlinkSync } from "fs";
 import { resolve } from "path";
+function isSystemdServiceEnabled() {
+  try {
+    execFileSync("systemctl", ["is-enabled", "--quiet", "volute"]);
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function stopDaemon() {
+  if (isSystemdServiceEnabled()) {
+    return { stopped: false, reason: "systemd" };
+  }
   const home = voluteHome();
   const pidPath = resolve(home, "daemon.pid");
   if (!existsSync(pidPath)) {
@@ -99,7 +111,10 @@ async function stopDaemon() {
 async function run(_args) {
   const result = await stopDaemon();
   if (result.stopped) return;
-  if (result.reason === "orphan") {
+  if (result.reason === "systemd") {
+    console.error("Volute is managed by a systemd service.");
+    console.error("Use: sudo systemctl stop volute");
+  } else if (result.reason === "orphan") {
     console.error(`Daemon appears to be running on port ${result.port} but PID file is missing.`);
     console.error(`Kill the process manually: lsof -ti :${result.port} | xargs kill`);
   } else if (result.reason === "not-running") {

package/dist/cli.js

@@ -9,52 +9,52 @@ if (!process.env.VOLUTE_HOME) {
 var command = process.argv[2];
 var args = process.argv.slice(3);
 if (command === "--version" || command === "-v") {
-  const { default: pkg } = await import("./package-TWWKVRRL.js");
+  const { default: pkg } = await import("./package-WPX6LCYE.js");
   console.log(pkg.version);
   process.exit(0);
 }
 switch (command) {
   case "agent":
-    await import("./agent-YORVRB6I.js").then((m) => m.run(args));
+    await import("./agent-MB3OTRRK.js").then((m) => m.run(args));
     break;
   case "send":
-    await import("./send-BNC2S5BY.js").then((m) => m.run(args));
+    await import("./send-TFZ62XPZ.js").then((m) => m.run(args));
     break;
   case "history":
-    await import("./history-PXJVYLVY.js").then((m) => m.run(args));
+    await import("./history-SH25BAA5.js").then((m) => m.run(args));
     break;
   case "variant":
-    await import("./variant-RKXPN5DH.js").then((m) => m.run(args));
+    await import("./variant-AQRAN6FR.js").then((m) => m.run(args));
     break;
   case "connector":
-    await import("./connector-ZP6MEFF4.js").then((m) => m.run(args));
+    await import("./connector-PK7D5GTN.js").then((m) => m.run(args));
     break;
   case "channel":
-    await import("./channel-RDGHBFSI.js").then((m) => m.run(args));
+    await import("./channel-G5D4VBXY.js").then((m) => m.run(args));
     break;
   case "schedule":
-    await import("./schedule-HCUCBNQI.js").then((m) => m.run(args));
+    await import("./schedule-XGBUF7NU.js").then((m) => m.run(args));
     break;
   case "env":
-    await import("./env-KMNYGVZ2.js").then((m) => m.run(args));
+    await import("./env-HZMZSWWD.js").then((m) => m.run(args));
     break;
   case "up":
-    await import("./up-V6EAA7OZ.js").then((m) => m.run(args));
+    await import("./up-J7AHQHIM.js").then((m) => m.run(args));
     break;
   case "down":
-    await import("./down-O4EWZTVA.js").then((m) => m.run(args));
+    await import("./down-4DGRZRJU.js").then((m) => m.run(args));
     break;
   case "restart":
-    await import("./daemon-restart-CPBLMMRI.js").then((m) => m.run(args));
+    await import("./daemon-restart-EKDXXHKH.js").then((m) => m.run(args));
     break;
   case "setup":
-    await import("./setup-2JDBGU7Y.js").then((m) => m.run(args));
+    await import("./setup-7SPMWF2O.js").then((m) => m.run(args));
     break;
   case "service":
-    await import("./service-XCADRKIS.js").then((m) => m.run(args));
+    await import("./service-56CY4S6Z.js").then((m) => m.run(args));
     break;
   case "update":
-    await import("./update-EUCZ7XGG.js").then((m) => m.run(args));
+    await import("./update-3TGXUTO2.js").then((m) => m.run(args));
     break;
   case "--help":
   case "-h":

package/dist/{connector-ZP6MEFF4.js → connector-PK7D5GTN.js}

@@ -3,19 +3,16 @@ import {
   resolveAgentName
 } from "./chunk-AZEL2IEK.js";
 import {
-  agentEnvPath,
-  readEnv,
-  writeEnv
-} from "./chunk-QF22MYDJ.js";
+  daemonFetch
+} from "./chunk-STOEJOJO.js";
 import {
   parseArgs
 } from "./chunk-D424ZQGI.js";
+import "./chunk-DP2DX4WV.js";
 import {
-  daemonFetch
-} from "./chunk-23L3MKEV.js";
-import {
-  agentDir
-} from "./chunk-DP2DX4WV.js";
+  getClient,
+  urlOf
+} from "./chunk-4RQBJWQX.js";
 import "./chunk-K3NQKI34.js";
 
 // src/commands/connector.ts
@@ -84,8 +81,13 @@ async function connectConnector(args) {
     console.error("Usage: volute connector connect <type> [--agent <name>]");
     process.exit(1);
   }
-  const url = `/api/agents/${encodeURIComponent(agentName)}/connectors/${encodeURIComponent(type)}`;
-  let res = await daemonFetch(url, { method: "POST" });
+  const client = getClient();
+  const connectorUrl = urlOf(
+    client.api.agents[":name"].connectors[":type"].$url({
+      param: { name: agentName, type }
+    })
+  );
+  let res = await daemonFetch(connectorUrl, { method: "POST" });
   if (!res.ok) {
     const body = await res.json().catch(() => ({ error: "Unknown error" }));
     if (body.error === "missing_env" && "missing" in body) {
@@ -101,20 +103,32 @@ Set them with: volute env set <KEY> --agent ${agentName}`);
       }
       console.error(`${connectorName} connector requires some environment variables.
 `);
-      const dir = agentDir(agentName);
-      const envPath = agentEnvPath(dir);
-      const env = readEnv(envPath);
       for (const v of missing) {
         const value = await promptValue(v.name, v.description);
         if (!value) {
           console.error(`No value provided for ${v.name}. Aborting.`);
           process.exit(1);
         }
-        env[v.name] = value;
+        const envRes = await daemonFetch(
+          urlOf(
+            client.api.agents[":name"].env[":key"].$url({
+              param: { name: agentName, key: v.name }
+            })
+          ),
+          {
+            method: "PUT",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ value })
+          }
+        );
+        if (!envRes.ok) {
+          const errBody = await envRes.json().catch(() => ({}));
+          console.error(`Failed to set ${v.name}: ${errBody.error ?? `HTTP ${envRes.status}`}`);
+          process.exit(1);
+        }
       }
-      writeEnv(envPath, env);
       console.log("Environment variables saved.\n");
-      res = await daemonFetch(url, { method: "POST" });
+      res = await daemonFetch(connectorUrl, { method: "POST" });
       if (!res.ok) {
         const retryBody = await res.json().catch(() => ({ error: "Unknown error" }));
         console.error(
@@ -139,11 +153,14 @@ async function disconnectConnector(args) {
     console.error("Usage: volute connector disconnect <type> [--agent <name>]");
     process.exit(1);
   }
+  const client = getClient();
   const res = await daemonFetch(
-    `/api/agents/${encodeURIComponent(agentName)}/connectors/${encodeURIComponent(type)}`,
-    {
-      method: "DELETE"
-    }
+    urlOf(
+      client.api.agents[":name"].connectors[":type"].$url({
+        param: { name: agentName, type }
+      })
+    ),
+    { method: "DELETE" }
   );
   if (!res.ok) {
     const body = await res.json().catch(() => ({ error: "Unknown error" }));

package/dist/{daemon-client-54J3EIZD.js → daemon-client-P44NU3KU.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   daemonFetch
-} from "./chunk-23L3MKEV.js";
+} from "./chunk-STOEJOJO.js";
 import "./chunk-DP2DX4WV.js";
 import "./chunk-K3NQKI34.js";
 export {

package/dist/{daemon-restart-CPBLMMRI.js → daemon-restart-EKDXXHKH.js}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import {
   run
-} from "./chunk-XSJ27WEM.js";
+} from "./chunk-AWHQZDB4.js";
 import {
   stopDaemon
-} from "./chunk-HZ5LTOEJ.js";
+} from "./chunk-YNNK4QN2.js";
 import "./chunk-D424ZQGI.js";
 import "./chunk-DP2DX4WV.js";
 import "./chunk-K3NQKI34.js";
@@ -12,6 +12,11 @@ import "./chunk-K3NQKI34.js";
 // src/commands/daemon-restart.ts
 async function run2(args) {
   const result = await stopDaemon();
+  if (!result.stopped && result.reason === "systemd") {
+    console.error("Volute is managed by a systemd service.");
+    console.error("Use: sudo systemctl restart volute");
+    process.exit(1);
+  }
   if (!result.stopped && result.reason === "kill-failed") {
     console.error("Cannot restart: failed to stop the running daemon.");
     process.exit(1);