@tekmidian/pai 0.41.0 → 0.42.0

package/dist/hooks/worker-supervision.mjs

@@ -0,0 +1,593 @@
+#!/usr/bin/env node
+
+// src/hooks/ts/user-prompt/worker-supervision.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+
+// src/hooks/ts/lib/worker-session.ts
+function isWorkerSession(env = process.env) {
+  return env.PAI_WORKER === "1";
+}
+
+// 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 MODEL_TIERS = ["haiku", "sonnet", "opus"];
+var PROVIDER_TAGS = [
+  "code",
+  "vision",
+  "image-gen",
+  "long-context",
+  "fast",
+  "reasoning"
+];
+var MODEL_CAPABILITIES = ["default", "fast", "image"];
+function isModelCapability(v) {
+  return MODEL_CAPABILITIES.includes(v);
+}
+var DEFAULT_LOG_DIR = "~/.claude/logs/workers";
+var DEFAULT_PANE = {
+  enabled: true,
+  fontSize: 13,
+  autoExitSecs: 60
+};
+var DEFAULT_ROUTING2 = {
+  order: [],
+  cooldownMinutes: 30,
+  retryOnQuota: true
+};
+var DEFAULT_TREE = {
+  maxDepth: 2,
+  maxChildren: 4
+};
+var DEFAULT_MCP_SETS = {
+  desktop: ["clickr"]
+};
+function defaultWorkersConfig() {
+  return {
+    enabled: false,
+    active: null,
+    providers: {},
+    classes: {},
+    mcpSets: { ...DEFAULT_MCP_SETS },
+    pane: { ...DEFAULT_PANE },
+    logDir: DEFAULT_LOG_DIR,
+    routing: { ...DEFAULT_ROUTING2, order: [] },
+    tree: { ...DEFAULT_TREE },
+    fallback: null
+  };
+}
+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 models = { default: defaultModel };
+  for (const key of Object.keys(m)) {
+    if (key === "default") continue;
+    if (!isModelCapability(key)) {
+      bad(
+        `.providers.${name}.models.${key}`,
+        `"${key}" is not a model capability (from: ${MODEL_CAPABILITIES.join(", ")})`
+      );
+    }
+    const id = str(m[key]);
+    if (!id) bad(`.providers.${name}.models.${key}`, "must be a non-empty model id");
+    models[key] = id;
+  }
+  let modelTiers;
+  if (p.modelTiers !== void 0) {
+    if (typeof p.modelTiers !== "object" || p.modelTiers === null || Array.isArray(p.modelTiers)) {
+      bad(`.providers.${name}.modelTiers`, "must be an object of model id \u2192 haiku | sonnet | opus");
+    }
+    modelTiers = {};
+    for (const [id, tier] of Object.entries(p.modelTiers)) {
+      if (typeof tier !== "string" || !MODEL_TIERS.includes(tier)) {
+        bad(
+          `.providers.${name}.modelTiers.${id}`,
+          `must be "haiku", "sonnet" or "opus" (got ${JSON.stringify(tier)})`
+        );
+      }
+      modelTiers[id] = tier;
+    }
+  }
+  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,
+    ...modelTiers ? { modelTiers } : {},
+    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 = { ...DEFAULT_MCP_SETS };
+  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
+    };
+  }
+  let tree = { ...DEFAULT_TREE };
+  if (w.tree !== void 0) {
+    if (typeof w.tree !== "object" || w.tree === null || Array.isArray(w.tree)) {
+      bad(".tree", "must be an object");
+    }
+    const t = w.tree;
+    if (t.maxDepth !== void 0) {
+      if (typeof t.maxDepth !== "number" || !Number.isInteger(t.maxDepth) || t.maxDepth < 0) {
+        bad(".tree.maxDepth", "must be a non-negative integer");
+      }
+    }
+    if (t.maxChildren !== void 0) {
+      if (typeof t.maxChildren !== "number" || !Number.isInteger(t.maxChildren) || t.maxChildren < 1) {
+        bad(".tree.maxChildren", "must be a positive integer");
+      }
+    }
+    tree = {
+      maxDepth: t.maxDepth === void 0 ? DEFAULT_TREE.maxDepth : t.maxDepth,
+      maxChildren: t.maxChildren === void 0 ? DEFAULT_TREE.maxChildren : t.maxChildren
+    };
+  }
+  const active = w.active === void 0 || w.active === null ? null : str(w.active);
+  if (active !== null && active !== "auto" && !(active in providers)) {
+  }
+  let fallback = null;
+  if (w.fallback !== void 0 && w.fallback !== null) {
+    if (typeof w.fallback !== "object" || Array.isArray(w.fallback)) {
+      bad(".fallback", "must be an object (written by `pai worker fallback on`)");
+    }
+    const f = w.fallback;
+    const provider = str(f.provider);
+    if (!provider) bad(".fallback.provider", "is required");
+    const savedRaw = f.saved;
+    if (typeof savedRaw !== "object" || savedRaw === null || Array.isArray(savedRaw)) {
+      bad(".fallback.saved", "must be an object");
+    }
+    const s = savedRaw;
+    if (typeof s.env !== "object" || s.env === null || Array.isArray(s.env)) {
+      bad(".fallback.saved.env", "must be an object of env key \u2192 previous value or null");
+    }
+    const env = {};
+    for (const [k, v] of Object.entries(s.env)) {
+      env[k] = v === null || typeof v === "string" ? v : null;
+    }
+    if (s.model !== null && s.model !== void 0 && typeof s.model !== "string") {
+      bad(".fallback.saved.model", "must be a string or null");
+    }
+    fallback = {
+      provider,
+      saved: {
+        env,
+        model: typeof s.model === "string" ? s.model : null,
+        envExisted: s.envExisted === true
+      },
+      on: str(f.on) || (/* @__PURE__ */ new Date(0)).toISOString()
+    };
+  }
+  return {
+    enabled: w.enabled === void 0 ? d.enabled : w.enabled === true,
+    active,
+    providers,
+    classes,
+    mcpSets,
+    pane,
+    logDir: str(w.logDir) || d.logDir,
+    routing,
+    tree,
+    fallback
+  };
+}
+function readWorkersSection(path = CONFIG_FILE) {
+  const raw = readJsonStrict(path, "~/.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
+function workersLogDir(config) {
+  return expandHome(config.logDir);
+}
+
+// src/hooks/ts/user-prompt/worker-supervision.ts
+function readCursor(path) {
+  try {
+    return Math.max(0, Number(readFileSync2(path, "utf8").trim()) || 0);
+  } catch {
+    return 0;
+  }
+}
+function main() {
+  if (isWorkerSession()) return;
+  let raw = "";
+  try {
+    raw = readFileSync2(0, "utf8");
+  } catch {
+    return;
+  }
+  if (!raw.trim()) return;
+  let input;
+  try {
+    input = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  const session = input.session_id;
+  if (!session) return;
+  let logDir;
+  try {
+    logDir = workersLogDir(readWorkersSection().workers);
+  } catch {
+    return;
+  }
+  const dir = join3(logDir, "supervision");
+  const eventsPath = join3(dir, `${session}.events`);
+  const cursorPath = join3(dir, `${session}.cursor`);
+  if (!existsSync2(eventsPath)) return;
+  let lines;
+  try {
+    lines = readFileSync2(eventsPath, "utf8").split("\n").filter((l) => l.trim());
+  } catch {
+    return;
+  }
+  const fresh = lines.slice(readCursor(cursorPath));
+  if (fresh.length === 0) return;
+  let pushedIds = /* @__PURE__ */ new Set();
+  try {
+    pushedIds = new Set(
+      readFileSync2(join3(dir, `${session}.pushed`), "utf8").split("\n").map((l) => l.trim()).filter(Boolean)
+    );
+  } catch {
+  }
+  const texts = fresh.map((l) => {
+    try {
+      const ev = JSON.parse(l);
+      if (ev.id && pushedIds.has(ev.id)) return null;
+      return ev.text ?? null;
+    } catch {
+      return null;
+    }
+  }).filter((t) => t !== null);
+  try {
+    writeFileSync2(cursorPath, String(lines.length), "utf8");
+  } catch {
+  }
+  if (texts.length === 0) return;
+  process.stdout.write(
+    `<system-reminder>
+WORKER EVENTS (delivered by the daemon's supervision \u2014 no polling needed):
+` + texts.join("\n") + `
+</system-reminder>
+`
+  );
+}
+main();
+//# sourceMappingURL=worker-supervision.mjs.map