svamp-cli 0.2.187 → 0.2.190

package/bin/skills/loop/test/test-loop-gate.mjs

@@ -302,6 +302,40 @@ try {
     ok(readState(d).phase !== 'done', 'loop B did not close as done at iteration 0');
   }
 
+  // ---- Test 21: inject-loop self-heals a clobbered Stop gate (#0072) -------
+  console.log('Test 21: inject-loop re-installs a dropped Stop gate (shared-tree self-heal)');
+  { const INJECT = resolve(HERE, '..', 'bin', 'inject-loop.mjs');
+    const d = newProject(); dirs.push(d);
+    const settingsPath = join(d, '.claude', 'settings.json');
+    const stopGate = join(d, '.svamp', SID, 'loop', 'bin', 'stop-gate.mjs');
+    const runInject = () => execFileSync(node, [INJECT], {
+      input: JSON.stringify({ hook_event_name: 'SessionStart', cwd: d }),
+      encoding: 'utf8', env: { ...process.env, SVAMP_SESSION_ID: SID, CLAUDE_PROJECT_DIR: d },
+    });
+    const hasStop = () => { const s = JSON.parse(readFileSync(settingsPath, 'utf8'));
+      return Array.isArray(s.hooks?.Stop) && s.hooks.Stop.some((g) => Array.isArray(g?.hooks)
+        && g.hooks.some((h) => typeof h?.command === 'string' && h.command.includes(stopGate))); };
+    ok(hasStop(), 'precondition: loop-init installed the Stop gate');
+    // Simulate a shared-tree clobber: another tool rewrites settings.json, dropping the Stop hook.
+    const clob = JSON.parse(readFileSync(settingsPath, 'utf8'));
+    delete clob.hooks.Stop; clob.permissions = { allow: ['Bash(ls:*)'] };
+    writeFileSync(settingsPath, JSON.stringify(clob, null, 2));
+    ok(!hasStop(), 'precondition: Stop gate removed by the clobber');
+    runInject();
+    ok(hasStop(), 'inject-loop re-installed the missing Stop gate');
+    ok(JSON.parse(readFileSync(settingsPath, 'utf8')).permissions?.allow?.includes('Bash(ls:*)'),
+      'self-heal preserved unrelated settings (merge, not clobber)');
+    runInject();
+    ok(JSON.parse(readFileSync(settingsPath, 'utf8')).hooks.Stop.length === 1,
+      'self-heal is idempotent when the gate is intact');
+    // Inactive loop (cancelled) must NOT be resurrected by inject-loop.
+    const stateP = join(d, '.svamp', SID, 'loop', 'loop-state.json');
+    const st = JSON.parse(readFileSync(stateP, 'utf8')); st.active = false; writeFileSync(stateP, JSON.stringify(st));
+    const clob2 = JSON.parse(readFileSync(settingsPath, 'utf8')); delete clob2.hooks.Stop; writeFileSync(settingsPath, JSON.stringify(clob2, null, 2));
+    runInject();
+    ok(!hasStop(), 'inactive loop: inject-loop does not re-install (respects cancel)');
+  }
+
   console.log(`\n${fail === 0 ? '✅' : '❌'} ${pass} passed, ${fail} failed`);
   process.exit(fail === 0 ? 0 : 1);
 } finally {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svamp-cli",
-  "version": "0.2.187",
+  "version": "0.2.190",
   "description": "Svamp CLI — AI workspace daemon on Hypha Cloud",
   "author": "Amun AI AB",
   "license": "SEE LICENSE IN LICENSE",

package/dist/agentCommands-D82YAIjn.mjs

@@ -1,379 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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 };