svamp-cli 0.2.341 → 0.2.346

package/dist/friendlyName-1UZcyDhu.mjs

@@ -0,0 +1,586 @@
+import { rmSync, mkdirSync, writeFileSync, renameSync, statSync, existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import os from 'node:os';
+import { randomUUID, randomBytes } from 'node:crypto';
+
+const SVAMP_HOME = process.env.SVAMP_HOME || join(os.homedir(), ".svamp");
+const num = (key, def) => {
+  const v = Number(process.env[key]);
+  return Number.isFinite(v) && v > 0 ? v : def;
+};
+const MAX_AGENT_HOPS = num("SVAMP_INBOX_MAX_HOPS", 3);
+const URGENT_BURST = num("SVAMP_INBOX_URGENT_BURST", 5);
+const URGENT_REFILL_MS = num("SVAMP_INBOX_URGENT_REFILL_MS", 6e4);
+const BREAKER_WINDOW_MS = num("SVAMP_INBOX_BREAKER_WINDOW_MS", 6e4);
+const BREAKER_MAX_WAKES = num("SVAMP_INBOX_BREAKER_MAX_WAKES", 30);
+const BREAKER_COOLDOWN_MS = num("SVAMP_INBOX_BREAKER_COOLDOWN_MS", 12e4);
+const CTX_STALE_MS = num("SVAMP_INBOX_CTX_STALE_MS", 30 * 6e4);
+function ctxPath(sessionId) {
+  return join(SVAMP_HOME, "inbound", `${sessionId}.json`);
+}
+function writeInboundContext(sessionId, ctx) {
+  try {
+    const p = ctxPath(sessionId);
+    mkdirSync(join(SVAMP_HOME, "inbound"), { recursive: true });
+    const tmp = `${p}.${process.pid}.${randomUUID()}.tmp`;
+    writeFileSync(tmp, JSON.stringify({ ...ctx, deliveredAt: Date.now() }));
+    renameSync(tmp, p);
+  } catch {
+  }
+}
+function clearInboundContext(sessionId) {
+  try {
+    rmSync(ctxPath(sessionId), { force: true });
+  } catch {
+  }
+}
+function readInboundContext(sessionId) {
+  try {
+    const p = ctxPath(sessionId);
+    if (!existsSync(p)) return null;
+    const ctx = JSON.parse(readFileSync(p, "utf-8"));
+    if (!ctx || typeof ctx.hopCount !== "number") return null;
+    if (Date.now() - (ctx.deliveredAt || 0) > CTX_STALE_MS) return null;
+    return ctx;
+  } catch {
+    return null;
+  }
+}
+const AWAIT_TTL_MS = num("SVAMP_INBOX_AWAIT_TTL_MS", 60 * 6e4);
+const AWAIT_MAX = num("SVAMP_INBOX_AWAIT_MAX", 200);
+function awaitPath(sessionId) {
+  return join(SVAMP_HOME, "awaiting", `${sessionId}.json`);
+}
+const _sleepSab = new Int32Array(new SharedArrayBuffer(4));
+function sleepSync(ms) {
+  try {
+    Atomics.wait(_sleepSab, 0, 0, ms);
+  } catch {
+  }
+}
+function withAwaitLock(sessionId, fn) {
+  const lock = awaitPath(sessionId) + ".lock";
+  try {
+    mkdirSync(join(SVAMP_HOME, "awaiting"), { recursive: true });
+  } catch {
+  }
+  const deadline = Date.now() + 50;
+  let held = false;
+  while (Date.now() < deadline) {
+    try {
+      mkdirSync(lock);
+      held = true;
+      break;
+    } catch {
+      try {
+        if (Date.now() - statSync(lock).mtimeMs > 5e3) {
+          rmSync(lock, { recursive: true, force: true });
+          continue;
+        }
+      } catch {
+      }
+      sleepSync(5);
+    }
+  }
+  try {
+    return fn();
+  } finally {
+    if (held) {
+      try {
+        rmSync(lock, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  }
+}
+function readAwaiting(sessionId) {
+  try {
+    const p = awaitPath(sessionId);
+    if (!existsSync(p)) return {};
+    const m = JSON.parse(readFileSync(p, "utf-8"));
+    return m && typeof m === "object" ? m : {};
+  } catch {
+    return {};
+  }
+}
+function writeAwaiting(sessionId, map) {
+  try {
+    mkdirSync(join(SVAMP_HOME, "awaiting"), { recursive: true });
+    const p = awaitPath(sessionId);
+    const tmp = `${p}.${process.pid}.${randomUUID()}.tmp`;
+    writeFileSync(tmp, JSON.stringify(map));
+    renameSync(tmp, p);
+  } catch {
+  }
+}
+function registerAwaitingReply(sessionId, threadId, now = Date.now()) {
+  if (!sessionId || !threadId) return;
+  withAwaitLock(sessionId, () => {
+    const map = readAwaiting(sessionId);
+    for (const k of Object.keys(map)) if (now - map[k] > AWAIT_TTL_MS) delete map[k];
+    map[threadId] = now;
+    const keys = Object.keys(map);
+    if (keys.length > AWAIT_MAX) {
+      keys.sort((a, b) => map[a] - map[b]).slice(0, keys.length - AWAIT_MAX).forEach((k) => delete map[k]);
+    }
+    writeAwaiting(sessionId, map);
+  });
+}
+function peekAwaitingReply(sessionId, threadId, now = Date.now()) {
+  if (!sessionId || !threadId) return false;
+  const map = readAwaiting(sessionId);
+  const at = map[threadId];
+  if (typeof at !== "number") return false;
+  return now - at <= AWAIT_TTL_MS;
+}
+function consumeAwaitingReply(sessionId, threadId) {
+  if (!sessionId || !threadId) return;
+  withAwaitLock(sessionId, () => {
+    const map = readAwaiting(sessionId);
+    if (!(threadId in map)) return;
+    delete map[threadId];
+    writeAwaiting(sessionId, map);
+  });
+}
+function computeOutboundHop(sessionId) {
+  if (!sessionId) return { hopCount: 0, fromInboxTurn: false };
+  const ctx = readInboundContext(sessionId);
+  if (ctx) return { hopCount: (ctx.hopCount || 0) + 1, threadId: ctx.threadId, fromInboxTurn: true };
+  return { hopCount: 1, fromInboxTurn: false };
+}
+const buckets = /* @__PURE__ */ new Map();
+const FULL_REFILL_MS = URGENT_BURST * URGENT_REFILL_MS;
+let lastBucketSweep = 0;
+function pruneIdleBuckets(now) {
+  if (now - lastBucketSweep < URGENT_REFILL_MS) return;
+  lastBucketSweep = now;
+  for (const [k, b] of buckets) {
+    if (now - b.last >= FULL_REFILL_MS) buckets.delete(k);
+  }
+}
+function takeUrgentToken(sender, now) {
+  pruneIdleBuckets(now);
+  let b = buckets.get(sender);
+  if (!b) {
+    b = { tokens: URGENT_BURST, last: now };
+    buckets.set(sender, b);
+  }
+  const refill = Math.floor((now - b.last) / URGENT_REFILL_MS);
+  if (refill > 0) {
+    b.tokens = Math.min(URGENT_BURST, b.tokens + refill);
+    b.last = now;
+  }
+  if (b.tokens > 0) {
+    b.tokens -= 1;
+    return true;
+  }
+  return false;
+}
+let wakeTimes = [];
+let breakerOpenUntil = 0;
+function isBreakerOpenAt(now) {
+  return now < breakerOpenUntil;
+}
+function recordWake(now) {
+  wakeTimes = wakeTimes.filter((t) => now - t < BREAKER_WINDOW_MS);
+  wakeTimes.push(now);
+  if (wakeTimes.length > BREAKER_MAX_WAKES) {
+    const wasOpen = isBreakerOpenAt(now);
+    if (!wasOpen) breakerOpenUntil = now + BREAKER_COOLDOWN_MS;
+    return !wasOpen;
+  }
+  return false;
+}
+function senderIsHuman(message) {
+  const f = message.from || "";
+  if (!(f.startsWith("cli:") || f.startsWith("user:"))) return false;
+  if (message.verified === false) return false;
+  return true;
+}
+function senderKey(message) {
+  return message.fromSession || message.from || "unknown";
+}
+function classifyInbound(message, now = Date.now(), opts) {
+  const hop = message.hopCount ?? 0;
+  const human = senderIsHuman(message);
+  const self = !!opts?.self;
+  const openThreadReply = !!opts?.openThreadReply;
+  if (!human && !self && !message.channel && hop > MAX_AGENT_HOPS) {
+    return { action: "silent", reason: `loop-guard: hop ${hop} > ${MAX_AGENT_HOPS}` };
+  }
+  if (human || self) {
+    const tripped2 = recordWake(now);
+    return { action: "wake", reason: self ? "always-wake (self)" : "always-wake (human)", breakerTripped: tripped2 };
+  }
+  if (openThreadReply) {
+    if (isBreakerOpenAt(now)) {
+      return { action: "queue", reason: "open-thread reply (breaker open)" };
+    }
+    const tripped2 = recordWake(now);
+    return { action: "wake", reason: "open-thread reply", breakerTripped: tripped2 };
+  }
+  if (message.urgency !== "urgent") {
+    return { action: "queue", reason: "non-urgent" };
+  }
+  if (isBreakerOpenAt(now)) {
+    return { action: "queue", reason: "circuit-breaker-open" };
+  }
+  if (!takeUrgentToken(senderKey(message), now)) {
+    return { action: "queue", reason: "rate-limited" };
+  }
+  const tripped = recordWake(now);
+  return { action: "wake", reason: "urgent", breakerTripped: tripped };
+}
+function isHopCapParked(message, opts) {
+  const hop = message.hopCount ?? 0;
+  const human = senderIsHuman(message);
+  const self = false;
+  return !human && !self && !message.channel && hop > MAX_AGENT_HOPS;
+}
+function applyInboxClear(inbox, opts) {
+  let kept;
+  if (opts?.messageId) kept = inbox.filter((m) => m.messageId !== opts.messageId);
+  else if (opts?.all) kept = [];
+  else kept = inbox.filter((m) => !m.read);
+  return { kept, removed: inbox.length - kept.length };
+}
+
+const ALPHABET = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+const LOWER_ALPHABET = "abcdefghijklmnopqrstuvwxyz";
+function shortId(length = 10, alphabet = ALPHABET) {
+  const maxUnbiased = Math.floor(256 / alphabet.length) * alphabet.length;
+  let out = "";
+  while (out.length < length) {
+    const buf = randomBytes(length - out.length);
+    for (let i = 0; i < buf.length && out.length < length; i++) {
+      const b = buf[i];
+      if (b < maxUnbiased) out += alphabet[b % alphabet.length];
+    }
+  }
+  return out;
+}
+
+const ADJECTIVES = [
+  "able",
+  "amber",
+  "amused",
+  "ancient",
+  "arctic",
+  "autumn",
+  "azure",
+  "blithe",
+  "bold",
+  "brave",
+  "breezy",
+  "bright",
+  "brisk",
+  "calm",
+  "candid",
+  "cheery",
+  "chill",
+  "clever",
+  "cobalt",
+  "cosmic",
+  "cozy",
+  "crimson",
+  "crisp",
+  "curious",
+  "dapper",
+  "daring",
+  "dawn",
+  "deft",
+  "dewy",
+  "eager",
+  "early",
+  "easy",
+  "electric",
+  "fancy",
+  "feisty",
+  "fleet",
+  "fond",
+  "frosty",
+  "gallant",
+  "gentle",
+  "giddy",
+  "glad",
+  "gleaming",
+  "golden",
+  "graceful",
+  "grand",
+  "hardy",
+  "hazel",
+  "hearty",
+  "honest",
+  "humble",
+  "jolly",
+  "jovial",
+  "keen",
+  "kind",
+  "lively",
+  "loyal",
+  "lucky",
+  "lunar",
+  "mellow",
+  "merry",
+  "mighty",
+  "mint",
+  "misty",
+  "nimble",
+  "noble",
+  "opal",
+  "patient",
+  "peppy",
+  "placid",
+  "plucky",
+  "polar",
+  "prim",
+  "proud",
+  "quick",
+  "quiet",
+  "quirky",
+  "radiant",
+  "rapid",
+  "ready",
+  "regal",
+  "rosy",
+  "royal",
+  "rugged",
+  "sage",
+  "sandy",
+  "scarlet",
+  "serene",
+  "sharp",
+  "shiny",
+  "silent",
+  "silver",
+  "sleek",
+  "smooth",
+  "snappy",
+  "snowy",
+  "solar",
+  "spry",
+  "stellar",
+  "sturdy",
+  "sunny",
+  "swift",
+  "tender",
+  "tidal",
+  "tidy",
+  "tranquil",
+  "trusty",
+  "upbeat",
+  "valiant",
+  "vivid",
+  "warm",
+  "whimsical",
+  "wise",
+  "witty",
+  "zesty",
+  "zippy"
+];
+const ANIMALS = [
+  "ant",
+  "badger",
+  "bat",
+  "bear",
+  "beaver",
+  "bee",
+  "bison",
+  "boar",
+  "bobcat",
+  "buffalo",
+  "camel",
+  "caribou",
+  "cat",
+  "cheetah",
+  "cobra",
+  "condor",
+  "cougar",
+  "coyote",
+  "crab",
+  "crane",
+  "cricket",
+  "crow",
+  "deer",
+  "dingo",
+  "dolphin",
+  "donkey",
+  "dove",
+  "dragon",
+  "duck",
+  "eagle",
+  "eel",
+  "egret",
+  "elk",
+  "falcon",
+  "ferret",
+  "finch",
+  "fox",
+  "frog",
+  "gecko",
+  "gibbon",
+  "goat",
+  "goose",
+  "gopher",
+  "hare",
+  "hawk",
+  "hedgehog",
+  "heron",
+  "hippo",
+  "horse",
+  "ibex",
+  "ibis",
+  "iguana",
+  "jackal",
+  "jaguar",
+  "jay",
+  "kestrel",
+  "koala",
+  "krill",
+  "lark",
+  "lemur",
+  "leopard",
+  "lion",
+  "llama",
+  "lynx",
+  "macaw",
+  "magpie",
+  "mantis",
+  "marmot",
+  "marten",
+  "meerkat",
+  "mink",
+  "mole",
+  "moose",
+  "moth",
+  "mouse",
+  "newt",
+  "ocelot",
+  "octopus",
+  "orca",
+  "osprey",
+  "otter",
+  "owl",
+  "ox",
+  "panda",
+  "panther",
+  "parrot",
+  "pelican",
+  "penguin",
+  "pheasant",
+  "pigeon",
+  "puffin",
+  "puma",
+  "quail",
+  "rabbit",
+  "raccoon",
+  "ram",
+  "raven",
+  "robin",
+  "salmon",
+  "seal",
+  "shark",
+  "sheep",
+  "shrew",
+  "skunk",
+  "sloth",
+  "snail",
+  "sparrow",
+  "spider",
+  "squid",
+  "stag",
+  "stoat",
+  "stork",
+  "swan",
+  "tapir",
+  "tiger",
+  "toad",
+  "trout",
+  "turtle",
+  "viper",
+  "vole",
+  "walrus",
+  "weasel",
+  "whale",
+  "wolf",
+  "wombat",
+  "wren",
+  "yak",
+  "zebra"
+];
+function pick(arr) {
+  const n = arr.length;
+  const max = Math.floor(256 / n) * n;
+  let b;
+  do {
+    b = randomBytes(1)[0];
+  } while (b >= max);
+  return arr[b % n];
+}
+function generateFriendlyName(taken = []) {
+  const used = taken instanceof Set ? taken : new Set(taken);
+  for (let i = 0; i < 1e3; i++) {
+    const name = `${pick(ADJECTIVES)}-${pick(ANIMALS)}`;
+    if (!used.has(name)) return name;
+  }
+  const base = `${pick(ADJECTIVES)}-${pick(ANIMALS)}`;
+  let n = 2;
+  while (used.has(`${base}-${n}`)) n++;
+  return `${base}-${n}`;
+}
+function sanitizeSegment(s) {
+  return String(s || "").toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function friendlyNameFromId(id) {
+  const m = /^(.+)-[a-zA-Z0-9]{6,10}$/.exec(String(id || ""));
+  return m ? m[1] : void 0;
+}
+function composeSessionId(friendlyName, takenIds = [], len = 6) {
+  const taken = takenIds instanceof Set ? takenIds : new Set(takenIds);
+  const A = LOWER_ALPHABET.length;
+  const nthSuffix = (i, width2) => {
+    let s = "";
+    for (let k = 0; k < width2; k++) {
+      s = LOWER_ALPHABET[i % A] + s;
+      i = Math.floor(i / A);
+    }
+    return s;
+  };
+  let width = Math.max(1, len);
+  for (; ; ) {
+    const space = Math.pow(A, width);
+    for (let i = 0; i < 64; i++) {
+      const candidate = `${friendlyName}-${shortId(width, LOWER_ALPHABET)}`;
+      if (!taken.has(candidate)) return candidate;
+    }
+    if (space <= 1e6) {
+      for (let i = 0; i < space; i++) {
+        const candidate = `${friendlyName}-${nthSuffix(i, width)}`;
+        if (!taken.has(candidate)) return candidate;
+      }
+    }
+    width++;
+  }
+}
+function formatHandle(projectName, friendlyName) {
+  if (!friendlyName) return void 0;
+  const proj = sanitizeSegment(projectName || "");
+  return proj ? `${proj}:${friendlyName}` : friendlyName;
+}
+function parseHandle(input) {
+  const str = String(input || "").trim().replace(/^@/, "");
+  if (!str) return null;
+  const i = str.indexOf(":");
+  if (i === -1) return { name: str.toLowerCase() };
+  return { project: sanitizeSegment(str.slice(0, i)), name: str.slice(i + 1).toLowerCase() };
+}
+function handleMatchesMetadata(parsed, metadata) {
+  const fn = String(metadata?.friendlyName || "").toLowerCase();
+  if (!fn || fn !== parsed.name) return false;
+  if (parsed.project) {
+    return sanitizeSegment(metadata?.projectName || "") === parsed.project;
+  }
+  return true;
+}
+
+export { composeSessionId as a, applyInboxClear as b, computeOutboundHop as c, friendlyNameFromId as d, clearInboundContext as e, formatHandle as f, generateFriendlyName as g, handleMatchesMetadata as h, isHopCapParked as i, classifyInbound as j, consumeAwaitingReply as k, peekAwaitingReply as l, parseHandle as p, registerAwaitingReply as r, shortId as s, writeInboundContext as w };

package/dist/{headlessCli-CptF7_lZ.mjs → headlessCli-C8HzQvis.mjs}

@@ -1,27 +1,9 @@
-import { a4 as resolveModel, al as describeMisconfiguration, am as buildMachineDeps } from './run-LHJh7jLy.mjs';
-import { handleRealtimeEvent, initMachineVoiceSession } from './sideband-B5n9fNxM.mjs';
+import { c as buildMachineDeps } from './machineTools-DygM1jXW.mjs';
+import { r as resolveModel, d as describeMisconfiguration } from './model-CUHojegn.mjs';
+import { handleRealtimeEvent, initMachineVoiceSession } from './sideband-68HhGT0i.mjs';
 import { WebSocket } from 'ws';
 import { execSync, spawn } from 'child_process';
-import 'os';
-import 'fs/promises';
-import 'fs';
-import 'path';
-import 'url';
-import 'crypto';
-import 'node:fs';
-import 'node:path';
-import 'node:crypto';
 import 'node:child_process';
-import 'util';
-import 'http';
-import 'net';
-import 'node:os';
-import 'node:events';
-import '@agentclientprotocol/sdk';
-import 'node:util';
-import 'node:readline';
-import 'node:fs/promises';
-import 'yaml';
 
 const PCM_RATE = 24e3;
 function buildHeadlessSessionUpdate(cfg) {