agent-kanban 1.0.0

package/src/processManager.ts

@@ -0,0 +1,222 @@
+import { spawn, type ChildProcess } from "child_process";
+import type { ApiClient, AgentClient } from "./client.js";
+
+// Agent Process Lifecycle:
+//   SPAWN → stdin task notification → RUNNING
+//     agent claims task via CLI, works, completes via CLI
+//     stdout (stream-json) → parse events → POST /messages
+//   EXIT(0) → log success → cleanup
+//   EXIT(N) → POST /release (crash recovery) → cleanup
+//   KILL (shutdown) → POST /release → cleanup
+
+export interface AgentProcess {
+  taskId: string;
+  sessionId: string;
+  process: ChildProcess;
+  agentClient?: AgentClient;
+  timeoutTimer?: ReturnType<typeof setTimeout>;
+}
+
+export class ProcessManager {
+  private agents = new Map<string, AgentProcess>();
+  private client: ApiClient;
+  private agentCli: string;
+  private onSlotFreed: () => void;
+  private taskTimeoutMs: number;
+
+  constructor(client: ApiClient, agentCli: string, onSlotFreed: () => void, taskTimeoutMs = 2 * 60 * 60 * 1000) {
+    this.client = client;
+    this.agentCli = agentCli;
+    this.onSlotFreed = onSlotFreed;
+    this.taskTimeoutMs = taskTimeoutMs;
+  }
+
+  get activeCount(): number {
+    return this.agents.size;
+  }
+
+  hasTask(taskId: string): boolean {
+    return this.agents.has(taskId);
+  }
+
+  async spawnAgent(
+    taskId: string,
+    sessionId: string,
+    cwd: string,
+    taskContext: string,
+    agentClient?: AgentClient,
+  ): Promise<void> {
+    const args = [
+      "--print",
+      "--verbose",
+      "--input-format", "stream-json",
+      "--output-format", "stream-json",
+      "--dangerously-skip-permissions",
+      "--session-id", sessionId,
+      "-w",
+    ];
+
+    let proc: ChildProcess;
+    try {
+      proc = spawn(this.agentCli, args, {
+        cwd,
+        stdio: ["pipe", "pipe", "pipe"],
+        env: { ...process.env },
+      });
+    } catch (err: any) {
+      console.error(`[ERROR] Failed to spawn ${this.agentCli}: ${err.message}`);
+      await this.releaseTask(taskId);
+      return;
+    }
+
+    if (!proc.pid) {
+      console.error(`[ERROR] ${this.agentCli} not found or failed to start`);
+      await this.releaseTask(taskId);
+      return;
+    }
+
+    const agent: AgentProcess = { taskId, sessionId, process: proc, agentClient };
+    this.agents.set(taskId, agent);
+
+    // Kill agent if it exceeds the task timeout
+    if (this.taskTimeoutMs > 0) {
+      agent.timeoutTimer = setTimeout(() => {
+        console.warn(`[WARN] Agent for task ${taskId} exceeded timeout (${Math.round(this.taskTimeoutMs / 60000)}m), killing`);
+        proc.kill("SIGTERM");
+      }, this.taskTimeoutMs);
+    }
+
+    // Send task context as JSON message via stdin, then close
+    proc.on("spawn", () => {
+      const payload = JSON.stringify({
+        type: "user",
+        message: { role: "user", content: taskContext },
+      });
+      proc.stdin?.write(payload + "\n");
+      proc.stdin?.end();
+    });
+
+    // Parse stdout (stream-json): each line is a JSON event
+    let stdoutBuffer = "";
+    proc.stdout?.on("data", (chunk: Buffer) => {
+      stdoutBuffer += chunk.toString();
+      const lines = stdoutBuffer.split("\n");
+      stdoutBuffer = lines.pop() || "";
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const event = JSON.parse(line);
+          this.handleEvent(taskId, sessionId, event, agentClient);
+        } catch { /* non-JSON line, skip */ }
+      }
+    });
+
+    // Capture stderr for crash diagnostics
+    let stderrBuffer = "";
+    proc.stderr?.on("data", (chunk: Buffer) => {
+      stderrBuffer += chunk.toString();
+      if (stderrBuffer.length > 10000) stderrBuffer = stderrBuffer.slice(-5000);
+    });
+
+    // Handle exit
+    proc.on("close", async (code) => {
+      // Clear timeout timer
+      if (agent.timeoutTimer) clearTimeout(agent.timeoutTimer);
+
+      // Flush remaining stdout
+      if (stdoutBuffer.trim()) {
+        try {
+          const event = JSON.parse(stdoutBuffer);
+          this.handleEvent(taskId, sessionId, event, agentClient);
+        } catch { /* skip */ }
+      }
+
+      this.agents.delete(taskId);
+
+      if (code === 0) {
+        console.log(`[INFO] Agent finished task ${taskId}`);
+      } else {
+        console.warn(`[WARN] Agent crashed on task ${taskId} (exit ${code})`);
+        if (stderrBuffer.trim()) {
+          const lastLines = stderrBuffer.trim().split("\n").slice(-5).join("\n");
+          console.warn(`  stderr: ${lastLines}`);
+        }
+        await this.releaseTask(taskId);
+      }
+
+      this.onSlotFreed();
+    });
+
+    proc.on("error", async (err) => {
+      console.error(`[ERROR] Agent process error for task ${taskId}: ${err.message}`);
+      if (agent.timeoutTimer) clearTimeout(agent.timeoutTimer);
+      this.agents.delete(taskId);
+      await this.releaseTask(taskId);
+      this.onSlotFreed();
+    });
+
+    console.log(`[INFO] Spawned ${this.agentCli} (session=${sessionId}) for task ${taskId} in ${cwd}`);
+  }
+
+  async killAll(): Promise<void> {
+    const entries = [...this.agents.entries()];
+    for (const [taskId, agent] of entries) {
+      console.log(`[INFO] Killing agent for task ${taskId}`);
+      if (agent.timeoutTimer) clearTimeout(agent.timeoutTimer);
+      agent.process.kill("SIGTERM");
+      this.agents.delete(taskId);
+      await this.releaseTask(taskId);
+    }
+  }
+
+  private handleEvent(taskId: string, sessionId: string, event: any, agentClient?: AgentClient): void {
+    // Extract text from assistant messages → post as agent chat messages
+    if (event.type === "assistant" && Array.isArray(event.message?.content)) {
+      for (const block of event.message.content) {
+        if (block.type === "text" && block.text) {
+          this.postMessage(taskId, sessionId, "agent", block.text, agentClient).catch(() => {});
+        }
+      }
+    }
+    // Report usage on result event
+    if (event.type === "result") {
+      const cost = event.total_cost_usd || 0;
+      const usage = event.usage || {};
+      console.log(`[INFO] Agent result for task ${taskId}: cost=$${cost.toFixed(4)}`);
+      const usageData = {
+        input_tokens: usage.input_tokens || 0,
+        output_tokens: usage.output_tokens || 0,
+        cache_read_tokens: usage.cache_read_input_tokens || 0,
+        cache_creation_tokens: usage.cache_creation_input_tokens || 0,
+        cost_micro_usd: Math.round(cost * 1_000_000),
+      };
+      if (agentClient) {
+        agentClient.updateAgentUsage(usageData).catch(() => {});
+      } else {
+        this.client.updateAgentUsage(sessionId, usageData).catch(() => {});
+      }
+    }
+  }
+
+  private async postMessage(taskId: string, sessionId: string, role: string, content: string, agentClient?: AgentClient): Promise<void> {
+    const body = { agent_id: sessionId, role, content };
+    if (agentClient) {
+      await agentClient.sendMessage(taskId, body);
+    } else {
+      await this.client.sendMessage(taskId, body);
+    }
+  }
+
+  private async releaseTask(taskId: string, retries = 3): Promise<void> {
+    for (let i = 0; i < retries; i++) {
+      try {
+        await this.client.releaseTask(taskId);
+        return;
+      } catch (err: any) {
+        console.error(`[WARN] Failed to release task ${taskId} (attempt ${i + 1}/${retries}): ${err.message}`);
+        if (i < retries - 1) await new Promise((r) => setTimeout(r, 1000 * (i + 1)));
+      }
+    }
+    console.error(`[ERROR] Could not release task ${taskId} after ${retries} attempts. Task will remain locked until stale detection.`);
+  }
+}

package/src/types.ts

@@ -0,0 +1,12 @@
+export interface UsageWindow {
+  utilization: number;
+  resets_at: string;
+}
+
+export interface UsageInfo {
+  five_hour?: UsageWindow;
+  seven_day?: UsageWindow;
+  seven_day_sonnet?: UsageWindow;
+  seven_day_opus?: UsageWindow;
+  updated_at: string;
+}

package/src/usage.ts

@@ -0,0 +1,71 @@
+import { execSync } from "child_process";
+import { readFileSync } from "fs";
+import { join } from "path";
+import { homedir, platform } from "os";
+import type { UsageInfo } from "./types.js";
+
+const CREDENTIALS_PATH = join(homedir(), ".claude", ".credentials.json");
+const USAGE_API = "https://api.anthropic.com/api/oauth/usage";
+const CACHE_TTL_MS = 5 * 60 * 1000;
+
+let cachedUsage: UsageInfo | null = null;
+let cachedAt = 0;
+let cachedToken: string | null = null;
+
+function parseToken(raw: string): string | null {
+  const creds = JSON.parse(raw);
+  return creds.claudeAiOauth?.accessToken || null;
+}
+
+function readOAuthToken(): string | null {
+  if (cachedToken) return cachedToken;
+  try {
+    if (platform() === "darwin") {
+      const raw = execSync('security find-generic-password -s "Claude Code-credentials" -w', { stdio: ["pipe", "pipe", "pipe"] }).toString().trim();
+      cachedToken = parseToken(raw);
+    } else {
+      cachedToken = parseToken(readFileSync(CREDENTIALS_PATH, "utf-8"));
+    }
+    return cachedToken;
+  } catch {
+    return null;
+  }
+}
+
+export async function getUsage(): Promise<UsageInfo | null> {
+  if (cachedUsage && Date.now() - cachedAt < CACHE_TTL_MS) {
+    return cachedUsage;
+  }
+
+  const token = readOAuthToken();
+  if (!token) return cachedUsage;
+
+  try {
+    const res = await fetch(USAGE_API, {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "anthropic-beta": "oauth-2025-04-20",
+      },
+      signal: AbortSignal.timeout(5000),
+    });
+
+    if (!res.ok) {
+      console.error(`[WARN] Usage API returned ${res.status}`);
+      return cachedUsage;
+    }
+
+    const data = await res.json() as Record<string, { utilization: number; resets_at: string }>;
+    cachedUsage = {
+      ...data.five_hour && { five_hour: data.five_hour },
+      ...data.seven_day && { seven_day: data.seven_day },
+      ...data.seven_day_sonnet && { seven_day_sonnet: data.seven_day_sonnet },
+      ...data.seven_day_opus && { seven_day_opus: data.seven_day_opus },
+      updated_at: new Date().toISOString(),
+    };
+    cachedAt = Date.now();
+    return cachedUsage;
+  } catch (err: any) {
+    console.error(`[WARN] Failed to fetch usage: ${err.message}`);
+    return cachedUsage;
+  }
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}