@tekmidian/pai 0.36.2 → 0.38.0

package/dist/hooks/route-agents-to-worker.mjs

@@ -0,0 +1,518 @@
+#!/usr/bin/env node
+
+// src/workers/config.ts
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+
+// src/config/json-store.ts
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  copyFileSync,
+  renameSync,
+  unlinkSync,
+  mkdirSync
+} from "node:fs";
+function readJsonStrict(path, label = path) {
+  if (!existsSync(path)) return {};
+  let raw;
+  try {
+    raw = readFileSync(path, "utf8");
+  } catch (e) {
+    throw new Error(
+      `Could not read ${label}: ${e instanceof Error ? e.message : String(e)}
+Refusing to continue \u2014 writing now would replace its contents with ours alone.`
+    );
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (e) {
+    throw new Error(
+      `${label} exists but is not valid JSON: ${e instanceof Error ? e.message : String(e)}
+Refusing to continue \u2014 overwriting it would destroy whatever it holds.
+Repair the file, or move it aside and re-run this command.`
+    );
+  }
+}
+
+// src/daemon/config.ts
+import { homedir, userInfo } from "node:os";
+import { join } from "node:path";
+
+// src/notifications/types.ts
+var DEFAULT_ROUTING = {
+  error: ["whatsapp", "macos", "ntfy", "cli"],
+  completion: ["whatsapp", "macos", "ntfy", "cli"],
+  info: ["cli"],
+  progress: ["cli"],
+  debug: []
+};
+var DEFAULT_CHANNELS = {
+  ntfy: {
+    enabled: false,
+    url: void 0,
+    priority: "default"
+  },
+  whatsapp: {
+    enabled: true,
+    recipient: void 0
+  },
+  macos: {
+    enabled: true
+  },
+  voice: {
+    enabled: false,
+    voiceName: "bm_george"
+  },
+  cli: {
+    enabled: true
+  }
+};
+var DEFAULT_NOTIFICATION_CONFIG = {
+  mode: "auto",
+  channels: DEFAULT_CHANNELS,
+  routing: DEFAULT_ROUTING
+};
+
+// src/tasks/types.ts
+var DEFAULT_TASK_CONFIG = {
+  enabled: false,
+  providers: {
+    todoist: {
+      enabled: false
+    }
+  },
+  autoDispatch: false
+};
+
+// src/runtime-paths.ts
+function paiSocketPath() {
+  return process.env.PAI_SOCKET_PATH ?? "/tmp/pai.sock";
+}
+
+// src/daemon/config.ts
+function perUserDbName() {
+  const username = userInfo().username;
+  const safe = username.replace(/[^a-zA-Z0-9_]/g, "_").toLowerCase();
+  return `pai_${safe}`;
+}
+function perUserConnectionString() {
+  const db = perUserDbName();
+  return `postgresql://pai:pai@localhost:5432/${db}`;
+}
+var DEFAULTS = {
+  socketPath: paiSocketPath(),
+  indexIntervalSecs: 300,
+  embedIntervalSecs: 600,
+  embedOnStartup: false,
+  storageBackend: "sqlite",
+  postgres: {
+    connectionString: perUserConnectionString(),
+    maxConnections: 5,
+    connectionTimeoutMs: 5e3
+  },
+  embeddingModel: "Snowflake/snowflake-arctic-embed-m-v1.5",
+  logLevel: "info",
+  notifications: DEFAULT_NOTIFICATION_CONFIG,
+  tasks: DEFAULT_TASK_CONFIG,
+  // Deliberately empty. An install must not guess who the user is: a wrong
+  // guess here is an address that can be mailed without review.
+  identity: { selfEmails: [] },
+  search: {
+    mode: "keyword",
+    rerank: true,
+    recencyBoostDays: 90,
+    defaultLimit: 10,
+    snippetLength: 200
+  }
+};
+var CONFIG_DIR = join(homedir(), ".config", "pai");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+
+// src/workers/config.ts
+var PROVIDER_TAGS = [
+  "code",
+  "vision",
+  "image-gen",
+  "long-context",
+  "fast",
+  "reasoning"
+];
+var DEFAULT_LOG_DIR = "~/.claude/logs/workers";
+var DEFAULT_PANE = {
+  enabled: true,
+  fontSize: 13,
+  autoExitSecs: 60
+};
+var DEFAULT_ROUTING2 = {
+  order: [],
+  cooldownMinutes: 30,
+  retryOnQuota: true
+};
+function defaultWorkersConfig() {
+  return {
+    enabled: false,
+    active: null,
+    providers: {},
+    classes: {},
+    mcpSets: {},
+    pane: { ...DEFAULT_PANE },
+    logDir: DEFAULT_LOG_DIR,
+    routing: { ...DEFAULT_ROUTING2, order: [] }
+  };
+}
+var WorkersConfigError = class extends Error {
+};
+function bad(path, why) {
+  throw new WorkersConfigError(`workers${path}: ${why}`);
+}
+function str(v) {
+  return typeof v === "string" ? v : "";
+}
+function parseProvider(name, raw) {
+  if (typeof raw !== "object" || raw === null) bad(`.providers.${name}`, "must be an object");
+  const p = raw;
+  const protocol = p.protocol === void 0 ? "anthropic" : str(p.protocol);
+  if (protocol !== "anthropic" && protocol !== "openai") {
+    bad(`.providers.${name}.protocol`, `"${str(p.protocol)}" is neither "anthropic" nor "openai"`);
+  }
+  const engine = p.engine === void 0 ? "claude" : str(p.engine);
+  if (engine !== "claude" && engine !== "codex") {
+    bad(`.providers.${name}.engine`, `"${str(p.engine)}" is neither "claude" nor "codex"`);
+  }
+  const baseUrl = str(p.baseUrl);
+  if (!baseUrl && protocol !== "openai") bad(`.providers.${name}.baseUrl`, "is required");
+  const keyFile = p.keyFile === void 0 || p.keyFile === null || str(p.keyFile) === "" ? null : str(p.keyFile);
+  const modelsRaw = p.models === void 0 ? {} : p.models;
+  if (typeof modelsRaw !== "object" || modelsRaw === null) {
+    bad(`.providers.${name}.models`, "must be an object");
+  }
+  const m = modelsRaw;
+  const defaultModel = str(m.default);
+  if (!defaultModel) bad(`.providers.${name}.models.default`, "is required");
+  const fast = m.fast === void 0 ? void 0 : str(m.fast);
+  const env = {};
+  if (p.env !== void 0) {
+    if (typeof p.env !== "object" || p.env === null || Array.isArray(p.env)) {
+      bad(`.providers.${name}.env`, "must be an object of string values");
+    }
+    for (const [k, v] of Object.entries(p.env)) {
+      if (typeof v !== "string") bad(`.providers.${name}.env.${k}`, "must be a string");
+      env[k] = v;
+    }
+  }
+  const quotaSkipAt = p.quotaSkipAt === void 0 ? void 0 : p.quotaSkipAt;
+  if (quotaSkipAt !== void 0) {
+    if (typeof quotaSkipAt !== "number" || quotaSkipAt < 0 || quotaSkipAt > 100) {
+      bad(`.providers.${name}.quotaSkipAt`, "must be a number between 0 and 100");
+    }
+  }
+  const contextWindow = p.contextWindow === void 0 ? void 0 : p.contextWindow;
+  if (contextWindow !== void 0) {
+    if (typeof contextWindow !== "number" || contextWindow <= 0) {
+      bad(`.providers.${name}.contextWindow`, "must be a positive number of tokens");
+    }
+  }
+  const upstreamUrl = str(p.upstreamUrl);
+  if (protocol === "openai" && !upstreamUrl) {
+    bad(`.providers.${name}.upstreamUrl`, `is required for protocol "openai" (the Chat Completions base, e.g. "https://api.openai.com/v1")`);
+  }
+  const costTier = p.costTier === void 0 ? void 0 : p.costTier;
+  if (costTier !== void 0) {
+    if (typeof costTier !== "number" || !Number.isInteger(costTier) || costTier < 1 || costTier > 5) {
+      bad(`.providers.${name}.costTier`, "must be an integer 1 (cheapest) \u2026 5 (most expensive)");
+    }
+  }
+  let tags;
+  if (p.tags !== void 0) {
+    if (!Array.isArray(p.tags) || p.tags.some((x) => typeof x !== "string")) {
+      bad(`.providers.${name}.tags`, `must be an array of tags from: ${PROVIDER_TAGS.join(", ")}`);
+    }
+    for (const t of p.tags) {
+      if (!PROVIDER_TAGS.includes(t)) {
+        bad(`.providers.${name}.tags`, `"${t}" is not a tag (from: ${PROVIDER_TAGS.join(", ")})`);
+      }
+    }
+    tags = p.tags;
+  }
+  return {
+    enabled: p.enabled === void 0 ? true : p.enabled === true,
+    protocol,
+    baseUrl,
+    keyFile,
+    models: fast ? { default: defaultModel, fast } : { default: defaultModel },
+    env,
+    ...str(p.note) ? { note: str(p.note) } : {},
+    ...upstreamUrl ? { upstreamUrl } : {},
+    ...engine !== "claude" ? { engine } : {},
+    ...str(p.quotaProbe) ? { quotaProbe: str(p.quotaProbe) } : {},
+    ...quotaSkipAt !== void 0 ? { quotaSkipAt } : {},
+    ...contextWindow !== void 0 ? { contextWindow } : {},
+    ...costTier !== void 0 ? { costTier } : {},
+    ...tags ? { tags } : {}
+  };
+}
+function parseWorkersConfig(raw) {
+  const d = defaultWorkersConfig();
+  if (raw === void 0 || raw === null) return d;
+  if (typeof raw !== "object" || Array.isArray(raw)) {
+    bad("", "section must be an object");
+  }
+  const w = raw;
+  const providers = {};
+  if (w.providers !== void 0) {
+    if (typeof w.providers !== "object" || w.providers === null || Array.isArray(w.providers)) {
+      bad(".providers", "must be an object keyed by provider name");
+    }
+    for (const [name, p] of Object.entries(w.providers)) {
+      providers[name] = parseProvider(name, p);
+    }
+  }
+  const classes = {};
+  const classesRaw = w.classes !== void 0 ? w.classes : w.roles;
+  if (classesRaw !== void 0) {
+    if (typeof classesRaw !== "object" || classesRaw === null || Array.isArray(classesRaw)) {
+      bad(w.classes !== void 0 ? ".classes" : ".roles", "must be an object of class \u2192 provider[/alias] or {provider, mcp, maxCostTier, requireTags, order}");
+    }
+    for (const [cls, target] of Object.entries(classesRaw)) {
+      if (typeof target === "object" && target !== null && !Array.isArray(target)) {
+        const o = target;
+        const provider = str(o.provider);
+        if (o.provider !== void 0 && (!provider || provider.includes(" "))) {
+          bad(`.classes.${cls}.provider`, `invalid provider "${provider}"`);
+        }
+        let mcp;
+        if (o.mcp !== void 0) {
+          if (!Array.isArray(o.mcp) || o.mcp.some((x) => typeof x !== "string")) {
+            bad(`.classes.${cls}.mcp`, "must be an array of MCP server or set names");
+          }
+          mcp = o.mcp;
+        }
+        let maxCostTier;
+        if (o.maxCostTier !== void 0) {
+          if (typeof o.maxCostTier !== "number" || !Number.isInteger(o.maxCostTier) || o.maxCostTier < 1 || o.maxCostTier > 5) {
+            bad(`.classes.${cls}.maxCostTier`, "must be an integer 1 \u2026 5");
+          }
+          maxCostTier = o.maxCostTier;
+        }
+        let requireTags;
+        if (o.requireTags !== void 0) {
+          if (!Array.isArray(o.requireTags) || o.requireTags.some((x) => typeof x !== "string")) {
+            bad(`.classes.${cls}.requireTags`, `must be an array of tags from: ${PROVIDER_TAGS.join(", ")}`);
+          }
+          for (const t of o.requireTags) {
+            if (!PROVIDER_TAGS.includes(t)) {
+              bad(`.classes.${cls}.requireTags`, `"${t}" is not a tag (from: ${PROVIDER_TAGS.join(", ")})`);
+            }
+          }
+          requireTags = o.requireTags;
+        }
+        let order;
+        if (o.order !== void 0) {
+          if (!Array.isArray(o.order) || o.order.some((x) => typeof x !== "string")) {
+            bad(`.classes.${cls}.order`, "must be an array of provider names");
+          }
+          order = o.order;
+        }
+        const obj = {
+          ...provider ? { provider } : {},
+          ...mcp ? { mcp } : {},
+          ...maxCostTier !== void 0 ? { maxCostTier } : {},
+          ...requireTags ? { requireTags } : {},
+          ...order ? { order } : {}
+        };
+        classes[cls] = Object.keys(obj).length ? obj : {};
+      } else {
+        const t = str(target);
+        if (!t || t.includes(" ")) bad(`.classes.${cls}`, `invalid target "${t}"`);
+        classes[cls] = t;
+      }
+    }
+  }
+  const mcpSets = {};
+  if (w.mcpSets !== void 0) {
+    if (typeof w.mcpSets !== "object" || w.mcpSets === null || Array.isArray(w.mcpSets)) {
+      bad(".mcpSets", "must be an object of set name \u2192 [server names]");
+    }
+    for (const [setName, servers] of Object.entries(w.mcpSets)) {
+      if (!Array.isArray(servers) || servers.some((x) => typeof x !== "string")) {
+        bad(`.mcpSets.${setName}`, "must be an array of MCP server names");
+      }
+      mcpSets[setName] = servers;
+    }
+  }
+  let pane = { ...DEFAULT_PANE };
+  if (w.pane !== void 0) {
+    if (typeof w.pane !== "object" || w.pane === null) bad(".pane", "must be an object");
+    const pc = w.pane;
+    if (pc.enabled !== void 0 && typeof pc.enabled !== "boolean") bad(".pane.enabled", "must be boolean");
+    if (pc.fontSize !== void 0 && (typeof pc.fontSize !== "number" || pc.fontSize <= 0)) {
+      bad(".pane.fontSize", "must be a positive number of points");
+    }
+    if (pc.autoExitSecs !== void 0 && typeof pc.autoExitSecs !== "number") {
+      bad(".pane.autoExitSecs", "must be a number");
+    }
+    pane = {
+      enabled: pc.enabled === void 0 ? DEFAULT_PANE.enabled : pc.enabled === true,
+      fontSize: pc.fontSize === void 0 ? DEFAULT_PANE.fontSize : pc.fontSize,
+      autoExitSecs: pc.autoExitSecs === void 0 ? DEFAULT_PANE.autoExitSecs : pc.autoExitSecs
+    };
+  }
+  let routing = { ...DEFAULT_ROUTING2, order: [] };
+  if (w.routing !== void 0) {
+    if (typeof w.routing !== "object" || w.routing === null) bad(".routing", "must be an object");
+    const r = w.routing;
+    if (r.order !== void 0) {
+      if (!Array.isArray(r.order) || r.order.some((x) => typeof x !== "string")) {
+        bad(".routing.order", "must be an array of provider names");
+      }
+      routing.order = r.order;
+    }
+    if (r.cooldownMinutes !== void 0 && typeof r.cooldownMinutes !== "number") {
+      bad(".routing.cooldownMinutes", "must be a number");
+    }
+    if (r.retryOnQuota !== void 0 && typeof r.retryOnQuota !== "boolean") {
+      bad(".routing.retryOnQuota", "must be boolean");
+    }
+    routing = {
+      order: routing.order,
+      cooldownMinutes: r.cooldownMinutes === void 0 ? DEFAULT_ROUTING2.cooldownMinutes : r.cooldownMinutes,
+      retryOnQuota: r.retryOnQuota === void 0 ? DEFAULT_ROUTING2.retryOnQuota : r.retryOnQuota === true
+    };
+  }
+  const active = w.active === void 0 || w.active === null ? null : str(w.active);
+  if (active !== null && active !== "auto" && !(active in providers)) {
+  }
+  return {
+    enabled: w.enabled === void 0 ? d.enabled : w.enabled === true,
+    active,
+    providers,
+    classes,
+    mcpSets,
+    pane,
+    logDir: str(w.logDir) || d.logDir,
+    routing
+  };
+}
+function readWorkersSection() {
+  const raw = readJsonStrict(CONFIG_FILE, "~/.config/pai/config.json");
+  return { raw, workers: parseWorkersConfig(raw.workers) };
+}
+function expandHome(p) {
+  if (p === "~" || p.startsWith("~/")) return join2(homedir2(), p.slice(1));
+  return p;
+}
+
+// src/workers/paths.ts
+import { join as join3 } from "node:path";
+function workersLogDir(config) {
+  return expandHome(config.logDir);
+}
+function ledgerPath(logDir) {
+  return join3(logDir, "ledger.log");
+}
+
+// src/workers/ledger.ts
+import { appendFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2 } from "node:fs";
+import { dirname } from "node:path";
+function ledgerStamp(d = /* @__PURE__ */ new Date()) {
+  const p = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`;
+}
+function appendLedger(path, event, kv, now = /* @__PURE__ */ new Date()) {
+  const parts = [];
+  for (const [k, v] of Object.entries(kv)) {
+    if (v === void 0 || v === null) continue;
+    parts.push(`${k}=${String(v).replace(/\s+/g, " ")}`);
+  }
+  const dir = dirname(path);
+  if (!existsSync2(dir)) mkdirSync2(dir, { recursive: true });
+  const tail = parts.length ? " " + parts.join(" ") : "";
+  appendFileSync(path, `${ledgerStamp(now)} ${event}${tail}
+`, "utf8");
+}
+
+// src/hooks/ts/pre-tool-use/route-agents-to-worker.ts
+var ALLOW = JSON.stringify({ hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "allow" } });
+function deny(reason) {
+  return JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      permissionDecision: "deny",
+      permissionDecisionReason: reason
+    }
+  });
+}
+function shortLabel(input) {
+  const desc = typeof input.tool_input === "object" && input.tool_input !== null ? input.tool_input.description ?? "" : "";
+  return desc.replace(/\s+/g, " ").trim().slice(0, 60);
+}
+async function main() {
+  let text = "";
+  try {
+    for await (const chunk of process.stdin) text += chunk;
+  } catch {
+    process.stdout.write(ALLOW);
+    return;
+  }
+  if (!text.trim()) {
+    process.stdout.write(ALLOW);
+    return;
+  }
+  let input;
+  try {
+    input = JSON.parse(text);
+  } catch {
+    process.stdout.write(ALLOW);
+    return;
+  }
+  if (input.tool_name && input.tool_name !== "Agent") {
+    process.stdout.write(ALLOW);
+    return;
+  }
+  const label = shortLabel(input);
+  const cwd = input.cwd ?? process.cwd();
+  const ledger = (event) => {
+    try {
+      appendLedger(ledgerPath(workersLogDir(readWorkersSection().workers)), event, {
+        cwd,
+        ...label ? { label } : {}
+      });
+    } catch {
+    }
+  };
+  if (process.env.ALLOW_ANTHROPIC_AGENTS === "1") {
+    ledger("ALLOWED-ANTHROPIC-AGENT");
+    process.stdout.write(ALLOW);
+    return;
+  }
+  let workers;
+  try {
+    workers = readWorkersSection().workers;
+  } catch {
+    process.stdout.write(ALLOW);
+    return;
+  }
+  if (!workers.enabled || Object.keys(workers.providers).length === 0) {
+    process.stdout.write(ALLOW);
+    return;
+  }
+  ledger("DENIED-ANTHROPIC-AGENT");
+  process.stdout.write(
+    deny(
+      `Agent tool is disabled: subagents run on the configured worker provider, not Anthropic. Delegate with Bash instead, in the background:
+
+pai worker run --label "${label || "task"}" --role research -p '<full, self-contained task spec>' --allowedTools 'Read,Edit,Write,Bash,Grep,Glob' --output-format json
+
+- Run it with run_in_background: true and always with a timeout.
+- Use --role spotcheck (or implement) as the task demands.
+- Web research: add WebSearch,WebFetch to --allowedTools.
+- The answer is in the \`result\` field of the JSON it prints. Review the diff yourself.
+- pai worker ps lists running workers; pai worker follow <id> shows one live.
+Keep only orchestration, review and synthesis in this session. To run subagents on Anthropic for one session: start it with ALLOW_ANTHROPIC_AGENTS=1.`
+    )
+  );
+}
+main().catch(() => process.stdout.write(ALLOW));
+//# sourceMappingURL=route-agents-to-worker.mjs.map