@securecoms/agent-runtime 0.1.0

package/dist/bin.js

@@ -0,0 +1,1277 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { readFileSync as readFileSync4 } from "node:fs";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { dirname as dirname3, join as join5 } from "node:path";
+import { spawnSync } from "node:child_process";
+import { accessSync, constants, existsSync as existsSync3, mkdirSync as mkdirSync2, realpathSync, rmSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { homedir as homedir3, userInfo } from "node:os";
+
+// src/config.ts
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+var MISSING_IDENTITY_MESSAGE = "Missing agent identity: pass --identity <id> or set SECURECOMS_IDENTITY";
+var LOG_LEVELS = /* @__PURE__ */ new Set(["debug", "info", "warn", "error"]);
+var TOOL_DEFAULTS = /* @__PURE__ */ new Set(["allow", "deny"]);
+function parseIdentity(argv, env) {
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--identity") {
+      const value = argv[i + 1];
+      if (value) return value;
+    } else if (arg.startsWith("--identity=")) {
+      const value = arg.slice("--identity=".length);
+      if (value) return value;
+    }
+  }
+  if (env.SECURECOMS_IDENTITY) return env.SECURECOMS_IDENTITY;
+  throw new Error(MISSING_IDENTITY_MESSAGE);
+}
+function parseStringFlag(argv, flag, env, envVar) {
+  const prefix = `${flag}=`;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === flag) {
+      const value = argv[i + 1];
+      if (value) return value;
+    } else if (arg.startsWith(prefix)) {
+      const value = arg.slice(prefix.length);
+      if (value) return value;
+    }
+  }
+  return env[envVar] || void 0;
+}
+function parseList(value) {
+  if (value === void 0) return void 0;
+  const items = value.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  return items.length > 0 ? items : void 0;
+}
+function defaultSkillsDir() {
+  return join(dirname(fileURLToPath(import.meta.url)), "..", "skills");
+}
+function loadConfig(argv, env) {
+  const identityId = parseIdentity(argv, env);
+  const logLevel = env.SECURECOMS_LOG_LEVEL ?? "info";
+  if (!LOG_LEVELS.has(logLevel)) {
+    throw new Error(
+      `Invalid SECURECOMS_LOG_LEVEL "${logLevel}": expected one of debug, info, warn, error`
+    );
+  }
+  const toolDefault = env.SECURECOMS_TOOL_DEFAULT ?? "deny";
+  if (!TOOL_DEFAULTS.has(toolDefault)) {
+    throw new Error(
+      `Invalid SECURECOMS_TOOL_DEFAULT "${toolDefault}": expected one of allow, deny`
+    );
+  }
+  const parsedAllow = parseList(env.SECURECOMS_TOOL_ALLOW);
+  const allow = parsedAllow ?? ["echo"];
+  const deny = parseList(env.SECURECOMS_TOOL_DENY);
+  const toolGate = {
+    default: toolDefault,
+    ...allow !== void 0 ? { allow } : {},
+    ...deny !== void 0 ? { deny } : {}
+  };
+  return {
+    identityId,
+    llmEndpoint: env.SECURECOMS_LLM_ENDPOINT || "http://127.0.0.1:11434",
+    llmModel: env.SECURECOMS_LLM_MODEL || "llama3",
+    llmApiKey: env.SECURECOMS_LLM_API_KEY,
+    llmApiKeyFile: parseStringFlag(argv, "--llm-key-file", env, "SECURECOMS_LLM_API_KEY_FILE"),
+    skillsDir: env.SECURECOMS_SKILLS_DIR || defaultSkillsDir(),
+    dataDir: env.SECURECOMS_DATA_DIR || join(homedir(), ".securecoms", "agent-runtime"),
+    logLevel,
+    toolGate
+  };
+}
+
+// src/llm-key.ts
+var LlmKeyFileError = class extends Error {
+};
+function resolveLlmApiKey(cfg, readFile) {
+  const path = cfg.llmApiKeyFile;
+  if (!path) return cfg.llmApiKey;
+  let raw;
+  try {
+    raw = readFile(path);
+  } catch (e) {
+    throw new LlmKeyFileError(
+      `cannot read LLM key file ${path}: ${e instanceof Error ? e.message : String(e)}`
+    );
+  }
+  const key = raw.trim();
+  if (!key) throw new LlmKeyFileError(`cannot read LLM key file ${path}: file is empty`);
+  return key;
+}
+
+// src/service/args.ts
+function parseVerb(argv) {
+  const v = argv[2];
+  return v === "install" || v === "uninstall" ? v : null;
+}
+function flagOrEnv(argv, flag, env, envVar) {
+  const prefix = `${flag}=`;
+  for (let i = 2; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === flag) {
+      const value = argv[i + 1];
+      if (value) return value;
+    } else if (arg.startsWith(prefix)) {
+      const value = arg.slice(prefix.length);
+      if (value) return value;
+    }
+  }
+  return envVar ? env[envVar] || void 0 : void 0;
+}
+function parseServiceFlags(argv, env) {
+  const pairs = [
+    ["identityId", "--identity", "SECURECOMS_IDENTITY"],
+    ["llmEndpoint", "--llm-endpoint", "SECURECOMS_LLM_ENDPOINT"],
+    ["llmModel", "--llm-model", "SECURECOMS_LLM_MODEL"],
+    ["llmApiKeyFile", "--llm-key-file", "SECURECOMS_LLM_API_KEY_FILE"],
+    ["skillsDir", "--skills-dir", "SECURECOMS_SKILLS_DIR"],
+    ["dataDir", "--data-dir", "SECURECOMS_DATA_DIR"],
+    // The interpreter is never taken from the environment: baking a Node path
+    // into a service definition is an explicit operator decision.
+    ["execPath", "--exec-path", void 0]
+  ];
+  const out = {};
+  for (const [key, flag, envVar] of pairs) {
+    const value = flagOrEnv(argv, flag, env, envVar);
+    if (value !== void 0) out[key] = value;
+  }
+  return out;
+}
+var UNINSTALL_EXEC_PATH = "/usr/bin/node";
+function chooseVerbExecPath(verb, override, resolveForInstall) {
+  if (verb === "uninstall") return UNINSTALL_EXEC_PATH;
+  return resolveForInstall();
+}
+
+// src/service/install.ts
+import { dirname as dirname2 } from "node:path";
+
+// src/service/config.ts
+import { isAbsolute, resolve } from "node:path";
+
+// src/service/resolve-node.ts
+var REQUIRED_NODE_MAJOR = 22;
+var VERSION_EMBEDDED = [
+  /[\\/]Cellar[\\/]/,
+  // Homebrew keg
+  /[\\/]node[\\/]v?\d+\.\d+/,
+  // nvm, generic .../node/v24.4.1/...
+  /[\\/]nodejs[\\/]\d/,
+  // asdf .../installs/nodejs/24.4.1/...
+  /[\\/]node-versions[\\/]/,
+  // fnm
+  /[\\/]\.volta[\\/]/,
+  // volta
+  /[\\/]\.fnm[\\/]/,
+  // fnm (alt layout)
+  /[\\/]\.nvm[\\/]/,
+  // nvm home
+  /[\\/]\.asdf[\\/]/,
+  // asdf home
+  /[\\/]n[\\/]versions[\\/]/
+  // n
+];
+function isVersionEmbeddedNodePath(p) {
+  return VERSION_EMBEDDED.some((re) => re.test(p));
+}
+var STABLE_LOCATIONS = [
+  "/usr/local/bin/node",
+  // nodejs.org pkg (mac + linux)
+  "/opt/homebrew/bin/node",
+  // Homebrew symlink (arm mac)
+  "/opt/homebrew/opt/node/bin/node",
+  "/usr/bin/node"
+  // system (linux)
+];
+function candidates(home) {
+  return home ? [...STABLE_LOCATIONS, `${home}/.local/bin/node`] : STABLE_LOCATIONS;
+}
+function usable(path, deps) {
+  if (!deps.fileExists(path)) return false;
+  if (isVersionEmbeddedNodePath(path)) return false;
+  const major = deps.nodeMajorOf(path);
+  if (major == null || major < REQUIRED_NODE_MAJOR) return false;
+  const a = deps.archOf(path);
+  if (a != null && a !== deps.arch()) return false;
+  return true;
+}
+function resolveStableNodePath(runningExecPath, deps, home) {
+  const locations = candidates(home);
+  let runningReal;
+  try {
+    runningReal = deps.realpath(runningExecPath);
+  } catch {
+    runningReal = runningExecPath;
+  }
+  for (const loc of locations) {
+    if (!deps.fileExists(loc)) continue;
+    let locReal;
+    try {
+      locReal = deps.realpath(loc);
+    } catch {
+      continue;
+    }
+    if (locReal === runningReal && usable(loc, deps)) return { path: loc, stable: true };
+  }
+  for (const loc of locations) {
+    if (usable(loc, deps)) return { path: loc, stable: true };
+  }
+  return { path: runningExecPath, stable: false };
+}
+function chooseInstallExecPath(runningExecPath, override, deps, home) {
+  if (override) return override;
+  const r = resolveStableNodePath(runningExecPath, deps, home);
+  if (!r.stable) {
+    throw new Error(
+      `install: no reboot-stable Node found (need major >= ${REQUIRED_NODE_MAJOR} at a path whose location does not encode a version). Version-manager Nodes (nvm/asdf/fnm/volta/n) and Homebrew kegs are relocated on upgrade and would break the service after a reboot. Install a system Node (nodejs.org pkg \u2192 /usr/local/bin/node) or pass --exec-path <stable-path> to override.`
+    );
+  }
+  return r.path;
+}
+
+// src/service/config.ts
+function slugify(s) {
+  return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "") || "agent";
+}
+function abs(p) {
+  return isAbsolute(p) ? p : resolve(p);
+}
+function deriveServiceConfig(input) {
+  if (isVersionEmbeddedNodePath(input.execPath)) {
+    throw new Error(
+      `install: refusing to bake a version-embedded Node path into the service definition: ${input.execPath}. Re-run install under a system/Homebrew Node, or pass --exec-path <stable-path>.`
+    );
+  }
+  const head = input.identityId.slice(0, 8).toLowerCase();
+  const slug = /^[0-9a-f]{8}$/.test(head) ? head : slugify(input.identityId);
+  const env = {};
+  if (input.llmEndpoint) env.SECURECOMS_LLM_ENDPOINT = input.llmEndpoint;
+  if (input.llmModel) env.SECURECOMS_LLM_MODEL = input.llmModel;
+  if (input.llmApiKeyFile) env.SECURECOMS_LLM_API_KEY_FILE = abs(input.llmApiKeyFile);
+  if (input.skillsDir) env.SECURECOMS_SKILLS_DIR = abs(input.skillsDir);
+  if (input.dataDir) env.SECURECOMS_DATA_DIR = abs(input.dataDir);
+  return {
+    slug,
+    label: `com.securecoms.agent.${slug}`,
+    unitName: `securecoms-agent-${slug}`,
+    args: ["--identity", input.identityId],
+    env,
+    execPath: input.execPath,
+    binScript: input.binScript,
+    uid: input.uid,
+    plistPath: `${input.home}/Library/LaunchAgents/com.securecoms.agent.${slug}.plist`,
+    unitPath: `${input.home}/.config/systemd/user/securecoms-agent-${slug}.service`,
+    logPath: `${input.home}/Library/Logs/securecoms-agent-${slug}.log`
+  };
+}
+
+// src/service/launchd.ts
+function renderLaunchdPlist(cfg) {
+  const argv = [cfg.execPath, cfg.binScript, ...cfg.args];
+  const programArgs = argv.map((a) => `    <string>${escapeXml(a)}</string>`).join("\n");
+  const entries = Object.entries(cfg.env);
+  const envBlock = entries.length === 0 ? "" : `  <key>EnvironmentVariables</key>
+  <dict>
+${entries.map(([k, v]) => `    <key>${escapeXml(k)}</key>
+    <string>${escapeXml(v)}</string>`).join("\n")}
+  </dict>
+`;
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${cfg.label}</string>
+  <key>ProgramArguments</key>
+  <array>
+${programArgs}
+  </array>
+${envBlock}  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${escapeXml(cfg.logPath)}</string>
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(cfg.logPath)}</string>
+</dict>
+</plist>
+`;
+}
+function escapeXml(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+// src/service/systemd.ts
+function sdQuote(s) {
+  return s.includes(" ") || s.includes('"') ? `"${sdEscape(s)}"` : sdEscape(s);
+}
+function sdEscape(s) {
+  return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/%/g, "%%");
+}
+function renderSystemdUnit(cfg) {
+  const execStart = [cfg.execPath, cfg.binScript, ...cfg.args].map(sdQuote).join(" ");
+  const envLines = Object.entries(cfg.env).map(([k, v]) => `Environment="${sdEscape(k)}=${sdEscape(v)}"
+`).join("");
+  return `[Unit]
+Description=SecureComs agent (${cfg.slug})
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${execStart}
+${envLines}Restart=always
+RestartSec=5
+
+[Install]
+WantedBy=default.target
+`;
+}
+
+// src/service/install.ts
+var ServiceUnsupportedError = class extends Error {
+};
+function planService(input, platform) {
+  const cfg = deriveServiceConfig(input);
+  const keyFile = cfg.env.SECURECOMS_LLM_API_KEY_FILE;
+  const common = { label: cfg.label, execPath: cfg.execPath, ...keyFile ? { keyFile } : {} };
+  if (platform === "darwin") {
+    return { ...common, filePath: cfg.plistPath, logHint: cfg.logPath, contents: renderLaunchdPlist(cfg) };
+  }
+  if (platform === "linux") {
+    return {
+      ...common,
+      label: cfg.unitName,
+      filePath: cfg.unitPath,
+      logHint: `journalctl --user -u ${cfg.unitName} -f`,
+      contents: renderSystemdUnit(cfg)
+    };
+  }
+  throw new ServiceUnsupportedError(
+    `Service install isn't supported on ${platform} yet. Run the agent in a terminal, or use a process manager.`
+  );
+}
+function requireKeyFileReadable(keyFile, deps) {
+  if (!keyFile) return;
+  if (!deps.canRead(keyFile)) {
+    throw new Error(
+      `LLM key file ${keyFile} is missing or unreadable. Create it (and chmod 600 it), or install without --llm-key-file.`
+    );
+  }
+}
+function requireOk(r, what) {
+  if (r.status !== 0) throw new Error(`${what} failed (exit ${r.status})${r.stderr ? `: ${r.stderr.trim()}` : ""}`);
+}
+function prepareInstall(input, platform, deps) {
+  const plan = planService(input, platform);
+  requireKeyFileReadable(plan.keyFile, deps);
+  return plan;
+}
+function installService(input, deps) {
+  const cfg = deriveServiceConfig(input);
+  const plan = prepareInstall(input, deps.platform, deps);
+  const keyFile = plan.keyFile;
+  if (deps.platform === "darwin") {
+    deps.mkdirp(dirname2(cfg.plistPath));
+    deps.mkdirp(dirname2(cfg.logPath));
+    deps.writeFile(cfg.plistPath, plan.contents);
+    deps.run("launchctl", ["bootout", `gui/${cfg.uid}/${cfg.label}`]);
+    requireOk(deps.run("launchctl", ["bootstrap", `gui/${cfg.uid}`, cfg.plistPath]), "launchctl bootstrap");
+    deps.run("launchctl", ["enable", `gui/${cfg.uid}/${cfg.label}`]);
+    return { label: cfg.label, filePath: cfg.plistPath, logHint: cfg.logPath, ...keyFile ? { keyFile } : {} };
+  }
+  if (deps.platform === "linux") {
+    deps.mkdirp(dirname2(cfg.unitPath));
+    deps.writeFile(cfg.unitPath, plan.contents);
+    deps.run("systemctl", ["--user", "daemon-reload"]);
+    deps.run("loginctl", ["enable-linger", deps.user]);
+    requireOk(deps.run("systemctl", ["--user", "enable", "--now", cfg.unitName]), "systemctl --user enable --now");
+    return {
+      label: cfg.unitName,
+      filePath: cfg.unitPath,
+      logHint: `journalctl --user -u ${cfg.unitName} -f`,
+      ...keyFile ? { keyFile } : {}
+    };
+  }
+  throw new ServiceUnsupportedError(
+    `Service install isn't supported on ${deps.platform} yet. Run the agent in a terminal, or use a process manager.`
+  );
+}
+function uninstallService(input, deps) {
+  const cfg = deriveServiceConfig(input);
+  if (deps.platform === "darwin") {
+    const existed = deps.fileExists(cfg.plistPath);
+    deps.run("launchctl", ["bootout", `gui/${cfg.uid}/${cfg.label}`]);
+    if (existed) deps.removeFile(cfg.plistPath);
+    return { removed: existed, filePath: cfg.plistPath };
+  }
+  if (deps.platform === "linux") {
+    const existed = deps.fileExists(cfg.unitPath);
+    deps.run("systemctl", ["--user", "disable", "--now", cfg.unitName]);
+    if (existed) deps.removeFile(cfg.unitPath);
+    deps.run("systemctl", ["--user", "daemon-reload"]);
+    return { removed: existed, filePath: cfg.unitPath };
+  }
+  throw new ServiceUnsupportedError(`Service uninstall isn't supported on ${deps.platform} yet.`);
+}
+
+// src/llm-dispatch.ts
+function normalizeEndpoint(endpoint) {
+  return endpoint.replace(/\/+$/, "").replace(/\/v1$/, "").replace(/\/+$/, "");
+}
+var LLMDispatcher = class {
+  endpoint;
+  model;
+  apiKey;
+  constructor(endpoint, model, opts = {}) {
+    this.endpoint = normalizeEndpoint(endpoint);
+    this.model = model;
+    this.apiKey = opts.apiKey;
+  }
+  async complete(messages, tools) {
+    const body = {
+      model: this.model,
+      messages,
+      stream: false
+    };
+    if (tools && tools.length > 0) {
+      body.tools = tools;
+    }
+    const url = `${this.endpoint}/v1/chat/completions`;
+    const headers = { "Content-Type": "application/json" };
+    if (this.apiKey) {
+      headers.Authorization = `Bearer ${this.apiKey}`;
+    }
+    const resp = await fetch(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+    if (!resp.ok) {
+      const text = await resp.text();
+      throw new Error(`LLM request failed (${resp.status}): ${text}`);
+    }
+    const data = await resp.json();
+    const choice = data.choices?.[0];
+    if (!choice) {
+      throw new Error("LLM returned no choices");
+    }
+    return {
+      content: choice.message.content,
+      toolCalls: choice.message.tool_calls || [],
+      finishReason: choice.finish_reason
+    };
+  }
+};
+
+// src/memory.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { join as join2 } from "node:path";
+var MAX_HISTORY = 50;
+var AgentMemory = class {
+  history = [];
+  memories = [];
+  dataDir;
+  constructor(dataDir) {
+    this.dataDir = dataDir;
+    this.loadHistory();
+    this.loadMemories();
+  }
+  /** Add a message to conversation history. */
+  addMessage(msg) {
+    this.history.push(msg);
+    if (this.history.length > MAX_HISTORY * 2) {
+      this.history = this.history.slice(-MAX_HISTORY);
+    }
+    this.saveHistory();
+  }
+  /** Get recent conversation history for LLM context. */
+  getHistory() {
+    return this.history.slice(-MAX_HISTORY);
+  }
+  /** Clear conversation history. */
+  clear() {
+    this.history = [];
+    this.saveHistory();
+  }
+  /**
+   * Recall relevant memories to prepend to the LLM context.
+   * Case-insensitive keyword-overlap match over captured entries: query is
+   * split into words of length >= 3, entries are scored by number of
+   * matching words, and the top 5 with score > 0 are returned.
+   */
+  async recall(query) {
+    const queryWords = query.toLowerCase().split(/\W+/).filter((w) => w.length >= 3);
+    if (queryWords.length === 0) return null;
+    const scored = this.memories.map((m) => {
+      const contentLower = m.content.toLowerCase();
+      const score = queryWords.reduce(
+        (acc, w) => contentLower.includes(w) ? acc + 1 : acc,
+        0
+      );
+      return { memory: m, score };
+    }).filter((s) => s.score > 0).sort((a, b) => b.score - a.score).slice(0, 5);
+    if (scored.length === 0) return null;
+    const memories = scored.map((s) => `- ${s.memory.content}`).join("\n");
+    return `Relevant context from memory:
+${memories}`;
+  }
+  /**
+   * Capture a notable fact to local memory (best-effort).
+   */
+  async capture(content, kind) {
+    try {
+      this.memories.push({
+        content,
+        category: kind,
+        capturedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      this.saveMemories();
+    } catch {
+    }
+  }
+  get historyPath() {
+    return join2(this.dataDir, "conversation-history.json");
+  }
+  get memoriesPath() {
+    return join2(this.dataDir, "memories.json");
+  }
+  loadHistory() {
+    try {
+      if (existsSync(this.historyPath)) {
+        const raw = readFileSync(this.historyPath, "utf-8");
+        this.history = JSON.parse(raw);
+      }
+    } catch {
+      this.history = [];
+    }
+  }
+  saveHistory() {
+    try {
+      mkdirSync(this.dataDir, { recursive: true });
+      writeFileSync(this.historyPath, JSON.stringify(this.history));
+    } catch {
+    }
+  }
+  loadMemories() {
+    try {
+      if (existsSync(this.memoriesPath)) {
+        const raw = readFileSync(this.memoriesPath, "utf-8");
+        this.memories = JSON.parse(raw);
+      }
+    } catch {
+      this.memories = [];
+    }
+  }
+  saveMemories() {
+    try {
+      mkdirSync(this.dataDir, { recursive: true });
+      writeFileSync(this.memoriesPath, JSON.stringify(this.memories));
+    } catch {
+    }
+  }
+};
+
+// src/skill-invoker.ts
+import { readFileSync as readFileSync2, readdirSync, existsSync as existsSync2, statSync } from "node:fs";
+import { join as join3 } from "node:path";
+var SkillInvoker = class {
+  skills = /* @__PURE__ */ new Map();
+  skillsDir;
+  constructor(skillsDir) {
+    this.skillsDir = skillsDir;
+  }
+  /**
+   * Load all skill manifests from the skills directory. Supports two
+   * layouts: flat `<skillsDir>/*.json` files, and one level of nesting via
+   * `<skillsDir>/<subdir>/manifest.json`.
+   */
+  loadSkills() {
+    if (!existsSync2(this.skillsDir)) {
+      console.warn(`[SkillInvoker] Skills directory not found: ${this.skillsDir}`);
+      return;
+    }
+    const entries = readdirSync(this.skillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.endsWith(".json")) {
+        this.loadManifestFile(join3(this.skillsDir, entry.name));
+        continue;
+      }
+      if (entry.isDirectory()) {
+        const manifestPath = join3(this.skillsDir, entry.name, "manifest.json");
+        if (existsSync2(manifestPath) && statSync(manifestPath).isFile()) {
+          this.loadManifestFile(manifestPath);
+        }
+      }
+    }
+    console.log(`[SkillInvoker] Loaded ${this.skills.size} skills`);
+  }
+  loadManifestFile(path) {
+    try {
+      const raw = readFileSync2(path, "utf-8");
+      const manifest = JSON.parse(raw);
+      if (typeof manifest.handler !== "string" || !(manifest.handler.startsWith("builtin:") || manifest.handler.startsWith("script:"))) {
+        console.warn(
+          `[SkillInvoker] Skipping manifest with invalid handler ${path}: expected "builtin:<name>" or "script:<path>"`
+        );
+        return;
+      }
+      if (manifest.name && manifest.description) {
+        this.skills.set(manifest.name, manifest);
+      }
+    } catch (err) {
+      console.warn(`[SkillInvoker] Failed to load skill ${path}:`, err);
+    }
+  }
+  /** Convert loaded skills to OpenAI tool definitions for LLM dispatch. */
+  getToolDefinitions() {
+    return Array.from(this.skills.values()).map((skill) => ({
+      type: "function",
+      function: {
+        name: skill.name,
+        description: skill.description,
+        parameters: skill.parameters
+      }
+    }));
+  }
+  /**
+   * Execute a skill by name with the given arguments.
+   *
+   * @param context Optional room/group binding for the in-flight message
+   *   that triggered this call. Callers without room/group context simply
+   *   omit it.
+   */
+  async invoke(name, args, context) {
+    const skill = this.skills.get(name);
+    if (!skill) {
+      return JSON.stringify({ error: `Unknown skill: ${name}` });
+    }
+    const handler = skill.handler;
+    if (handler.startsWith("builtin:")) {
+      return this.invokeBuiltin(handler.slice(8), args);
+    }
+    if (handler.startsWith("script:")) {
+      return this.invokeScript(handler.slice(7), args);
+    }
+    return JSON.stringify({ error: `Unknown handler type: ${handler}` });
+  }
+  async invokeBuiltin(name, args) {
+    switch (name) {
+      case "echo":
+        return String(args.text ?? "");
+      case "timestamp":
+        return JSON.stringify({ timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+      default:
+        return JSON.stringify({ error: `Unknown builtin: ${name}` });
+    }
+  }
+  async invokeScript(scriptPath, args) {
+    const { resolve: resolve2, relative } = await import("node:path");
+    const resolved = resolve2(this.skillsDir, scriptPath);
+    const rel = relative(this.skillsDir, resolved);
+    if (rel.startsWith("..") || !resolved.startsWith(resolve2(this.skillsDir))) {
+      return JSON.stringify({ error: "Script path must be within skills directory" });
+    }
+    const { realpathSync: realpathSync2, existsSync: fsExistsSync } = await import("node:fs");
+    if (fsExistsSync(resolved)) {
+      const realResolved = realpathSync2(resolved);
+      const realSkillsDir = realpathSync2(this.skillsDir);
+      const realRel = relative(realSkillsDir, realResolved);
+      if (realRel.startsWith("..") || !realResolved.startsWith(realSkillsDir)) {
+        return JSON.stringify({ error: "Script path must be within skills directory" });
+      }
+    }
+    const { accessSync: accessSync2, constants: constants2 } = await import("node:fs");
+    try {
+      accessSync2(resolved, constants2.X_OK);
+    } catch {
+      return JSON.stringify({ error: `Script not found or not executable: ${scriptPath}` });
+    }
+    const { execSync } = await import("node:child_process");
+    try {
+      const result = execSync(resolved, {
+        input: JSON.stringify(args),
+        timeout: 3e4,
+        maxBuffer: 1024 * 1024,
+        encoding: "utf-8",
+        cwd: this.skillsDir,
+        env: { PATH: "/usr/bin:/bin", HOME: "/tmp" }
+      });
+      return result;
+    } catch (err) {
+      return JSON.stringify({
+        error: `Script execution failed: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
+};
+
+// src/tool-gate.ts
+function createLocalToolGate(policy) {
+  return {
+    gate(toolName) {
+      if (policy.deny && policy.deny.includes(toolName)) {
+        return {
+          allowed: false,
+          reason: `Tool "${toolName}" is denied by policy`
+        };
+      }
+      if (policy.allow && policy.allow.includes(toolName)) {
+        return {
+          allowed: true,
+          reason: `Tool "${toolName}" is allowed by allow-list`
+        };
+      }
+      if (policy.default === "allow") {
+        return {
+          allowed: true,
+          reason: `Tool "${toolName}" allowed by default policy`
+        };
+      } else {
+        return {
+          allowed: false,
+          reason: `Tool "${toolName}" not allowed by default policy`
+        };
+      }
+    }
+  };
+}
+
+// src/data-plane.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+import { WebSocket } from "node:http";
+import { homedir as homedir2 } from "node:os";
+import { join as join4 } from "node:path";
+var SEEN_MAX = 5e3;
+function errText(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+var SecureComsDataPlane = class {
+  identityId;
+  connectionPath;
+  establishedMs;
+  initialDelayMs;
+  maxDelayMs;
+  log;
+  sleep;
+  random;
+  onMessage;
+  seen = /* @__PURE__ */ new Set();
+  stopped = false;
+  running = false;
+  socket = null;
+  /**
+   * The CURRENT attempt's establish timer, published here only so stop() can
+   * cancel it. Each attempt also holds its own local reference and clears only
+   * that one — see attemptOnce.
+   */
+  settle = null;
+  /**
+   * The handle of the DEFAULT backoff sleep's timer, so stop() can cancel it.
+   * Without this, stopping during a 30 s backoff leaves a live timer holding
+   * the event loop open for the rest of that delay. It is deliberately NOT
+   * unref()'d: while the plane is running, a pending reconnect is a reason for
+   * the process to stay alive — cancelling on stop() is the right lever, not
+   * making the timer invisible.
+   */
+  sleepTimer = null;
+  /** Resolvers for a wait() currently parked, released immediately by stop(). */
+  sleepWaiters = [];
+  /**
+   * Bumped by stop() and by start(). A loop only keeps running while its own
+   * generation is current, so a restart can never end up with two live loops.
+   */
+  generation = 0;
+  constructor(cfg, onMessage) {
+    this.identityId = cfg.identityId;
+    const dir = cfg.connectionsDir ?? join4(homedir2(), ".securecoms", "connections");
+    this.connectionPath = join4(dir, `${cfg.identityId}.json`);
+    this.establishedMs = cfg.establishedMs ?? 5e3;
+    this.initialDelayMs = cfg.initialDelayMs ?? 250;
+    this.maxDelayMs = cfg.maxDelayMs ?? 3e4;
+    this.log = cfg.log ?? ((level, msg) => {
+      if (level === "info") console.log(msg);
+      else console.error(msg);
+    });
+    this.sleep = cfg.sleep ?? ((ms) => new Promise((resolve2) => {
+      this.sleepTimer = setTimeout(() => {
+        this.sleepTimer = null;
+        resolve2();
+      }, ms);
+    }));
+    this.random = cfg.random ?? Math.random;
+    this.onMessage = onMessage;
+  }
+  /**
+   * Resolves once the reconnect loop is running — NOT once attached. The loop
+   * runs in the background for the life of the process; every error inside it
+   * is logged, never thrown out of here.
+   */
+  async start() {
+    if (this.running) return;
+    this.running = true;
+    this.stopped = false;
+    void this.loop(++this.generation);
+  }
+  stop() {
+    this.stopped = true;
+    this.running = false;
+    this.generation++;
+    this.clearSettle();
+    this.cancelSleep();
+    const ws = this.socket;
+    this.socket = null;
+    if (ws) {
+      try {
+        ws.close();
+      } catch (e) {
+        this.log("warn", `error closing socket: ${errText(e)}`);
+      }
+    }
+  }
+  /**
+   * Cancels the default sleep's timer and releases whatever is parked in
+   * wait(), so the loop observes `stopped` immediately rather than after the
+   * remaining backoff (up to maxDelayMs). An INJECTED sleep cannot be
+   * cancelled from here, so wait() races it against this release instead —
+   * that keeps the injectable signature exactly as the tests use it.
+   */
+  cancelSleep() {
+    if (this.sleepTimer) {
+      clearTimeout(this.sleepTimer);
+      this.sleepTimer = null;
+    }
+    for (const release of this.sleepWaiters.splice(0)) release();
+  }
+  /** The backoff sleep, made interruptible by stop(). */
+  wait(ms) {
+    if (this.stopped) return Promise.resolve();
+    return new Promise((resolve2) => {
+      let settled = false;
+      const finish = () => {
+        if (settled) return;
+        settled = true;
+        this.sleepWaiters = this.sleepWaiters.filter((w) => w !== finish);
+        resolve2();
+      };
+      this.sleepWaiters.push(finish);
+      void this.sleep(ms).then(finish, finish);
+    });
+  }
+  clearSettle() {
+    if (this.settle) {
+      clearTimeout(this.settle);
+      this.settle = null;
+    }
+  }
+  remember(id) {
+    if (this.seen.size >= SEEN_MAX) {
+      const oldest = this.seen.values().next();
+      if (!oldest.done) this.seen.delete(oldest.value);
+    }
+    this.seen.add(id);
+  }
+  async loop(generation) {
+    const live = () => !this.stopped && this.generation === generation;
+    let delay = this.initialDelayMs;
+    while (live()) {
+      try {
+        await this.attemptOnce();
+        delay = this.initialDelayMs;
+      } catch (e) {
+        this.log("error", errText(e));
+      }
+      if (!live()) break;
+      await this.wait(this.random() * delay);
+      delay = Math.min(delay * 2, this.maxDelayMs);
+    }
+    if (this.generation === generation) this.running = false;
+  }
+  async attemptOnce() {
+    const conn = JSON.parse(readFileSync3(this.connectionPath, "utf8"));
+    const httpBase = conn.bridge_url.replace(/^ws/, "http").replace(/\/v1\/ws$/, "");
+    const token = readFileSync3(conn.token_file, "utf8").trim();
+    const health = await (await fetch(`${httpBase}/healthz`)).json();
+    if (conn.identity_id !== health.identity_id || this.identityId !== health.identity_id) {
+      throw new Error(
+        `gate refused: expected ${this.identityId}, connection file says ${conn.identity_id}, daemon on this port is ${health.identity_id}`
+      );
+    }
+    if (this.stopped) return;
+    const ws = new WebSocket(`${conn.bridge_url}?token=${encodeURIComponent(token)}`);
+    this.socket = ws;
+    let established = false;
+    let settle = null;
+    try {
+      await new Promise((resolve2, reject) => {
+        ws.addEventListener("error", (e) => {
+          reject(new Error(`socket error: ${errText(e?.message ?? e)}`));
+        });
+        ws.addEventListener("close", (e) => {
+          if (established) resolve2();
+          else {
+            reject(
+              new Error(
+                `closed with code ${e.code} before the connection settled \u2014 bad token, or another connector took this port`
+              )
+            );
+          }
+        });
+        ws.addEventListener("open", () => {
+          settle = setTimeout(() => {
+            established = true;
+            this.log("info", `attached to ${conn.bridge_url}`);
+          }, this.establishedMs);
+          this.settle = settle;
+        });
+        ws.addEventListener("message", (ev) => {
+          void this.handleFrame(ws, ev.data).catch((e) => {
+            this.log("error", `frame handling failed: ${errText(e)}`);
+          });
+        });
+      });
+    } finally {
+      if (settle !== null) clearTimeout(settle);
+      if (this.settle === settle) this.settle = null;
+      try {
+        ws.close();
+      } catch {
+      }
+      if (this.socket === ws) this.socket = null;
+    }
+  }
+  async handleFrame(ws, data) {
+    let frame;
+    try {
+      frame = JSON.parse(String(data));
+    } catch (e) {
+      this.log("error", `ignoring unparseable frame: ${errText(e)}`);
+      return;
+    }
+    if (frame?.type === "error") {
+      this.log("error", `daemon error frame: ${String(frame.error)}: ${String(frame.message)}`);
+      return;
+    }
+    if (frame?.type !== "message") return;
+    const messageId = frame.message_id;
+    if (typeof messageId !== "string") {
+      this.log("error", "ignoring message frame with no message_id");
+      return;
+    }
+    const channelId = String(frame.channel_id);
+    try {
+      if (!this.seen.has(messageId)) {
+        this.remember(messageId);
+        const reply = await this.onMessage({
+          text: String(frame.text ?? ""),
+          senderId: String(frame.sender_id ?? ""),
+          channelId,
+          messageId
+        });
+        if (reply != null) {
+          ws.send(JSON.stringify({ type: "send", channel_id: channelId, text: String(reply) }));
+        }
+      }
+    } catch (e) {
+      this.log("error", `handler threw: ${errText(e)}`);
+    } finally {
+      try {
+        ws.send(JSON.stringify({ type: "ack", message_id: messageId }));
+      } catch (e) {
+        this.log("error", `could not ack ${messageId}: ${errText(e)}`);
+      }
+    }
+  }
+};
+function createSecureComsDataPlane(cfg, onMessage) {
+  return new SecureComsDataPlane(cfg, onMessage);
+}
+
+// src/tool-runner.ts
+async function runToolCalls(toolCalls, skills, context) {
+  const out = [];
+  for (const call of toolCalls) {
+    let args;
+    try {
+      args = JSON.parse(call.function.arguments);
+    } catch {
+      args = {};
+    }
+    let content;
+    try {
+      content = await skills.invoke(call.function.name, args, context);
+    } catch (err) {
+      content = JSON.stringify({
+        error: "tool_failed",
+        message: String(err instanceof Error ? err.message : err)
+      });
+    }
+    out.push({ role: "tool", content, tool_call_id: call.id });
+  }
+  return out;
+}
+
+// src/turn-loop.ts
+var DEFAULT_SYSTEM_PROMPT = "You are a SecureComs agent. Respond helpfully and concisely.";
+var DEFAULT_MAX_ITERATIONS = 5;
+function buildHandler(deps) {
+  const systemPrompt = deps.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
+  const maxIterations = deps.maxIterations ?? DEFAULT_MAX_ITERATIONS;
+  const log = deps.log ?? (() => {
+  });
+  const { llm, memoryFor, skills, gate } = deps;
+  return async (m) => {
+    const text = m.text?.trim() ? m.text : "";
+    if (!text) return null;
+    log("info", `message from ${m.senderId.slice(0, 8)}: ${text.slice(0, 80)}`);
+    const memory = memoryFor(m.channelId);
+    const messages = [{ role: "system", content: systemPrompt }];
+    const recalled = await memory.recall(text);
+    if (recalled) messages.push({ role: "system", content: recalled });
+    messages.push(...memory.getHistory());
+    messages.push({ role: "user", content: text });
+    memory.addMessage({ role: "user", content: text });
+    const tools = skills.getToolDefinitions();
+    let response = null;
+    for (let iteration = 0; iteration < maxIterations; iteration++) {
+      const result = await llm.complete(messages, tools.length > 0 ? tools : void 0);
+      if (result.toolCalls.length === 0) {
+        response = result.content;
+        break;
+      }
+      messages.push({
+        role: "assistant",
+        content: result.content ?? "",
+        tool_calls: result.toolCalls
+      });
+      const verdicts = result.toolCalls.map((call) => ({
+        call,
+        verdict: gate.gate(call.function.name)
+      }));
+      const allowed = verdicts.filter((v) => v.verdict.allowed).map((v) => v.call);
+      for (const v of verdicts) {
+        if (!v.verdict.allowed) {
+          log("warn", `tool call denied: ${v.call.function.name} \u2014 ${v.verdict.reason}`);
+        }
+      }
+      const executed = await runToolCalls(allowed, skills, { roomId: m.channelId });
+      const byId = new Map(executed.map((r) => [r.tool_call_id, r]));
+      for (const { call, verdict } of verdicts) {
+        if (verdict.allowed) {
+          const done = byId.get(call.id);
+          if (done) {
+            messages.push({ role: "tool", content: done.content, tool_call_id: done.tool_call_id });
+            continue;
+          }
+          messages.push({
+            role: "tool",
+            content: JSON.stringify({ error: "tool_call_no_result" }),
+            tool_call_id: call.id
+          });
+          continue;
+        }
+        messages.push({
+          role: "tool",
+          content: JSON.stringify({ error: "tool_call_denied", reason: verdict.reason }),
+          tool_call_id: call.id
+        });
+      }
+    }
+    if (!response) {
+      log("warn", `no final answer after ${maxIterations} iterations; dropping the turn`);
+      return null;
+    }
+    memory.addMessage({ role: "assistant", content: response });
+    if (response.length > 50) {
+      try {
+        await memory.capture(
+          `User asked: "${text.slice(0, 100)}". Agent responded: "${response.slice(0, 200)}"`,
+          "conversation"
+        );
+      } catch (e) {
+        log("warn", `memory capture failed: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    }
+    log("info", `response: ${response.slice(0, 80)}`);
+    return response;
+  };
+}
+
+// src/index.ts
+if (process.argv.includes("--version")) {
+  const pkg = JSON.parse(readFileSync4(join5(dirname3(dirname3(fileURLToPath2(import.meta.url))), "package.json"), "utf8"));
+  console.log(pkg.version);
+  process.exit(0);
+}
+var LEVEL_RANK = { debug: 0, info: 1, warn: 2, error: 3 };
+function makeLogger(cfg) {
+  const floor = LEVEL_RANK[cfg.logLevel];
+  return (level, msg) => {
+    if (LEVEL_RANK[level] < floor) return;
+    const line = `[runtime] ${level}: ${msg}`;
+    if (level === "warn" || level === "error") console.error(line);
+    else console.log(line);
+  };
+}
+function safeChannelSegment(channelId) {
+  return channelId.replace(/[^A-Za-z0-9_-]/g, "_") || "_";
+}
+function endpointHost(endpoint) {
+  try {
+    return new URL(endpoint).host;
+  } catch {
+    return "(unparseable endpoint)";
+  }
+}
+function realServiceDeps() {
+  return {
+    platform: process.platform,
+    run: (cmd, args) => {
+      const r = spawnSync(cmd, args, { encoding: "utf8" });
+      return { status: r.status ?? 1, stdout: r.stdout ?? "", stderr: r.stderr ?? "" };
+    },
+    writeFile: (p, data) => writeFileSync2(p, data, { mode: 420 }),
+    removeFile: (p) => rmSync(p, { force: true }),
+    mkdirp: (p) => mkdirSync2(p, { recursive: true }),
+    fileExists: (p) => existsSync3(p),
+    canRead: (p) => {
+      try {
+        accessSync(p, constants.R_OK);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    user: userInfo().username
+  };
+}
+function realResolveNodeDeps() {
+  return {
+    realpath: (p) => realpathSync(p),
+    fileExists: (p) => existsSync3(p),
+    nodeMajorOf: (p) => {
+      const r = spawnSync(p, ["--version"], { encoding: "utf8" });
+      if (r.status !== 0) return null;
+      const m = /v?(\d+)\./.exec((r.stdout ?? "").trim());
+      return m ? Number(m[1]) : null;
+    },
+    arch: () => process.arch,
+    archOf: (p) => {
+      const r = spawnSync(p, ["-p", "process.arch"], { encoding: "utf8" });
+      return r.status === 0 ? (r.stdout ?? "").trim() : null;
+    }
+  };
+}
+function runServiceVerb(verb) {
+  const flags = parseServiceFlags(process.argv, process.env);
+  if (!flags.identityId) {
+    console.error(`securecoms-agent: ${MISSING_IDENTITY_MESSAGE}`);
+    process.exit(2);
+  }
+  const home = homedir3();
+  try {
+    const execPath = chooseVerbExecPath(
+      verb,
+      flags.execPath,
+      () => chooseInstallExecPath(process.execPath, flags.execPath, realResolveNodeDeps(), home)
+    );
+    const input = {
+      ...flags,
+      identityId: flags.identityId,
+      execPath,
+      binScript: fileURLToPath2(import.meta.url),
+      home,
+      uid: userInfo().uid
+    };
+    if (verb === "install" && process.argv.includes("--dry-run")) {
+      const plan = prepareInstall(input, process.platform, realServiceDeps());
+      console.log(`would install ${plan.label}`);
+      console.log(`exec path: ${plan.execPath}`);
+      console.log(`service file: ${plan.filePath}`);
+      console.log(`logs: ${plan.logHint}`);
+      console.log(
+        plan.keyFile ? `key file: ${plan.keyFile}` : "key file: (none \u2014 set SECURECOMS_LLM_API_KEY_FILE or pass --llm-key-file)"
+      );
+      console.log("--- rendered service definition (not written) ---");
+      console.log(plan.contents);
+      process.exit(0);
+    }
+    if (verb === "install") {
+      const r = installService(input, realServiceDeps());
+      console.log(`installed ${r.label}`);
+      console.log(`exec path: ${input.execPath}`);
+      console.log(`service file: ${r.filePath}`);
+      console.log(`logs: ${r.logHint}`);
+      console.log(
+        r.keyFile ? `key file: ${r.keyFile}` : "key file: (none \u2014 set SECURECOMS_LLM_API_KEY_FILE or pass --llm-key-file)"
+      );
+    } else {
+      const r = uninstallService(input, realServiceDeps());
+      console.log(r.removed ? `removed ${r.filePath}` : "no service installed for this identity");
+    }
+  } catch (e) {
+    const raw = e instanceof ServiceUnsupportedError;
+    console.error(
+      raw ? e.message : `securecoms-agent: ${verb} failed: ${e instanceof Error ? e.message : String(e)}`
+    );
+    process.exit(1);
+  }
+  process.exit(0);
+}
+async function main() {
+  const verb = parseVerb(process.argv);
+  if (verb) runServiceVerb(verb);
+  let cfg;
+  try {
+    cfg = loadConfig(process.argv.slice(2), process.env);
+  } catch (e) {
+    console.error(`securecoms-agent: ${e instanceof Error ? e.message : String(e)}`);
+    process.exit(2);
+    return;
+  }
+  const log = makeLogger(cfg);
+  let apiKey;
+  try {
+    apiKey = resolveLlmApiKey(cfg, (p) => readFileSync4(p, "utf8"));
+  } catch (e) {
+    console.error(`securecoms-agent: ${e instanceof Error ? e.message : String(e)}`);
+    process.exit(2);
+    return;
+  }
+  const llm = new LLMDispatcher(cfg.llmEndpoint, cfg.llmModel, { apiKey });
+  const memories = /* @__PURE__ */ new Map();
+  const memoryFor = (channelId) => {
+    let mem = memories.get(channelId);
+    if (!mem) {
+      mem = new AgentMemory(join5(cfg.dataDir, "channels", safeChannelSegment(channelId)));
+      memories.set(channelId, mem);
+    }
+    return mem;
+  };
+  const skills = new SkillInvoker(cfg.skillsDir);
+  skills.loadSkills();
+  const gate = createLocalToolGate(cfg.toolGate);
+  const plane = createSecureComsDataPlane(
+    { identityId: cfg.identityId, log: (level, msg) => log(level, msg) },
+    buildHandler({ llm, memoryFor, skills, gate, log })
+  );
+  console.log(
+    `securecoms-agent ${cfg.identityId.slice(0, 8)} \u2192 llm ${endpointHost(cfg.llmEndpoint)} (${cfg.llmModel}), ${skills.getToolDefinitions().length} skills, tool gate default=${cfg.toolGate.default}`
+  );
+  await plane.start();
+  const shutdown = () => {
+    log("info", "shutting down");
+    plane.stop();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+void main();