svamp-cli 0.2.190 → 0.2.192

package/dist/agentCommands-D82YAIjn.mjs

@@ -0,0 +1,379 @@
+import { existsSync, readFileSync, mkdirSync, writeFileSync, renameSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import os from 'node:os';
+import { requireNotSandboxed } from './sandboxDetect-DNTcbgWD.mjs';
+import { x as shortId } from './run-DZLwKdGH.mjs';
+import 'os';
+import 'fs/promises';
+import 'fs';
+import 'path';
+import 'url';
+import 'child_process';
+import 'crypto';
+import 'node:crypto';
+import 'node:child_process';
+import 'util';
+import 'node:events';
+import '@agentclientprotocol/sdk';
+import '@modelcontextprotocol/sdk/client/index.js';
+import '@modelcontextprotocol/sdk/client/stdio.js';
+import '@modelcontextprotocol/sdk/types.js';
+import 'zod';
+import 'node:fs/promises';
+import 'node:util';
+
+const SVAMP_HOME = process.env.SVAMP_HOME || join(os.homedir(), ".svamp");
+function getConfigPath(sessionId) {
+  const cwd = process.cwd();
+  return join(cwd, ".svamp", sessionId, "config.json");
+}
+function readConfig(configPath) {
+  try {
+    if (existsSync(configPath)) return JSON.parse(readFileSync(configPath, "utf-8"));
+  } catch {
+  }
+  return {};
+}
+function writeConfig(configPath, config) {
+  mkdirSync(dirname(configPath), { recursive: true });
+  const tmp = configPath + ".tmp";
+  writeFileSync(tmp, JSON.stringify(config, null, 2));
+  renameSync(tmp, configPath);
+}
+async function connectAndEmit(event) {
+  const ENV_FILE = join(SVAMP_HOME, ".env");
+  if (existsSync(ENV_FILE)) {
+    const lines = readFileSync(ENV_FILE, "utf-8").split("\n");
+    for (const line of lines) {
+      const m = line.match(/^([A-Z_]+)=(.*)/);
+      if (m && !process.env[m[1]]) process.env[m[1]] = m[2].replace(/^["']|["']$/g, "");
+    }
+  }
+  const serverUrl = process.env.HYPHA_SERVER_URL;
+  const token = process.env.HYPHA_TOKEN;
+  if (!serverUrl || !token) {
+    console.error('No Hypha credentials. Run "svamp login" first.');
+    process.exit(1);
+  }
+  const origLog = console.log;
+  const origWarn = console.warn;
+  const origInfo = console.info;
+  console.log = () => {
+  };
+  console.warn = () => {
+  };
+  console.info = () => {
+  };
+  let server;
+  try {
+    const mod = await import('hypha-rpc');
+    const connectToServer = mod.connectToServer || mod.default?.connectToServer;
+    server = await connectToServer({ server_url: serverUrl, token, name: "svamp-agent-emit" });
+  } catch (err) {
+    console.log = origLog;
+    console.warn = origWarn;
+    console.info = origInfo;
+    console.error(`Failed to connect to Hypha: ${err.message}`);
+    process.exit(1);
+  }
+  console.log = origLog;
+  console.warn = origWarn;
+  console.info = origInfo;
+  await server.emit({ ...event, to: "*" });
+  await server.disconnect();
+}
+async function sessionSetTitle(title) {
+  const sessionId = process.env.SVAMP_SESSION_ID;
+  if (!sessionId) {
+    console.error("SVAMP_SESSION_ID not set. This command must be run inside a Svamp session.");
+    process.exit(1);
+  }
+  const configPath = getConfigPath(sessionId);
+  const config = readConfig(configPath);
+  config.title = title.trim();
+  writeConfig(configPath, config);
+  console.log(`Session title set: "${title.trim()}"`);
+}
+async function sessionSetProjectDescription(description) {
+  const dir = process.cwd();
+  const { projectName, writeProjectInfo, sanitizeDescription, projectInfoPath } = await import('./run-DZLwKdGH.mjs').then(function (n) { return n.a5; });
+  const desc = sanitizeDescription(description, 240);
+  if (!desc) {
+    console.error("Project description is empty.");
+    process.exit(1);
+  }
+  const name = projectName(dir);
+  writeProjectInfo(dir, { name, description: desc, source: "manual", updatedAt: Date.now() });
+  console.log(`Project description set for "${name}": "${desc}"`);
+  console.log(`Shared across all sessions in this project (${projectInfoPath(dir)}).`);
+}
+async function sessionSetLink(url, label) {
+  const sessionId = process.env.SVAMP_SESSION_ID;
+  if (!sessionId) {
+    console.error("SVAMP_SESSION_ID not set. This command must be run inside a Svamp session.");
+    process.exit(1);
+  }
+  const resolvedLabel = label?.trim() || (() => {
+    try {
+      return new URL(url).hostname;
+    } catch {
+      return "View";
+    }
+  })();
+  const configPath = getConfigPath(sessionId);
+  const config = readConfig(configPath);
+  config.session_link = { url: url.trim(), label: resolvedLabel };
+  writeConfig(configPath, config);
+  console.log(`Session link set: "${resolvedLabel}" \u2192 ${url.trim()}`);
+}
+async function sessionNotify(message, level = "info") {
+  requireNotSandboxed("session notify");
+  const sessionId = process.env.SVAMP_SESSION_ID;
+  if (!sessionId) {
+    console.error("SVAMP_SESSION_ID not set. This command must be run inside a Svamp session.");
+    process.exit(1);
+  }
+  await connectAndEmit({
+    type: "svamp:session-notify",
+    data: { sessionId, message, level, timestamp: Date.now() }
+  });
+  console.log(`Notification sent [${level}]: ${message}`);
+}
+async function sessionBroadcast(action, args) {
+  requireNotSandboxed("session broadcast");
+  const sessionId = process.env.SVAMP_SESSION_ID;
+  if (!sessionId) {
+    console.error("SVAMP_SESSION_ID not set. This command must be run inside a Svamp session.");
+    process.exit(1);
+  }
+  let payload = { action };
+  if (action === "open-canvas") {
+    const url = args[0];
+    if (!url) {
+      console.error("Usage: svamp session broadcast open-canvas <url> [label]");
+      process.exit(1);
+    }
+    const label = args[1] || (() => {
+      try {
+        return new URL(url).hostname;
+      } catch {
+        return "View";
+      }
+    })();
+    payload = { action, url, label };
+  } else if (action === "close-canvas") ; else if (action === "toast") {
+    const message = args[0];
+    if (!message) {
+      console.error("Usage: svamp session broadcast toast <message>");
+      process.exit(1);
+    }
+    payload = { action, message };
+  } else {
+    console.error(`Unknown broadcast action: ${action}`);
+    console.error("Available actions: open-canvas, close-canvas, toast");
+    process.exit(1);
+  }
+  await connectAndEmit({
+    type: "svamp:session-broadcast",
+    data: { sessionId, ...payload }
+  });
+  console.log(`Broadcast sent: ${action}`);
+}
+async function connectToMachineService() {
+  const { connectAndGetMachine } = await import('./commands-CkxVt5V0.mjs');
+  return connectAndGetMachine();
+}
+function buildInboxMessage(args) {
+  return {
+    messageId: shortId(),
+    body: args.body,
+    timestamp: Date.now(),
+    read: false,
+    from: `agent:${args.fromSessionId}`,
+    fromSession: args.fromSessionId,
+    to: args.to,
+    subject: args.subject,
+    urgency: args.urgency || "normal",
+    ...args.replyTo ? { replyTo: args.replyTo } : {},
+    ...args.threadId ? { threadId: args.threadId } : {}
+  };
+}
+async function inboxSendCore(resolve, args) {
+  const { machine, fullId } = await resolve(args.target);
+  const message = buildInboxMessage({
+    fromSessionId: args.fromSessionId,
+    to: fullId,
+    body: args.body,
+    subject: args.subject,
+    urgency: args.urgency
+  });
+  const result = await machine.sessionRPC(fullId, "sendInboxMessage", { message });
+  return { targetId: fullId, messageId: result.messageId, message };
+}
+async function inboxReplyCore(localMachine, resolve, args) {
+  const result = await localMachine.sessionRPC(args.sessionId, "getInbox", {});
+  const original = (result.messages || []).find(
+    (m) => m.messageId === args.messageId || m.messageId.startsWith(args.messageId)
+  );
+  if (!original) return { kind: "not-found" };
+  let channelDelivered = false;
+  if (original.channelId && original.correlationId) {
+    const rr = await localMachine.sessionRPC(args.sessionId, "channelReply", {
+      params: { channel: original.channelId, correlationId: original.correlationId, to: original.from, body: args.body }
+    });
+    if (rr?.error) {
+      if (!original.fromSession) return { kind: "channel-error", error: rr.error };
+    } else channelDelivered = true;
+  }
+  if (original.fromSession) {
+    try {
+      const { machine, fullId } = await resolve(original.fromSession);
+      const reply = buildInboxMessage({
+        fromSessionId: args.sessionId,
+        to: fullId,
+        body: args.body,
+        subject: original.subject ? `Re: ${original.subject}` : void 0,
+        replyTo: original.messageId,
+        threadId: original.threadId || original.messageId
+      });
+      const sendResult = await machine.sessionRPC(fullId, "sendInboxMessage", { message: reply });
+      return { kind: "sent", targetId: fullId, messageId: sendResult.messageId, message: reply };
+    } catch (err) {
+      if (channelDelivered) return { kind: "channel", from: original.from, channelId: original.channelId, correlationId: original.correlationId };
+      throw err;
+    }
+  }
+  if (channelDelivered) return { kind: "channel", from: original.from, channelId: original.channelId, correlationId: original.correlationId };
+  return { kind: "no-from-session" };
+}
+async function inboxSend(targetSessionId, opts) {
+  requireNotSandboxed("inbox send");
+  const sessionId = process.env.SVAMP_SESSION_ID;
+  if (!sessionId) {
+    console.error("SVAMP_SESSION_ID not set. This command must be run inside a Svamp session.");
+    process.exit(1);
+  }
+  const body = opts?.body || "";
+  if (!body) {
+    console.error("Message body is required.");
+    process.exit(1);
+  }
+  const { connectAndResolveSession } = await import('./commands-CkxVt5V0.mjs');
+  let server;
+  try {
+    const { targetId, messageId } = await inboxSendCore(
+      async (target) => {
+        const r = await connectAndResolveSession(target);
+        server = r.server;
+        return { machine: r.machine, fullId: r.fullId };
+      },
+      { fromSessionId: sessionId, target: targetSessionId, body, subject: opts?.subject, urgency: opts?.urgency }
+    );
+    console.log(`Inbox message sent to ${targetId.slice(0, 8)} (id: ${messageId.slice(0, 8)})`);
+  } finally {
+    if (server) await server.disconnect();
+  }
+}
+async function inboxList(opts) {
+  requireNotSandboxed("inbox list");
+  const sessionId = process.env.SVAMP_SESSION_ID;
+  if (!sessionId) {
+    console.error("SVAMP_SESSION_ID not set. This command must be run inside a Svamp session.");
+    process.exit(1);
+  }
+  const { server, machine } = await connectToMachineService();
+  try {
+    const result = await machine.sessionRPC(sessionId, "getInbox", { opts: { unread: opts?.unread, limit: opts?.limit } });
+    const messages = result.messages;
+    if (opts?.json) {
+      console.log(JSON.stringify({ messages }, null, 2));
+      return;
+    }
+    if (messages.length === 0) {
+      console.log("Inbox is empty.");
+      return;
+    }
+    for (const msg of messages) {
+      const status = msg.read ? " " : "\u25CF";
+      const from = msg.from ? ` from ${msg.from}` : "";
+      const subject = msg.subject ? ` \u2014 ${msg.subject}` : "";
+      const urgencyTag = msg.urgency === "urgent" ? " [URGENT]" : "";
+      const preview = msg.body.length > 100 ? msg.body.slice(0, 97) + "..." : msg.body;
+      console.log(`${status} ${msg.messageId.slice(0, 8)}${urgencyTag}${from}${subject}: ${preview}`);
+    }
+  } finally {
+    await server.disconnect();
+  }
+}
+async function inboxReply(messageId, body) {
+  requireNotSandboxed("inbox reply");
+  const sessionId = process.env.SVAMP_SESSION_ID;
+  if (!sessionId) {
+    console.error("SVAMP_SESSION_ID not set. This command must be run inside a Svamp session.");
+    process.exit(1);
+  }
+  const { connectAndResolveSession } = await import('./commands-CkxVt5V0.mjs');
+  const { server: localServer, machine: localMachine } = await connectToMachineService();
+  let localDisconnected = false;
+  const disconnectLocal = async () => {
+    if (!localDisconnected) {
+      localDisconnected = true;
+      try {
+        await localServer.disconnect();
+      } catch {
+      }
+    }
+  };
+  let senderServer;
+  try {
+    const res = await inboxReplyCore(
+      localMachine,
+      async (target) => {
+        await disconnectLocal();
+        const r = await connectAndResolveSession(target);
+        senderServer = r.server;
+        return { machine: r.machine, fullId: r.fullId };
+      },
+      { sessionId, messageId, body }
+    );
+    switch (res.kind) {
+      case "not-found":
+        console.error(`Message ${messageId} not found in inbox.`);
+        process.exit(1);
+        break;
+      case "no-from-session":
+        console.error("Cannot reply: original message has no fromSession (and not a channel message).");
+        process.exit(1);
+        break;
+      case "channel-error":
+        console.error(`Channel reply failed: ${res.error}`);
+        process.exit(1);
+        break;
+      case "channel":
+        console.log(`Reply queued to "${res.from}" on channel ${res.channelId} (correlation ${res.correlationId}).`);
+        break;
+      case "sent":
+        console.log(`Reply sent to ${res.targetId.slice(0, 8)} (id: ${res.messageId.slice(0, 8)})`);
+        break;
+    }
+  } finally {
+    await disconnectLocal();
+    if (senderServer) {
+      try {
+        await senderServer.disconnect();
+      } catch {
+      }
+    }
+  }
+}
+async function machineNotify(message, level = "info") {
+  requireNotSandboxed("machine notify");
+  const machineId = process.env.SVAMP_MACHINE_ID;
+  await connectAndEmit({
+    type: "svamp:machine-notify",
+    data: { machineId, message, level, timestamp: Date.now() }
+  });
+  console.log(`Machine notification sent [${level}]: ${message}`);
+}
+
+export { buildInboxMessage, inboxList, inboxReply, inboxReplyCore, inboxSend, inboxSendCore, machineNotify, sessionBroadcast, sessionNotify, sessionSetLink, sessionSetProjectDescription, sessionSetTitle };

package/dist/auth-CRgqElsS.mjs

@@ -0,0 +1,83 @@
+import { M as resolveModel } from './run-DZLwKdGH.mjs';
+import 'os';
+import 'fs/promises';
+import 'fs';
+import 'path';
+import 'url';
+import 'child_process';
+import 'crypto';
+import 'node:crypto';
+import 'node:fs';
+import 'node:child_process';
+import 'util';
+import 'node:path';
+import 'node:events';
+import 'node:os';
+import '@agentclientprotocol/sdk';
+import '@modelcontextprotocol/sdk/client/index.js';
+import '@modelcontextprotocol/sdk/client/stdio.js';
+import '@modelcontextprotocol/sdk/types.js';
+import 'zod';
+import 'node:fs/promises';
+import 'node:util';
+
+function buildWiseAgentEnvUpdates(action) {
+  switch (action.kind) {
+    case "use-openai":
+      return { WISE_AGENT_PROVIDER: "openai", ...action.key ? { WISE_AGENT_API_KEY: action.key } : {} };
+    case "use-hypha-proxy":
+      return { WISE_AGENT_PROVIDER: "hypha-proxy", ...action.url ? { SVAMP_HYPHA_PROXY_URL: action.url } : {} };
+    case "use-claude-haiku":
+      return { WISE_AGENT_PROVIDER: "claude-haiku", WISE_AGENT_MODEL: void 0, ...action.url ? { SVAMP_HYPHA_PROXY_URL: action.url } : {} };
+    case "set":
+      return { WISE_AGENT_PROVIDER: "openai", WISE_AGENT_BASE_URL: action.url, WISE_AGENT_API_KEY: action.key };
+    case "set-key":
+      return { WISE_AGENT_API_KEY: action.key };
+    case "set-model":
+      return { WISE_AGENT_MODEL: action.model };
+    case "set-base-url":
+      return { WISE_AGENT_BASE_URL: action.url };
+  }
+}
+function redactKey(key) {
+  if (!key) return "(none)";
+  if (key.length <= 12) return "***";
+  return `${key.slice(0, 8)}\u2026${key.slice(-4)}`;
+}
+function describeWiseAgentAuth(env) {
+  const r = resolveModel(void 0, env);
+  return {
+    provider: r.provider,
+    model: r.model,
+    baseUrl: r.baseUrl || "(unset)",
+    keyRedacted: redactKey(r.apiKey)
+  };
+}
+function parseWiseAgentAuthArgs(args) {
+  const [sub, ...rest] = args;
+  if (!sub || sub === "status") return null;
+  switch (sub) {
+    case "use-openai":
+      return { kind: "use-openai", key: rest[0] };
+    case "use-hypha-proxy":
+      return { kind: "use-hypha-proxy", url: rest[0] };
+    case "use-claude-haiku":
+      return { kind: "use-claude-haiku", url: rest[0] };
+    case "set":
+      if (!rest[0] || !rest[1]) throw new Error("Usage: svamp wise-agent auth set <BASE_URL> <KEY>");
+      return { kind: "set", url: rest[0], key: rest[1] };
+    case "set-key":
+      if (!rest[0]) throw new Error("Usage: svamp wise-agent auth set-key <KEY>");
+      return { kind: "set-key", key: rest[0] };
+    case "set-model":
+      if (!rest[0]) throw new Error("Usage: svamp wise-agent auth set-model <model>");
+      return { kind: "set-model", model: rest[0] };
+    case "set-base-url":
+      if (!rest[0]) throw new Error("Usage: svamp wise-agent auth set-base-url <url>");
+      return { kind: "set-base-url", url: rest[0] };
+    default:
+      throw new Error(`Unknown wise-agent auth command "${sub}". Try: status | use-openai [KEY] | use-hypha-proxy [URL] | use-claude-haiku [URL] | set <URL> <KEY> | set-key <KEY> | set-model <m> | set-base-url <url>`);
+  }
+}
+
+export { buildWiseAgentEnvUpdates, describeWiseAgentAuth, parseWiseAgentAuthArgs, redactKey };