diragent 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,1621 @@
+#!/usr/bin/env node
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/server/config.ts
+var config_exports = {};
+__export(config_exports, {
+  loadConfig: () => loadConfig,
+  validateAuth: () => validateAuth
+});
+import { readFileSync, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import { z } from "zod";
+function loadConfig(configPath) {
+  if (cachedConfig) return cachedConfig;
+  const path = configPath || findConfigPath();
+  if (!path || !existsSync2(path)) {
+    cachedConfig = ConfigSchema.parse({});
+    return cachedConfig;
+  }
+  const raw = readFileSync(path, "utf-8");
+  const parsed = JSON.parse(raw);
+  cachedConfig = ConfigSchema.parse(parsed);
+  return cachedConfig;
+}
+function findConfigPath() {
+  const candidates = [
+    join2(process.cwd(), ".dirigent", "config.json"),
+    join2(process.cwd(), "dirigent.json"),
+    join2(process.env.HOME || "", ".dirigent", "config.json")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync2(candidate)) return candidate;
+  }
+  return null;
+}
+function validateAuth(token, config) {
+  if (!config.auth.enabled) return true;
+  if (config.auth.adminToken && token === config.auth.adminToken) return true;
+  if (config.auth.apiKeys?.includes(token)) return true;
+  return false;
+}
+var AgentTemplateSchema, ConfigSchema, cachedConfig;
+var init_config = __esm({
+  "src/server/config.ts"() {
+    "use strict";
+    AgentTemplateSchema = z.object({
+      driver: z.string(),
+      model: z.string().optional(),
+      maxTokens: z.number().optional(),
+      command: z.array(z.string()).optional(),
+      env: z.record(z.string()).optional()
+    });
+    ConfigSchema = z.object({
+      version: z.string().default("1"),
+      server: z.object({
+        port: z.number().default(3e3),
+        host: z.string().default("0.0.0.0")
+      }).default({}),
+      auth: z.object({
+        enabled: z.boolean().default(true),
+        adminToken: z.string().optional(),
+        apiKeys: z.array(z.string()).optional()
+      }).default({}),
+      agents: z.object({
+        maxConcurrent: z.number().default(10),
+        defaultTimeout: z.number().default(3600),
+        templates: z.record(AgentTemplateSchema).default({})
+      }).default({}),
+      logging: z.object({
+        level: z.enum(["debug", "info", "warn", "error"]).default("info"),
+        format: z.enum(["pretty", "json"]).default("pretty"),
+        file: z.string().optional()
+      }).default({}),
+      database: z.object({
+        path: z.string().default("data/dirigent.db")
+      }).default({})
+    });
+    cachedConfig = null;
+  }
+});
+
+// src/server/db/index.ts
+import Database from "better-sqlite3";
+function initDatabase(path) {
+  db = new Database(path);
+  db.pragma("journal_mode = WAL");
+  db.exec(`
+    -- Agents table
+    CREATE TABLE IF NOT EXISTS agents (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      template TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'created',
+      workspace TEXT,
+      model TEXT,
+      config TEXT,
+      pid INTEGER,
+      created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+      started_at INTEGER,
+      stopped_at INTEGER,
+      error TEXT
+    );
+
+    -- Agent logs table
+    CREATE TABLE IF NOT EXISTS agent_logs (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      agent_id TEXT NOT NULL,
+      level TEXT NOT NULL,
+      message TEXT NOT NULL,
+      timestamp INTEGER NOT NULL DEFAULT (unixepoch() * 1000),
+      metadata TEXT,
+      FOREIGN KEY (agent_id) REFERENCES agents(id)
+    );
+
+    -- Tasks table
+    CREATE TABLE IF NOT EXISTS tasks (
+      id TEXT PRIMARY KEY,
+      agent_id TEXT,
+      content TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'pending',
+      result TEXT,
+      created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+      started_at INTEGER,
+      completed_at INTEGER,
+      error TEXT,
+      FOREIGN KEY (agent_id) REFERENCES agents(id)
+    );
+
+    -- Audit log table
+    CREATE TABLE IF NOT EXISTS audit_log (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      action TEXT NOT NULL,
+      actor TEXT,
+      target_type TEXT,
+      target_id TEXT,
+      details TEXT,
+      timestamp INTEGER NOT NULL DEFAULT (unixepoch() * 1000)
+    );
+
+    -- Sessions table (for WebSocket connections)
+    CREATE TABLE IF NOT EXISTS sessions (
+      id TEXT PRIMARY KEY,
+      user_id TEXT,
+      connected_at INTEGER NOT NULL DEFAULT (unixepoch()),
+      last_activity INTEGER NOT NULL DEFAULT (unixepoch()),
+      metadata TEXT
+    );
+
+    -- Indexes
+    CREATE INDEX IF NOT EXISTS idx_agent_logs_agent_id ON agent_logs(agent_id);
+    CREATE INDEX IF NOT EXISTS idx_agent_logs_timestamp ON agent_logs(timestamp);
+    CREATE INDEX IF NOT EXISTS idx_tasks_agent_id ON tasks(agent_id);
+    CREATE INDEX IF NOT EXISTS idx_tasks_status ON tasks(status);
+    CREATE INDEX IF NOT EXISTS idx_audit_log_timestamp ON audit_log(timestamp);
+  `);
+  return db;
+}
+function getDatabase() {
+  return db;
+}
+function insertAgent(agent2) {
+  const stmt = db.prepare(`
+    INSERT INTO agents (id, name, template, workspace, model, config)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `);
+  stmt.run(
+    agent2.id,
+    agent2.name,
+    agent2.template,
+    agent2.workspace || null,
+    agent2.model || null,
+    agent2.config ? JSON.stringify(agent2.config) : null
+  );
+}
+function updateAgent(id, updates) {
+  const keys = Object.keys(updates);
+  const values = keys.map((k) => typeof updates[k] === "object" ? JSON.stringify(updates[k]) : updates[k]);
+  const stmt = db.prepare(`
+    UPDATE agents SET ${keys.map((k) => `${k} = ?`).join(", ")}
+    WHERE id = ?
+  `);
+  stmt.run(...values, id);
+}
+function getAgents(includesStopped = false) {
+  const stmt = db.prepare(
+    includesStopped ? "SELECT * FROM agents ORDER BY created_at DESC" : "SELECT * FROM agents WHERE status != 'stopped' ORDER BY created_at DESC"
+  );
+  return stmt.all().map((row) => {
+    if (row.config) row.config = JSON.parse(row.config);
+    return row;
+  });
+}
+function insertLog(log) {
+  const stmt = db.prepare(`
+    INSERT INTO agent_logs (agent_id, level, message, metadata)
+    VALUES (?, ?, ?, ?)
+  `);
+  stmt.run(log.agentId, log.level, log.message, log.metadata ? JSON.stringify(log.metadata) : null);
+}
+function getLogs(agentId, limit = 100) {
+  const stmt = db.prepare(`
+    SELECT * FROM agent_logs
+    WHERE agent_id = ?
+    ORDER BY timestamp DESC
+    LIMIT ?
+  `);
+  return stmt.all(agentId, limit).reverse().map((row) => {
+    if (row.metadata) row.metadata = JSON.parse(row.metadata);
+    return row;
+  });
+}
+function audit(action, actor, targetType, targetId, details) {
+  const stmt = db.prepare(`
+    INSERT INTO audit_log (action, actor, target_type, target_id, details)
+    VALUES (?, ?, ?, ?, ?)
+  `);
+  stmt.run(action, actor, targetType, targetId, details ? JSON.stringify(details) : null);
+}
+var db;
+var init_db = __esm({
+  "src/server/db/index.ts"() {
+    "use strict";
+    db = null;
+  }
+});
+
+// src/server/agents/manager.ts
+import { EventEmitter } from "events";
+import { nanoid as nanoid2 } from "nanoid";
+import { spawn } from "child_process";
+import treeKill from "tree-kill";
+import { join as join3 } from "path";
+import { mkdirSync as mkdirSync2, existsSync as existsSync3 } from "fs";
+var AgentManager;
+var init_manager = __esm({
+  "src/server/agents/manager.ts"() {
+    "use strict";
+    init_db();
+    AgentManager = class extends EventEmitter {
+      agents = /* @__PURE__ */ new Map();
+      processes = /* @__PURE__ */ new Map();
+      dataDir;
+      config;
+      logger;
+      constructor(options) {
+        super();
+        this.dataDir = options.dataDir;
+        this.config = options.config;
+        this.logger = options.logger;
+        this.loadAgents();
+      }
+      loadAgents() {
+        const dbAgents = getAgents(false);
+        for (const dbAgent of dbAgents) {
+          if (dbAgent.status !== "stopped") {
+            this.agents.set(dbAgent.id, {
+              id: dbAgent.id,
+              name: dbAgent.name,
+              template: dbAgent.template,
+              status: "stopped",
+              // Reset to stopped since we restarted
+              workspace: dbAgent.workspace,
+              model: dbAgent.model,
+              createdAt: dbAgent.created_at * 1e3
+            });
+            updateAgent(dbAgent.id, { status: "stopped" });
+          }
+        }
+      }
+      async spawn(options) {
+        const { template, name, workspace, task, model } = options;
+        const templateConfig = this.config.agents.templates[template];
+        if (!templateConfig) {
+          throw new Error(`Unknown template: ${template}`);
+        }
+        const runningCount = Array.from(this.agents.values()).filter(
+          (a) => a.status === "running" || a.status === "starting"
+        ).length;
+        if (runningCount >= this.config.agents.maxConcurrent) {
+          throw new Error(`Max concurrent agents (${this.config.agents.maxConcurrent}) reached`);
+        }
+        const id = nanoid2(12);
+        const agentName = name || `${template}-${id.slice(0, 6)}`;
+        const agentWorkspace = workspace || join3(this.dataDir, "workspaces", id);
+        if (!existsSync3(agentWorkspace)) {
+          mkdirSync2(agentWorkspace, { recursive: true });
+        }
+        const agent2 = {
+          id,
+          name: agentName,
+          template,
+          status: "created",
+          workspace: agentWorkspace,
+          model: model || templateConfig.model,
+          currentTask: task,
+          createdAt: Date.now()
+        };
+        insertAgent({
+          id: agent2.id,
+          name: agent2.name,
+          template: agent2.template,
+          workspace: agent2.workspace,
+          model: agent2.model
+        });
+        audit("agent.created", null, "agent", id, { name: agentName, template });
+        this.agents.set(id, agent2);
+        this.emit("agent:created", agent2);
+        await this.startAgent(agent2, templateConfig, task);
+        return agent2;
+      }
+      async startAgent(agent2, template, initialTask) {
+        agent2.status = "starting";
+        updateAgent(agent2.id, { status: "starting" });
+        this.emit("agent:starting", agent2);
+        try {
+          const { command, env } = this.buildCommand(agent2, template);
+          this.logger.info({ agentId: agent2.id, command }, "Starting agent");
+          const proc = spawn(command[0], command.slice(1), {
+            cwd: agent2.workspace,
+            env: {
+              ...process.env,
+              ...env,
+              DIRIGENT_AGENT_ID: agent2.id,
+              DIRIGENT_AGENT_NAME: agent2.name
+            },
+            stdio: ["pipe", "pipe", "pipe"]
+          });
+          agent2.pid = proc.pid;
+          agent2.process = proc;
+          agent2.status = "running";
+          agent2.startedAt = Date.now();
+          updateAgent(agent2.id, {
+            status: "running",
+            pid: proc.pid,
+            started_at: Math.floor(Date.now() / 1e3)
+          });
+          this.processes.set(agent2.id, proc);
+          proc.stdout?.on("data", (data) => {
+            const message = data.toString().trim();
+            if (message) {
+              this.log(agent2.id, "info", message);
+            }
+          });
+          proc.stderr?.on("data", (data) => {
+            const message = data.toString().trim();
+            if (message) {
+              this.log(agent2.id, "error", message);
+            }
+          });
+          proc.on("exit", (code, signal) => {
+            this.logger.info({ agentId: agent2.id, code, signal }, "Agent exited");
+            agent2.status = code === 0 ? "stopped" : "error";
+            agent2.stoppedAt = Date.now();
+            if (code !== 0) {
+              agent2.error = `Exited with code ${code}`;
+            }
+            updateAgent(agent2.id, {
+              status: agent2.status,
+              stopped_at: Math.floor(Date.now() / 1e3),
+              error: agent2.error || null
+            });
+            this.processes.delete(agent2.id);
+            this.emit("agent:stopped", agent2);
+            audit("agent.stopped", null, "agent", agent2.id, { code, signal });
+          });
+          proc.on("error", (err) => {
+            this.logger.error({ agentId: agent2.id, err }, "Agent process error");
+            agent2.status = "error";
+            agent2.error = err.message;
+            updateAgent(agent2.id, { status: "error", error: err.message });
+            this.emit("agent:error", agent2, err);
+          });
+          this.emit("agent:running", agent2);
+          audit("agent.started", null, "agent", agent2.id, { pid: proc.pid });
+          if (initialTask && proc.stdin) {
+            proc.stdin.write(initialTask + "\n");
+          }
+        } catch (err) {
+          agent2.status = "error";
+          agent2.error = err.message;
+          updateAgent(agent2.id, { status: "error", error: err.message });
+          this.emit("agent:error", agent2, err);
+          throw err;
+        }
+      }
+      buildCommand(agent2, template) {
+        const env = { ...template.env };
+        switch (template.driver) {
+          case "claude-code":
+            return {
+              command: ["claude", "--dangerously-skip-permissions"],
+              env: {
+                ...env,
+                ANTHROPIC_MODEL: agent2.model || template.model || "claude-sonnet-4-5"
+              }
+            };
+          case "codex":
+            return {
+              command: ["codex", "--model", agent2.model || template.model || "codex-1"],
+              env
+            };
+          case "clawdbot":
+            return {
+              command: ["clawdbot", "agent", "--headless"],
+              env: {
+                ...env,
+                CLAWDBOT_MODEL: agent2.model || template.model || "claude-sonnet-4-5"
+              }
+            };
+          case "subprocess":
+            if (!template.command || template.command.length === 0) {
+              throw new Error("subprocess driver requires command");
+            }
+            return { command: template.command, env };
+          default:
+            throw new Error(`Unknown driver: ${template.driver}`);
+        }
+      }
+      async stop(id, force = false) {
+        const agent2 = this.agents.get(id);
+        if (!agent2) {
+          throw new Error(`Agent not found: ${id}`);
+        }
+        if (agent2.status !== "running" && agent2.status !== "starting") {
+          return;
+        }
+        agent2.status = "stopping";
+        this.emit("agent:stopping", agent2);
+        const proc = this.processes.get(id);
+        if (proc && proc.pid) {
+          await new Promise((resolve, reject) => {
+            treeKill(proc.pid, force ? "SIGKILL" : "SIGTERM", (err) => {
+              if (err) reject(err);
+              else resolve();
+            });
+          });
+        }
+        audit("agent.stop_requested", null, "agent", id, { force });
+      }
+      async stopAll() {
+        const promises = Array.from(this.agents.values()).filter((a) => a.status === "running" || a.status === "starting").map((a) => this.stop(a.id, true));
+        await Promise.allSettled(promises);
+      }
+      async send(id, message) {
+        const agent2 = this.agents.get(id);
+        if (!agent2) {
+          throw new Error(`Agent not found: ${id}`);
+        }
+        if (agent2.status !== "running") {
+          throw new Error(`Agent is not running: ${agent2.status}`);
+        }
+        const proc = this.processes.get(id);
+        if (!proc || !proc.stdin) {
+          throw new Error("Agent process not available");
+        }
+        proc.stdin.write(message + "\n");
+        this.log(id, "info", `[USER] ${message}`);
+        audit("agent.message_sent", null, "agent", id, { length: message.length });
+      }
+      get(id) {
+        return this.agents.get(id);
+      }
+      list(includeStopped = false) {
+        const agents = Array.from(this.agents.values());
+        if (includeStopped) return agents;
+        return agents.filter((a) => a.status !== "stopped");
+      }
+      log(agentId, level, message) {
+        insertLog({ agentId, level, message });
+        this.emit("agent:log", { agentId, level, message, timestamp: Date.now() });
+      }
+      getLogs(agentId, limit = 100) {
+        return getLogs(agentId, limit);
+      }
+      getStats() {
+        const agents = Array.from(this.agents.values());
+        return {
+          total: agents.length,
+          running: agents.filter((a) => a.status === "running").length,
+          idle: agents.filter((a) => a.status === "idle").length,
+          stopped: agents.filter((a) => a.status === "stopped").length,
+          error: agents.filter((a) => a.status === "error").length
+        };
+      }
+    };
+  }
+});
+
+// src/server/api/routes.ts
+function registerApiRoutes(server2, options) {
+  const { config, agentManager: agentManager2, startTime: startTime2 } = options;
+  server2.addHook("onRequest", async (request, reply) => {
+    if (request.url === "/health") return;
+    if (!request.url.startsWith("/api")) return;
+    if (config.auth.enabled) {
+      const authHeader = request.headers.authorization;
+      const token = authHeader?.replace("Bearer ", "");
+      if (!token || !validateAuth(token, config)) {
+        reply.code(401).send({ error: "Unauthorized" });
+        return;
+      }
+    }
+  });
+  server2.get("/api/status", async () => {
+    const stats = agentManager2.getStats();
+    const agents = agentManager2.list(false);
+    return {
+      status: "ok",
+      uptime: Math.floor((Date.now() - startTime2) / 1e3),
+      agents: {
+        ...stats,
+        list: agents.map((a) => ({
+          id: a.id,
+          name: a.name,
+          template: a.template,
+          status: a.status,
+          workspace: a.workspace,
+          currentTask: a.currentTask
+        }))
+      }
+    };
+  });
+  server2.get("/api/agents", async (request) => {
+    const includeStopped = request.query.all === "true";
+    const agents = agentManager2.list(includeStopped);
+    return {
+      agents: agents.map((a) => ({
+        id: a.id,
+        name: a.name,
+        template: a.template,
+        status: a.status,
+        workspace: a.workspace,
+        model: a.model,
+        pid: a.pid,
+        currentTask: a.currentTask,
+        createdAt: a.createdAt,
+        startedAt: a.startedAt,
+        stoppedAt: a.stoppedAt,
+        error: a.error
+      }))
+    };
+  });
+  server2.post("/api/agents", async (request, reply) => {
+    const { template, name, workspace, task, model } = request.body;
+    if (!template) {
+      reply.code(400).send({ error: "template is required" });
+      return;
+    }
+    try {
+      const agent2 = await agentManager2.spawn({ template, name, workspace, task, model });
+      return {
+        agent: {
+          id: agent2.id,
+          name: agent2.name,
+          template: agent2.template,
+          status: agent2.status,
+          workspace: agent2.workspace,
+          model: agent2.model
+        }
+      };
+    } catch (err) {
+      reply.code(400).send({ error: err.message });
+    }
+  });
+  server2.get("/api/agents/:id", async (request, reply) => {
+    const agent2 = agentManager2.get(request.params.id);
+    if (!agent2) {
+      reply.code(404).send({ error: "Agent not found" });
+      return;
+    }
+    return {
+      agent: {
+        id: agent2.id,
+        name: agent2.name,
+        template: agent2.template,
+        status: agent2.status,
+        workspace: agent2.workspace,
+        model: agent2.model,
+        pid: agent2.pid,
+        currentTask: agent2.currentTask,
+        createdAt: agent2.createdAt,
+        startedAt: agent2.startedAt,
+        stoppedAt: agent2.stoppedAt,
+        error: agent2.error
+      }
+    };
+  });
+  server2.delete(
+    "/api/agents/:id",
+    async (request, reply) => {
+      const agent2 = agentManager2.get(request.params.id);
+      if (!agent2) {
+        reply.code(404).send({ error: "Agent not found" });
+        return;
+      }
+      const force = request.query.force === "true";
+      try {
+        await agentManager2.stop(request.params.id, force);
+        return { ok: true };
+      } catch (err) {
+        reply.code(500).send({ error: err.message });
+      }
+    }
+  );
+  server2.post(
+    "/api/agents/:id/send",
+    async (request, reply) => {
+      const agent2 = agentManager2.get(request.params.id);
+      if (!agent2) {
+        reply.code(404).send({ error: "Agent not found" });
+        return;
+      }
+      const { message } = request.body;
+      if (!message) {
+        reply.code(400).send({ error: "message is required" });
+        return;
+      }
+      try {
+        await agentManager2.send(request.params.id, message);
+        return { ok: true };
+      } catch (err) {
+        reply.code(400).send({ error: err.message });
+      }
+    }
+  );
+  server2.get(
+    "/api/agents/:id/logs",
+    async (request, reply) => {
+      const agent2 = agentManager2.get(request.params.id);
+      if (!agent2) {
+        reply.code(404).send({ error: "Agent not found" });
+        return;
+      }
+      const limit = parseInt(request.query.lines || "100");
+      const logs = agentManager2.getLogs(request.params.id, limit);
+      return { logs };
+    }
+  );
+  server2.get("/api/templates", async () => {
+    return {
+      templates: Object.entries(config.agents.templates).map(([name, template]) => ({
+        name,
+        driver: template.driver,
+        model: template.model
+      }))
+    };
+  });
+  server2.get("/api/audit", async (request) => {
+    return { logs: [] };
+  });
+}
+var init_routes = __esm({
+  "src/server/api/routes.ts"() {
+    "use strict";
+    init_config();
+  }
+});
+
+// src/server/ws/index.ts
+function registerWebSocket(server2, options) {
+  const { config, agentManager: agentManager2 } = options;
+  const clients = /* @__PURE__ */ new Map();
+  server2.register(async (fastify) => {
+    fastify.get("/ws", { websocket: true }, (connection, req) => {
+      const ws = connection;
+      const clientId = Math.random().toString(36).slice(2);
+      const client = {
+        ws,
+        subscriptions: /* @__PURE__ */ new Set(),
+        authenticated: !config.auth.enabled
+      };
+      clients.set(clientId, client);
+      ws.on("message", (data) => {
+        try {
+          const msg = JSON.parse(data.toString());
+          handleMessage(clientId, client, msg);
+        } catch (err) {
+          send(ws, { type: "error", error: "Invalid JSON" });
+        }
+      });
+      ws.on("close", () => {
+        clients.delete(clientId);
+      });
+      ws.on("error", (err) => {
+        console.error("WebSocket error:", err);
+        clients.delete(clientId);
+      });
+      send(ws, {
+        type: "welcome",
+        clientId,
+        authenticated: client.authenticated
+      });
+    });
+  });
+  function handleMessage(clientId, client, msg) {
+    if (msg.type === "auth") {
+      if (validateAuth(msg.token, config)) {
+        client.authenticated = true;
+        send(client.ws, { type: "auth", success: true });
+      } else {
+        send(client.ws, { type: "auth", success: false, error: "Invalid token" });
+      }
+      return;
+    }
+    if (!client.authenticated) {
+      send(client.ws, { type: "error", error: "Not authenticated" });
+      return;
+    }
+    switch (msg.type) {
+      case "subscribe:logs":
+        if (msg.agentId) {
+          client.subscriptions.add(`logs:${msg.agentId}`);
+          send(client.ws, { type: "subscribed", channel: `logs:${msg.agentId}` });
+        }
+        break;
+      case "unsubscribe:logs":
+        if (msg.agentId) {
+          client.subscriptions.delete(`logs:${msg.agentId}`);
+          send(client.ws, { type: "unsubscribed", channel: `logs:${msg.agentId}` });
+        }
+        break;
+      case "subscribe:agents":
+        client.subscriptions.add("agents");
+        send(client.ws, { type: "subscribed", channel: "agents" });
+        break;
+      case "unsubscribe:agents":
+        client.subscriptions.delete("agents");
+        send(client.ws, { type: "unsubscribed", channel: "agents" });
+        break;
+      case "ping":
+        send(client.ws, { type: "pong", ts: Date.now() });
+        break;
+      default:
+        send(client.ws, { type: "error", error: `Unknown message type: ${msg.type}` });
+    }
+  }
+  agentManager2.on("agent:created", (agent2) => {
+    broadcast("agents", { type: "agent:created", agent: sanitizeAgent(agent2) });
+  });
+  agentManager2.on("agent:running", (agent2) => {
+    broadcast("agents", { type: "agent:running", agent: sanitizeAgent(agent2) });
+  });
+  agentManager2.on("agent:stopped", (agent2) => {
+    broadcast("agents", { type: "agent:stopped", agent: sanitizeAgent(agent2) });
+  });
+  agentManager2.on("agent:error", (agent2, error) => {
+    broadcast("agents", { type: "agent:error", agent: sanitizeAgent(agent2), error: error.message });
+  });
+  agentManager2.on("agent:log", (data) => {
+    broadcast(`logs:${data.agentId}`, { type: "agent:log", ...data });
+  });
+  function broadcast(channel, message) {
+    for (const client of clients.values()) {
+      if (client.authenticated && client.subscriptions.has(channel)) {
+        send(client.ws, message);
+      }
+    }
+  }
+  function send(ws, message) {
+    if (ws.readyState === ws.OPEN) {
+      ws.send(JSON.stringify(message));
+    }
+  }
+  function sanitizeAgent(agent2) {
+    return {
+      id: agent2.id,
+      name: agent2.name,
+      template: agent2.template,
+      status: agent2.status,
+      workspace: agent2.workspace,
+      model: agent2.model,
+      pid: agent2.pid,
+      currentTask: agent2.currentTask,
+      createdAt: agent2.createdAt,
+      startedAt: agent2.startedAt,
+      stoppedAt: agent2.stoppedAt,
+      error: agent2.error
+    };
+  }
+}
+var init_ws = __esm({
+  "src/server/ws/index.ts"() {
+    "use strict";
+    init_config();
+  }
+});
+
+// src/server/index.ts
+var server_exports = {};
+__export(server_exports, {
+  startServer: () => startServer
+});
+import Fastify from "fastify";
+import fastifyWebsocket from "@fastify/websocket";
+import fastifyCors from "@fastify/cors";
+import fastifyStatic from "@fastify/static";
+import pino from "pino";
+import { join as join4, dirname } from "path";
+import { fileURLToPath } from "url";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3 } from "fs";
+async function startServer(options) {
+  const config = loadConfig(options.configPath);
+  const logPath = join4(options.dataDir, "logs", "dirigent.log");
+  mkdirSync3(dirname(logPath), { recursive: true });
+  const logger = pino({
+    level: config.logging?.level || "info",
+    transport: {
+      targets: [
+        {
+          target: "pino-pretty",
+          options: { colorize: true },
+          level: "info"
+        },
+        {
+          target: "pino/file",
+          options: { destination: logPath },
+          level: "debug"
+        }
+      ]
+    }
+  });
+  const dbPath = join4(options.dataDir, "data", "dirigent.db");
+  mkdirSync3(dirname(dbPath), { recursive: true });
+  initDatabase(dbPath);
+  server = Fastify({ logger });
+  await server.register(fastifyCors, {
+    origin: true,
+    credentials: true
+  });
+  await server.register(fastifyWebsocket);
+  const dashboardPath = join4(__dirname, "..", "dashboard", "dist");
+  if (existsSync4(dashboardPath)) {
+    await server.register(fastifyStatic, {
+      root: dashboardPath,
+      prefix: "/"
+    });
+  }
+  agentManager = new AgentManager({
+    dataDir: options.dataDir,
+    config,
+    logger
+  });
+  registerApiRoutes(server, {
+    config,
+    agentManager,
+    startTime
+  });
+  registerWebSocket(server, {
+    config,
+    agentManager
+  });
+  server.get("/health", async () => ({ status: "ok", uptime: Math.floor((Date.now() - startTime) / 1e3) }));
+  const shutdown = async (signal) => {
+    logger.info(`Received ${signal}, shutting down...`);
+    if (agentManager) {
+      await agentManager.stopAll();
+    }
+    if (server) {
+      await server.close();
+    }
+    const db2 = getDatabase();
+    if (db2) db2.close();
+    process.exit(0);
+  };
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  try {
+    await server.listen({ port: options.port, host: config.server?.host || "0.0.0.0" });
+    console.log(`
+\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+\u2551                                                          \u2551
+\u2551   \u{1F3AD} DIRIGENT SERVER RUNNING                             \u2551
+\u2551                                                          \u2551
+\u2551   Dashboard:  http://localhost:${options.port.toString().padEnd(25)}\u2551
+\u2551   API:        http://localhost:${options.port}/api${" ".repeat(21)}\u2551
+\u2551   WebSocket:  ws://localhost:${options.port}/ws${" ".repeat(22)}\u2551
+\u2551                                                          \u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+`);
+  } catch (err) {
+    logger.error(err);
+    process.exit(1);
+  }
+}
+var __filename, __dirname, server, agentManager, startTime;
+var init_server = __esm({
+  "src/server/index.ts"() {
+    "use strict";
+    init_config();
+    init_db();
+    init_manager();
+    init_routes();
+    init_ws();
+    __filename = fileURLToPath(import.meta.url);
+    __dirname = dirname(__filename);
+    server = null;
+    agentManager = null;
+    startTime = Date.now();
+    if (process.env.DIRIGENT_CONFIG) {
+      startServer({
+        port: parseInt(process.env.DIRIGENT_PORT || "3000"),
+        configPath: process.env.DIRIGENT_CONFIG,
+        dataDir: process.env.DIRIGENT_DATA_DIR || ".dirigent"
+      });
+    }
+  }
+});
+
+// src/cli/index.ts
+import { Command } from "commander";
+import chalk8 from "chalk";
+
+// src/cli/commands/init.ts
+import chalk from "chalk";
+import ora from "ora";
+import * as readline from "readline";
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+import { nanoid } from "nanoid";
+async function prompt(question, defaultValue) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    const q = defaultValue ? `${question} (${defaultValue}): ` : `${question}: `;
+    rl.question(q, (answer) => {
+      rl.close();
+      resolve(answer || defaultValue || "");
+    });
+  });
+}
+async function confirm(question, defaultValue = true) {
+  const answer = await prompt(`${question} (${defaultValue ? "Y/n" : "y/N"})`, defaultValue ? "y" : "n");
+  return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
+}
+var DEFAULT_CONFIG = {
+  version: "1",
+  server: {
+    port: 3e3,
+    host: "0.0.0.0"
+  },
+  auth: {
+    enabled: true,
+    adminToken: ""
+    // Generated during init
+  },
+  agents: {
+    maxConcurrent: 10,
+    defaultTimeout: 3600,
+    templates: {
+      claude: {
+        driver: "claude-code",
+        model: "claude-sonnet-4-5",
+        maxTokens: 16e3
+      },
+      codex: {
+        driver: "codex",
+        model: "codex-1"
+      },
+      custom: {
+        driver: "subprocess",
+        command: []
+      }
+    }
+  },
+  logging: {
+    level: "info",
+    format: "pretty",
+    file: "logs/dirigent.log"
+  },
+  database: {
+    path: "data/dirigent.db"
+  }
+};
+async function initCommand(options) {
+  console.log(chalk.cyan("\n\u{1F3AD} Initializing Dirigent workspace\n"));
+  const dataDir = options.dataDir || ".dirigent";
+  const configPath = join(process.cwd(), dataDir, "config.json");
+  if (existsSync(configPath)) {
+    const overwrite = options.yes ? true : await confirm("Dirigent is already initialized. Overwrite config?", false);
+    if (!overwrite) {
+      console.log(chalk.yellow("Aborted."));
+      return;
+    }
+  }
+  let config = { ...DEFAULT_CONFIG };
+  if (!options.yes) {
+    const portStr = await prompt("Server port", options.port || "3000");
+    const authEnabled = await confirm("Enable authentication?", true);
+    const maxAgentsStr = await prompt("Max concurrent agents", "10");
+    config.server.port = parseInt(portStr) || 3e3;
+    config.auth.enabled = authEnabled;
+    config.agents.maxConcurrent = parseInt(maxAgentsStr) || 10;
+  } else {
+    config.server.port = parseInt(options.port || "3000");
+  }
+  config.auth.adminToken = nanoid(32);
+  const spinner = ora("Creating workspace...").start();
+  try {
+    const dirs = [
+      dataDir,
+      join(dataDir, "data"),
+      join(dataDir, "logs"),
+      join(dataDir, "agents"),
+      join(dataDir, "workspaces")
+    ];
+    for (const dir of dirs) {
+      mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(configPath, JSON.stringify(config, null, 2));
+    writeFileSync(
+      join(dataDir, ".gitignore"),
+      `# Dirigent data
+data/
+logs/
+agents/
+workspaces/
+*.db
+*.db-journal
+`
+    );
+    spinner.succeed("Workspace created");
+    console.log(chalk.green("\n\u2705 Dirigent initialized successfully!\n"));
+    console.log(chalk.dim("Configuration:"));
+    console.log(`   ${chalk.cyan("Config:")} ${configPath}`);
+    console.log(`   ${chalk.cyan("Port:")} ${config.server.port}`);
+    console.log(`   ${chalk.cyan("Auth:")} ${config.auth.enabled ? "Enabled" : "Disabled"}`);
+    if (config.auth.enabled) {
+      console.log(chalk.yellow("\n\u26A0\uFE0F  Save your admin token (shown only once):"));
+      console.log(chalk.bold.white(`   ${config.auth.adminToken}
+`));
+    }
+    console.log(chalk.dim("Next steps:"));
+    console.log(`   ${chalk.cyan("1.")} Start the server: ${chalk.bold("dirigent up")}`);
+    console.log(`   ${chalk.cyan("2.")} Open dashboard: ${chalk.bold(`http://localhost:${config.server.port}`)}`);
+    console.log(`   ${chalk.cyan("3.")} Spawn an agent: ${chalk.bold("dirigent agent spawn claude")}
+`);
+  } catch (err) {
+    spinner.fail("Failed to create workspace");
+    console.error(chalk.red(err));
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/up.ts
+import chalk2 from "chalk";
+import ora2 from "ora";
+import { existsSync as existsSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { join as join5 } from "path";
+import { spawn as spawn2 } from "child_process";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname2 } from "path";
+async function upCommand(options) {
+  const dataDir = ".dirigent";
+  const configPath = join5(process.cwd(), dataDir, "config.json");
+  const pidPath = join5(process.cwd(), dataDir, "dirigent.pid");
+  if (!existsSync5(configPath)) {
+    console.log(chalk2.red("\n\u274C Dirigent not initialized. Run `dirigent init` first.\n"));
+    process.exit(1);
+  }
+  if (existsSync5(pidPath)) {
+    const pid = parseInt(readFileSync3(pidPath, "utf-8").trim());
+    try {
+      process.kill(pid, 0);
+      console.log(chalk2.yellow(`
+\u26A0\uFE0F  Dirigent is already running (PID: ${pid})`));
+      console.log(chalk2.dim("   Use `dirigent down` to stop it first.\n"));
+      return;
+    } catch {
+    }
+  }
+  const config = JSON.parse(readFileSync3(configPath, "utf-8"));
+  const port = options.port || config.server.port;
+  console.log(chalk2.cyan("\n\u{1F3AD} Starting Dirigent server...\n"));
+  const spinner = ora2("Starting server...").start();
+  try {
+    const __filename2 = fileURLToPath2(import.meta.url);
+    const __dirname2 = dirname2(__filename2);
+    const serverPath = join5(__dirname2, "..", "..", "server", "index.js");
+    const env = {
+      ...process.env,
+      DIRIGENT_PORT: port.toString(),
+      DIRIGENT_CONFIG: configPath,
+      DIRIGENT_DATA_DIR: join5(process.cwd(), dataDir)
+    };
+    if (options.detach) {
+      const child = spawn2(process.execPath, [serverPath], {
+        detached: true,
+        stdio: "ignore",
+        env
+      });
+      child.unref();
+      writeFileSync3(pidPath, child.pid.toString());
+      spinner.succeed(`Server started (PID: ${child.pid})`);
+      console.log(chalk2.green(`
+\u2705 Dirigent is running
+`));
+      console.log(`   ${chalk2.cyan("Dashboard:")} http://localhost:${port}`);
+      console.log(`   ${chalk2.cyan("API:")} http://localhost:${port}/api`);
+      console.log(`   ${chalk2.cyan("WebSocket:")} ws://localhost:${port}/ws
+`);
+      console.log(chalk2.dim(`   Stop with: dirigent down
+`));
+    } else {
+      spinner.succeed("Server starting...");
+      const { startServer: startServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
+      await startServer2({
+        port: parseInt(port),
+        configPath,
+        dataDir: join5(process.cwd(), dataDir)
+      });
+    }
+  } catch (err) {
+    spinner.fail("Failed to start server");
+    console.error(chalk2.red(err));
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/down.ts
+import chalk3 from "chalk";
+import ora3 from "ora";
+import { existsSync as existsSync6, readFileSync as readFileSync4, unlinkSync } from "fs";
+import { join as join6 } from "path";
+import treeKill2 from "tree-kill";
+async function downCommand(options) {
+  const dataDir = ".dirigent";
+  const pidPath = join6(process.cwd(), dataDir, "dirigent.pid");
+  if (!existsSync6(pidPath)) {
+    console.log(chalk3.yellow("\n\u26A0\uFE0F  Dirigent is not running.\n"));
+    return;
+  }
+  const pid = parseInt(readFileSync4(pidPath, "utf-8").trim());
+  const spinner = ora3("Stopping Dirigent...").start();
+  try {
+    try {
+      process.kill(pid, 0);
+    } catch {
+      spinner.warn("Dirigent was not running (stale PID file)");
+      unlinkSync(pidPath);
+      return;
+    }
+    await new Promise((resolve, reject) => {
+      const signal = options.force ? "SIGKILL" : "SIGTERM";
+      treeKill2(pid, signal, (err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+    unlinkSync(pidPath);
+    spinner.succeed("Dirigent stopped");
+    console.log(chalk3.green("\n\u2705 Dirigent has been stopped.\n"));
+  } catch (err) {
+    spinner.fail("Failed to stop Dirigent");
+    console.error(chalk3.red(err));
+    if (options.force) {
+      try {
+        unlinkSync(pidPath);
+      } catch {
+      }
+    }
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/status.ts
+import chalk4 from "chalk";
+import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
+import { join as join7 } from "path";
+import boxen from "boxen";
+async function statusCommand(options) {
+  const dataDir = ".dirigent";
+  const configPath = join7(process.cwd(), dataDir, "config.json");
+  const pidPath = join7(process.cwd(), dataDir, "dirigent.pid");
+  if (!existsSync7(configPath)) {
+    if (options.json) {
+      console.log(JSON.stringify({ initialized: false, running: false }));
+    } else {
+      console.log(chalk4.yellow("\n\u26A0\uFE0F  Dirigent not initialized. Run `dirigent init` first.\n"));
+    }
+    return;
+  }
+  const config = JSON.parse(readFileSync5(configPath, "utf-8"));
+  let running = false;
+  let pid = null;
+  let serverStatus = null;
+  if (existsSync7(pidPath)) {
+    pid = parseInt(readFileSync5(pidPath, "utf-8").trim());
+    try {
+      process.kill(pid, 0);
+      running = true;
+      try {
+        const res = await fetch(`http://localhost:${config.server.port}/api/status`);
+        if (res.ok) {
+          serverStatus = await res.json();
+        }
+      } catch {
+      }
+    } catch {
+      running = false;
+    }
+  }
+  if (options.json) {
+    console.log(
+      JSON.stringify({
+        initialized: true,
+        running,
+        pid,
+        port: config.server.port,
+        agents: serverStatus?.agents || [],
+        uptime: serverStatus?.uptime || null
+      })
+    );
+    return;
+  }
+  const statusIcon = running ? chalk4.green("\u25CF") : chalk4.red("\u25CF");
+  const statusText = running ? chalk4.green("Running") : chalk4.red("Stopped");
+  console.log(
+    boxen(
+      `${chalk4.bold.white("\u{1F3AD} DIRIGENT STATUS")}
+
+${chalk4.dim("Status:")}    ${statusIcon} ${statusText}${pid ? chalk4.dim(` (PID: ${pid})`) : ""}
+${chalk4.dim("Port:")}      ${config.server.port}
+${chalk4.dim("Auth:")}      ${config.auth.enabled ? "Enabled" : "Disabled"}
+` + (serverStatus ? `${chalk4.dim("Uptime:")}    ${formatUptime(serverStatus.uptime)}
+${chalk4.dim("Agents:")}    ${serverStatus.agents.running}/${serverStatus.agents.total} running` : ""),
+      {
+        padding: 1,
+        margin: 1,
+        borderStyle: "round",
+        borderColor: running ? "green" : "red"
+      }
+    )
+  );
+  if (running && serverStatus?.agents?.list?.length > 0) {
+    console.log(chalk4.dim("\nActive Agents:\n"));
+    for (const agent2 of serverStatus.agents.list) {
+      const agentIcon = agent2.status === "running" ? chalk4.green("\u25CF") : chalk4.yellow("\u25CF");
+      console.log(`  ${agentIcon} ${chalk4.bold(agent2.name)} ${chalk4.dim(`(${agent2.id})`)}`);
+      console.log(`    ${chalk4.dim("Template:")} ${agent2.template}`);
+      console.log(`    ${chalk4.dim("Workspace:")} ${agent2.workspace}`);
+      console.log("");
+    }
+  }
+  if (!running) {
+    console.log(chalk4.dim(`
+  Start with: ${chalk4.cyan("dirigent up")}
+`));
+  }
+}
+function formatUptime(seconds) {
+  if (seconds < 60) return `${seconds}s`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor(seconds % 3600 / 60);
+  return `${h}h ${m}m`;
+}
+
+// src/cli/commands/agent.ts
+import chalk5 from "chalk";
+import ora4 from "ora";
+import { existsSync as existsSync8, readFileSync as readFileSync6 } from "fs";
+import { join as join8 } from "path";
+async function getConfig() {
+  const dataDir = ".dirigent";
+  const configPath = join8(process.cwd(), dataDir, "config.json");
+  if (!existsSync8(configPath)) {
+    console.log(chalk5.red("\n\u274C Dirigent not initialized. Run `dirigent init` first.\n"));
+    process.exit(1);
+  }
+  return JSON.parse(readFileSync6(configPath, "utf-8"));
+}
+async function apiCall(method, path, body) {
+  const config = await getConfig();
+  const url = `http://localhost:${config.server.port}/api${path}`;
+  const res = await fetch(url, {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${config.auth.adminToken}`
+    },
+    body: body ? JSON.stringify(body) : void 0
+  });
+  if (!res.ok) {
+    const error = await res.json().catch(() => ({ error: res.statusText }));
+    throw new Error(error.error || error.message || "API call failed");
+  }
+  return res.json();
+}
+async function agentCommand(action, options) {
+  switch (action) {
+    case "list":
+      await listAgents(options);
+      break;
+    case "spawn":
+      await spawnAgent(options);
+      break;
+    case "stop":
+      await stopAgent(options);
+      break;
+    case "send":
+      await sendToAgent(options);
+      break;
+    case "logs":
+      await agentLogs(options);
+      break;
+    default:
+      console.log(chalk5.red(`Unknown action: ${action}`));
+  }
+}
+async function listAgents(options) {
+  try {
+    const result = await apiCall("GET", `/agents${options.all ? "?all=true" : ""}`);
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    if (result.agents.length === 0) {
+      console.log(chalk5.yellow("\nNo agents found.\n"));
+      console.log(chalk5.dim("  Spawn one with: dirigent agent spawn claude\n"));
+      return;
+    }
+    console.log(chalk5.cyan("\n\u{1F916} Agents\n"));
+    for (const agent2 of result.agents) {
+      const icon = agent2.status === "running" ? chalk5.green("\u25CF") : agent2.status === "idle" ? chalk5.yellow("\u25CF") : chalk5.red("\u25CF");
+      console.log(`${icon} ${chalk5.bold(agent2.name)} ${chalk5.dim(`[${agent2.id}]`)}`);
+      console.log(`  ${chalk5.dim("Template:")} ${agent2.template}`);
+      console.log(`  ${chalk5.dim("Status:")} ${agent2.status}`);
+      console.log(`  ${chalk5.dim("Workspace:")} ${agent2.workspace || "N/A"}`);
+      if (agent2.currentTask) {
+        console.log(`  ${chalk5.dim("Task:")} ${agent2.currentTask.substring(0, 60)}...`);
+      }
+      console.log("");
+    }
+  } catch (err) {
+    console.log(chalk5.red(`
+\u274C ${err.message}
+`));
+    console.log(chalk5.dim("  Make sure Dirigent is running: dirigent up\n"));
+  }
+}
+async function spawnAgent(options) {
+  const spinner = ora4("Spawning agent...").start();
+  try {
+    const result = await apiCall("POST", "/agents", {
+      template: options.template,
+      name: options.name,
+      workspace: options.workspace,
+      task: options.task,
+      model: options.model
+    });
+    spinner.succeed(`Agent spawned: ${chalk5.bold(result.agent.name)}`);
+    console.log(`
+  ${chalk5.dim("ID:")} ${result.agent.id}`);
+    console.log(`  ${chalk5.dim("Template:")} ${result.agent.template}`);
+    console.log(`  ${chalk5.dim("Workspace:")} ${result.agent.workspace}`);
+    if (options.task) {
+      console.log(`  ${chalk5.dim("Task:")} ${options.task.substring(0, 60)}...`);
+    }
+    console.log(chalk5.dim(`
+  View logs: dirigent agent logs ${result.agent.id}
+`));
+  } catch (err) {
+    spinner.fail("Failed to spawn agent");
+    console.log(chalk5.red(`
+\u274C ${err.message}
+`));
+  }
+}
+async function stopAgent(options) {
+  const spinner = ora4("Stopping agent...").start();
+  try {
+    await apiCall("DELETE", `/agents/${options.id}${options.force ? "?force=true" : ""}`);
+    spinner.succeed(`Agent stopped: ${options.id}`);
+  } catch (err) {
+    spinner.fail("Failed to stop agent");
+    console.log(chalk5.red(`
+\u274C ${err.message}
+`));
+  }
+}
+async function sendToAgent(options) {
+  try {
+    const result = await apiCall("POST", `/agents/${options.id}/send`, {
+      message: options.message
+    });
+    console.log(chalk5.green(`
+\u2709\uFE0F  Message sent to agent ${options.id}
+`));
+    if (result.response) {
+      console.log(chalk5.dim("Response:"));
+      console.log(result.response);
+    }
+  } catch (err) {
+    console.log(chalk5.red(`
+\u274C ${err.message}
+`));
+  }
+}
+async function agentLogs(options) {
+  const config = await getConfig();
+  if (options.follow) {
+    const { io } = await import("socket.io-client");
+    const socket = io(`http://localhost:${config.server.port}`, {
+      auth: { token: config.auth.adminToken }
+    });
+    socket.on("connect", () => {
+      socket.emit("subscribe:logs", { agentId: options.id });
+      console.log(chalk5.dim(`
+Streaming logs for agent ${options.id}...
+`));
+    });
+    socket.on("agent:log", (data) => {
+      const timestamp = chalk5.dim(new Date(data.timestamp).toISOString().split("T")[1].slice(0, 8));
+      const level = data.level === "error" ? chalk5.red("ERR") : data.level === "warn" ? chalk5.yellow("WRN") : chalk5.blue("INF");
+      console.log(`${timestamp} ${level} ${data.message}`);
+    });
+    socket.on("disconnect", () => {
+      console.log(chalk5.dim("\nDisconnected.\n"));
+      process.exit(0);
+    });
+    process.on("SIGINT", () => {
+      socket.disconnect();
+    });
+  } else {
+    try {
+      const result = await apiCall(
+        "GET",
+        `/agents/${options.id}/logs?lines=${options.lines || 50}`
+      );
+      console.log(chalk5.dim(`
+Logs for agent ${options.id}:
+`));
+      for (const log of result.logs) {
+        const timestamp = chalk5.dim(new Date(log.timestamp).toISOString().split("T")[1].slice(0, 8));
+        const level = log.level === "error" ? chalk5.red("ERR") : log.level === "warn" ? chalk5.yellow("WRN") : chalk5.blue("INF");
+        console.log(`${timestamp} ${level} ${log.message}`);
+      }
+      console.log(chalk5.dim(`
+  Stream with: dirigent agent logs ${options.id} -f
+`));
+    } catch (err) {
+      console.log(chalk5.red(`
+\u274C ${err.message}
+`));
+    }
+  }
+}
+
+// src/cli/commands/logs.ts
+import chalk6 from "chalk";
+import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
+import { join as join9 } from "path";
+async function logsCommand(options) {
+  const dataDir = ".dirigent";
+  const logPath = join9(process.cwd(), dataDir, "logs", "dirigent.log");
+  if (!existsSync9(logPath)) {
+    console.log(chalk6.yellow("\n\u26A0\uFE0F  No logs found.\n"));
+    return;
+  }
+  const lines = parseInt(options.lines || "100");
+  if (options.follow) {
+    const { spawn: spawn4 } = await import("child_process");
+    const tail = spawn4("tail", ["-f", "-n", lines.toString(), logPath], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    tail.stdout.on("data", (data) => {
+      process.stdout.write(formatLog(data.toString()));
+    });
+    tail.stderr.on("data", (data) => {
+      process.stderr.write(data);
+    });
+    process.on("SIGINT", () => {
+      tail.kill();
+      process.exit(0);
+    });
+  } else {
+    const content = readFileSync7(logPath, "utf-8");
+    const allLines = content.trim().split("\n");
+    const lastLines = allLines.slice(-lines);
+    for (const line of lastLines) {
+      console.log(formatLog(line));
+    }
+    console.log(chalk6.dim(`
+  Stream with: dirigent logs -f
+`));
+  }
+}
+function formatLog(line) {
+  try {
+    const parsed = JSON.parse(line);
+    const time = chalk6.dim(
+      new Date(parsed.time).toISOString().split("T")[1].slice(0, 8)
+    );
+    const level = parsed.level <= 20 ? chalk6.dim("DBG") : parsed.level <= 30 ? chalk6.blue("INF") : parsed.level <= 40 ? chalk6.yellow("WRN") : chalk6.red("ERR");
+    const msg = parsed.msg || "";
+    return `${time} ${level} ${msg}`;
+  } catch {
+    return line;
+  }
+}
+
+// src/cli/commands/config.ts
+import chalk7 from "chalk";
+import { existsSync as existsSync10, readFileSync as readFileSync8, writeFileSync as writeFileSync4 } from "fs";
+import { join as join10 } from "path";
+import { spawn as spawn3 } from "child_process";
+async function configCommand(options) {
+  const dataDir = ".dirigent";
+  const configPath = join10(process.cwd(), dataDir, "config.json");
+  if (!existsSync10(configPath)) {
+    console.log(chalk7.red("\n\u274C Dirigent not initialized. Run `dirigent init` first.\n"));
+    process.exit(1);
+  }
+  const config = JSON.parse(readFileSync8(configPath, "utf-8"));
+  if (options.get) {
+    const value = getNestedValue(config, options.get);
+    if (value === void 0) {
+      console.log(chalk7.yellow(`
+\u26A0\uFE0F  Key not found: ${options.get}
+`));
+    } else {
+      console.log(typeof value === "object" ? JSON.stringify(value, null, 2) : value);
+    }
+    return;
+  }
+  if (options.set) {
+    const [key, ...valueParts] = options.set.split("=");
+    const value = valueParts.join("=");
+    if (!key || value === void 0) {
+      console.log(chalk7.red("\n\u274C Invalid format. Use: --set key=value\n"));
+      process.exit(1);
+    }
+    let parsedValue = value;
+    if (value === "true") parsedValue = true;
+    else if (value === "false") parsedValue = false;
+    else if (!isNaN(Number(value))) parsedValue = Number(value);
+    else {
+      try {
+        parsedValue = JSON.parse(value);
+      } catch {
+      }
+    }
+    setNestedValue(config, key, parsedValue);
+    writeFileSync4(configPath, JSON.stringify(config, null, 2));
+    console.log(chalk7.green(`
+\u2705 Set ${key} = ${JSON.stringify(parsedValue)}
+`));
+    console.log(chalk7.dim("  Restart Dirigent for changes to take effect: dirigent down && dirigent up\n"));
+    return;
+  }
+  if (options.edit) {
+    const editor = process.env.EDITOR || process.env.VISUAL || "vim";
+    const child = spawn3(editor, [configPath], {
+      stdio: "inherit"
+    });
+    child.on("exit", () => {
+      console.log(chalk7.dim("\n  Restart Dirigent for changes to take effect: dirigent down && dirigent up\n"));
+    });
+    return;
+  }
+  console.log(chalk7.cyan("\n\u{1F527} Configuration\n"));
+  console.log(JSON.stringify(config, null, 2));
+  console.log(chalk7.dim(`
+  File: ${configPath}
+`));
+}
+function getNestedValue(obj, path) {
+  return path.split(".").reduce((acc, key) => acc?.[key], obj);
+}
+function setNestedValue(obj, path, value) {
+  const keys = path.split(".");
+  const lastKey = keys.pop();
+  const target = keys.reduce((acc, key) => {
+    if (!(key in acc)) acc[key] = {};
+    return acc[key];
+  }, obj);
+  target[lastKey] = value;
+}
+
+// src/cli/index.ts
+var version = "0.1.0";
+var program = new Command();
+var banner = `
+${chalk8.bold.cyan("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557")}
+${chalk8.bold.cyan("\u2551")}  ${chalk8.bold.white("\u{1F3AD} DIRIGENT")}                          ${chalk8.bold.cyan("\u2551")}
+${chalk8.bold.cyan("\u2551")}  ${chalk8.dim("AI Agent Orchestration Platform")}      ${chalk8.bold.cyan("\u2551")}
+${chalk8.bold.cyan("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D")}
+`;
+program.name("dirigent").description("AI Agent Orchestration Platform - Enterprise-grade orchestration for AI coding agents").version(version).addHelpText("beforeAll", banner);
+program.command("init").description("Initialize a new Dirigent workspace").option("-y, --yes", "Accept all defaults").option("--port <port>", "Server port", "3000").option("--data-dir <dir>", "Data directory", ".dirigent").action(initCommand);
+program.command("up").description("Start the Dirigent server").option("-d, --detach", "Run in background").option("--port <port>", "Override server port").action(upCommand);
+program.command("down").description("Stop the Dirigent server").option("-f, --force", "Force stop all agents").action(downCommand);
+program.command("status").description("Show server and agent status").option("-j, --json", "Output as JSON").action(statusCommand);
+var agent = program.command("agent").description("Manage agents");
+agent.command("list").description("List all agents").option("-a, --all", "Include stopped agents").option("-j, --json", "Output as JSON").action((opts) => agentCommand("list", opts));
+agent.command("spawn <template>").description("Spawn a new agent from template").option("-n, --name <name>", "Agent name").option("-w, --workspace <path>", "Workspace directory").option("-t, --task <task>", "Initial task").option("--model <model>", "Model override").action((template, opts) => agentCommand("spawn", { template, ...opts }));
+agent.command("stop <id>").description("Stop an agent").option("-f, --force", "Force stop").action((id, opts) => agentCommand("stop", { id, ...opts }));
+agent.command("send <id> <message>").description("Send a message to an agent").action((id, message) => agentCommand("send", { id, message }));
+agent.command("logs <id>").description("Stream agent logs").option("-f, --follow", "Follow log output").option("-n, --lines <n>", "Number of lines", "50").action((id, opts) => agentCommand("logs", { id, ...opts }));
+program.command("logs").description("View server logs").option("-f, --follow", "Follow log output").option("-n, --lines <n>", "Number of lines", "100").action(logsCommand);
+program.command("config").description("View or edit configuration").option("--get <key>", "Get a config value").option("--set <key=value>", "Set a config value").option("--list", "List all config").option("--edit", "Open config in editor").action(configCommand);
+program.command("dashboard").alias("ui").description("Open the web dashboard").option("-p, --port <port>", "Dashboard port").action(async () => {
+  const config = await Promise.resolve().then(() => (init_config(), config_exports)).then((m) => m.loadConfig());
+  console.log(chalk8.cyan(`
+\u{1F310} Dashboard: ${chalk8.bold(`http://localhost:${config.server.port}`)}
+`));
+});
+program.parse();
+if (!process.argv.slice(2).length) {
+  console.log(banner);
+  program.outputHelp();
+}
+//# sourceMappingURL=index.js.map