claude-code-controller 0.5.1 → 0.6.0

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { L as Logger, I as InboxMessage, S as StructuredMessage, a as LogLevel } from './claude-0cg912ch.js';
-export { A as Agent, b as AgentEvents, c as AgentHandle, d as AgentType, e as AskOptions, C as ClaudeCodeController, f as ClaudeOptions, g as ControllerEvents, h as ControllerOptions, i as IdleNotificationMessage, P as PermissionMode, j as PermissionPreset, k as PermissionRequestInfo, l as PermissionRequestMessage, m as PermissionResponseMessage, n as PlainTextMessage, o as PlanApprovalRequestMessage, p as PlanApprovalResponseMessage, q as PlanRequestInfo, R as ReceiveOptions, r as SandboxPermissionRequestMessage, s as SandboxPermissionResponseMessage, t as Session, u as SessionAgentOptions, v as SessionOptions, w as ShutdownApprovedMessage, x as ShutdownRequestMessage, y as SpawnAgentOptions, T as TaskAssignmentMessage, z as TaskCompletedMessage, B as TaskFile, D as TaskManager, E as TaskStatus, F as TeamConfig, G as TeamManager, H as TeamMember, J as claude } from './claude-0cg912ch.js';
+import { L as Logger, I as InboxMessage, S as StructuredMessage, a as StatusLineData, b as LogLevel } from './claude-B7-oBjuE.js';
+export { A as Agent, c as AgentEvents, d as AgentHandle, e as AgentType, f as AskOptions, C as ClaudeCodeController, g as ClaudeOptions, h as ControllerEvents, i as ControllerOptions, j as IdleNotificationMessage, P as PermissionMode, k as PermissionPreset, l as PermissionRequestInfo, m as PermissionRequestMessage, n as PermissionResponseMessage, o as PlainTextMessage, p as PlanApprovalRequestMessage, q as PlanApprovalResponseMessage, r as PlanRequestInfo, R as ReceiveOptions, s as SandboxPermissionRequestMessage, t as SandboxPermissionResponseMessage, u as Session, v as SessionAgentOptions, w as SessionOptions, x as ShutdownApprovedMessage, y as ShutdownRequestMessage, z as SpawnAgentOptions, T as TaskAssignmentMessage, B as TaskCompletedMessage, D as TaskFile, E as TaskManager, F as TaskStatus, G as TeamConfig, H as TeamManager, J as TeamMember, K as claude } from './claude-B7-oBjuE.js';
 import { ChildProcess } from 'node:child_process';
-import 'node:events';
+import { EventEmitter } from 'node:events';
 
 interface SpawnOptions {
     teamName: string;
@@ -117,6 +117,62 @@ declare function readUnread(teamName: string, agentName: string): Promise<InboxM
  */
 declare function parseMessage(msg: InboxMessage): StructuredMessage;
 
+/**
+ * Directory where statusLine JSON logs are written per agent.
+ */
+declare function statusLineDir(teamName: string): string;
+declare function statusLineLogPath(teamName: string, agentName: string): string;
+interface StatusLineEvent {
+    agentName: string;
+    data: StatusLineData;
+    timestamp: string;
+}
+interface StatusLineCaptureEvents {
+    update: [event: StatusLineEvent];
+    error: [error: Error];
+}
+/**
+ * Generates the statusLine capture script.
+ * This script receives JSON from Claude Code via stdin and appends it to a log file.
+ * It also outputs a minimal display for the TUI statusline bar.
+ */
+declare function buildStatusLineCommand(logFilePath: string): string;
+/**
+ * Generates the settings.local.json content with statusLine configuration.
+ */
+declare function buildStatusLineSettings(logFilePath: string): Record<string, unknown>;
+/**
+ * Watches statusLine log files for a team and emits parsed events.
+ */
+declare class StatusLineWatcher extends EventEmitter<StatusLineCaptureEvents> {
+    private teamName;
+    private log;
+    private watchers;
+    private fileOffsets;
+    private stopped;
+    constructor(teamName: string, logger: Logger);
+    /**
+     * Ensure the statusline directory exists.
+     */
+    ensureDir(): void;
+    /**
+     * Start watching a specific agent's statusLine log file.
+     */
+    watchAgent(agentName: string): void;
+    /**
+     * Stop watching a specific agent.
+     */
+    unwatchAgent(agentName: string): void;
+    /**
+     * Stop all watchers.
+     */
+    stop(): void;
+    /**
+     * Read new lines appended to the log file since last read.
+     */
+    private readNewLines;
+}
+
 declare function teamsDir(): string;
 declare function teamDir(teamName: string): string;
 declare function teamConfigPath(teamName: string): string;
@@ -129,4 +185,4 @@ declare function taskPath(teamName: string, taskId: string): string;
 declare function createLogger(level?: LogLevel): Logger;
 declare const silentLogger: Logger;
 
-export { InboxMessage, InboxPoller, LogLevel, Logger, ProcessManager, StructuredMessage, createLogger, inboxPath, inboxesDir, parseMessage, readInbox, readUnread, silentLogger, taskPath, tasksBaseDir, tasksDir, teamConfigPath, teamDir, teamsDir, writeInbox };
+export { InboxMessage, InboxPoller, LogLevel, Logger, ProcessManager, type StatusLineCaptureEvents, StatusLineData, type StatusLineEvent, StatusLineWatcher, StructuredMessage, buildStatusLineCommand, buildStatusLineSettings, createLogger, inboxPath, inboxesDir, parseMessage, readInbox, readUnread, silentLogger, statusLineDir, statusLineLogPath, taskPath, tasksBaseDir, tasksDir, teamConfigPath, teamDir, teamsDir, writeInbox };

package/dist/index.js

@@ -1,13 +1,13 @@
 // src/claude.ts
-import { EventEmitter as EventEmitter2 } from "events";
+import { EventEmitter as EventEmitter3 } from "events";
 import { randomUUID as randomUUID3 } from "crypto";
 
 // src/controller.ts
-import { EventEmitter } from "events";
+import { EventEmitter as EventEmitter2 } from "events";
 import { execSync as execSync2 } from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
-import { mkdirSync, existsSync as existsSync4, writeFileSync } from "fs";
-import { join as join2 } from "path";
+import { mkdirSync as mkdirSync2, existsSync as existsSync5, writeFileSync as writeFileSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join3 } from "path";
 
 // src/team-manager.ts
 import { readFile, writeFile, mkdir, rm } from "fs/promises";
@@ -712,6 +712,135 @@ var silentLogger = {
   }
 };
 
+// src/statusline-capture.ts
+import { EventEmitter } from "events";
+import { watch, existsSync as existsSync4, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join as join2 } from "path";
+function statusLineDir(teamName) {
+  return join2(teamDir(teamName), "statusline");
+}
+function statusLineLogPath(teamName, agentName) {
+  return join2(statusLineDir(teamName), `${agentName}.jsonl`);
+}
+function buildStatusLineCommand(logFilePath) {
+  const escapedPath = logFilePath.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+  return [
+    "python3 -c",
+    `'import sys,json;`,
+    `d=json.load(sys.stdin);`,
+    `open("${escapedPath}","a").write(json.dumps(d)+"\\n");`,
+    `print(d.get("model",{}).get("display_name",""))'`
+  ].join(" ");
+}
+function buildStatusLineSettings(logFilePath) {
+  return {
+    statusLine: {
+      type: "command",
+      command: buildStatusLineCommand(logFilePath)
+    }
+  };
+}
+var StatusLineWatcher = class extends EventEmitter {
+  teamName;
+  log;
+  watchers = /* @__PURE__ */ new Map();
+  fileOffsets = /* @__PURE__ */ new Map();
+  stopped = false;
+  constructor(teamName, logger) {
+    super();
+    this.teamName = teamName;
+    this.log = logger;
+  }
+  /**
+   * Ensure the statusline directory exists.
+   */
+  ensureDir() {
+    const dir = statusLineDir(this.teamName);
+    if (!existsSync4(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+  }
+  /**
+   * Start watching a specific agent's statusLine log file.
+   */
+  watchAgent(agentName) {
+    if (this.stopped) return;
+    const filePath = statusLineLogPath(this.teamName, agentName);
+    if (!existsSync4(filePath)) {
+      writeFileSync(filePath, "");
+    }
+    try {
+      const stats = readFileSync(filePath);
+      this.fileOffsets.set(filePath, stats.length);
+    } catch {
+      this.fileOffsets.set(filePath, 0);
+    }
+    try {
+      const watcher = watch(filePath, (eventType) => {
+        if (eventType === "change") {
+          this.readNewLines(agentName, filePath);
+        }
+      });
+      this.watchers.set(agentName, watcher);
+      this.log.debug(`Watching statusLine for agent "${agentName}" at ${filePath}`);
+    } catch (err) {
+      this.log.error(`Failed to watch statusLine for "${agentName}": ${err}`);
+    }
+  }
+  /**
+   * Stop watching a specific agent.
+   */
+  unwatchAgent(agentName) {
+    const watcher = this.watchers.get(agentName);
+    if (watcher) {
+      watcher.close();
+      this.watchers.delete(agentName);
+    }
+    const filePath = statusLineLogPath(this.teamName, agentName);
+    this.fileOffsets.delete(filePath);
+  }
+  /**
+   * Stop all watchers.
+   */
+  stop() {
+    this.stopped = true;
+    for (const [, watcher] of this.watchers) {
+      watcher.close();
+    }
+    this.watchers.clear();
+    this.fileOffsets.clear();
+  }
+  /**
+   * Read new lines appended to the log file since last read.
+   */
+  readNewLines(agentName, filePath) {
+    try {
+      const content = readFileSync(filePath, "utf-8");
+      const offset = this.fileOffsets.get(filePath) ?? 0;
+      const newContent = content.slice(offset);
+      this.fileOffsets.set(filePath, content.length);
+      if (!newContent.trim()) return;
+      const lines = newContent.trim().split("\n");
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const data = JSON.parse(line);
+          const event = {
+            agentName,
+            data,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          this.emit("update", event);
+        } catch (parseErr) {
+          this.log.debug(`Failed to parse statusLine JSON: ${line}`);
+        }
+      }
+    } catch (err) {
+      this.log.debug(`Error reading statusLine file: ${err}`);
+    }
+  }
+};
+
 // src/controller.ts
 var PROTOCOL_ONLY_TYPES = /* @__PURE__ */ new Set([
   "shutdown_approved",
@@ -731,12 +860,13 @@ var AGENT_COLORS = [
   "#FF69B4",
   "#7B68EE"
 ];
-var ClaudeCodeController = class extends EventEmitter {
+var ClaudeCodeController = class extends EventEmitter2 {
   teamName;
   team;
   tasks;
   processes;
   poller;
+  statusLineWatcher;
   log;
   cwd;
   claudeBinary;
@@ -758,7 +888,11 @@ var ClaudeCodeController = class extends EventEmitter {
       "controller",
       this.log
     );
+    this.statusLineWatcher = new StatusLineWatcher(this.teamName, this.log);
     this.poller.onMessages((events) => this.handlePollEvents(events));
+    this.statusLineWatcher.on("update", (event) => {
+      this.emit("agent:statusline", event.agentName, event.data);
+    });
   }
   // ─── Lifecycle ───────────────────────────────────────────────────────
   /**
@@ -769,6 +903,7 @@ var ClaudeCodeController = class extends EventEmitter {
     if (this.initialized) return this;
     await this.team.create({ cwd: this.cwd });
     await this.tasks.init();
+    this.statusLineWatcher.ensureDir();
     this.poller.start();
     this.initialized = true;
     this.log.info(
@@ -809,6 +944,7 @@ var ClaudeCodeController = class extends EventEmitter {
     }
     await this.processes.killAll();
     this.poller.stop();
+    this.statusLineWatcher.stop();
     await this.team.destroy();
     this.initialized = false;
     this.log.info("Controller shut down");
@@ -837,7 +973,8 @@ var ClaudeCodeController = class extends EventEmitter {
       subscriptions: []
     };
     await this.team.addMember(member);
-    this.ensureWorkspaceTrusted(cwd);
+    this.ensureWorkspaceTrusted(cwd, opts.name);
+    this.statusLineWatcher.watchAgent(opts.name);
     const env = Object.keys(this.defaultEnv).length > 0 || opts.env ? { ...this.defaultEnv, ...opts.env } : void 0;
     const proc = this.processes.spawn({
       teamName: this.teamName,
@@ -1044,6 +1181,7 @@ var ClaudeCodeController = class extends EventEmitter {
    * Kill a specific agent.
    */
   async killAgent(name) {
+    this.statusLineWatcher.unwatchAgent(name);
     await this.processes.kill(name);
     await this.team.removeMember(name);
   }
@@ -1108,15 +1246,28 @@ var ClaudeCodeController = class extends EventEmitter {
   /**
    * Ensure the agent's cwd has a .claude/settings.local.json so the
    * CLI skips the interactive workspace trust prompt.
+   * Also injects statusLine capture configuration.
    */
-  ensureWorkspaceTrusted(cwd) {
-    const claudeDir = join2(cwd, ".claude");
-    const settingsPath = join2(claudeDir, "settings.local.json");
-    if (!existsSync4(settingsPath)) {
-      mkdirSync(claudeDir, { recursive: true });
-      writeFileSync(settingsPath, "{}\n");
-      this.log.debug(`Created ${settingsPath} for workspace trust`);
+  ensureWorkspaceTrusted(cwd, agentName) {
+    const claudeDir = join3(cwd, ".claude");
+    const settingsPath = join3(claudeDir, "settings.local.json");
+    mkdirSync2(claudeDir, { recursive: true });
+    let settings = {};
+    if (existsSync5(settingsPath)) {
+      try {
+        settings = JSON.parse(readFileSync2(settingsPath, "utf-8"));
+      } catch {
+        settings = {};
+      }
+    }
+    if (agentName && !settings.statusLine) {
+      const logPath = statusLineLogPath(this.teamName, agentName);
+      const statusLineSettings = buildStatusLineSettings(logPath);
+      settings = { ...settings, ...statusLineSettings };
+      this.log.debug(`Injected statusLine capture for "${agentName}"`);
     }
+    writeFileSync2(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+    this.log.debug(`Updated ${settingsPath}`);
   }
   ensureInitialized() {
     if (!this.initialized) {
@@ -1202,7 +1353,7 @@ function waitForReady(controller, agentName, timeoutMs = 15e3) {
     controller.on("agent:exited", onExit);
   });
 }
-var Agent = class _Agent extends EventEmitter2 {
+var Agent = class _Agent extends EventEmitter3 {
   controller;
   handle;
   ownsController;
@@ -1402,6 +1553,9 @@ IMPORTANT: You MUST send your complete answer back using the SendMessage tool. D
     const onIdle = (name, _details) => {
       if (name === agentName) this.emit("idle");
     };
+    const onStatusLine = (name, data) => {
+      if (name === agentName) this.emit("statusline", data);
+    };
     const onPermission = (name, parsed) => {
       if (name !== agentName) return;
       let handled = false;
@@ -1450,6 +1604,7 @@ IMPORTANT: You MUST send your complete answer back using the SendMessage tool. D
     };
     this.controller.on("message", onMessage);
     this.controller.on("idle", onIdle);
+    this.controller.on("agent:statusline", onStatusLine);
     this.controller.on("permission:request", onPermission);
     this.controller.on("plan:approval_request", onPlan);
     this.controller.on("agent:exited", onExit);
@@ -1457,6 +1612,7 @@ IMPORTANT: You MUST send your complete answer back using the SendMessage tool. D
     this.boundListeners = [
       { event: "message", fn: onMessage },
       { event: "idle", fn: onIdle },
+      { event: "agent:statusline", fn: onStatusLine },
       { event: "permission:request", fn: onPermission },
       { event: "plan:approval_request", fn: onPlan },
       { event: "agent:exited", fn: onExit },
@@ -1602,8 +1758,11 @@ export {
   InboxPoller,
   ProcessManager,
   Session,
+  StatusLineWatcher,
   TaskManager,
   TeamManager,
+  buildStatusLineCommand,
+  buildStatusLineSettings,
   claude,
   createLogger,
   inboxPath,
@@ -1612,6 +1771,8 @@ export {
   readInbox,
   readUnread,
   silentLogger,
+  statusLineDir,
+  statusLineLogPath,
   taskPath,
   tasksBaseDir,
   tasksDir,