@orchestrator-claude/definitions 3.32.2 → 3.33.0

package/hooks/subagent-start.mjs

@@ -0,0 +1,289 @@
+import { createRequire as __createRequireShim } from 'node:module'; const require = __createRequireShim(import.meta.url);
+
+// hooks/lib/api-client.ts
+import { readFileSync, writeFileSync, mkdirSync, statSync, unlinkSync, readdirSync } from "node:fs";
+import { join as join2, dirname as dirname2 } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// ../project-root-resolver/dist/index.js
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+function resolveProjectRoot(cwd, sentinel = ".orchestrator") {
+  let currentDir = cwd;
+  for (; ; ) {
+    if (existsSync(join(currentDir, sentinel))) {
+      return currentDir;
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+
+// hooks/lib/api-client.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname2(__filename);
+var PROJECT_ROOT = join2(__dirname, "..", "..", "..");
+var STATE_DIR = join2(PROJECT_ROOT, ".orchestrator", ".state");
+var JWT_CACHE = join2(STATE_DIR, "jwt-token");
+var DEBUG_LOG = join2(STATE_DIR, "hook-debug.log");
+mkdirSync(STATE_DIR, { recursive: true });
+var API_URL = process.env.ORCHESTRATOR_API_URL || "http://localhost:3001";
+var AUTH_EMAIL = process.env.ORCHESTRATOR_ADMIN_EMAIL || process.env.ORCHESTRATOR_AUTH_EMAIL || "system@orchestrator.local";
+var AUTH_PASSWORD = process.env.ORCHESTRATOR_ADMIN_PASSWORD || process.env.ORCHESTRATOR_AUTH_PASSWORD || "system123";
+var PROJECT_ID = process.env.ORCHESTRATOR_PROJECT_ID || "";
+function resolveHookProjectRoot(cwd) {
+  return resolveProjectRoot(cwd);
+}
+var projectIdResolutionAttempted = false;
+async function ensureProjectIdResolved(token) {
+  if (PROJECT_ID || projectIdResolutionAttempted) return;
+  projectIdResolutionAttempted = true;
+  try {
+    const rootPath = resolveHookProjectRoot(process.cwd());
+    if (rootPath === null) {
+      log(
+        "API-CLIENT",
+        "ensureProjectIdResolved: cwd not registered (.orchestrator sentinel not found) \u2014 skipping"
+      );
+      return;
+    }
+    const resolved = await resolveProjectIdByPath(rootPath, token);
+    if (resolved) {
+      PROJECT_ID = resolved;
+      log(
+        "API-CLIENT",
+        `ensureProjectIdResolved: resolved projectId=${resolved} rootPath=${rootPath}`
+      );
+    } else {
+      log(
+        "API-CLIENT",
+        `ensureProjectIdResolved: rootPath=${rootPath} not registered to any project \u2014 skipping`
+      );
+    }
+  } catch (err) {
+    log(
+      "API-CLIENT",
+      `ensureProjectIdResolved: unexpected failure \u2014 ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+function log(prefix, msg) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d+Z$/, "Z");
+  try {
+    const line = `[${ts}] ${prefix}: ${msg}
+`;
+    writeFileSync(DEBUG_LOG, line, { flag: "a" });
+  } catch {
+  }
+}
+function getCachedToken() {
+  try {
+    const stat = statSync(JWT_CACHE);
+    const ageMs = Date.now() - stat.mtimeMs;
+    if (ageMs < 35e5) {
+      return readFileSync(JWT_CACHE, "utf-8").trim();
+    }
+  } catch {
+  }
+  return null;
+}
+async function login() {
+  try {
+    const resp = await fetch(`${API_URL}/api/v1/auth/login`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Project-ID": PROJECT_ID
+      },
+      body: JSON.stringify({ email: AUTH_EMAIL, password: AUTH_PASSWORD }),
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!resp.ok) return null;
+    const data = await resp.json();
+    const token = data.accessToken || data.data?.accessToken || "";
+    if (token) {
+      writeFileSync(JWT_CACHE, token);
+    }
+    return token || null;
+  } catch {
+    return null;
+  }
+}
+async function getToken() {
+  const token = getCachedToken() || await login();
+  if (token) {
+    await ensureProjectIdResolved(token);
+  }
+  return token;
+}
+async function apiGet(path, token, timeoutMs = 5e3) {
+  try {
+    const resp = await fetch(`${API_URL}${path}`, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "X-Project-ID": PROJECT_ID
+      },
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (!resp.ok) return null;
+    return await resp.json();
+  } catch {
+    return null;
+  }
+}
+async function apiPost(path, token, body, timeoutMs = 5e3) {
+  try {
+    const resp = await fetch(`${API_URL}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`,
+        "X-Project-ID": PROJECT_ID
+      },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (!resp.ok) return null;
+    return await resp.json();
+  } catch {
+    return null;
+  }
+}
+async function resolveProjectIdByPath(rootPath, token) {
+  const resp = await apiGet(
+    `/api/v1/projects/resolve?rootPath=${encodeURIComponent(rootPath)}`,
+    token
+  );
+  return resp?.projectId ?? null;
+}
+async function getActiveWorkflow() {
+  const token = await getToken();
+  if (!token) return null;
+  for (const status of ["in_progress", "awaiting_agent", "awaiting_approval"]) {
+    const resp = await apiGet(
+      `/api/v1/workflows?status=${status}&limit=1`,
+      token,
+      3e3
+    );
+    const list = resp?.data || (Array.isArray(resp) ? resp : null);
+    const wf = list?.[0];
+    if (wf?.id) return wf;
+  }
+  return null;
+}
+var LAST_COMPLETED_FILE = join2(STATE_DIR, "last-completed-workflow.json");
+var LAST_COMPLETED_TTL_MS = 60 * 60 * 1e3;
+var INVOCATIONS_DIR = join2(STATE_DIR, "invocations");
+function buildInvocationStatePath(stateDir, workflowId, agentType) {
+  return join2(stateDir, "invocations", `${workflowId}-${agentType}.json`);
+}
+function writeInvocationState(workflowId, agentType, invocationId) {
+  try {
+    mkdirSync(INVOCATIONS_DIR, { recursive: true });
+    const path = buildInvocationStatePath(STATE_DIR, workflowId, agentType);
+    const payload = {
+      invocationId,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      agentType,
+      workflowId
+    };
+    writeFileSync(path, JSON.stringify(payload), "utf-8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+var INVOCATION_STATE_TTL_MS = 4 * 60 * 60 * 1e3;
+var DISPATCH_INTENT_DIR = join2(STATE_DIR, "dispatch-intent");
+async function startInvocation(agentType, workflowId, phase) {
+  const token = await getToken();
+  if (!token) {
+    log(
+      "API-CLIENT",
+      `startInvocation: no token \u2014 skipping (agent=${agentType} workflow=${workflowId})`
+    );
+    return null;
+  }
+  const resp = await apiPost(`/api/v1/invocations/start`, token, {
+    agentName: agentType,
+    workflowId,
+    phase
+  });
+  if (!resp) {
+    log(
+      "API-CLIENT",
+      `startInvocation: POST failed \u2014 agent=${agentType} workflow=${workflowId} phase=${phase}`
+    );
+    return null;
+  }
+  const invocationId = typeof resp.invocationId === "string" && resp.invocationId.length > 0 ? resp.invocationId : null;
+  if (!invocationId) {
+    log(
+      "API-CLIENT",
+      `startInvocation: response missing invocationId \u2014 agent=${agentType} workflow=${workflowId}`
+    );
+  }
+  return invocationId;
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  const raw = Buffer.concat(chunks).toString("utf-8").trim();
+  if (!raw) return {};
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function getField(obj, path) {
+  const parts = path.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current == null || typeof current !== "object") return "";
+    current = current[part];
+  }
+  return current != null ? String(current) : "";
+}
+
+// hooks/subagent-start.ts
+var HOOK = "SUBAGENT-START";
+var PHASE_MAP = {
+  specifier: "specify",
+  planner: "plan",
+  "task-generator": "tasks",
+  implementer: "implement",
+  researcher: "research",
+  reviewer: "review"
+};
+async function main() {
+  const stdin = await readStdin();
+  log(HOOK, `SubagentStart triggered`);
+  const agentType = getField(stdin, "tool_input.subagent_type") || getField(stdin, "subagent_type") || getField(stdin, "tool_input.type") || "unknown";
+  const phase = PHASE_MAP[agentType] || agentType;
+  log(HOOK, `agent=${agentType} phase=${phase}`);
+  const workflow = await getActiveWorkflow();
+  if (!workflow) {
+    log(HOOK, "No active workflow, skipping");
+    return;
+  }
+  const invocationId = await startInvocation(agentType, workflow.id, phase);
+  if (invocationId) {
+    const written = writeInvocationState(workflow.id, agentType, invocationId);
+    log(
+      HOOK,
+      `START: agent=${agentType} phase=${phase} workflow=${workflow.id} invocationId=${invocationId} stateWritten=${written}`
+    );
+  } else {
+    log(
+      HOOK,
+      `START: agent=${agentType} phase=${phase} workflow=${workflow.id} \u2014 startInvocation returned null (POST failed or no token)`
+    );
+  }
+}
+main().catch(() => process.exit(0));