crewdesk 0.1.0

package/packages/hook/dist/hook.js

@@ -0,0 +1,457 @@
+// src/handlers.ts
+import fs3 from "node:fs";
+import path3 from "node:path";
+
+// ../shared/src/operations.ts
+function summarizeToolInput(toolName, input) {
+  const str = (k) => typeof input[k] === "string" ? input[k] : void 0;
+  switch (toolName) {
+    case "Bash":
+    case "PowerShell":
+      return str("command") ?? "";
+    case "Write":
+    case "Edit":
+    case "MultiEdit":
+    case "Read":
+    case "NotebookEdit":
+      return str("file_path") ?? str("notebook_path") ?? "";
+    case "WebFetch":
+      return str("url") ?? "";
+    case "WebSearch":
+      return str("query") ?? "";
+    case "Glob":
+    case "Grep":
+      return str("pattern") ?? "";
+    default: {
+      const json = JSON.stringify(input);
+      return json.length > 500 ? json.slice(0, 497) + "..." : json;
+    }
+  }
+}
+var DESTRUCTIVE_PATTERNS = [
+  [/\brm\s+(-[a-z]*[rf][a-z]*\s+)+/i, "Recursive or forced file deletion"],
+  [/\brm\s+/i, "Deletes files"],
+  [/\bRemove-Item\b/i, "Deletes files"],
+  [/\b(del|erase|rmdir|rd)\s+/i, "Deletes files"],
+  [/\bgit\s+(reset\s+--hard|clean\s+-[a-z]*f|push\s+(.*\s)?(-f|--force)|branch\s+-D|checkout\s+--\s)/i, "Discards git history or changes"],
+  [/\b(drop|truncate)\s+(table|database|schema)\b/i, "Drops database objects"],
+  [/\bdelete\s+from\b/i, "Deletes database rows"],
+  [/\bmkfs\b|\bformat\s+[a-z]:/i, "Formats a filesystem"],
+  [/\bdd\s+if=/i, "Raw disk write"],
+  [/\bchmod\s+-R\b|\bchown\s+-R\b/i, "Recursive permission change"],
+  [/>\s*\/dev\/sd[a-z]/i, "Writes to a block device"],
+  [/\b(shutdown|reboot|Stop-Computer|Restart-Computer)\b/i, "Shuts down or restarts the machine"],
+  [/\bkill(all)?\s+-9\b|\bStop-Process\b|\btaskkill\b/i, "Kills processes"],
+  [/\bnpm\s+publish\b|\bpnpm\s+publish\b/i, "Publishes a package"]
+];
+function assessRisk(toolName, input) {
+  if (toolName === "Bash" || toolName === "PowerShell") {
+    const cmd = typeof input.command === "string" ? input.command : "";
+    for (const [re, reason] of DESTRUCTIVE_PATTERNS) {
+      if (re.test(cmd)) return { destructive: true, reason };
+    }
+  }
+  return { destructive: false };
+}
+
+// src/client.ts
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+var RETRY_DELAYS_MS = [100, 500, 1e3, 2e3];
+function hubHome() {
+  return process.env.CREWDESK_HOME ?? path.join(os.homedir(), ".crewdesk");
+}
+function hubUrl() {
+  if (process.env.CREWDESK_URL) return process.env.CREWDESK_URL.replace(/\/+$/, "");
+  let host = "127.0.0.1";
+  let port = 7777;
+  try {
+    const cfg = JSON.parse(fs.readFileSync(path.join(hubHome(), "config.json"), "utf8"));
+    if (typeof cfg.host === "string") host = cfg.host;
+    if (typeof cfg.port === "number") port = cfg.port;
+  } catch {
+  }
+  if (process.env.CREWDESK_PORT) port = Number(process.env.CREWDESK_PORT);
+  if (host === "0.0.0.0") host = "127.0.0.1";
+  return `http://${host}:${port}`;
+}
+var HubUnavailable = class extends Error {
+};
+var HubHttpError = class extends Error {
+  constructor(status, body) {
+    super(`hub responded ${status}: ${JSON.stringify(body)}`);
+    this.status = status;
+    this.body = body;
+  }
+  status;
+  body;
+};
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function request(method, url, body, opts = {}) {
+  const retries = opts.retries ?? RETRY_DELAYS_MS;
+  let lastErr;
+  for (let attempt = 0; attempt <= retries.length; attempt++) {
+    if (attempt > 0) await sleep(retries[attempt - 1]);
+    try {
+      const res = await fetch(hubUrl() + url, {
+        method,
+        headers: body !== void 0 ? { "content-type": "application/json" } : {},
+        body: body !== void 0 ? JSON.stringify(body) : void 0,
+        signal: AbortSignal.timeout(opts.timeoutMs ?? 5e3)
+      });
+      const text = await res.text();
+      const json = text ? JSON.parse(text) : void 0;
+      if (!res.ok) {
+        if (res.status >= 500) {
+          lastErr = new HubHttpError(res.status, json);
+          continue;
+        }
+        throw new HubHttpError(res.status, json);
+      }
+      return json;
+    } catch (err) {
+      if (err instanceof HubHttpError && err.status < 500) throw err;
+      lastErr = err;
+    }
+  }
+  throw new HubUnavailable(`hub unavailable at ${hubUrl()}: ${lastErr?.message ?? lastErr}`);
+}
+function debugLog(msg) {
+  if (!process.env.CREWDESK_HOOK_DEBUG) return;
+  try {
+    const file = path.join(hubHome(), "logs", "hook.log");
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.appendFileSync(file, `${(/* @__PURE__ */ new Date()).toISOString()} [${process.pid}] ${msg}
+`);
+  } catch {
+  }
+}
+
+// src/session.ts
+import { execFileSync } from "node:child_process";
+import fs2 from "node:fs";
+import path2 from "node:path";
+function sessionCacheFile(sessionId) {
+  return path2.join(hubHome(), "sessions", `${sessionId.replace(/[^A-Za-z0-9_.-]/g, "_")}.json`);
+}
+function readSessionCache(sessionId) {
+  try {
+    return JSON.parse(fs2.readFileSync(sessionCacheFile(sessionId), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeSessionCache(sessionId, data) {
+  try {
+    const file = sessionCacheFile(sessionId);
+    fs2.mkdirSync(path2.dirname(file), { recursive: true });
+    fs2.writeFileSync(file, JSON.stringify(data));
+  } catch {
+  }
+}
+function removeSessionCache(sessionId) {
+  try {
+    fs2.rmSync(sessionCacheFile(sessionId), { force: true });
+  } catch {
+  }
+}
+function agentMeta(input, pid) {
+  const cwd = process.env.CLAUDE_PROJECT_DIR || input.cwd || process.cwd();
+  const configDir = process.env.CLAUDE_CONFIG_DIR;
+  return {
+    name: process.env.CREWDESK_AGENT_NAME || void 0,
+    project: process.env.CREWDESK_PROJECT || path2.basename(cwd),
+    cwd,
+    pid: pid ?? readSessionCache(input.session_id).pid,
+    account: configDir ? path2.basename(configDir) : void 0,
+    source: "hook"
+  };
+}
+function processTable() {
+  const table = /* @__PURE__ */ new Map();
+  if (process.platform === "win32") {
+    const out = execFileSync(
+      "powershell.exe",
+      [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        'Get-CimInstance Win32_Process | ForEach-Object { "$($_.ProcessId)`t$($_.ParentProcessId)`t$($_.Name)" }'
+      ],
+      { encoding: "utf8", timeout: 8e3, windowsHide: true }
+    );
+    for (const line of out.split(/\r?\n/)) {
+      const [pid, ppid, name] = line.split("	");
+      if (pid && ppid) table.set(Number(pid), { pid: Number(pid), ppid: Number(ppid), name: name ?? "" });
+    }
+  } else {
+    const out = execFileSync("ps", ["-A", "-o", "pid=,ppid=,args="], { encoding: "utf8", timeout: 5e3 });
+    for (const line of out.split("\n")) {
+      const m = line.trim().match(/^(\d+)\s+(\d+)\s+(\S+)/);
+      if (m) table.set(Number(m[1]), { pid: Number(m[1]), ppid: Number(m[2]), name: path2.basename(m[3]) });
+    }
+  }
+  return table;
+}
+function findClaudePid() {
+  if (process.env.CREWDESK_CLAUDE_PID) return Number(process.env.CREWDESK_CLAUDE_PID) || void 0;
+  if (process.env.CLAUDE_PID && Number(process.env.CLAUDE_PID) > 0) return Number(process.env.CLAUDE_PID);
+  try {
+    const table = processTable();
+    let cur = table.get(process.pid);
+    const seen = /* @__PURE__ */ new Set();
+    let nodeCandidate;
+    while (cur && !seen.has(cur.pid)) {
+      seen.add(cur.pid);
+      const name = cur.name.toLowerCase();
+      if (cur.pid !== process.pid) {
+        if (/^claude(\.exe)?$/.test(name)) return cur.pid;
+        if (!nodeCandidate && /^(node|bun)(\.exe)?$/.test(name)) nodeCandidate = cur.pid;
+      }
+      cur = table.get(cur.ppid);
+    }
+    return nodeCandidate;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/handlers.ts
+function hookSettings() {
+  let cfg = {};
+  try {
+    cfg = JSON.parse(fs3.readFileSync(path3.join(hubHome(), "config.json"), "utf8"));
+  } catch {
+  }
+  const num = (env, key, dflt) => {
+    const v = process.env[env] ?? cfg[key];
+    const n = Number(v);
+    return v !== void 0 && v !== "" && Number.isFinite(n) && n >= 0 ? n : dflt;
+  };
+  const idleEnv = process.env.CREWDESK_IDLE_PROMPTS;
+  return {
+    questionWaitSeconds: num("CREWDESK_QUESTION_WAIT", "questionWaitSeconds", 600),
+    idleWaitSeconds: num("CREWDESK_IDLE_WAIT", "idleWaitSeconds", 1800),
+    permissionWaitSeconds: num("CREWDESK_PERMISSION_WAIT", "permissionWaitSeconds", 43200),
+    idlePrompts: idleEnv !== void 0 && idleEnv !== "" ? /^(1|true|yes|on)$/i.test(idleEnv) : cfg.idlePrompts !== false
+  };
+}
+async function createEvent(input, body) {
+  const res = await request("POST", "/api/events", {
+    sessionId: input.session_id,
+    agent: agentMeta(input),
+    ...body
+  });
+  return res.event;
+}
+async function waitForDecision(ev, sessionId, maxWaitMs) {
+  const deadline = Date.now() + maxWaitMs;
+  let failures = 0;
+  while (Date.now() < deadline) {
+    const pollMs = Math.max(0, Math.min(25e3, deadline - Date.now()));
+    try {
+      const r = await request(
+        "GET",
+        `/api/events/${ev.id}/wait?sessionId=${encodeURIComponent(sessionId)}&timeout=${pollMs}`,
+        void 0,
+        { timeoutMs: pollMs + 1e4, retries: [] }
+      );
+      failures = 0;
+      if (r.state === "resolved") return r.response;
+      if (r.state === "cancelled") return null;
+    } catch (err) {
+      if (err instanceof HubHttpError) return null;
+      failures++;
+      if (failures > 30) return null;
+      await sleep(Math.min(2e3, 100 * 2 ** failures));
+    }
+  }
+  await request("POST", `/api/events/${ev.id}/cancel`, { sessionId, reason: "Timed out waiting; continuing in the terminal." }, { retries: [] }).catch(() => {
+  });
+  return null;
+}
+async function onSessionStart(input) {
+  const pid = findClaudePid();
+  writeSessionCache(input.session_id, { pid });
+  const meta = agentMeta(input, pid);
+  await request("POST", "/api/agents/register", { sessionId: input.session_id, ...meta });
+  return null;
+}
+async function onSessionEnd(input) {
+  removeSessionCache(input.session_id);
+  await request(
+    "POST",
+    "/api/events",
+    { sessionId: input.session_id, type: "session.stopped", message: `Session ended (${input.reason ?? "exit"})`, agent: agentMeta(input) },
+    { retries: [], timeoutMs: 1e3 }
+  );
+  return null;
+}
+async function onPromptSubmit(input) {
+  await createEvent(input, { type: "task.started", message: String(input.prompt ?? "").slice(0, 2e3) });
+  return null;
+}
+var QUIET_NOTIFICATIONS = /* @__PURE__ */ new Set(["permission_prompt", "idle_prompt"]);
+async function onNotification(input) {
+  const notificationType = String(input.notification_type ?? input.type ?? "");
+  await createEvent(input, {
+    type: "notification.created",
+    message: String(input.message ?? "Claude needs your attention"),
+    // Permission/idle notifications duplicate requests the hub already shows; log them silently.
+    payload: { notificationType, silent: QUIET_NOTIFICATIONS.has(notificationType) }
+  });
+  return null;
+}
+async function onPermission(input) {
+  const toolName = String(input.tool_name ?? "");
+  const toolInput = input.tool_input ?? {};
+  if (toolName === "AskUserQuestion") return null;
+  const summary = summarizeToolInput(toolName, toolInput);
+  const risk = assessRisk(toolName, toolInput);
+  const ev = await createEvent(input, {
+    type: "permission.created",
+    message: `${toolName}: ${summary}`.slice(0, 2e3),
+    payload: {
+      toolName,
+      toolInput,
+      summary,
+      cwd: input.cwd,
+      destructive: risk.destructive,
+      destructiveReason: risk.reason,
+      permissionMode: input.permission_mode,
+      transport: "hook"
+    }
+  });
+  const response = ev.response && (ev.status === "PROCESSING" || ev.status === "RESOLVED") ? ev.response : await waitForDecision(ev, input.session_id, hookSettings().permissionWaitSeconds * 1e3);
+  if (!response) return null;
+  if (response.action === "allow") {
+    return { hookSpecificOutput: { hookEventName: "PermissionRequest", decision: { behavior: "allow" } } };
+  }
+  if (response.action === "deny") {
+    const via = response.source === "policy" ? "a Crewdesk policy" : "Crewdesk";
+    return {
+      hookSpecificOutput: {
+        hookEventName: "PermissionRequest",
+        decision: { behavior: "deny", message: response.response ? `Denied by ${via}: ${response.response}` : `Denied by ${via}.` }
+      }
+    };
+  }
+  return null;
+}
+function buildAnswers(questions, response) {
+  const answers = {};
+  for (const q of questions) {
+    const a = response.answers?.[q.question] ?? response.response;
+    if (a) answers[q.question] = a;
+  }
+  return answers;
+}
+async function onQuestion(input) {
+  if (input.tool_name !== "AskUserQuestion") return null;
+  const toolInput = input.tool_input ?? {};
+  const questions = Array.isArray(toolInput.questions) ? toolInput.questions : [];
+  if (questions.length === 0) return null;
+  const ev = await createEvent(input, {
+    type: "question.created",
+    message: questions.map((q) => q.question).join("\n"),
+    payload: { questions, transport: "hook" }
+  });
+  const response = await waitForDecision(ev, input.session_id, hookSettings().questionWaitSeconds * 1e3);
+  if (!response || response.action !== "answer") return null;
+  const answers = buildAnswers(questions, response);
+  if (Object.keys(answers).length === 0) return null;
+  return {
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      permissionDecision: "allow",
+      permissionDecisionReason: "Answered from Crewdesk",
+      updatedInput: { ...toolInput, answers }
+    }
+  };
+}
+async function onStop(input) {
+  const settings = hookSettings();
+  const last = typeof input.last_assistant_message === "string" ? input.last_assistant_message : "";
+  const message = last.length > 4e3 ? last.slice(0, 3997) + "..." : last;
+  await createEvent(input, { type: "task.completed", message: message.slice(0, 500) || "Turn finished" });
+  if (!settings.idlePrompts || settings.idleWaitSeconds <= 0) return null;
+  const ev = await createEvent(input, {
+    type: "prompt.created",
+    message: message || "Claude finished and is waiting for your next instruction.",
+    payload: { lastMessage: message, stopHookActive: Boolean(input.stop_hook_active), transport: "hook" }
+  });
+  const response = await waitForDecision(ev, input.session_id, settings.idleWaitSeconds * 1e3);
+  if (!response || response.action !== "prompt" || !response.response?.trim()) return null;
+  return { decision: "block", reason: response.response };
+}
+var HANDLERS = {
+  register: onSessionStart,
+  "session-start": onSessionStart,
+  "session-end": onSessionEnd,
+  end: onSessionEnd,
+  prompt: onPromptSubmit,
+  notification: onNotification,
+  permission: onPermission,
+  question: onQuestion,
+  stop: onStop
+};
+
+// src/cli.ts
+var USAGE = `crewdesk-hook <command>
+
+Claude Code hook bridge for Crewdesk. Reads the hook JSON from stdin.
+
+Commands:
+  register       SessionStart: register the session with the hub
+  permission     PermissionRequest: forward and wait for Allow/Deny
+  question       PreToolUse(AskUserQuestion): answer from the dashboard
+  notification   Notification: forward notifications
+  prompt         UserPromptSubmit: mark the session as working
+  stop           Stop: report completion and wait for a follow-up prompt
+  session-end    SessionEnd: mark the session offline
+
+Environment:
+  CREWDESK_URL          hub base URL (default http://127.0.0.1:7777)
+  CREWDESK_AGENT_NAME   display name for this session
+  CREWDESK_HOOK_DEBUG   log to ~/.crewdesk/logs/hook.log
+`;
+async function readStdin() {
+  if (process.stdin.isTTY) return "";
+  const chunks = [];
+  for await (const c of process.stdin) chunks.push(c);
+  return Buffer.concat(chunks).toString("utf8");
+}
+async function main() {
+  const cmd = process.argv[2];
+  if (!cmd || cmd === "--help" || cmd === "-h") {
+    process.stdout.write(USAGE);
+    return cmd ? 0 : 1;
+  }
+  const handler = HANDLERS[cmd];
+  if (!handler) {
+    process.stderr.write(`crewdesk-hook: unknown command "${cmd}"
+`);
+    return 0;
+  }
+  let input;
+  try {
+    input = JSON.parse(await readStdin());
+    if (!input || typeof input.session_id !== "string") throw new Error("missing session_id");
+  } catch (err) {
+    debugLog(`${cmd}: bad stdin: ${err.message}`);
+    return 0;
+  }
+  try {
+    const out = await handler(input);
+    debugLog(`${cmd}: ${out ? JSON.stringify(out) : "no output"}`);
+    if (out) await new Promise((r) => process.stdout.write(JSON.stringify(out), () => r()));
+  } catch (err) {
+    debugLog(`${cmd}: ${err.message}`);
+  }
+  return 0;
+}
+main().then(
+  (code) => process.exit(code),
+  () => process.exit(0)
+);