@fancyboi999/open-tag-daemon 0.2.0 → 0.4.0

package/dist/cli.mjs

@@ -5649,9 +5649,28 @@ async function readSkillsDir(dir, sourcePath) {
   }
   return out;
 }
-async function listSkills(agentId) {
-  const global = await readSkillsDir(path11.join(os3.homedir(), ".claude", "skills"), "~/.claude/skills");
-  const workspace = await readSkillsDir(path11.join(DATA_DIR2, agentId, ".claude", "skills"), "<workspace>/.claude/skills");
+var HOME = os3.homedir();
+var UNIVERSAL_SKILLS = { dir: path11.join(HOME, ".agents", "skills"), label: "~/.agents/skills" };
+var PROVIDER_HOME_SKILLS = {
+  claude: { dir: path11.join(HOME, ".claude", "skills"), label: "~/.claude/skills" },
+  codex: { dir: path11.join(process.env.CODEX_HOME || path11.join(HOME, ".codex"), "skills"), label: "~/.codex/skills" },
+  copilot: { dir: path11.join(HOME, ".copilot", "skills"), label: "~/.copilot/skills" },
+  opencode: { dir: path11.join(HOME, ".config", "opencode", "skills"), label: "~/.config/opencode/skills" },
+  cursor: { dir: path11.join(HOME, ".cursor", "skills"), label: "~/.cursor/skills" },
+  pi: { dir: path11.join(HOME, ".pi", "agent", "skills"), label: "~/.pi/agent/skills" }
+};
+var PROVIDER_WS_DIR = { claude: ".claude", codex: ".codex", copilot: ".copilot", opencode: ".opencode", cursor: ".cursor", pi: ".pi" };
+function skillRootsFor(runtime, agentId) {
+  const home = PROVIDER_HOME_SKILLS[runtime];
+  const global = home ? [home, UNIVERSAL_SKILLS] : [UNIVERSAL_SKILLS];
+  const wsName = PROVIDER_WS_DIR[runtime];
+  const workspace = wsName ? { dir: path11.join(DATA_DIR2, agentId, wsName, "skills"), label: `<workspace>/${wsName}/skills` } : null;
+  return { global, workspace };
+}
+async function listSkills(agentId, runtime = "claude") {
+  const roots = skillRootsFor(runtime, agentId);
+  const global = (await Promise.all(roots.global.map((r) => readSkillsDir(r.dir, r.label)))).flat();
+  const workspace = roots.workspace ? await readSkillsDir(roots.workspace.dir, roots.workspace.label) : [];
   return { global, workspace };
 }
 async function readWorkspaceFile(agentId, rel) {
@@ -5669,6 +5688,190 @@ async function readWorkspaceFile(agentId, rel) {
   }
 }
 
+// src/daemon/listModels.ts
+import { spawn as spawn8 } from "node:child_process";
+var titleCase = (s) => s ? s[0].toUpperCase() + s.slice(1) : s;
+function isModelId(s) {
+  return /^[A-Za-z][A-Za-z0-9\-_./]*$/.test(s);
+}
+var CLAUDE_MODELS = [
+  { id: "sonnet", label: "Sonnet" },
+  { id: "opus", label: "Opus" },
+  { id: "haiku", label: "Haiku" }
+];
+var CLAUDE_EFFORT_LABEL = {
+  low: "Low",
+  medium: "Medium",
+  high: "High",
+  xhigh: "Extra high",
+  max: "Max"
+};
+var CLAUDE_MODEL_EFFORT_ALLOW = {
+  opus: /* @__PURE__ */ new Set(["low", "medium", "high", "xhigh", "max"]),
+  sonnet: /* @__PURE__ */ new Set(["low", "medium", "high", "max"]),
+  haiku: /* @__PURE__ */ new Set(["low", "medium", "high"])
+};
+function parseClaudeEffortLevels(helpText) {
+  const m = /--effort\s*(?:<[^>]+>)?\s*(?:Effort level[^(]*)?\(([^)]+)\)/.exec(helpText);
+  if (!m) return [];
+  return m[1].split(",").map((s) => s.trim()).filter((s) => /^[a-z]+$/i.test(s));
+}
+function claudeThinkingForModel(modelId, superset) {
+  const allow = CLAUDE_MODEL_EFFORT_ALLOW[modelId];
+  const levels = superset.filter((v) => !allow || allow.has(v)).map((v) => ({ value: v, label: CLAUDE_EFFORT_LABEL[v] ?? titleCase(v) }));
+  if (!levels.length) return void 0;
+  return { levels, default: levels.some((l) => l.value === "medium") ? "medium" : levels[0].value };
+}
+function parseCodexModels(jsonStr) {
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonStr);
+  } catch {
+    return [];
+  }
+  const models = Array.isArray(parsed?.models) ? parsed.models : [];
+  const out = [];
+  for (const m of models) {
+    if (m?.visibility !== "list") continue;
+    const slug = typeof m?.slug === "string" ? m.slug : "";
+    if (!slug) continue;
+    const raw = Array.isArray(m?.supported_reasoning_levels) ? m.supported_reasoning_levels : [];
+    const levels = raw.map((l) => ({ value: String(l?.effort ?? ""), label: titleCase(String(l?.effort ?? "")), description: typeof l?.description === "string" ? l.description : void 0 })).filter((l) => l.value);
+    const thinking = levels.length ? { levels, default: typeof m?.default_reasoning_level === "string" ? m.default_reasoning_level : void 0 } : void 0;
+    out.push({ id: slug, label: typeof m?.display_name === "string" && m.display_name ? m.display_name : slug, provider: "openai", ...thinking ? { thinking } : {} });
+  }
+  return out;
+}
+function parseOpencodeModels(stdout) {
+  const out = [];
+  for (const raw of stdout.split("\n")) {
+    const line = raw.trim();
+    if (!line) continue;
+    if (line.startsWith("{") || line.startsWith('"') || line.startsWith("}")) continue;
+    if (line === line.toUpperCase() && /[A-Z]/.test(line)) continue;
+    const id = line.split(/\s+/)[0];
+    const slash = id.indexOf("/");
+    if (slash <= 0 || slash >= id.length - 1) continue;
+    out.push({ id, label: id, provider: id.slice(0, slash) });
+  }
+  return out;
+}
+function parseCursorModels(stdout) {
+  const out = [];
+  for (const raw of stdout.split("\n")) {
+    const line = raw.trim();
+    if (!line) continue;
+    const sep = line.indexOf(" - ");
+    if (sep < 0) continue;
+    const id = line.slice(0, sep).trim();
+    if (!isModelId(id)) continue;
+    let label = line.slice(sep + 3).trim();
+    const isDefault = /default/i.test(label);
+    const paren = label.indexOf("(");
+    if (paren >= 0) label = label.slice(0, paren).trim();
+    out.push({ id, label: label || id, provider: "cursor", ...isDefault ? { default: true } : {} });
+  }
+  return out;
+}
+function parsePiModels(out) {
+  const res = [];
+  for (const raw of out.split("\n")) {
+    const line = raw.trim();
+    if (!line) continue;
+    if (isPiNoise(line)) continue;
+    const fields = line.split(/\s+/);
+    const first = fields[0];
+    if (first.toLowerCase() === "provider") continue;
+    let id;
+    if (first.includes(":") || first.includes("/")) id = first.replace(":", "/");
+    else if (fields.length >= 2) id = `${first}/${fields[1]}`;
+    else continue;
+    const slash = id.indexOf("/");
+    if (slash <= 0 || slash >= id.length - 1) continue;
+    res.push({ id, label: id, provider: id.slice(0, slash) });
+  }
+  return res;
+}
+function isPiNoise(line) {
+  const l = line.toLowerCase();
+  return l.includes("no models match pattern") || l.startsWith("warning:") || l.startsWith("error:") || l.startsWith("info:");
+}
+var LIST_TIMEOUT_MS = 7e3;
+var OUT_CAP = 256 * 1024;
+function runList(bin, args2, timeoutMs = LIST_TIMEOUT_MS) {
+  return new Promise((resolve) => {
+    const env = { ...process.env };
+    delete env.NODE_OPTIONS;
+    let proc;
+    try {
+      proc = spawn8(bin, args2, { stdio: ["ignore", "pipe", "pipe"], env });
+    } catch (e) {
+      return resolve({ stdout: "", stderr: String(e?.message ?? e), code: 1 });
+    }
+    let stdout = "";
+    let stderr = "";
+    proc.stdout?.on("data", (c) => {
+      if (stdout.length < OUT_CAP) stdout += c.toString();
+    });
+    proc.stderr?.on("data", (c) => {
+      if (stderr.length < OUT_CAP) stderr += c.toString();
+    });
+    const timer = setTimeout(() => {
+      try {
+        proc.kill("SIGKILL");
+      } catch {
+      }
+    }, timeoutMs);
+    proc.on("error", (e) => {
+      clearTimeout(timer);
+      resolve({ stdout, stderr: stderr || String(e?.message ?? e), code: 1 });
+    });
+    proc.on("exit", (code) => {
+      clearTimeout(timer);
+      resolve({ stdout, stderr, code });
+    });
+  });
+}
+async function listModels(runtime) {
+  switch (runtime) {
+    case "opencode": {
+      let r = await runList("opencode", ["models", "--verbose"], 5e3);
+      let models = parseOpencodeModels(r.stdout);
+      if (!models.length) {
+        r = await runList("opencode", ["models"], 2e3);
+        models = parseOpencodeModels(r.stdout);
+      }
+      return models.length ? models : null;
+    }
+    case "cursor": {
+      const r = await runList("cursor-agent", ["--list-models"]);
+      const models = parseCursorModels(r.stdout);
+      return models.length ? models : null;
+    }
+    case "pi": {
+      const r = await runList("pi", ["--list-models"]);
+      const models = parsePiModels(r.stdout || r.stderr);
+      return models.length ? models : null;
+    }
+    case "claude": {
+      const r = await runList("claude", ["--help"]);
+      const superset = parseClaudeEffortLevels(r.stdout || r.stderr);
+      if (!superset.length) return null;
+      return CLAUDE_MODELS.map((m) => {
+        const thinking = claudeThinkingForModel(m.id, superset);
+        return { ...m, provider: "anthropic", ...thinking ? { thinking } : {} };
+      });
+    }
+    case "codex": {
+      const r = await runList("codex", ["debug", "models"]);
+      const models = parseCodexModels(r.stdout);
+      return models.length ? models : null;
+    }
+    default:
+      return null;
+  }
+}
+
 // src/daemon/index.ts
 var log = createLogger("daemon");
 var args = process.argv.slice(2);
@@ -5732,7 +5935,10 @@ conn = new Connection(serverUrl, apiKey, (msg) => {
       void readWorkspaceFile(msg.agentId, msg.path ?? "").then((r) => conn.send({ type: "workspace:file_content", requestId: msg.requestId, agentId: msg.agentId, ...r }));
       break;
     case "agent:skills:list":
-      void listSkills(msg.agentId).then((r) => conn.send({ type: "skills:list", requestId: msg.requestId, agentId: msg.agentId, ...r }));
+      void listSkills(msg.agentId, msg.runtime).then((r) => conn.send({ type: "skills:list", requestId: msg.requestId, agentId: msg.agentId, ...r }));
+      break;
+    case "probe-models":
+      void listModels(msg.runtime ?? "").then((models) => conn.send({ type: "models", requestId: msg.requestId, runtime: msg.runtime, models })).catch((e) => conn.send({ type: "models", requestId: msg.requestId, runtime: msg.runtime, models: null, error: String(e?.message ?? e) }));
       break;
     case "ping":
       conn.send({ type: "pong" });
@@ -5748,7 +5954,7 @@ conn = new Connection(serverUrl, apiKey, (msg) => {
     runningAgents: mgr.running(),
     hostname: os4.hostname(),
     os: `${os4.platform()} ${os4.arch()}`,
-    daemonVersion: "0.1.0",
+    daemonVersion: "0.4.0",
     machineId: readMachineId()
     // Stable identity: empty on first connection; server sends it back via ready:ack for persistence.
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fancyboi999/open-tag-daemon",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "open-tag compute-plane daemon — connect any machine to an open-tag server so its agents run there. No repo clone needed.",
   "license": "Apache-2.0",
   "type": "module",