svamp-cli 0.1.87 → 0.1.88

package/dist/agentCommands-B6IJhpDh.mjs

@@ -0,0 +1,263 @@
+import { existsSync, readFileSync, mkdirSync, writeFileSync, renameSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import os from 'node:os';
+
+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 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") {
+  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) {
+  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-Cf89hwcf.mjs');
+  return connectAndGetMachine();
+}
+async function inboxSend(targetSessionId, opts) {
+  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 { server, machine } = await connectToMachineService();
+  try {
+    const { resolveSessionId } = await import('./commands-Cf89hwcf.mjs');
+    const sessions = await machine.listSessions();
+    const match = resolveSessionId(sessions, targetSessionId);
+    const fullTargetId = match.sessionId;
+    const { randomUUID } = await import('node:crypto');
+    const message = {
+      messageId: randomUUID(),
+      body,
+      timestamp: Date.now(),
+      read: false,
+      from: `agent:${sessionId}`,
+      fromSession: sessionId,
+      to: fullTargetId,
+      subject: opts?.subject,
+      urgency: opts?.urgency || "normal"
+    };
+    const result = await machine.sessionRPC(fullTargetId, "sendInboxMessage", { message });
+    console.log(`Inbox message sent to ${fullTargetId.slice(0, 8)} (id: ${result.messageId.slice(0, 8)})`);
+  } finally {
+    await server.disconnect();
+  }
+}
+async function inboxList(opts) {
+  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) {
+  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", {});
+    const original = result.messages.find((m) => m.messageId === messageId || m.messageId.startsWith(messageId));
+    if (!original) {
+      console.error(`Message ${messageId} not found in inbox.`);
+      process.exit(1);
+    }
+    if (!original.fromSession) {
+      console.error("Cannot reply: original message has no fromSession.");
+      process.exit(1);
+    }
+    const { randomUUID } = await import('node:crypto');
+    const reply = {
+      messageId: randomUUID(),
+      body,
+      timestamp: Date.now(),
+      read: false,
+      from: `agent:${sessionId}`,
+      fromSession: sessionId,
+      to: original.fromSession,
+      subject: original.subject ? `Re: ${original.subject}` : void 0,
+      urgency: "normal",
+      replyTo: original.messageId,
+      threadId: original.threadId || original.messageId
+    };
+    const sendResult = await machine.sessionRPC(original.fromSession, "sendInboxMessage", { message: reply });
+    console.log(`Reply sent to ${original.fromSession.slice(0, 8)} (id: ${sendResult.messageId.slice(0, 8)})`);
+  } finally {
+    await server.disconnect();
+  }
+}
+async function machineNotify(message, level = "info") {
+  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 { inboxList, inboxReply, inboxSend, machineNotify, sessionBroadcast, sessionNotify, sessionSetLink, sessionSetTitle };

package/dist/api-BRbsyqJ4.mjs

@@ -0,0 +1,147 @@
+function getSandboxEnv() {
+  return {
+    apiUrl: process.env.SANDBOX_API_URL || "https://agent-sandbox.aicell.io",
+    apiKey: process.env.SANDBOX_API_KEY || process.env.HYPHA_TOKEN || "",
+    namespace: process.env.SANDBOX_NAMESPACE || process.env.HYPHA_WORKSPACE || "",
+    sandboxId: process.env.SANDBOX_ID || ""
+  };
+}
+function requireSandboxEnv() {
+  const env = getSandboxEnv();
+  if (!env.apiKey) {
+    throw new Error(
+      'No API credentials found.\nRun "svamp login" to authenticate with Hypha, or set SANDBOX_API_KEY directly.'
+    );
+  }
+  if (!env.namespace) {
+    throw new Error(
+      'No namespace/workspace found.\nRun "svamp login" to set HYPHA_WORKSPACE, or set SANDBOX_NAMESPACE directly.'
+    );
+  }
+  return env;
+}
+function requireSandboxApiEnv() {
+  const env = getSandboxEnv();
+  if (!env.apiKey) {
+    throw new Error(
+      'No API credentials found.\nRun "svamp login" to authenticate with Hypha, or set SANDBOX_API_KEY directly.'
+    );
+  }
+  return env;
+}
+async function sandboxFetch(env, path, init, timeoutMs = 3e4) {
+  const url = `${env.apiUrl.replace(/\/+$/, "")}${path}`;
+  const headers = {
+    "Authorization": `Bearer ${env.apiKey}`,
+    "Content-Type": "application/json",
+    ...init?.headers || {}
+  };
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let res;
+  try {
+    res = await fetch(url, { ...init, headers, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    let detail = body;
+    try {
+      detail = JSON.parse(body).detail || body;
+    } catch {
+    }
+    throw new Error(`${res.status} ${res.statusText}: ${detail}`);
+  }
+  return res;
+}
+async function createServiceGroup(name, ports, options) {
+  const env = requireSandboxEnv();
+  const body = {};
+  if (ports.length === 1 && options?.subdomain) {
+    body.port = ports[0];
+    body.subdomain = options.subdomain;
+  } else {
+    body.ports = ports.map((p) => ({ port: p }));
+  }
+  if (options?.healthPath) {
+    body.health_path = options.healthPath;
+    if (options.healthInterval) {
+      body.health_interval = options.healthInterval;
+    }
+  }
+  const res = await sandboxFetch(env, `/services/${env.namespace}/${name}`, {
+    method: "POST",
+    body: JSON.stringify(body)
+  });
+  return res.json();
+}
+async function listServiceGroups() {
+  const env = requireSandboxEnv();
+  const res = await sandboxFetch(env, `/services/${env.namespace}`);
+  return res.json();
+}
+async function getServiceGroup(name) {
+  const env = requireSandboxEnv();
+  const res = await sandboxFetch(env, `/services/${env.namespace}/${name}`);
+  return res.json();
+}
+async function deleteServiceGroup(name) {
+  const env = requireSandboxEnv();
+  const res = await sandboxFetch(env, `/services/${env.namespace}/${name}`, {
+    method: "DELETE"
+  });
+  return res.json();
+}
+async function addPort(name, port, subdomain) {
+  const env = requireSandboxEnv();
+  const res = await sandboxFetch(env, `/services/${env.namespace}/${name}/ports`, {
+    method: "POST",
+    body: JSON.stringify({ port, subdomain })
+  });
+  return res.json();
+}
+async function removePort(name, port) {
+  const env = requireSandboxEnv();
+  const res = await sandboxFetch(env, `/services/${env.namespace}/${name}/ports/${port}`, {
+    method: "DELETE"
+  });
+  return res.json();
+}
+async function renameSubdomain(name, port, subdomain) {
+  const env = requireSandboxEnv();
+  const res = await sandboxFetch(env, `/services/${env.namespace}/${name}/subdomain`, {
+    method: "PUT",
+    body: JSON.stringify({ port, subdomain })
+  });
+  return res.json();
+}
+async function addBackend(name, sandboxId) {
+  const env = requireSandboxEnv();
+  const sid = sandboxId || env.sandboxId;
+  if (!sid) {
+    throw new Error(
+      "No sandbox ID provided and SANDBOX_ID is not set.\nUse --sandbox-id <id> to specify which sandbox to add."
+    );
+  }
+  const res = await sandboxFetch(env, `/services/${env.namespace}/${name}/backends`, {
+    method: "POST",
+    body: JSON.stringify({ sandbox_id: sid })
+  });
+  return res.json();
+}
+async function removeBackend(name, sandboxId) {
+  const env = requireSandboxEnv();
+  const sid = sandboxId || env.sandboxId;
+  if (!sid) {
+    throw new Error(
+      "No sandbox ID provided and SANDBOX_ID is not set.\nUse --sandbox-id <id> to specify which sandbox to remove."
+    );
+  }
+  const res = await sandboxFetch(env, `/services/${env.namespace}/${name}/backends/${sid}`, {
+    method: "DELETE"
+  });
+  return res.json();
+}
+
+export { addBackend, addPort, createServiceGroup, deleteServiceGroup, getSandboxEnv, getServiceGroup, listServiceGroups, removeBackend, removePort, renameSubdomain, requireSandboxApiEnv, requireSandboxEnv };