svamp-cli 0.2.342 → 0.2.356

package/dist/{httpServer-Be1Hcddr.mjs → httpServer-BzEDbOGn.mjs}

@@ -89,11 +89,24 @@ function createChannelHttpServer(deps) {
       m = u.pathname.match(/^\/channel\/([\w.-]+)\/events$/);
       if (m) {
         const cid = m[1];
+        let closed = false;
+        const markClosed = () => {
+          closed = true;
+        };
+        req.on("close", markClosed);
+        req.on("aborted", markClosed);
         let rpc2 = await findOwner(deps, cid);
         if (!rpc2?.channelReceive) {
           res.writeHead(404).end("not found");
           return;
         }
+        if (closed || res.destroyed) {
+          try {
+            res.end();
+          } catch {
+          }
+          return;
+        }
         const live = _sseStreams.get(cid) || 0;
         if (live >= MAX_SSE_STREAMS_PER_CHANNEL) {
           res.writeHead(429, { "content-type": "application/json", "retry-after": "5" }).end(JSON.stringify({ error: `too many concurrent event streams for this channel (max ${MAX_SSE_STREAMS_PER_CHANNEL})` }));
@@ -105,10 +118,6 @@ function createChannelHttpServer(deps) {
         let cursor = Number(u.searchParams.get("cursor") || 0);
         res.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-cache", connection: "keep-alive", "x-accel-buffering": "no" });
         res.write(": connected\n\n");
-        let closed = false;
-        req.on("close", () => {
-          closed = true;
-        });
         let released = false;
         const releaseSlot = () => {
           if (released) return;
@@ -120,7 +129,7 @@ function createChannelHttpServer(deps) {
         req.on("close", releaseSlot);
         try {
           const MIN_LOOP_MS = 1e3;
-          while (!closed) {
+          while (!closed && !res.destroyed) {
             const started = Date.now();
             let out;
             try {

package/dist/hyphaClient-ybivOjZo.mjs

@@ -0,0 +1,49 @@
+let connectToServerFn = null;
+async function getConnectToServer() {
+  if (!connectToServerFn) {
+    const mod = await import('hypha-rpc');
+    connectToServerFn = mod.connectToServer || mod.default && mod.default.connectToServer || mod.hyphaWebsocketClient && mod.hyphaWebsocketClient.connectToServer;
+    if (!connectToServerFn) {
+      throw new Error("Could not find connectToServer in hypha-rpc module");
+    }
+  }
+  return connectToServerFn;
+}
+async function connectToHypha(config) {
+  const connectToServer = await getConnectToServer();
+  const workspace = config.token ? parseWorkspaceFromToken(config.token) : void 0;
+  const server = await Promise.race([
+    connectToServer({
+      server_url: config.serverUrl,
+      token: config.token,
+      client_id: config.clientId,
+      name: config.name || "svamp-cli",
+      workspace,
+      ...config.transport ? { transport: config.transport } : {}
+    }),
+    new Promise((_, reject) => setTimeout(() => reject(new Error(
+      "Timeout connecting to Hypha server (30s). A previous daemon may still be connected. Retrying..."
+    )), 3e4))
+  ]);
+  if (!server.on && server.rpc) {
+    server.on = server.rpc.on.bind(server.rpc);
+    server.off = server.rpc.off.bind(server.rpc);
+    server.emit = server.rpc.emit.bind(server.rpc);
+  }
+  return server;
+}
+function parseWorkspaceFromToken(token) {
+  try {
+    const payload = JSON.parse(Buffer.from(token.split(".")[1], "base64").toString());
+    const scope = payload.scope || "";
+    const match = scope.match(/wid:([^\s]+)/);
+    return match ? match[1] : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function getHyphaServerUrl() {
+  return process.env.HYPHA_SERVER_URL || "http://localhost:9527";
+}
+
+export { connectToHypha as c, getHyphaServerUrl as g };

package/dist/index.mjs

@@ -1,22 +1,54 @@
-export { c as connectToHypha, a as createSessionStore, d as daemonStatus, g as getHyphaServerUrl, r as registerMachineService, s as startDaemon, b as stopDaemon } from './run-CF4kAVPW.mjs';
-import 'os';
-import 'fs/promises';
+export { c as connectToHypha, g as getHyphaServerUrl } from './hyphaClient-ybivOjZo.mjs';
+export { c as createSessionStore, r as registerMachineService } from './hookSettings-FFc1pi8j.mjs';
+export { d as daemonStatus, s as startDaemon, a as stopDaemon } from './run-DDmeV9K3.mjs';
 import 'fs';
 import 'path';
-import 'url';
-import 'child_process';
-import 'crypto';
-import 'node:fs';
-import 'node:path';
 import 'node:crypto';
+import './types-57J3Re0n.mjs';
+import './securityContext-Cm5UTCuD.mjs';
+import 'node:fs';
+import './machineTools-DygM1jXW.mjs';
 import 'node:child_process';
+import './model-CUHojegn.mjs';
+import 'child_process';
+import 'fs/promises';
+import 'crypto';
 import 'util';
 import 'http';
 import 'net';
+import 'os';
+import './instance-CeHz5C8v.mjs';
+import './serveAuth-4M0vwMyj.mjs';
 import 'node:os';
+import 'node:path';
+import './envFlag-COOuJ3AH.mjs';
+import './claudeAuth-C0wc1GTM.mjs';
+import './fileLock-BMPwCrB6.mjs';
+import './codexProvider-BtxYc5Rj.mjs';
+import './friendlyName-1UZcyDhu.mjs';
 import 'node:events';
+import './cron-hHGdb5kU.mjs';
+import 'url';
+import './sharingNotificationSync-qGIQ-3yf.mjs';
+import './acpBackend-UaBD4zL3.mjs';
 import '@agentclientprotocol/sdk';
+import './DefaultTransport-vfp78fug.mjs';
+import './wrapCommand-CdNawSaa.mjs';
+import './acpAgentConfig-CObOPlA8.mjs';
+import './codexAppServerBackend-VGsYtbqg.mjs';
 import 'node:util';
 import 'node:readline';
+import './pinnedCodex-XW4qvOAe.mjs';
+import './GeminiTransport-3OkhtFRO.mjs';
+import './KimiTransport-D8n009Tr.mjs';
+import './kimiProvider-DbxODebR.mjs';
+import './kimiSetup-NGsoYB5h.mjs';
+import './detectIsolation-CrV8IFDv.mjs';
 import 'node:fs/promises';
+import './pinnedNono-5ZHb6328.mjs';
+import './bootStatus-DqtNgJch.mjs';
+import './loopVerify-DALtTk2V.mjs';
+import './store-B4E6NzG6.mjs';
+import './api-BHjyC0Ph.mjs';
+import './store-fi0f-ff1.mjs';
 import 'yaml';

package/dist/instance-CeHz5C8v.mjs

@@ -0,0 +1,203 @@
+import { existsSync, rmSync, readFileSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+function svampHome() {
+  return process.env.SVAMP_HOME || join(homedir(), ".svamp");
+}
+function cacheFile() {
+  return join(svampHome(), "instance-config.json");
+}
+const CONFIG_FILENAME = "svamp.json";
+let _config = null;
+let _loaded = false;
+let _cacheChecked = false;
+let _source = "none";
+function stripSlash$1(u) {
+  return u.replace(/\/+$/, "");
+}
+function getInstanceUrl() {
+  const raw = (process.env.SVAMP_INSTANCE_URL || "").trim();
+  return raw ? stripSlash$1(raw) : void 0;
+}
+function configUrlsFor(anchor) {
+  const base = stripSlash$1(anchor);
+  return [`${base}/${CONFIG_FILENAME}`, `${base}/.well-known/${CONFIG_FILENAME}`];
+}
+async function fetchConfig(anchor) {
+  for (const url of configUrlsFor(anchor)) {
+    try {
+      const resp = await fetch(url, { signal: AbortSignal.timeout(8e3) });
+      if (!resp.ok) continue;
+      const data = await resp.json();
+      if (data && typeof data === "object" && !Array.isArray(data)) {
+        return data;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function readCache() {
+  try {
+    if (existsSync(cacheFile())) {
+      const data = JSON.parse(readFileSync(cacheFile(), "utf-8"));
+      if (data && typeof data === "object" && !Array.isArray(data)) return data;
+    }
+  } catch {
+  }
+  return null;
+}
+function writeCache(cfg) {
+  try {
+    mkdirSync(svampHome(), { recursive: true });
+    writeFileSync(cacheFile(), JSON.stringify(cfg, null, 2) + "\n", "utf-8");
+  } catch {
+  }
+}
+function applyConfig(cfg) {
+  _config = cfg;
+  if (cfg.hyphaServerUrl && typeof cfg.hyphaServerUrl === "string") {
+    process.env.HYPHA_SERVER_URL = stripSlash$1(cfg.hyphaServerUrl.trim());
+  }
+}
+async function loadInstanceConfig(opts = {}) {
+  if (_loaded && !opts.force) return _config;
+  const anchor = opts.anchor ? stripSlash$1(opts.anchor) : getInstanceUrl();
+  if (anchor) {
+    const fetched = await fetchConfig(anchor);
+    if (fetched) {
+      applyConfig(fetched);
+      writeCache(fetched);
+      _source = "fetched";
+      _loaded = true;
+      _cacheChecked = true;
+      return _config;
+    }
+  }
+  const cached = readCache();
+  if (cached) applyConfig(cached);
+  _source = cached ? "cache" : "none";
+  _loaded = true;
+  _cacheChecked = true;
+  return _config;
+}
+function getConfigSource() {
+  return _source;
+}
+function getLoadedConfig() {
+  if (!_loaded && !_cacheChecked) {
+    const cached = readCache();
+    if (cached) {
+      applyConfig(cached);
+      _source = "cache";
+    }
+    _cacheChecked = true;
+  }
+  return _config;
+}
+function clearInstanceConfigCache() {
+  _config = null;
+  _loaded = false;
+  _cacheChecked = false;
+  _source = "none";
+  try {
+    if (existsSync(cacheFile())) rmSync(cacheFile());
+  } catch {
+  }
+}
+function __setConfigForTest(cfg) {
+  _config = cfg;
+  _loaded = true;
+  _cacheChecked = true;
+  _source = cfg ? "fetched" : "none";
+  if (cfg) applyConfig(cfg);
+}
+function __resetForTest() {
+  _config = null;
+  _loaded = false;
+  _cacheChecked = false;
+  _source = "none";
+}
+
+var instanceConfig = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    CONFIG_FILENAME: CONFIG_FILENAME,
+    __resetForTest: __resetForTest,
+    __setConfigForTest: __setConfigForTest,
+    clearInstanceConfigCache: clearInstanceConfigCache,
+    configUrlsFor: configUrlsFor,
+    getConfigSource: getConfigSource,
+    getInstanceUrl: getInstanceUrl,
+    getLoadedConfig: getLoadedConfig,
+    loadInstanceConfig: loadInstanceConfig
+});
+
+function stripSlash(u) {
+  return u.replace(/\/+$/, "");
+}
+function notConfigured(what, key, legacy) {
+  const anchor = getInstanceUrl();
+  const where = anchor ? `Nothing usable was loaded from ${anchor} \u2014 check that ${anchor}/${CONFIG_FILENAME} serves a doc containing "${key}". If that is the wrong instance, re-run \`svamp login <frontend-url>\` with the frontend URL (NOT the Hypha server URL).` : `No instance URL is set \u2014 run \`svamp login <frontend-url>\`; the frontend serves /${CONFIG_FILENAME}.`;
+  return `${what} is not configured. ${where} Legacy override: ${legacy}. It is deployment-specific and never guessed.`;
+}
+function getHyphaServerUrl() {
+  const fromCfg = getLoadedConfig()?.hyphaServerUrl;
+  if (typeof fromCfg === "string" && fromCfg.trim()) return stripSlash(fromCfg.trim());
+  const env = (process.env.HYPHA_SERVER_URL || "").trim();
+  return env ? stripSlash(env) : void 0;
+}
+function getFrpsSubdomainHost() {
+  const fromCfg = getLoadedConfig()?.frps?.subdomainHost;
+  if (typeof fromCfg === "string" && fromCfg.trim()) return fromCfg.trim();
+  const env = (process.env.FRPS_SUBDOMAIN_HOST || "").trim();
+  if (env) return env;
+  throw new Error(notConfigured("frps subdomain host", "frps.subdomainHost", "FRPS_SUBDOMAIN_HOST"));
+}
+function getFrpsServerAddr() {
+  const fromCfg = getLoadedConfig()?.frps?.serverAddr;
+  if (typeof fromCfg === "string" && fromCfg.trim()) return fromCfg.trim();
+  const env = (process.env.FRPS_SERVER_ADDR || "").trim();
+  if (env) return env;
+  return `frps-ctrl.${getFrpsSubdomainHost()}`;
+}
+function getFrpsServerPort() {
+  const fromCfg = getLoadedConfig()?.frps?.serverPort;
+  if (typeof fromCfg === "number" && Number.isFinite(fromCfg)) return fromCfg;
+  const env = parseInt(process.env.FRPS_SERVER_PORT || "", 10);
+  return Number.isFinite(env) ? env : void 0;
+}
+function getSvampWebBaseUrl() {
+  const fromCfg = getLoadedConfig()?.web?.baseUrl;
+  if (typeof fromCfg === "string" && fromCfg.trim()) return stripSlash(fromCfg.trim());
+  const env = (process.env.SVAMP_WEB_URL || "").trim();
+  if (env) return stripSlash(env);
+  const instance = getInstanceUrl();
+  if (instance) return instance;
+  throw new Error(
+    'Svamp web base URL is not configured. Serve a svamp.json with "web.baseUrl", log in with your frontend URL (svamp login <frontend-url>), or set SVAMP_WEB_URL (legacy).'
+  );
+}
+function getSkillsServerUrl() {
+  const fromCfg = getLoadedConfig()?.skills?.server;
+  if (typeof fromCfg === "string" && fromCfg.trim()) return stripSlash(fromCfg.trim());
+  const env = (process.env.HYPHA_SKILLS_SERVER || "").trim();
+  if (env) return stripSlash(env);
+  const server = getHyphaServerUrl();
+  if (server) return server;
+  throw new Error(
+    "Cannot determine skills marketplace server. Serve a svamp.json or set HYPHA_SERVER_URL."
+  );
+}
+function getSkillsWorkspace() {
+  const fromCfg = getLoadedConfig()?.skills?.workspace;
+  if (typeof fromCfg === "string" && fromCfg.trim()) return fromCfg.trim();
+  return (process.env.HYPHA_SKILLS_WORKSPACE || "").trim() || "hypha-cloud";
+}
+function getSkillsCollection() {
+  const fromCfg = getLoadedConfig()?.skills?.collection;
+  if (typeof fromCfg === "string" && fromCfg.trim()) return fromCfg.trim();
+  return (process.env.HYPHA_SKILLS_COLLECTION || "").trim() || "marketplace";
+}
+
+export { getSkillsServerUrl as a, getSkillsWorkspace as b, getSvampWebBaseUrl as c, getFrpsSubdomainHost as d, getFrpsServerPort as e, getFrpsServerAddr as f, getSkillsCollection as g, getHyphaServerUrl as h, instanceConfig as i, loadInstanceConfig as l };

package/dist/kimiProvider-DbxODebR.mjs

@@ -0,0 +1,69 @@
+const DEFAULT_KIMI_PROVIDER = "moonshotai";
+const DEFAULT_KIMI_MODEL_BY_PROVIDER = {
+  moonshotai: "kimi-k2.5",
+  "moonshotai-cn": "kimi-k2-turbo-preview",
+  "kimi-for-coding": "kimi-for-coding"
+};
+function kimiDefaultModelId(cfg) {
+  if (cfg.model) {
+    const m = cfg.model.trim();
+    return m.includes("/") ? m.split("/").pop() || void 0 : m;
+  }
+  return DEFAULT_KIMI_MODEL_BY_PROVIDER[cfg.provider];
+}
+function kimiSpawnEnv(_env = process.env) {
+  return { KIMI_CLI_NO_AUTO_UPDATE: "1" };
+}
+function resolveKimiProvider(env = process.env) {
+  return {
+    provider: env.SVAMP_KIMI_PROVIDER || DEFAULT_KIMI_PROVIDER,
+    apiKey: env.SVAMP_KIMI_API_KEY || env.LLM_API_KEY || void 0,
+    apiBase: env.SVAMP_KIMI_API_BASE || env.LLM_API_BASE || void 0,
+    model: env.SVAMP_KIMI_MODEL || env.LLM_MODEL || void 0
+  };
+}
+function hasKimiProvider(cfg) {
+  return !!cfg.apiKey;
+}
+function buildKimiCatalogAddArgs(cfg) {
+  if (!hasKimiProvider(cfg)) return null;
+  const args = ["provider", "catalog", "add", cfg.provider];
+  if (cfg.apiBase) args.push("--base-url", cfg.apiBase);
+  const defaultModel = kimiDefaultModelId(cfg);
+  if (defaultModel) args.push("--default-model", defaultModel);
+  return args;
+}
+function kimiProviderConfigured(configTomlText, provider) {
+  if (!configTomlText) return false;
+  const header = `[providers.${provider}]`;
+  const idx = configTomlText.indexOf(header);
+  if (idx < 0) return false;
+  const rest = configTomlText.slice(idx + header.length);
+  const nextTable = rest.search(/\n\s*\[/);
+  const block = nextTable < 0 ? rest : rest.slice(0, nextTable);
+  return /(^|\n)\s*api_key\s*=/.test(block);
+}
+function kimiHasGlobalDefaultModel(configTomlText) {
+  if (!configTomlText) return false;
+  const firstTable = configTomlText.search(/(^|\n)\s*\[/);
+  const preamble = firstTable < 0 ? configTomlText : configTomlText.slice(0, firstTable);
+  return /(^|\n)\s*default_model\s*=/.test(preamble);
+}
+function kimiConfigComplete(configTomlText, provider) {
+  return kimiProviderConfigured(configTomlText, provider) && kimiHasGlobalDefaultModel(configTomlText);
+}
+function kimiModelMenu(env = process.env) {
+  return (env.SVAMP_KIMI_MODELS || "").split(",").map((s) => s.trim()).filter(Boolean).filter((m, i, a) => a.indexOf(m) === i);
+}
+function kimiDefaultModel(env = process.env) {
+  const menu = kimiModelMenu(env);
+  return env.SVAMP_KIMI_MODEL || env.LLM_MODEL || menu[0] || void 0;
+}
+function kimiClampModel(requested, env = process.env) {
+  const menu = kimiModelMenu(env);
+  if (!menu.length) return requested;
+  if (requested && menu.includes(requested)) return requested;
+  return kimiDefaultModel(env);
+}
+
+export { DEFAULT_KIMI_MODEL_BY_PROVIDER, DEFAULT_KIMI_PROVIDER, buildKimiCatalogAddArgs, hasKimiProvider, kimiClampModel, kimiConfigComplete, kimiDefaultModel, kimiDefaultModelId, kimiHasGlobalDefaultModel, kimiModelMenu, kimiProviderConfigured, kimiSpawnEnv, resolveKimiProvider };

package/dist/kimiSetup-NGsoYB5h.mjs

@@ -0,0 +1,48 @@
+import { execFile } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { resolveKimiProvider, hasKimiProvider, kimiConfigComplete, buildKimiCatalogAddArgs } from './kimiProvider-DbxODebR.mjs';
+
+const KIMI_CONFIG_PATH = join(homedir(), ".kimi-code", "config.toml");
+function readKimiConfig() {
+  try {
+    return readFileSync(KIMI_CONFIG_PATH, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function ensureKimiProviderConfigured(env = process.env, command = "kimi", log = () => {
+}) {
+  const cfg = resolveKimiProvider(env);
+  if (!hasKimiProvider(cfg)) return false;
+  if (kimiConfigComplete(readKimiConfig(), cfg.provider)) return true;
+  const args = buildKimiCatalogAddArgs(cfg);
+  if (!args) return false;
+  try {
+    await new Promise((resolve, reject) => {
+      execFile(
+        command,
+        args,
+        {
+          timeout: 3e4,
+          // #0848: the API key travels in the child ENV, never on argv (argv is world-readable
+          // via ps / /proc/<pid>/cmdline). kimi reads KIMI_REGISTRY_API_KEY when --api-key is omitted.
+          env: { ...process.env, KIMI_CLI_NO_AUTO_UPDATE: "1", KIMI_REGISTRY_API_KEY: cfg.apiKey }
+        },
+        (err) => err ? reject(err) : resolve()
+      );
+    });
+    log(`[kimi] configured provider '${cfg.provider}' in ${KIMI_CONFIG_PATH}`);
+    const complete = kimiConfigComplete(readKimiConfig(), cfg.provider);
+    if (!complete) {
+      log(`[kimi] catalog add left ${KIMI_CONFIG_PATH} without a global default_model \u2014 \`kimi acp\` will refuse session/new ("no default model configured")`);
+    }
+    return complete;
+  } catch (err) {
+    log(`[kimi] provider auto-config failed (${err?.message || err}); session may need kimi-auth`);
+    return false;
+  }
+}
+
+export { ensureKimiProviderConfigured };