volute 0.5.0 → 0.6.0

package/dist/{agent-Z2B6EFEQ.js → agent-X7GJLBLW.js}

@@ -6,39 +6,42 @@ async function run(args) {
   const subcommand = args[0];
   switch (subcommand) {
     case "create":
-      await import("./create-RVCZN6HE.js").then((m) => m.run(args.slice(1)));
+      await import("./create-G525LWEA.js").then((m) => m.run(args.slice(1)));
       break;
     case "start":
-      await import("./start-TUOXDSFL.js").then((m) => m.run(args.slice(1)));
+      await import("./start-VHQ7LNWM.js").then((m) => m.run(args.slice(1)));
       break;
     case "stop":
-      await import("./stop-AOJZLQ5X.js").then((m) => m.run(args.slice(1)));
+      await import("./stop-CAGCT5NI.js").then((m) => m.run(args.slice(1)));
+      break;
+    case "restart":
+      await import("./restart-O4ETYLJF.js").then((m) => m.run(args.slice(1)));
       break;
     case "delete":
-      await import("./delete-3QH7VYIN.js").then((m) => m.run(args.slice(1)));
+      await import("./delete-2PH2CGDY.js").then((m) => m.run(args.slice(1)));
       break;
     case "list":
-      await import("./status-A36EHRO4.js").then((m) => m.run(args.slice(1)));
+      await import("./status-QAJWXKMZ.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-A36EHRO4.js").then((m) => m.run(rest));
+      await import("./status-QAJWXKMZ.js").then((m) => m.run(rest));
       break;
     }
     case "logs": {
       const rest = args.slice(1);
       const logsArgs = transformAgentFlag(rest);
-      await import("./logs-DF342W4M.js").then((m) => m.run(logsArgs));
+      await import("./logs-EDGK26AK.js").then((m) => m.run(logsArgs));
       break;
     }
     case "upgrade":
-      await import("./upgrade-FX2TKJ2S.js").then((m) => m.run(args.slice(1)));
+      await import("./upgrade-YXKPWDRU.js").then((m) => m.run(args.slice(1)));
       break;
     case "import":
-      await import("./import-MXJB2EII.js").then((m) => m.run(args.slice(1)));
+      await import("./import-AVKQJDYC.js").then((m) => m.run(args.slice(1)));
       break;
     case "--help":
     case "-h":
@@ -61,6 +64,7 @@ function printUsage() {
   volute agent create <name> [--template <name>]
   volute agent start <name>
   volute agent stop [name]
+  volute agent restart [name]
   volute agent delete [name] [--force]
   volute agent list
   volute agent status [name]

package/dist/{agent-manager-PXBKA2GK.js → agent-manager-JDVXU3ON.js}

@@ -3,10 +3,10 @@ import {
   AgentManager,
   getAgentManager,
   initAgentManager
-} from "./chunk-MW2KFO3B.js";
-import "./chunk-HE67X4T6.js";
-import "./chunk-UAVD2AHX.js";
-import "./chunk-UX25Z2ND.js";
+} from "./chunk-G6ZNGLUX.js";
+import "./chunk-H7AMDUIA.js";
+import "./chunk-W76KWE23.js";
+import "./chunk-UWHWAPGO.js";
 import "./chunk-K3NQKI34.js";
 export {
   AgentManager,

package/dist/channel-SMCNOIVQ.js

@@ -0,0 +1,262 @@
+#!/usr/bin/env node
+import {
+  readStdin
+} from "./chunk-ZYGKG6VC.js";
+import {
+  resolveAgentName
+} from "./chunk-AZEL2IEK.js";
+import {
+  CHANNELS,
+  getChannelDriver
+} from "./chunk-ZZOOTYXK.js";
+import {
+  loadMergedEnv
+} from "./chunk-H7AMDUIA.js";
+import {
+  writeChannelEntry
+} from "./chunk-BX7KI4S3.js";
+import {
+  parseArgs
+} from "./chunk-D424ZQGI.js";
+import {
+  daemonFetch
+} from "./chunk-JR4UXCTO.js";
+import {
+  resolveAgent
+} from "./chunk-UWHWAPGO.js";
+import "./chunk-K3NQKI34.js";
+
+// src/commands/channel.ts
+async function run(args) {
+  const subcommand = args[0];
+  switch (subcommand) {
+    case "read":
+      await readChannel(args.slice(1));
+      break;
+    case "send":
+      await sendChannel(args.slice(1));
+      break;
+    case "list":
+      await listChannels(args.slice(1));
+      break;
+    case "users":
+      await listUsers(args.slice(1));
+      break;
+    case "create":
+      await createChannel(args.slice(1));
+      break;
+    case "typing":
+      await typingChannel(args.slice(1));
+      break;
+    case "--help":
+    case "-h":
+    case void 0:
+      printUsage();
+      break;
+    default:
+      printUsage();
+      process.exit(1);
+  }
+}
+function printUsage() {
+  console.log(`Usage:
+  volute channel read <channel-uri> [--limit N] [--agent <name>]
+  volute channel send <channel-uri> "<message>" [--agent <name>]
+  volute channel list [<platform>] [--agent <name>]
+  volute channel users <platform> [--agent <name>]
+  volute channel create <platform> --participants user1,user2 [--name "..."] [--agent <name>]
+  volute channel typing <channel-uri> [--agent <name>]
+  echo "message" | volute channel send <channel-uri> [--agent <name>]`);
+}
+async function readChannel(args) {
+  const { positional, flags } = parseArgs(args, {
+    agent: { type: "string" },
+    limit: { type: "number" }
+  });
+  const uri = positional[0];
+  if (!uri) {
+    console.error("Usage: volute channel read <channel-uri> [--limit N] [--agent <name>]");
+    process.exit(1);
+  }
+  const agentName = resolveAgentName(flags);
+  const { platform } = parseUri(uri);
+  const driver = requireDriver(platform);
+  const { dir } = resolveAgent(agentName);
+  const env = { ...loadMergedEnv(dir), 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));
+    process.exit(1);
+  }
+}
+async function sendChannel(args) {
+  const { positional, flags } = parseArgs(args, {
+    agent: { type: "string" }
+  });
+  const uri = positional[0];
+  const message = positional[1] ?? await readStdin();
+  if (!uri || !message) {
+    console.error('Usage: volute channel send <channel-uri> "<message>" [--agent <name>]');
+    console.error('       echo "message" | volute channel send <channel-uri> [--agent <name>]');
+    process.exit(1);
+  }
+  const agentName = resolveAgentName(flags);
+  const { platform } = parseUri(uri);
+  const driver = requireDriver(platform);
+  const { dir } = resolveAgent(agentName);
+  const env = { ...loadMergedEnv(dir), VOLUTE_AGENT: agentName, VOLUTE_AGENT_DIR: dir };
+  try {
+    await driver.send(env, uri, message);
+    try {
+      await daemonFetch(`/api/agents/${encodeURIComponent(agentName)}/history`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ channel: uri, content: message })
+      });
+    } catch (err) {
+      console.error(`Failed to persist to history: ${err instanceof Error ? err.message : err}`);
+    }
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+async function listChannels(args) {
+  const { positional, flags } = parseArgs(args, {
+    agent: { type: "string" }
+  });
+  const platform = positional[0];
+  const agentName = resolveAgentName(flags);
+  const { dir } = resolveAgent(agentName);
+  const env = { ...loadMergedEnv(dir), 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(dir, 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("  "));
+      }
+    } catch (err) {
+      console.error(`${p}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+}
+async function listUsers(args) {
+  const { positional, flags } = parseArgs(args, {
+    agent: { type: "string" }
+  });
+  const platform = positional[0];
+  if (!platform) {
+    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 } = resolveAgent(agentName);
+  const env = { ...loadMergedEnv(dir), 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));
+    process.exit(1);
+  }
+}
+async function createChannel(args) {
+  const { positional, flags } = parseArgs(args, {
+    agent: { type: "string" },
+    participants: { type: "string" },
+    name: { type: "string" }
+  });
+  const platform = positional[0];
+  if (!platform || !flags.participants) {
+    console.error(
+      'Usage: volute channel create <platform> --participants user1,user2 [--name "..."] [--agent <name>]'
+    );
+    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 } = resolveAgent(agentName);
+  const env = { ...loadMergedEnv(dir), 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));
+    process.exit(1);
+  }
+}
+async function typingChannel(args) {
+  const { positional, flags } = parseArgs(args, {
+    agent: { type: "string" }
+  });
+  const uri = positional[0];
+  if (!uri) {
+    console.error("Usage: volute channel typing <channel-uri> [--agent <name>]");
+    process.exit(1);
+  }
+  const agentName = resolveAgentName(flags);
+  try {
+    const res = await daemonFetch(
+      `/api/agents/${encodeURIComponent(agentName)}/typing?channel=${encodeURIComponent(uri)}`
+    );
+    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();
+    if (data.typing.length > 0) {
+      console.log(data.typing.join(", "));
+    }
+  } catch (err) {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+function parseUri(uri) {
+  const colonIdx = uri.indexOf(":");
+  if (colonIdx === -1) {
+    console.error(`Invalid channel URI: ${uri} (expected format: platform:id)`);
+    process.exit(1);
+  }
+  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-5X7HGB6L.js → chunk-AOKAQGO4.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   voluteHome
-} from "./chunk-UX25Z2ND.js";
+} from "./chunk-UWHWAPGO.js";
 
 // src/lib/update-check.ts
 import { existsSync, readFileSync, writeFileSync } from "fs";

package/dist/{chunk-MXUCNIBG.js → chunk-BX7KI4S3.js}

@@ -1,8 +1,13 @@
 #!/usr/bin/env node
 
+// src/lib/slugify.ts
+function slugify(text) {
+  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+
 // src/connectors/sdk.ts
-import { existsSync, readFileSync } from "fs";
-import { resolve } from "path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join, resolve } from "path";
 function loadEnv() {
   const agentPort = process.env.VOLUTE_AGENT_PORT;
   const agentName = process.env.VOLUTE_AGENT_NAME;
@@ -92,6 +97,15 @@ function onShutdown(cleanup) {
   process.on("SIGINT", handler);
   process.on("SIGTERM", handler);
 }
+function reportTyping(env, channel, sender, active) {
+  fetch(`${env.baseUrl}/typing`, {
+    method: "POST",
+    headers: getHeaders(env),
+    body: JSON.stringify({ channel, sender, active })
+  }).catch((err) => {
+    console.warn(`[typing] failed to report for ${sender} on ${channel}: ${err}`);
+  });
+}
 async function fireAndForget(env, payload) {
   try {
     const res = await fetch(`${env.baseUrl}/message`, {
@@ -157,12 +171,63 @@ async function handleAgentMessage(env, payload, handlers) {
     await handlers.onError(errMsg);
   }
 }
+function buildChannelSlug(platform, meta) {
+  if (meta.isDM) {
+    if (meta.recipients && meta.recipients.length > 0) {
+      const sorted = meta.recipients.map(slugify).sort();
+      return `${platform}:@${sorted.join(",")}`;
+    }
+    if (meta.senderName) {
+      return `${platform}:@${slugify(meta.senderName)}`;
+    }
+  }
+  if (meta.channelName && meta.serverName) {
+    return `${platform}:${slugify(meta.serverName)}/${slugify(meta.channelName)}`;
+  }
+  if (meta.channelName) {
+    return `${platform}:${slugify(meta.channelName)}`;
+  }
+  if (meta.platformId) {
+    return `${platform}:${meta.platformId}`;
+  }
+  return `${platform}:unknown`;
+}
+function readChannelMap(agentDir) {
+  const filePath = join(agentDir, ".volute", "channels.json");
+  if (!existsSync(filePath)) return {};
+  try {
+    return JSON.parse(readFileSync(filePath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function writeChannelEntry(agentDir, slug, entry) {
+  const voluteDir = join(agentDir, ".volute");
+  mkdirSync(voluteDir, { recursive: true });
+  const filePath = join(voluteDir, "channels.json");
+  const map = readChannelMap(agentDir);
+  map[slug] = entry;
+  writeFileSync(filePath, JSON.stringify(map, null, 2) + "\n");
+}
+function resolveChannelId(agentDir, slug) {
+  const map = readChannelMap(agentDir);
+  if (map[slug]) {
+    return map[slug].platformId;
+  }
+  const colonIndex = slug.indexOf(":");
+  return colonIndex >= 0 ? slug.slice(colonIndex + 1) : slug;
+}
 
 export {
+  slugify,
   loadEnv,
   loadFollowedChannels,
   splitMessage,
   onShutdown,
+  reportTyping,
   fireAndForget,
-  handleAgentMessage
+  handleAgentMessage,
+  buildChannelSlug,
+  writeChannelEntry,
+  resolveChannelId
 };

package/dist/{chunk-MW2KFO3B.js → chunk-G6ZNGLUX.js}

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import {
   loadMergedEnv
-} from "./chunk-HE67X4T6.js";
+} from "./chunk-H7AMDUIA.js";
 import {
   applyIsolation
-} from "./chunk-UAVD2AHX.js";
+} from "./chunk-W76KWE23.js";
 import {
   agentDir,
   findAgent,
@@ -13,7 +13,7 @@ import {
   setVariantRunning,
   validateBranchName,
   voluteHome
-} from "./chunk-UX25Z2ND.js";
+} from "./chunk-UWHWAPGO.js";
 
 // src/lib/agent-manager.ts
 import { execFile, spawn } from "child_process";

package/dist/{chunk-HE67X4T6.js → chunk-H7AMDUIA.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   voluteHome
-} from "./chunk-UX25Z2ND.js";
+} from "./chunk-UWHWAPGO.js";
 
 // src/lib/env.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";

package/dist/{chunk-7L4AN5D4.js → chunk-JR4UXCTO.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   voluteHome
-} from "./chunk-UX25Z2ND.js";
+} from "./chunk-UWHWAPGO.js";
 
 // src/lib/daemon-client.ts
 import { existsSync, readFileSync } from "fs";

package/dist/{chunk-UX25Z2ND.js → chunk-UWHWAPGO.js}

@@ -90,6 +90,12 @@ function nextPort() {
   if (port > 65535) throw new Error("No available ports \u2014 all ports 4100-65535 are allocated");
   return port;
 }
+function daemonLoopback() {
+  const host = process.env.VOLUTE_DAEMON_HOSTNAME || "127.0.0.1";
+  if (host === "0.0.0.0") return "127.0.0.1";
+  if (host === "::") return "[::1]";
+  return host;
+}
 function resolveAgent(name) {
   const [baseName, variantName] = name.split("@", 2);
   const entry = findAgent(baseName);
@@ -227,5 +233,6 @@ export {
   findAgent,
   agentDir,
   nextPort,
+  daemonLoopback,
   resolveAgent
 };

package/dist/{chunk-UAVD2AHX.js → chunk-W76KWE23.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   validateAgentName
-} from "./chunk-UX25Z2ND.js";
+} from "./chunk-UWHWAPGO.js";
 
 // src/lib/isolation.ts
 import { execFile, execFileSync } from "child_process";