volute 0.3.1 → 0.5.0

package/dist/chunk-MXUCNIBG.js

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+
+// src/connectors/sdk.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+function loadEnv() {
+  const agentPort = process.env.VOLUTE_AGENT_PORT;
+  const agentName = process.env.VOLUTE_AGENT_NAME;
+  if (!agentPort || !agentName) {
+    console.error("Missing required env vars: VOLUTE_AGENT_PORT, VOLUTE_AGENT_NAME");
+    process.exit(1);
+  }
+  const agentDir = process.env.VOLUTE_AGENT_DIR;
+  const daemonUrl = process.env.VOLUTE_DAEMON_URL;
+  const daemonToken = process.env.VOLUTE_DAEMON_TOKEN;
+  const baseUrl = daemonUrl ? `${daemonUrl}/api/agents/${encodeURIComponent(agentName)}` : `http://127.0.0.1:${agentPort}`;
+  return { agentPort, agentName, agentDir, baseUrl, daemonUrl, daemonToken };
+}
+function loadFollowedChannels(env, platform) {
+  if (!env.agentDir) return [];
+  const configPath = resolve(env.agentDir, "home/.config/volute.json");
+  if (!existsSync(configPath)) return [];
+  try {
+    const config = JSON.parse(readFileSync(configPath, "utf-8"));
+    const platformConfig = config[platform];
+    return platformConfig?.channels ?? platformConfig?.chats ?? [];
+  } catch (err) {
+    console.warn(`Failed to load agent config: ${err}`);
+    return [];
+  }
+}
+function splitMessage(text, maxLength) {
+  const chunks = [];
+  while (text.length > maxLength) {
+    let splitAt = text.lastIndexOf("\n", maxLength);
+    if (splitAt < maxLength / 2) splitAt = maxLength;
+    chunks.push(text.slice(0, splitAt));
+    text = text.slice(splitAt).replace(/^\n/, "");
+  }
+  if (text) chunks.push(text);
+  return chunks;
+}
+async function* readNdjson(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          yield JSON.parse(line);
+        } catch {
+          console.warn(`ndjson: skipping invalid line: ${line.slice(0, 100)}`);
+        }
+      }
+    }
+    if (buffer.trim()) {
+      try {
+        yield JSON.parse(buffer);
+      } catch {
+        console.warn(`ndjson: skipping invalid line: ${buffer.slice(0, 100)}`);
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function getHeaders(env) {
+  const headers = { "Content-Type": "application/json" };
+  if (env.daemonUrl && env.daemonToken) {
+    headers.Authorization = `Bearer ${env.daemonToken}`;
+    headers.Origin = env.daemonUrl;
+  }
+  return headers;
+}
+function onShutdown(cleanup) {
+  const handler = () => {
+    Promise.resolve(cleanup()).then(
+      () => process.exit(0),
+      (err) => {
+        console.error(`Shutdown error: ${err}`);
+        process.exit(1);
+      }
+    );
+  };
+  process.on("SIGINT", handler);
+  process.on("SIGTERM", handler);
+}
+async function fireAndForget(env, payload) {
+  try {
+    const res = await fetch(`${env.baseUrl}/message`, {
+      method: "POST",
+      headers: getHeaders(env),
+      body: JSON.stringify(payload)
+    });
+    if (!res.ok) {
+      console.error(`fireAndForget: agent returned ${res.status}`);
+    }
+    if (res.body) {
+      const reader = res.body.getReader();
+      while (!(await reader.read()).done) {
+      }
+    }
+  } catch (err) {
+    console.error(`Failed to forward message: ${err}`);
+  }
+}
+async function handleAgentMessage(env, payload, handlers) {
+  try {
+    const res = await fetch(`${env.baseUrl}/message`, {
+      method: "POST",
+      headers: getHeaders(env),
+      body: JSON.stringify(payload)
+    });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      console.error(`Agent returned ${res.status}: ${body}`);
+      await handlers.onError(`Error: agent returned ${res.status}`);
+      return;
+    }
+    if (!res.body) {
+      await handlers.onError("Error: no response from agent");
+      return;
+    }
+    let accumulated = "";
+    const pendingImages = [];
+    for await (const event of readNdjson(res.body)) {
+      if (event.type === "text") {
+        accumulated += event.content;
+      } else if (event.type === "image") {
+        pendingImages.push({ data: event.data, media_type: event.media_type });
+      } else if (event.type === "tool_use") {
+        const text2 = accumulated.trim();
+        accumulated = "";
+        const images2 = pendingImages.splice(0);
+        if (text2 || images2.length > 0) {
+          await handlers.onFlush(text2, images2);
+        }
+      } else if (event.type === "done") {
+        break;
+      }
+    }
+    const text = accumulated.trim();
+    const images = pendingImages.splice(0);
+    if (text || images.length > 0) {
+      await handlers.onFlush(text, images);
+    }
+  } catch (err) {
+    console.error(`Failed to reach agent at ${env.baseUrl}/message:`, err);
+    const errMsg = err instanceof TypeError && err.cause?.code === "ECONNREFUSED" ? "Agent is not running" : `Error: ${err}`;
+    await handlers.onError(errMsg);
+  }
+}
+
+export {
+  loadEnv,
+  loadFollowedChannels,
+  splitMessage,
+  onShutdown,
+  fireAndForget,
+  handleAgentMessage
+};

package/dist/chunk-SMISE4SV.js

@@ -0,0 +1,226 @@
+#!/usr/bin/env node
+import {
+  voluteHome
+} from "./chunk-UX25Z2ND.js";
+import {
+  __export
+} from "./chunk-K3NQKI34.js";
+
+// src/lib/channels/discord.ts
+var discord_exports = {};
+__export(discord_exports, {
+  read: () => read,
+  send: () => send
+});
+var API_BASE = "https://discord.com/api/v10";
+function requireToken(env) {
+  const token = env.DISCORD_TOKEN;
+  if (!token) throw new Error("DISCORD_TOKEN not set");
+  return token;
+}
+async function read(env, channelId, limit) {
+  const token = requireToken(env);
+  const res = await fetch(`${API_BASE}/channels/${channelId}/messages?limit=${limit}`, {
+    headers: { Authorization: `Bot ${token}` }
+  });
+  if (!res.ok) {
+    throw new Error(`Discord API error: ${res.status} ${res.statusText}`);
+  }
+  const messages = await res.json();
+  return messages.reverse().map((m) => `${m.author.username}: ${m.content}`).join("\n");
+}
+async function send(env, channelId, message) {
+  const token = requireToken(env);
+  const res = await fetch(`${API_BASE}/channels/${channelId}/messages`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bot ${token}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ content: message })
+  });
+  if (!res.ok) {
+    throw new Error(`Discord API error: ${res.status} ${res.statusText}`);
+  }
+}
+
+// src/lib/channels/slack.ts
+var slack_exports = {};
+__export(slack_exports, {
+  read: () => read2,
+  send: () => send2
+});
+var API_BASE2 = "https://slack.com/api";
+function requireToken2(env) {
+  const token = env.SLACK_BOT_TOKEN;
+  if (!token) throw new Error("SLACK_BOT_TOKEN not set");
+  return token;
+}
+async function slackApi(token, method, body) {
+  const res = await fetch(`${API_BASE2}/${method}`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) {
+    throw new Error(`Slack API HTTP error: ${res.status} ${res.statusText}`);
+  }
+  const data = await res.json();
+  if (!data.ok) {
+    throw new Error(`Slack API error: ${data.error}`);
+  }
+  return data;
+}
+async function read2(env, channelId, limit) {
+  const token = requireToken2(env);
+  const data = await slackApi(token, "conversations.history", {
+    channel: channelId,
+    limit
+  });
+  return data.messages.reverse().map((m) => `${m.user ?? m.bot_id ?? "unknown"}: ${m.text}`).join("\n");
+}
+async function send2(env, channelId, message) {
+  const token = requireToken2(env);
+  await slackApi(token, "chat.postMessage", {
+    channel: channelId,
+    text: message
+  });
+}
+
+// src/lib/channels/telegram.ts
+var telegram_exports = {};
+__export(telegram_exports, {
+  read: () => read3,
+  send: () => send3
+});
+var API_BASE3 = "https://api.telegram.org";
+function requireToken3(env) {
+  const token = env.TELEGRAM_BOT_TOKEN;
+  if (!token) throw new Error("TELEGRAM_BOT_TOKEN not set");
+  return token;
+}
+async function read3(_env, _channelId, _limit) {
+  throw new Error(
+    "Telegram Bot API does not support reading chat history. Use volute channel send instead."
+  );
+}
+async function send3(env, chatId, message) {
+  const token = requireToken3(env);
+  const res = await fetch(`${API_BASE3}/bot${token}/sendMessage`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ chat_id: chatId, text: message })
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(`Telegram API error: ${res.status} ${body}`);
+  }
+}
+
+// src/lib/channels/volute.ts
+var volute_exports = {};
+__export(volute_exports, {
+  read: () => read4,
+  send: () => send4
+});
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+function getDaemonConfig() {
+  const configPath = resolve(voluteHome(), "daemon.json");
+  if (!existsSync(configPath)) {
+    throw new Error("Volute daemon is not running");
+  }
+  let config;
+  try {
+    config = JSON.parse(readFileSync(configPath, "utf-8"));
+  } catch (err) {
+    throw new Error(`Failed to parse ${configPath}: ${err}`);
+  }
+  if (typeof config.port !== "number") {
+    throw new Error(`Invalid or missing port in ${configPath}`);
+  }
+  const url = new URL("http://localhost");
+  url.hostname = config.hostname || "localhost";
+  url.port = String(config.port);
+  return { url: url.origin, token: config.token };
+}
+async function read4(env, conversationId, limit) {
+  const agentName = env.VOLUTE_AGENT;
+  if (!agentName) throw new Error("VOLUTE_AGENT not set");
+  const { url, token } = getDaemonConfig();
+  const headers = { Origin: url };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  const res = await fetch(
+    `${url}/api/agents/${encodeURIComponent(agentName)}/conversations/${encodeURIComponent(conversationId)}/messages`,
+    { headers }
+  );
+  if (!res.ok) {
+    throw new Error(`Failed to read conversation: ${res.status} ${res.statusText}`);
+  }
+  const messages = await res.json();
+  return messages.slice(-limit).map((m) => {
+    const text = Array.isArray(m.content) ? m.content.filter((b) => b.type === "text").map((b) => b.text).join("") : m.content;
+    return `${m.sender_name ?? m.role}: ${text}`;
+  }).join("\n");
+}
+async function send4(env, conversationId, message) {
+  const agentName = env.VOLUTE_AGENT;
+  if (!agentName) throw new Error("VOLUTE_AGENT not set");
+  const { url, token } = getDaemonConfig();
+  const headers = {
+    "Content-Type": "application/json",
+    Origin: url
+  };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  const res = await fetch(`${url}/api/agents/${encodeURIComponent(agentName)}/chat`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ message, conversationId, sender: agentName })
+  });
+  if (!res.ok) {
+    const data = await res.json().catch(() => ({}));
+    throw new Error(data.error ?? `Failed to send: ${res.status}`);
+  }
+  if (res.body) {
+    const reader = res.body.getReader();
+    while (true) {
+      const { done } = await reader.read();
+      if (done) break;
+    }
+  }
+}
+
+// src/lib/channels.ts
+var CHANNELS = {
+  volute: { name: "volute", displayName: "Volute", showToolCalls: true, driver: volute_exports },
+  discord: {
+    name: "discord",
+    displayName: "Discord",
+    showToolCalls: false,
+    driver: discord_exports
+  },
+  slack: {
+    name: "slack",
+    displayName: "Slack",
+    showToolCalls: false,
+    driver: slack_exports
+  },
+  telegram: {
+    name: "telegram",
+    displayName: "Telegram",
+    showToolCalls: false,
+    driver: telegram_exports
+  },
+  system: { name: "system", displayName: "System", showToolCalls: false }
+};
+function getChannelDriver(platform) {
+  return CHANNELS[platform]?.driver ?? null;
+}
+
+export {
+  CHANNELS,
+  getChannelDriver
+};

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

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

package/dist/{chunk-3C2XR4IY.js → chunk-UX25Z2ND.js}

@@ -1,27 +1,131 @@
 #!/usr/bin/env node
 
 // src/lib/variants.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+
+// src/lib/registry.ts
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "fs";
 import { homedir } from "os";
-import { resolve } from "path";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
 function voluteHome() {
-  return process.env.VOLUTE_HOME || resolve(homedir(), ".volute");
+  if (process.env.VOLUTE_HOME) return process.env.VOLUTE_HOME;
+  const dir = dirname(fileURLToPath(import.meta.url));
+  if (dir.endsWith("/src/lib")) {
+    throw new Error(
+      'VOLUTE_HOME must be set when running from source. For tests, run via "npm test" or add "--import ./test/setup.ts".'
+    );
+  }
+  return resolve(homedir(), ".volute");
+}
+function ensureVoluteHome() {
+  mkdirSync(resolve(voluteHome(), "agents"), { recursive: true });
+}
+function readRegistry() {
+  const registryPath = resolve(voluteHome(), "agents.json");
+  if (!existsSync(registryPath)) return [];
+  try {
+    const entries = JSON.parse(readFileSync(registryPath, "utf-8"));
+    return entries.map((e) => ({ ...e, running: e.running ?? false }));
+  } catch {
+    return [];
+  }
+}
+function writeRegistry(entries) {
+  ensureVoluteHome();
+  const registryPath = resolve(voluteHome(), "agents.json");
+  const tmpPath = `${registryPath}.tmp`;
+  writeFileSync(tmpPath, `${JSON.stringify(entries, null, 2)}
+`);
+  renameSync(tmpPath, registryPath);
+}
+var AGENT_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+var AGENT_NAME_MAX = 64;
+function validateAgentName(name) {
+  if (!name) return "Agent name is required";
+  if (name.length > AGENT_NAME_MAX)
+    return `Agent name must be at most ${AGENT_NAME_MAX} characters`;
+  if (!AGENT_NAME_RE.test(name)) {
+    return "Agent name must start with alphanumeric and contain only alphanumeric, dots, dashes, or underscores";
+  }
+  return null;
+}
+function addAgent(name, port) {
+  const err = validateAgentName(name);
+  if (err) throw new Error(err);
+  const entries = readRegistry();
+  const filtered = entries.filter((e) => e.name !== name);
+  filtered.push({ name, port, created: (/* @__PURE__ */ new Date()).toISOString(), running: false });
+  writeRegistry(filtered);
 }
+function removeAgent(name) {
+  const entries = readRegistry();
+  writeRegistry(entries.filter((e) => e.name !== name));
+}
+function setAgentRunning(name, running) {
+  const entries = readRegistry();
+  const entry = entries.find((e) => e.name === name);
+  if (entry) {
+    entry.running = running;
+    writeRegistry(entries);
+  }
+}
+function findAgent(name) {
+  return readRegistry().find((e) => e.name === name);
+}
+function agentDir(name) {
+  return resolve(voluteHome(), "agents", name);
+}
+function nextPort() {
+  const entries = readRegistry();
+  const usedPorts = new Set(entries.map((e) => e.port));
+  for (const entry of entries) {
+    for (const v of readVariants(entry.name)) {
+      if (v.port) usedPorts.add(v.port);
+    }
+  }
+  let port = 4100;
+  while (usedPorts.has(port)) port++;
+  if (port > 65535) throw new Error("No available ports \u2014 all ports 4100-65535 are allocated");
+  return port;
+}
+function resolveAgent(name) {
+  const [baseName, variantName] = name.split("@", 2);
+  const entry = findAgent(baseName);
+  if (!entry) {
+    throw new Error(`Unknown agent: ${baseName}`);
+  }
+  const dir = agentDir(baseName);
+  if (!existsSync(dir)) {
+    throw new Error(`Agent directory missing: ${dir}`);
+  }
+  if (variantName) {
+    const variant = findVariant(baseName, variantName);
+    if (!variant) {
+      throw new Error(`Unknown variant: ${variantName} (agent: ${baseName})`);
+    }
+    return { entry: { ...entry, port: variant.port }, dir: variant.path };
+  }
+  return { entry, dir };
+}
+
+// src/lib/variants.ts
 function variantsPath() {
-  return resolve(voluteHome(), "variants.json");
+  return resolve2(voluteHome(), "variants.json");
 }
 function readAllVariants() {
   const path = variantsPath();
-  if (!existsSync(path)) return {};
+  if (!existsSync2(path)) return {};
   try {
-    return JSON.parse(readFileSync(path, "utf-8"));
+    return JSON.parse(readFileSync2(path, "utf-8"));
   } catch {
     return {};
   }
 }
 function writeAllVariants(all) {
-  mkdirSync(voluteHome(), { recursive: true });
-  writeFileSync(variantsPath(), `${JSON.stringify(all, null, 2)}
+  mkdirSync2(voluteHome(), { recursive: true });
+  writeFileSync2(variantsPath(), `${JSON.stringify(all, null, 2)}
 `);
 }
 function readVariants(agentName) {
@@ -102,104 +206,6 @@ function validateBranchName(branch) {
   return null;
 }
 
-// src/lib/registry.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync, writeFileSync as writeFileSync2 } from "fs";
-import { homedir as homedir2 } from "os";
-import { resolve as resolve2 } from "path";
-function voluteHome2() {
-  return process.env.VOLUTE_HOME || resolve2(homedir2(), ".volute");
-}
-function ensureVoluteHome() {
-  mkdirSync2(resolve2(voluteHome2(), "agents"), { recursive: true });
-}
-function readRegistry() {
-  const registryPath = resolve2(voluteHome2(), "agents.json");
-  if (!existsSync2(registryPath)) return [];
-  try {
-    const entries = JSON.parse(readFileSync2(registryPath, "utf-8"));
-    return entries.map((e) => ({ ...e, running: e.running ?? false }));
-  } catch {
-    return [];
-  }
-}
-function writeRegistry(entries) {
-  ensureVoluteHome();
-  const registryPath = resolve2(voluteHome2(), "agents.json");
-  const tmpPath = `${registryPath}.tmp`;
-  writeFileSync2(tmpPath, `${JSON.stringify(entries, null, 2)}
-`);
-  renameSync(tmpPath, registryPath);
-}
-var AGENT_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
-var AGENT_NAME_MAX = 64;
-function validateAgentName(name) {
-  if (!name) return "Agent name is required";
-  if (name.length > AGENT_NAME_MAX)
-    return `Agent name must be at most ${AGENT_NAME_MAX} characters`;
-  if (!AGENT_NAME_RE.test(name)) {
-    return "Agent name must start with alphanumeric and contain only alphanumeric, dots, dashes, or underscores";
-  }
-  return null;
-}
-function addAgent(name, port) {
-  const err = validateAgentName(name);
-  if (err) throw new Error(err);
-  const entries = readRegistry();
-  const filtered = entries.filter((e) => e.name !== name);
-  filtered.push({ name, port, created: (/* @__PURE__ */ new Date()).toISOString(), running: false });
-  writeRegistry(filtered);
-}
-function removeAgent(name) {
-  const entries = readRegistry();
-  writeRegistry(entries.filter((e) => e.name !== name));
-}
-function setAgentRunning(name, running) {
-  const entries = readRegistry();
-  const entry = entries.find((e) => e.name === name);
-  if (entry) {
-    entry.running = running;
-    writeRegistry(entries);
-  }
-}
-function findAgent(name) {
-  return readRegistry().find((e) => e.name === name);
-}
-function agentDir(name) {
-  return resolve2(voluteHome2(), "agents", name);
-}
-function nextPort() {
-  const entries = readRegistry();
-  const usedPorts = new Set(entries.map((e) => e.port));
-  for (const entry of entries) {
-    for (const v of readVariants(entry.name)) {
-      if (v.port) usedPorts.add(v.port);
-    }
-  }
-  let port = 4100;
-  while (usedPorts.has(port)) port++;
-  if (port > 65535) throw new Error("No available ports \u2014 all ports 4100-65535 are allocated");
-  return port;
-}
-function resolveAgent(name) {
-  const [baseName, variantName] = name.split("@", 2);
-  const entry = findAgent(baseName);
-  if (!entry) {
-    throw new Error(`Unknown agent: ${baseName}`);
-  }
-  const dir = agentDir(baseName);
-  if (!existsSync2(dir)) {
-    throw new Error(`Agent directory missing: ${dir}`);
-  }
-  if (variantName) {
-    const variant = findVariant(baseName, variantName);
-    if (!variant) {
-      throw new Error(`Unknown variant: ${variantName} (agent: ${baseName})`);
-    }
-    return { entry: { ...entry, port: variant.port }, dir: variant.path };
-  }
-  return { entry, dir };
-}
-
 export {
   readVariants,
   writeVariants,
@@ -211,7 +217,7 @@ export {
   removeAllVariants,
   checkHealth,
   validateBranchName,
-  voluteHome2 as voluteHome,
+  voluteHome,
   ensureVoluteHome,
   readRegistry,
   validateAgentName,

package/dist/{chunk-GSPKUPKU.js → chunk-XUA3JUFK.js}

@@ -116,5 +116,6 @@ export {
   findTemplatesRoot,
   composeTemplate,
   copyTemplateToDir,
-  applyInitFiles
+  applyInitFiles,
+  listFiles
 };

package/dist/chunk-ZYGKG6VC.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+
+// src/lib/read-stdin.ts
+import { isatty } from "tty";
+async function readStdin() {
+  if (isatty(0)) return void 0;
+  const chunks = [];
+  try {
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk);
+    }
+  } catch (err) {
+    console.error(`Failed to read from stdin: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  const text = Buffer.concat(chunks).toString().replace(/\r?\n$/, "");
+  return text || void 0;
+}
+
+export {
+  readStdin
+};