volute 0.26.0 → 0.28.0

package/dist/chunk-B2CPS4QU.js

@@ -1,283 +0,0 @@
-#!/usr/bin/env node
-
-// src/lib/registry.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, renameSync, writeFileSync as writeFileSync2 } from "fs";
-import { homedir } from "os";
-import { dirname, resolve as resolve2 } from "path";
-import { fileURLToPath } from "url";
-
-// src/lib/variants.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { resolve } from "path";
-function variantsPath() {
-  return resolve(voluteHome(), "variants.json");
-}
-function readAllVariants() {
-  const path = variantsPath();
-  if (!existsSync(path)) return {};
-  try {
-    return JSON.parse(readFileSync(path, "utf-8"));
-  } catch {
-    return {};
-  }
-}
-function writeAllVariants(all) {
-  mkdirSync(voluteHome(), { recursive: true });
-  writeFileSync(variantsPath(), `${JSON.stringify(all, null, 2)}
-`);
-}
-function readVariants(mindName) {
-  return readAllVariants()[mindName] ?? [];
-}
-function writeVariants(mindName, variants) {
-  const all = readAllVariants();
-  if (variants.length === 0) {
-    delete all[mindName];
-  } else {
-    all[mindName] = variants;
-  }
-  writeAllVariants(all);
-}
-function addVariant(mindName, variant) {
-  const variants = readVariants(mindName);
-  const filtered = variants.filter((v) => v.name !== variant.name);
-  filtered.push(variant);
-  writeVariants(mindName, filtered);
-}
-function removeVariant(mindName, name) {
-  const variants = readVariants(mindName);
-  writeVariants(
-    mindName,
-    variants.filter((v) => v.name !== name)
-  );
-}
-function findVariant(mindName, name) {
-  return readVariants(mindName).find((v) => v.name === name);
-}
-function setVariantRunning(mindName, variantName, running) {
-  const all = readAllVariants();
-  const variants = all[mindName] ?? [];
-  const variant = variants.find((v) => v.name === variantName);
-  if (variant) {
-    variant.running = running;
-    all[mindName] = variants;
-    writeAllVariants(all);
-  }
-}
-function getAllRunningVariants() {
-  const all = readAllVariants();
-  const result = [];
-  for (const [mindName, variants] of Object.entries(all)) {
-    for (const variant of variants) {
-      if (variant.running) {
-        result.push({ mindName, variant });
-      }
-    }
-  }
-  return result;
-}
-function removeAllVariants(mindName) {
-  const all = readAllVariants();
-  delete all[mindName];
-  writeAllVariants(all);
-}
-async function checkHealth(port) {
-  try {
-    const res = await fetch(`http://127.0.0.1:${port}/health`, {
-      signal: AbortSignal.timeout(2e3)
-    });
-    if (!res.ok) return { ok: false };
-    const data = await res.json();
-    return { ok: true, name: data.name };
-  } catch {
-    return { ok: false };
-  }
-}
-var SAFE_BRANCH_RE = /^[a-zA-Z0-9._\-/]+$/;
-function validateBranchName(branch) {
-  if (!SAFE_BRANCH_RE.test(branch)) {
-    return `Invalid branch name: ${branch}. Only alphanumeric, '.', '_', '-', '/' allowed.`;
-  }
-  if (branch.includes("..")) {
-    return `Invalid branch name: ${branch}. '..' not allowed.`;
-  }
-  return null;
-}
-
-// src/lib/registry.ts
-var registryCache = null;
-function initRegistryCache() {
-  registryCache = readRegistryFromDisk();
-}
-function getRegistryCache() {
-  return registryCache;
-}
-function readRegistryFromDisk() {
-  const registryPath = resolve2(voluteHome(), "minds.json");
-  if (!existsSync2(registryPath)) return [];
-  try {
-    const entries = JSON.parse(readFileSync2(registryPath, "utf-8"));
-    return entries.map((e) => ({
-      ...e,
-      running: e.running ?? false,
-      stage: e.stage ?? "sprouted"
-    }));
-  } catch {
-    return [];
-  }
-}
-function voluteHome() {
-  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 resolve2(homedir(), ".volute");
-}
-function ensureVoluteHome() {
-  const mindsBase = process.env.VOLUTE_MINDS_DIR ?? resolve2(voluteHome(), "minds");
-  mkdirSync2(mindsBase, { recursive: true });
-}
-function readRegistry() {
-  if (registryCache) return registryCache;
-  return readRegistryFromDisk();
-}
-function writeRegistry(entries) {
-  if (registryCache) registryCache = entries;
-  ensureVoluteHome();
-  const registryPath = resolve2(voluteHome(), "minds.json");
-  const tmpPath = `${registryPath}.tmp`;
-  writeFileSync2(tmpPath, `${JSON.stringify(entries, null, 2)}
-`);
-  renameSync(tmpPath, registryPath);
-}
-var MIND_NAME_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
-var MIND_NAME_MAX = 64;
-function validateMindName(name) {
-  if (!name) return "Mind name is required";
-  if (name.length > MIND_NAME_MAX) return `Mind name must be at most ${MIND_NAME_MAX} characters`;
-  if (!MIND_NAME_RE.test(name)) {
-    return "Mind name must start with alphanumeric and contain only alphanumeric, dots, dashes, or underscores";
-  }
-  return null;
-}
-function addMind(name, port, stage, template) {
-  const err = validateMindName(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, stage, template });
-  writeRegistry(filtered);
-}
-function removeMind(name) {
-  const entries = readRegistry();
-  writeRegistry(entries.filter((e) => e.name !== name));
-}
-function setMindRunning(name, running) {
-  const entries = readRegistry();
-  const entry = entries.find((e) => e.name === name);
-  if (entry) {
-    entry.running = running;
-    writeRegistry(entries);
-  }
-}
-function setMindStage(name, stage) {
-  const entries = readRegistry();
-  const entry = entries.find((e) => e.name === name);
-  if (entry) {
-    entry.stage = stage;
-    writeRegistry(entries);
-  }
-}
-function setMindTemplateHash(name, hash) {
-  const entries = readRegistry();
-  const entry = entries.find((e) => e.name === name);
-  if (entry) {
-    entry.templateHash = hash;
-    writeRegistry(entries);
-  }
-}
-function findMind(name) {
-  return readRegistry().find((e) => e.name === name);
-}
-function mindDir(name) {
-  if (process.env.VOLUTE_MINDS_DIR) {
-    return resolve2(process.env.VOLUTE_MINDS_DIR, name);
-  }
-  return resolve2(voluteHome(), "minds", name);
-}
-function stateDir(name) {
-  return resolve2(voluteHome(), "state", 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);
-    }
-  }
-  const basePort = parseInt(process.env.VOLUTE_BASE_PORT || "4100", 10);
-  let port = basePort;
-  while (usedPorts.has(port)) port++;
-  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 resolveMind(name) {
-  const [baseName, variantName] = name.split("@", 2);
-  const entry = findMind(baseName);
-  if (!entry) {
-    throw new Error(`Unknown mind: ${baseName}`);
-  }
-  const dir = mindDir(baseName);
-  if (!existsSync2(dir)) {
-    throw new Error(`Mind directory missing: ${dir}`);
-  }
-  if (variantName) {
-    const variant = findVariant(baseName, variantName);
-    if (!variant) {
-      throw new Error(`Unknown variant: ${variantName} (mind: ${baseName})`);
-    }
-    return { entry: { ...entry, port: variant.port }, dir: variant.path };
-  }
-  return { entry, dir };
-}
-
-export {
-  readVariants,
-  writeVariants,
-  addVariant,
-  removeVariant,
-  findVariant,
-  setVariantRunning,
-  getAllRunningVariants,
-  removeAllVariants,
-  checkHealth,
-  validateBranchName,
-  initRegistryCache,
-  getRegistryCache,
-  voluteHome,
-  ensureVoluteHome,
-  readRegistry,
-  writeRegistry,
-  validateMindName,
-  addMind,
-  removeMind,
-  setMindRunning,
-  setMindStage,
-  setMindTemplateHash,
-  findMind,
-  mindDir,
-  stateDir,
-  nextPort,
-  daemonLoopback,
-  resolveMind
-};

package/dist/chunk-HFCBO2GL.js

@@ -1,50 +0,0 @@
-#!/usr/bin/env node
-import {
-  voluteHome
-} from "./chunk-B2CPS4QU.js";
-
-// src/lib/systems-config.ts
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
-import { resolve } from "path";
-var DEFAULT_API_URL = "https://volute.systems";
-function configPath() {
-  return resolve(voluteHome(), "systems.json");
-}
-function readSystemsConfig() {
-  const path = configPath();
-  if (!existsSync(path)) return null;
-  const raw = readFileSync(path, "utf-8");
-  let data;
-  try {
-    data = JSON.parse(raw);
-  } catch {
-    console.error(`Warning: ${path} contains invalid JSON. Run "volute auth logout" and re-login.`);
-    return null;
-  }
-  if (!data.apiKey || !data.system) return null;
-  return {
-    apiKey: data.apiKey,
-    system: data.system,
-    apiUrl: data.apiUrl || DEFAULT_API_URL
-  };
-}
-function writeSystemsConfig(config) {
-  mkdirSync(voluteHome(), { recursive: true });
-  writeFileSync(configPath(), `${JSON.stringify(config, null, 2)}
-`, { mode: 384 });
-}
-function deleteSystemsConfig() {
-  try {
-    unlinkSync(configPath());
-    return true;
-  } catch (err) {
-    if (err.code === "ENOENT") return false;
-    throw err;
-  }
-}
-
-export {
-  readSystemsConfig,
-  writeSystemsConfig,
-  deleteSystemsConfig
-};

package/dist/chunk-RWKVSSLY.js

@@ -1,26 +0,0 @@
-#!/usr/bin/env node
-
-// src/lib/systems-fetch.ts
-async function systemsFetch(url, init) {
-  try {
-    return await fetch(url, init);
-  } catch (err) {
-    const cause = err.cause;
-    const code = cause?.code;
-    const host = new URL(url).host;
-    if (code === "ENOTFOUND") {
-      console.error(`Could not resolve ${host}. Check your internet connection.`);
-    } else if (code === "ECONNREFUSED") {
-      console.error(`Connection refused by ${host}. The service may be down.`);
-    } else {
-      console.error(
-        `Network error connecting to ${host}: ${cause?.message ?? err.message}`
-      );
-    }
-    process.exit(1);
-  }
-}
-
-export {
-  systemsFetch
-};

package/dist/chunk-SIAG3QMM.js

@@ -1,42 +0,0 @@
-#!/usr/bin/env node
-
-// src/lib/volute-config.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { dirname, resolve } from "path";
-function readJson(path) {
-  if (!existsSync(path)) return null;
-  try {
-    return JSON.parse(readFileSync(path, "utf-8"));
-  } catch (err) {
-    console.error(`[volute-config] failed to parse ${path}: ${err}`);
-    return null;
-  }
-}
-function readVoluteConfig(mindDir) {
-  const path = resolve(mindDir, "home/.config/volute.json");
-  const config = readJson(path);
-  if (!config) return null;
-  const legacy = config;
-  if (!config.profile && ("displayName" in config || "description" in config || "avatar" in config)) {
-    config.profile = {
-      displayName: legacy.displayName,
-      description: legacy.description,
-      avatar: legacy.avatar
-    };
-    delete legacy.displayName;
-    delete legacy.description;
-    delete legacy.avatar;
-  }
-  return config;
-}
-function writeVoluteConfig(mindDir, config) {
-  const path = resolve(mindDir, "home/.config/volute.json");
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, `${JSON.stringify(config, null, 2)}
-`);
-}
-
-export {
-  readVoluteConfig,
-  writeVoluteConfig
-};

package/dist/chunk-WSLPZF72.js

@@ -1,173 +0,0 @@
-#!/usr/bin/env node
-import {
-  stateDir
-} from "./chunk-B2CPS4QU.js";
-
-// src/lib/slugify.ts
-function slugify(text) {
-  return text.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
-}
-function buildVoluteSlug(opts) {
-  if (opts.convType === "channel" && opts.convName) {
-    return `volute:#${opts.convName}`;
-  }
-  const isDM = opts.participants.length === 2;
-  if (isDM) {
-    const other = opts.participants.find((p) => p.username !== opts.mindUsername);
-    const otherSlug = other ? slugify(other.username) : "";
-    return otherSlug ? `volute:@${otherSlug}` : `volute:${opts.conversationId}`;
-  }
-  return opts.convTitle ? `volute:${slugify(opts.convTitle)}` : `volute:${opts.conversationId}`;
-}
-
-// src/connectors/sdk.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { join, resolve } from "path";
-function loadEnv() {
-  const mindPort = process.env.VOLUTE_MIND_PORT;
-  const mindName = process.env.VOLUTE_MIND_NAME;
-  if (!mindPort || !mindName) {
-    console.error("Missing required env vars: VOLUTE_MIND_PORT, VOLUTE_MIND_NAME");
-    process.exit(1);
-  }
-  const mindDir = process.env.VOLUTE_MIND_DIR;
-  const daemonUrl = process.env.VOLUTE_DAEMON_URL;
-  const daemonToken = process.env.VOLUTE_DAEMON_TOKEN;
-  const baseUrl = daemonUrl ? `${daemonUrl}/api/minds/${encodeURIComponent(mindName)}` : `http://127.0.0.1:${mindPort}`;
-  return { mindPort, mindName, mindDir, baseUrl, daemonUrl, daemonToken };
-}
-function loadFollowedChannels(env, platform) {
-  if (!env.mindDir) return [];
-  const configPath = resolve(env.mindDir, "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 mind 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;
-}
-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);
-}
-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 sendToMind(env, payload) {
-  const url = `${env.baseUrl}/message`;
-  try {
-    const res = await fetch(url, {
-      method: "POST",
-      headers: getHeaders(env),
-      body: JSON.stringify(payload)
-    });
-    if (!res.ok) {
-      const body = await res.text().catch(() => "");
-      console.error(`Mind returned ${res.status}: ${body}`);
-      return { ok: false, error: `Mind returned ${res.status}` };
-    }
-    return { ok: true };
-  } catch (err) {
-    console.error(`Failed to forward message: ${err}`);
-    const isConnRefused = err instanceof TypeError && err.cause?.code === "ECONNREFUSED";
-    return { ok: false, error: isConnRefused ? "Mind is not running" : "Failed to reach mind" };
-  }
-}
-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(mindName) {
-  const filePath = join(stateDir(mindName), "channels.json");
-  if (!existsSync(filePath)) return {};
-  try {
-    return JSON.parse(readFileSync(filePath, "utf-8"));
-  } catch (err) {
-    console.error(`[sdk] failed to parse ${filePath}:`, err);
-    return {};
-  }
-}
-function writeChannelEntry(mindName, slug, entry) {
-  const dir = stateDir(mindName);
-  mkdirSync(dir, { recursive: true });
-  const filePath = join(dir, "channels.json");
-  const map = readChannelMap(mindName);
-  map[slug] = entry;
-  writeFileSync(filePath, JSON.stringify(map, null, 2) + "\n");
-}
-function resolveChannelId(mindName, slug) {
-  const map = readChannelMap(mindName);
-  if (map[slug]) {
-    return map[slug].platformId;
-  }
-  const colonIndex = slug.indexOf(":");
-  return colonIndex >= 0 ? slug.slice(colonIndex + 1) : slug;
-}
-
-export {
-  slugify,
-  buildVoluteSlug,
-  loadEnv,
-  loadFollowedChannels,
-  splitMessage,
-  onShutdown,
-  reportTyping,
-  sendToMind,
-  buildChannelSlug,
-  writeChannelEntry,
-  resolveChannelId
-};