volute 0.34.0 → 0.35.0

package/dist/send-JBJJQ7CA.js

@@ -0,0 +1,409 @@
+#!/usr/bin/env node
+import {
+  readStdin
+} from "./chunk-33ODGMFZ.js";
+import {
+  isCompact
+} from "./chunk-5T5YMX6S.js";
+import {
+  command
+} from "./chunk-TXSA4Q3V.js";
+import "./chunk-O7IGP7ZW.js";
+import {
+  daemonFetch
+} from "./chunk-ZX7EAV5J.js";
+import {
+  getClient,
+  urlOf
+} from "./chunk-LOPXTW6H.js";
+import {
+  formatFileSize
+} from "./chunk-BV65KRHM.js";
+import "./chunk-BDYXIWA5.js";
+import "./chunk-5N7Y5WAM.js";
+import "./chunk-7KJOFUNN.js";
+
+// packages/cli/src/commands/send.ts
+import { existsSync, readFileSync, statSync } from "fs";
+import { userInfo } from "os";
+import { basename, extname } from "path";
+
+// packages/cli/src/lib/parse-target.ts
+function parseTarget(target) {
+  const colonIdx = target.indexOf(":");
+  if (colonIdx !== -1) {
+    const platform = target.slice(0, colonIdx);
+    const identifier = target.slice(colonIdx + 1);
+    return {
+      platform,
+      identifier,
+      uri: target,
+      isDM: identifier.startsWith("@")
+    };
+  }
+  if (target.startsWith("@")) {
+    return {
+      platform: "volute",
+      identifier: target,
+      uri: target,
+      isDM: true
+    };
+  }
+  return {
+    platform: "volute",
+    identifier: target,
+    uri: target,
+    isDM: false
+  };
+}
+
+// packages/cli/src/commands/send.ts
+async function isMind(name) {
+  try {
+    const res = await daemonFetch(`/api/minds/${encodeURIComponent(name)}`);
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+var IMAGE_MEDIA_TYPES = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp"
+};
+function loadImage(imagePath) {
+  if (!existsSync(imagePath)) {
+    console.error(`Image file not found: ${imagePath}`);
+    process.exit(1);
+  }
+  const ext = extname(imagePath).toLowerCase();
+  const mediaType = IMAGE_MEDIA_TYPES[ext];
+  if (!mediaType) {
+    console.error(`Unsupported image format: ${ext} (supported: png, jpg, jpeg, gif, webp)`);
+    process.exit(1);
+  }
+  const data = readFileSync(imagePath).toString("base64");
+  return { media_type: mediaType, data };
+}
+async function waitForResponse(mindName, conversationId, timeoutMs) {
+  const client = getClient();
+  const eventPath = urlOf(
+    client.api.minds[":name"].conversations[":id"].events.$url({
+      param: { name: mindName, id: conversationId }
+    })
+  );
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await daemonFetch(eventPath, {
+      signal: controller.signal
+    });
+  } catch {
+    clearTimeout(timeout);
+    console.error("Could not connect to event stream. Is the mind running?");
+    process.exit(1);
+  }
+  if (!response.body) {
+    clearTimeout(timeout);
+    return;
+  }
+  const reader = response.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 chunks = buffer.split("\n\n");
+      buffer = chunks.pop();
+      for (const chunk of chunks) {
+        for (const line of chunk.split("\n")) {
+          if (!line.startsWith("data: ")) continue;
+          const data = line.slice(6).trim();
+          if (!data) continue;
+          let event;
+          try {
+            event = JSON.parse(data);
+          } catch {
+            continue;
+          }
+          if (event.type === "message" && event.senderName === mindName && event.content) {
+            const text = event.content.filter((b) => b.type === "text" && !!b.text).map((b) => b.text).join("");
+            if (text) {
+              process.stdout.write(`${text}
+`);
+            }
+            return;
+          }
+        }
+      }
+    }
+  } catch (err) {
+    if (err.name === "AbortError") {
+      console.error(`(timed out after ${timeoutMs / 1e3}s)`);
+    } else {
+      throw err;
+    }
+  } finally {
+    clearTimeout(timeout);
+    reader.cancel().catch(() => {
+    });
+  }
+}
+var cmd = command({
+  name: "volute chat send",
+  description: "Send a message to a mind, channel, or platform",
+  args: [
+    {
+      name: "target",
+      required: true,
+      description: "Recipient (@name, #channel, or platform:channel)"
+    },
+    { name: "message", description: "Message text (or pipe via stdin)" }
+  ],
+  flags: {
+    image: { type: "string", description: "Path to image to embed" },
+    file: { type: "string", description: "Path to file to send" },
+    wait: { type: "boolean", description: "Wait for mind response" },
+    timeout: { type: "number", description: "Response timeout in ms (default 120000)" },
+    sender: { type: "string", description: "Send as a specific user" }
+  },
+  examples: [
+    'volute chat send @alice "hello"',
+    'volute chat send #general "announcement"',
+    "echo hi | volute chat send @alice"
+  ],
+  async run({ args, flags }) {
+    const target = args.target;
+    const message = args.message ?? await readStdin();
+    const images = flags.image ? [loadImage(flags.image)] : void 0;
+    if (!message && !images && !flags.file) {
+      console.error(
+        'Usage: volute chat send <target> "<message>" [--image <path>] [--file <path>] [--wait]'
+      );
+      console.error('       echo "message" | volute chat send <target>');
+      console.error("");
+      console.error("Examples:");
+      console.error('  volute chat send @other-mind "hello"');
+      console.error('  volute chat send #animal-chat "hello everyone"');
+      console.error('  volute chat send @mind "check this out" --image photo.png');
+      console.error("  volute chat send @mind --image photo.png");
+      console.error('  volute chat send @mind "check this out" --file notes.txt');
+      console.error('  volute chat send @mind "hello" --wait');
+      process.exit(1);
+    }
+    if (target === "system" || target === "@system") {
+      console.error(
+        `Can't send to system \u2014 system messages are automated.
+To reply to a person, use their username from the message prefix (e.g. volute chat send @username "msg").`
+      );
+      process.exit(1);
+    }
+    if (flags.file) {
+      const filePath = flags.file;
+      const parsed2 = parseTarget(target);
+      const targetName = parsed2.isDM && parsed2.platform === "volute" ? parsed2.identifier.slice(1) : parsed2.identifier;
+      const mindSelf = process.env.VOLUTE_MIND;
+      if (mindSelf) {
+        const res = await daemonFetch(`/api/minds/${encodeURIComponent(mindSelf)}/files/send`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ targetMind: targetName, filePath })
+        });
+        if (!res.ok) {
+          const data2 = await res.json();
+          console.error(data2.error ?? `Failed to send file: ${res.status}`);
+          process.exit(1);
+        }
+        const data = await res.json();
+        console.log(`File staged for ${targetName} (id: ${data.id})`);
+      } else {
+        if (!existsSync(filePath)) {
+          console.error(`File not found: ${filePath}`);
+          process.exit(1);
+        }
+        const stat = statSync(filePath);
+        const MAX_FILE_SIZE = 50 * 1024 * 1024;
+        if (stat.size > MAX_FILE_SIZE) {
+          console.error(
+            `File too large (${formatFileSize(stat.size)}, max ${formatFileSize(MAX_FILE_SIZE)})`
+          );
+          process.exit(1);
+        }
+        const content = readFileSync(filePath);
+        const filename = basename(filePath);
+        const senderName = flags.sender || userInfo().username;
+        const res = await daemonFetch(`/api/minds/${encodeURIComponent(targetName)}/files/stage`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            sender: senderName,
+            filename,
+            data: content.toString("base64")
+          })
+        });
+        if (!res.ok) {
+          const data2 = await res.json();
+          console.error(data2.error ?? `Failed to stage file: ${res.status}`);
+          process.exit(1);
+        }
+        const data = await res.json();
+        console.log(`File staged for ${targetName} (id: ${data.id})`);
+      }
+      if (!message) return;
+    }
+    let parsed = parseTarget(target);
+    if (!parsed.isDM && parsed.platform === "volute" && await isMind(parsed.identifier)) {
+      parsed = {
+        platform: "volute",
+        identifier: `@${parsed.identifier}`,
+        uri: `@${parsed.identifier}`,
+        isDM: true
+      };
+    }
+    const client = getClient();
+    let waitMindName;
+    let waitConversationId;
+    if (parsed.isDM && parsed.platform === "volute") {
+      const targetName = parsed.identifier.slice(1);
+      const mindSelf = process.env.VOLUTE_MIND;
+      const sender = flags.sender || mindSelf || userInfo().username;
+      const targetIsMind = await isMind(targetName);
+      waitMindName = targetIsMind ? targetName : void 0;
+      const contextMind = mindSelf ?? targetName;
+      const participants = mindSelf ? [targetName] : [sender];
+      const createRes = await daemonFetch(
+        urlOf(client.api.minds[":name"].channels.create.$url({ param: { name: contextMind } })),
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ platform: "volute", participants, sender })
+        }
+      );
+      if (!createRes.ok) {
+        const data = await createRes.json().catch(() => ({ error: "Unknown error" }));
+        console.error(data.error);
+        process.exit(1);
+      }
+      const { conversationId: convId } = await createRes.json();
+      if (convId) waitConversationId = convId;
+      const sendRes = await daemonFetch("/api/v1/chat", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          message: message ?? "",
+          conversationId: convId,
+          images,
+          sender,
+          targetMind: contextMind
+        })
+      });
+      if (!sendRes.ok) {
+        const data = await sendRes.json().catch(() => ({ error: "Unknown error" }));
+        console.error(data.error);
+        process.exit(1);
+      }
+      if (!flags.wait) {
+        let outboundId;
+        try {
+          const resData = await sendRes.json();
+          outboundId = resData.outboundId;
+        } catch (err) {
+          console.error(
+            `Warning: could not read outboundId from response: ${err.message}`
+          );
+        }
+        if (isCompact()) {
+          if (outboundId != null) console.log(`[volute:outbound:${outboundId}]`);
+        } else {
+          console.log(
+            `Message sent.${outboundId != null ? `
+[volute:outbound:${outboundId}]` : ""}`
+          );
+        }
+      }
+    } else if (!parsed.isDM && parsed.platform === "volute") {
+      if (!parsed.identifier.startsWith("#")) {
+        console.error(
+          `Mind "${parsed.identifier}" not found.
+  To send a DM:      volute chat send @${parsed.identifier} "..."
+  To send to channel: volute chat send #${parsed.identifier} "..."`
+        );
+        process.exit(1);
+      }
+      const channelName = parsed.identifier.slice(1);
+      const mindSelf = process.env.VOLUTE_MIND;
+      const sender = flags.sender || mindSelf || userInfo().username;
+      const channelRes = await daemonFetch(`/api/v1/channels/${encodeURIComponent(channelName)}`);
+      if (!channelRes.ok) {
+        console.error(`Channel "${channelName}" not found. Create it first or check the name.`);
+        process.exit(1);
+      }
+      const channelData = await channelRes.json();
+      const mindParticipant = channelData.participants?.find((p) => p.userType === "mind");
+      const contextMind = mindSelf ?? mindParticipant?.username;
+      if (!contextMind) {
+        console.error("No mind is a member of this channel. A mind must join the channel first.");
+        process.exit(1);
+      }
+      const sendRes = await daemonFetch("/api/v1/chat", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          message: message ?? "",
+          conversationId: channelData.id,
+          images,
+          sender,
+          targetMind: contextMind
+        })
+      });
+      if (!sendRes.ok) {
+        const data = await sendRes.json().catch(() => ({ error: "Unknown error" }));
+        console.error(data.error);
+        process.exit(1);
+      }
+      let outboundId;
+      try {
+        const resData = await sendRes.json();
+        outboundId = resData.outboundId;
+      } catch (err) {
+        console.error(
+          `Warning: could not read outboundId from response: ${err.message}`
+        );
+      }
+      if (isCompact()) {
+        if (outboundId != null) console.log(`[volute:outbound:${outboundId}]`);
+      } else {
+        console.log(
+          `Message sent.${outboundId != null ? `
+[volute:outbound:${outboundId}]` : ""}`
+        );
+      }
+    } else {
+      console.error(
+        `Direct sends to ${parsed.platform} channels are no longer supported.
+Use bridge channel names instead (e.g. volute chat send @mind-name or #channel-name).
+See: volute chat bridge --help`
+      );
+      process.exit(1);
+    }
+    if (flags.wait && waitMindName) {
+      if (!waitConversationId) {
+        console.error("--wait requires a volute conversation (DM to a mind)");
+        process.exit(1);
+      }
+      await waitForResponse(waitMindName, waitConversationId, flags.timeout ?? 12e4);
+    } else if (flags.wait && !waitMindName) {
+      console.error("--wait is only supported when sending to a mind");
+      process.exit(1);
+    }
+  }
+});
+var run = cmd.execute;
+export {
+  run
+};

package/dist/service-WNPCNHOX.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+import {
+  LAUNCHD_PLIST_LABEL,
+  LAUNCHD_PLIST_PATH,
+  SYSTEM_LAUNCHD_PLIST_PATH,
+  SYSTEM_SERVICE_PATH,
+  USER_SYSTEMD_UNIT
+} from "./chunk-2TGZJFAT.js";
+import {
+  subcommands
+} from "./chunk-TXSA4Q3V.js";
+import "./chunk-O7IGP7ZW.js";
+import "./chunk-AN2W47GW.js";
+import "./chunk-VHJRZM2S.js";
+import "./chunk-BDYXIWA5.js";
+import "./chunk-5N7Y5WAM.js";
+import "./chunk-7KJOFUNN.js";
+
+// packages/cli/src/commands/service.ts
+import { execFile } from "child_process";
+import { existsSync } from "fs";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function status() {
+  const platform = process.platform;
+  if (platform === "darwin") {
+    if (existsSync(SYSTEM_LAUNCHD_PLIST_PATH)) {
+      try {
+        const { stdout } = await execFileAsync("launchctl", ["list", LAUNCHD_PLIST_LABEL]);
+        console.log("System service (LaunchDaemon):");
+        console.log(stdout);
+      } catch {
+        console.log("System service installed but not currently loaded.");
+      }
+      return;
+    }
+    if (!existsSync(LAUNCHD_PLIST_PATH)) {
+      console.log("Service not installed.");
+      return;
+    }
+    try {
+      const { stdout } = await execFileAsync("launchctl", ["list", LAUNCHD_PLIST_LABEL]);
+      console.log(stdout);
+    } catch {
+      console.log("Service installed but not currently loaded.");
+    }
+  } else if (platform === "linux") {
+    if (existsSync(SYSTEM_SERVICE_PATH)) {
+      try {
+        const { stdout } = await execFileAsync("systemctl", ["status", "volute", "--no-pager"]);
+        console.log(stdout);
+      } catch (err) {
+        const e = err;
+        if (e.stdout) {
+          console.log(e.stdout);
+        } else {
+          console.error("System service installed but could not retrieve status.");
+          if (e.stderr) console.error(e.stderr);
+          else if (e.message) console.error(e.message);
+          console.error("Try running: systemctl status volute");
+        }
+      }
+      return;
+    }
+    if (!existsSync(USER_SYSTEMD_UNIT)) {
+      console.log("Service not installed.");
+      return;
+    }
+    try {
+      const { stdout } = await execFileAsync("systemctl", [
+        "--user",
+        "status",
+        "volute",
+        "--no-pager"
+      ]);
+      console.log(stdout);
+    } catch (err) {
+      const e = err;
+      if (e.stdout) console.log(e.stdout);
+      else console.log("Service installed but status unknown.");
+    }
+  } else {
+    console.error(`Unsupported platform: ${platform}`);
+    process.exit(1);
+  }
+}
+var cmd = subcommands({
+  name: "volute service",
+  description: "Manage the system service",
+  commands: {
+    status: {
+      description: "Check service status",
+      run: async () => status()
+    },
+    install: {
+      description: "(deprecated) Use 'volute setup' instead",
+      run: async () => {
+        console.log("'volute service install' has been replaced by 'volute setup'.");
+        console.log("Run `volute setup` to configure your installation.");
+      }
+    },
+    uninstall: {
+      description: "(deprecated) Use 'volute setup' instead",
+      run: async () => {
+        console.log("'volute service uninstall' has been replaced by 'volute setup'.");
+        console.log("To uninstall the service, remove the service file manually:");
+        if (process.platform === "darwin") {
+          console.log("  launchctl unload ~/Library/LaunchAgents/com.volute.daemon.plist");
+          console.log("  rm ~/Library/LaunchAgents/com.volute.daemon.plist");
+        } else {
+          console.log("  systemctl --user disable --now volute");
+          console.log("  rm ~/.config/systemd/user/volute.service");
+        }
+      }
+    }
+  }
+});
+var run = cmd.execute;
+export {
+  run
+};