diragent 0.1.0

package/dist/server/index.js

@@ -0,0 +1,861 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+
+// src/server/index.ts
+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 join3, dirname } from "path";
+import { fileURLToPath } from "url";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
+
+// src/server/config.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { z } from "zod";
+var 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()
+});
+var 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({})
+});
+var cachedConfig = null;
+function loadConfig(configPath) {
+  if (cachedConfig) return cachedConfig;
+  const path = configPath || findConfigPath();
+  if (!path || !existsSync(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 = [
+    join(process.cwd(), ".dirigent", "config.json"),
+    join(process.cwd(), "dirigent.json"),
+    join(process.env.HOME || "", ".dirigent", "config.json")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(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;
+}
+
+// src/server/db/index.ts
+import Database from "better-sqlite3";
+var db = null;
+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(agent) {
+  const stmt = db.prepare(`
+    INSERT INTO agents (id, name, template, workspace, model, config)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `);
+  stmt.run(
+    agent.id,
+    agent.name,
+    agent.template,
+    agent.workspace || null,
+    agent.model || null,
+    agent.config ? JSON.stringify(agent.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);
+}
+
+// src/server/agents/manager.ts
+import { EventEmitter } from "events";
+import { nanoid } from "nanoid";
+import { spawn } from "child_process";
+import treeKill from "tree-kill";
+import { join as join2 } from "path";
+import { mkdirSync, existsSync as existsSync2 } from "fs";
+var 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 = nanoid(12);
+    const agentName = name || `${template}-${id.slice(0, 6)}`;
+    const agentWorkspace = workspace || join2(this.dataDir, "workspaces", id);
+    if (!existsSync2(agentWorkspace)) {
+      mkdirSync(agentWorkspace, { recursive: true });
+    }
+    const agent = {
+      id,
+      name: agentName,
+      template,
+      status: "created",
+      workspace: agentWorkspace,
+      model: model || templateConfig.model,
+      currentTask: task,
+      createdAt: Date.now()
+    };
+    insertAgent({
+      id: agent.id,
+      name: agent.name,
+      template: agent.template,
+      workspace: agent.workspace,
+      model: agent.model
+    });
+    audit("agent.created", null, "agent", id, { name: agentName, template });
+    this.agents.set(id, agent);
+    this.emit("agent:created", agent);
+    await this.startAgent(agent, templateConfig, task);
+    return agent;
+  }
+  async startAgent(agent, template, initialTask) {
+    agent.status = "starting";
+    updateAgent(agent.id, { status: "starting" });
+    this.emit("agent:starting", agent);
+    try {
+      const { command, env } = this.buildCommand(agent, template);
+      this.logger.info({ agentId: agent.id, command }, "Starting agent");
+      const proc = spawn(command[0], command.slice(1), {
+        cwd: agent.workspace,
+        env: {
+          ...process.env,
+          ...env,
+          DIRIGENT_AGENT_ID: agent.id,
+          DIRIGENT_AGENT_NAME: agent.name
+        },
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      agent.pid = proc.pid;
+      agent.process = proc;
+      agent.status = "running";
+      agent.startedAt = Date.now();
+      updateAgent(agent.id, {
+        status: "running",
+        pid: proc.pid,
+        started_at: Math.floor(Date.now() / 1e3)
+      });
+      this.processes.set(agent.id, proc);
+      proc.stdout?.on("data", (data) => {
+        const message = data.toString().trim();
+        if (message) {
+          this.log(agent.id, "info", message);
+        }
+      });
+      proc.stderr?.on("data", (data) => {
+        const message = data.toString().trim();
+        if (message) {
+          this.log(agent.id, "error", message);
+        }
+      });
+      proc.on("exit", (code, signal) => {
+        this.logger.info({ agentId: agent.id, code, signal }, "Agent exited");
+        agent.status = code === 0 ? "stopped" : "error";
+        agent.stoppedAt = Date.now();
+        if (code !== 0) {
+          agent.error = `Exited with code ${code}`;
+        }
+        updateAgent(agent.id, {
+          status: agent.status,
+          stopped_at: Math.floor(Date.now() / 1e3),
+          error: agent.error || null
+        });
+        this.processes.delete(agent.id);
+        this.emit("agent:stopped", agent);
+        audit("agent.stopped", null, "agent", agent.id, { code, signal });
+      });
+      proc.on("error", (err) => {
+        this.logger.error({ agentId: agent.id, err }, "Agent process error");
+        agent.status = "error";
+        agent.error = err.message;
+        updateAgent(agent.id, { status: "error", error: err.message });
+        this.emit("agent:error", agent, err);
+      });
+      this.emit("agent:running", agent);
+      audit("agent.started", null, "agent", agent.id, { pid: proc.pid });
+      if (initialTask && proc.stdin) {
+        proc.stdin.write(initialTask + "\n");
+      }
+    } catch (err) {
+      agent.status = "error";
+      agent.error = err.message;
+      updateAgent(agent.id, { status: "error", error: err.message });
+      this.emit("agent:error", agent, err);
+      throw err;
+    }
+  }
+  buildCommand(agent, template) {
+    const env = { ...template.env };
+    switch (template.driver) {
+      case "claude-code":
+        return {
+          command: ["claude", "--dangerously-skip-permissions"],
+          env: {
+            ...env,
+            ANTHROPIC_MODEL: agent.model || template.model || "claude-sonnet-4-5"
+          }
+        };
+      case "codex":
+        return {
+          command: ["codex", "--model", agent.model || template.model || "codex-1"],
+          env
+        };
+      case "clawdbot":
+        return {
+          command: ["clawdbot", "agent", "--headless"],
+          env: {
+            ...env,
+            CLAWDBOT_MODEL: agent.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 agent = this.agents.get(id);
+    if (!agent) {
+      throw new Error(`Agent not found: ${id}`);
+    }
+    if (agent.status !== "running" && agent.status !== "starting") {
+      return;
+    }
+    agent.status = "stopping";
+    this.emit("agent:stopping", agent);
+    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 agent = this.agents.get(id);
+    if (!agent) {
+      throw new Error(`Agent not found: ${id}`);
+    }
+    if (agent.status !== "running") {
+      throw new Error(`Agent is not running: ${agent.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 agent = await agentManager2.spawn({ template, name, workspace, task, model });
+      return {
+        agent: {
+          id: agent.id,
+          name: agent.name,
+          template: agent.template,
+          status: agent.status,
+          workspace: agent.workspace,
+          model: agent.model
+        }
+      };
+    } catch (err) {
+      reply.code(400).send({ error: err.message });
+    }
+  });
+  server2.get("/api/agents/:id", async (request, reply) => {
+    const agent = agentManager2.get(request.params.id);
+    if (!agent) {
+      reply.code(404).send({ error: "Agent not found" });
+      return;
+    }
+    return {
+      agent: {
+        id: agent.id,
+        name: agent.name,
+        template: agent.template,
+        status: agent.status,
+        workspace: agent.workspace,
+        model: agent.model,
+        pid: agent.pid,
+        currentTask: agent.currentTask,
+        createdAt: agent.createdAt,
+        startedAt: agent.startedAt,
+        stoppedAt: agent.stoppedAt,
+        error: agent.error
+      }
+    };
+  });
+  server2.delete(
+    "/api/agents/:id",
+    async (request, reply) => {
+      const agent = agentManager2.get(request.params.id);
+      if (!agent) {
+        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 agent = agentManager2.get(request.params.id);
+      if (!agent) {
+        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 agent = agentManager2.get(request.params.id);
+      if (!agent) {
+        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: [] };
+  });
+}
+
+// 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", (agent) => {
+    broadcast("agents", { type: "agent:created", agent: sanitizeAgent(agent) });
+  });
+  agentManager2.on("agent:running", (agent) => {
+    broadcast("agents", { type: "agent:running", agent: sanitizeAgent(agent) });
+  });
+  agentManager2.on("agent:stopped", (agent) => {
+    broadcast("agents", { type: "agent:stopped", agent: sanitizeAgent(agent) });
+  });
+  agentManager2.on("agent:error", (agent, error) => {
+    broadcast("agents", { type: "agent:error", agent: sanitizeAgent(agent), 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(agent) {
+    return {
+      id: agent.id,
+      name: agent.name,
+      template: agent.template,
+      status: agent.status,
+      workspace: agent.workspace,
+      model: agent.model,
+      pid: agent.pid,
+      currentTask: agent.currentTask,
+      createdAt: agent.createdAt,
+      startedAt: agent.startedAt,
+      stoppedAt: agent.stoppedAt,
+      error: agent.error
+    };
+  }
+}
+
+// src/server/index.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var server = null;
+var agentManager = null;
+var startTime = Date.now();
+async function startServer(options) {
+  const config = loadConfig(options.configPath);
+  const logPath = join3(options.dataDir, "logs", "dirigent.log");
+  mkdirSync2(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 = join3(options.dataDir, "data", "dirigent.db");
+  mkdirSync2(dirname(dbPath), { recursive: true });
+  initDatabase(dbPath);
+  server = Fastify({ logger });
+  await server.register(fastifyCors, {
+    origin: true,
+    credentials: true
+  });
+  await server.register(fastifyWebsocket);
+  const dashboardPath = join3(__dirname, "..", "dashboard", "dist");
+  if (existsSync3(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);
+  }
+}
+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"
+  });
+}
+export {
+  startServer
+};
+//# sourceMappingURL=index.js.map