@jx0/agency 0.2.0

package/src/api/lib/fleet-sync.ts

@@ -0,0 +1,156 @@
+import * as fs from "fs";
+import * as path from "path";
+import { db } from "../db/client.js";
+
+function resolveFleetPath(): string {
+  return process.env.FLEET_PATH ?? path.resolve(process.cwd(), ".agency", "fleet.json");
+}
+
+let writeLock = false;
+let watcherTimeout: ReturnType<typeof setTimeout> | null = null;
+
+interface FleetAgent {
+  role: string;
+  location?: string;
+  host?: string;
+  slackBotToken?: string;
+  slackAppToken?: string;
+}
+
+interface Fleet {
+  agents: Record<string, FleetAgent>;
+  [key: string]: any;
+}
+
+export function readFleet(): Fleet {
+  const fleetPath = resolveFleetPath();
+  if (!fs.existsSync(fleetPath)) {
+    return { agents: {} };
+  }
+  return JSON.parse(fs.readFileSync(fleetPath, "utf-8"));
+}
+
+function writeFleet(fleet: Fleet): void {
+  const fleetPath = resolveFleetPath();
+  fs.writeFileSync(fleetPath, JSON.stringify(fleet, null, 2) + "\n");
+}
+
+export async function writeAgentToFleet(
+  name: string,
+  config: FleetAgent
+): Promise<void> {
+  writeLock = true;
+  try {
+    const fleet = readFleet();
+    fleet.agents[name] = config;
+    writeFleet(fleet);
+  } finally {
+    writeLock = false;
+  }
+}
+
+export async function removeAgentFromFleet(name: string): Promise<void> {
+  writeLock = true;
+  try {
+    const fleet = readFleet();
+    delete fleet.agents[name];
+    writeFleet(fleet);
+  } finally {
+    writeLock = false;
+  }
+}
+
+export async function reconcileDbFromFleet(): Promise<void> {
+  const fleet = readFleet();
+  const agents = fleet.agents ?? {};
+
+  for (const [name, config] of Object.entries(agents)) {
+    const existing = await db
+      .selectFrom("agents")
+      .select("id")
+      .where("name", "=", name)
+      .executeTakeFirst();
+
+    if (existing) {
+      await db
+        .updateTable("agents")
+        .where("id", "=", existing.id)
+        .set({
+          role: config.role,
+          location: config.location ?? null,
+          slack_bot_token: config.slackBotToken ?? null,
+          slack_app_token: config.slackAppToken ?? null,
+          updated_at: new Date().toISOString(),
+        })
+        .execute();
+    } else {
+      await db
+        .insertInto("agents")
+        .values({
+          id: crypto.randomUUID(),
+          name,
+          role: config.role,
+          location: config.location ?? null,
+          slack_bot_token: config.slackBotToken ?? null,
+          slack_app_token: config.slackAppToken ?? null,
+          status: "idle",
+          current_task: null,
+          session_key: `agent:${name}:main`,
+        })
+        .execute();
+    }
+  }
+
+  // Ensure "human" agent exists for dashboard task creation
+  const humanExists = await db
+    .selectFrom("agents")
+    .select("id")
+    .where("name", "=", "human")
+    .executeTakeFirst();
+
+  if (!humanExists) {
+    await db
+      .insertInto("agents")
+      .values({
+        id: crypto.randomUUID(),
+        name: "human",
+        role: "human",
+        status: "active",
+        current_task: null,
+        session_key: "agent:human:main",
+      })
+      .execute();
+    console.log("[fleet-sync] created human agent");
+  }
+
+  console.log(`[fleet-sync] reconciled ${Object.keys(agents).length} agent(s)`);
+}
+
+export async function regenerateCompose(): Promise<void> {
+  // No-op for now — docker compose generation moved to CLI
+}
+
+export function startWatcher(): void {
+  const fleetPath = resolveFleetPath();
+  if (!fs.existsSync(fleetPath)) {
+    console.log("[fleet-sync] no fleet.json found, skipping watcher");
+    return;
+  }
+  try {
+    fs.watch(fleetPath, () => {
+      if (writeLock) return;
+      if (watcherTimeout) clearTimeout(watcherTimeout);
+      watcherTimeout = setTimeout(async () => {
+        console.log("[fleet-sync] fleet.json changed externally, reconciling...");
+        try {
+          await reconcileDbFromFleet();
+        } catch (err) {
+          console.error("[fleet-sync] reconcile error:", err);
+        }
+      }, 500);
+    });
+    console.log("[fleet-sync] watching fleet.json for changes");
+  } catch (err) {
+    console.error("[fleet-sync] could not watch fleet.json:", err);
+  }
+}

package/src/api/lib/mentions.ts

@@ -0,0 +1,59 @@
+import { db } from "../db/client.js";
+
+export async function parseMentions(
+  content: string,
+  excludeAgentId: string
+): Promise<string[]> {
+  const mentionRegex = /@(\w+)/g;
+  const mentions: string[] = [];
+  let match: RegExpExecArray | null;
+  while ((match = mentionRegex.exec(content)) !== null) {
+    mentions.push(match[1]);
+  }
+
+  if (mentions.length === 0) return [];
+
+  // Handle @all
+  if (mentions.includes("all")) {
+    const agents = await db
+      .selectFrom("agents")
+      .where("id", "!=", excludeAgentId)
+      .select("id")
+      .execute();
+    return agents.map((a) => a.id);
+  }
+
+  // Resolve named mentions
+  const agents = await db
+    .selectFrom("agents")
+    .where("name", "in", mentions)
+    .where("id", "!=", excludeAgentId)
+    .select("id")
+    .execute();
+  return agents.map((a) => a.id);
+}
+
+export async function getTaskSubscribers(
+  taskId: string,
+  excludeAgentId: string
+): Promise<string[]> {
+  const assignees = await db
+    .selectFrom("task_assignees")
+    .where("task_id", "=", taskId)
+    .where("agent_id", "!=", excludeAgentId)
+    .select("agent_id")
+    .execute();
+
+  const messageAuthors = await db
+    .selectFrom("messages")
+    .where("task_id", "=", taskId)
+    .where("from_agent", "!=", excludeAgentId)
+    .select("from_agent")
+    .distinct()
+    .execute();
+
+  const ids = new Set<string>();
+  for (const a of assignees) ids.add(a.agent_id);
+  for (const m of messageAuthors) ids.add(m.from_agent);
+  return [...ids];
+}

package/src/api/lib/processes.ts

@@ -0,0 +1,45 @@
+import type { Subprocess } from "bun";
+
+const localProcesses = new Map<string, Subprocess>();
+
+export function startLocal(name: string, role: string): Subprocess {
+  const existing = localProcesses.get(name);
+  if (existing) {
+    existing.kill();
+    localProcesses.delete(name);
+  }
+
+  const proc = Bun.spawn(["bun", "packages/agent/src/index.ts"], {
+    cwd: process.cwd(),
+    env: {
+      ...process.env,
+      AGENCY_AGENT_NAME: name,
+      AGENCY_ROLE: role,
+    },
+    stdout: "inherit",
+    stderr: "inherit",
+  });
+
+  localProcesses.set(name, proc);
+
+  // Clean up map entry when process exits
+  proc.exited.then(() => {
+    if (localProcesses.get(name) === proc) {
+      localProcesses.delete(name);
+    }
+  });
+
+  return proc;
+}
+
+export function stopLocal(name: string): boolean {
+  const proc = localProcesses.get(name);
+  if (!proc) return false;
+  proc.kill();
+  localProcesses.delete(name);
+  return true;
+}
+
+export function isLocalRunning(name: string): boolean {
+  return localProcesses.has(name);
+}

package/src/api/lib/resolve-agent.ts

@@ -0,0 +1,5 @@
+import { db } from "../db/client.js";
+
+export async function resolveAgent(name: string) {
+  return db.selectFrom("agents").where("name", "=", name).selectAll().executeTakeFirst();
+}

package/src/api/lib/tunnels.ts

@@ -0,0 +1,99 @@
+import type { Subprocess } from "bun";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { db } from "../db/client.js";
+
+const tunnels = new Map<string, Subprocess>();
+
+const API_PORT = Number(process.env.PORT ?? 3100);
+
+async function getSSHConfig(): Promise<{ keyPath: string; user: string }> {
+  const rows = await db
+    .selectFrom("settings")
+    .where("category", "=", "ssh")
+    .selectAll()
+    .execute();
+
+  const settings: Record<string, string> = {};
+  for (const r of rows) settings[r.key] = r.value;
+
+  const user = settings["ssh.user"] || "ubuntu";
+  const privateKey = settings["ssh.private_key"] || "";
+
+  if (!privateKey) {
+    throw new Error("SSH private key not configured. Set it in Settings → SSH.");
+  }
+
+  // Write key to a temp file (SSH requires a file path)
+  const keyDir = path.join(os.tmpdir(), "agency-ssh");
+  fs.mkdirSync(keyDir, { recursive: true, mode: 0o700 });
+  const keyPath = path.join(keyDir, "agent_key");
+  fs.writeFileSync(keyPath, privateKey + "\n", { mode: 0o600 });
+
+  return { keyPath, user };
+}
+
+export async function startTunnel(name: string, host: string): Promise<void> {
+  // Kill existing tunnel if any
+  stopTunnel(name);
+
+  const { keyPath, user } = await getSSHConfig();
+
+  const args = [
+    "ssh",
+    "-i", keyPath,
+    "-o", "StrictHostKeyChecking=no",
+    "-o", "ServerAliveInterval=30",
+    "-o", "ServerAliveCountMax=3",
+    "-o", "ExitOnForwardFailure=yes",
+    "-N",               // no command, just tunnel
+    "-R", `${API_PORT}:localhost:${API_PORT}`,  // reverse tunnel: remote:3100 -> local:3100
+    `${user}@${host}`,
+  ];
+
+  console.log(`[tunnel] opening reverse tunnel to ${name} (${user}@${host})`);
+
+  const proc = Bun.spawn(args, {
+    stdout: "inherit",
+    stderr: "inherit",
+  });
+
+  tunnels.set(name, proc);
+
+  // Auto-restart on disconnect
+  proc.exited.then((code) => {
+    if (tunnels.get(name) !== proc) return; // already replaced
+    tunnels.delete(name);
+    console.log(`[tunnel] ${name} exited with code ${code}, reconnecting in 5s...`);
+    setTimeout(() => {
+      // Only restart if no new tunnel was created
+      if (!tunnels.has(name)) {
+        startTunnel(name, host).catch((err) =>
+          console.error(`[tunnel] failed to restart tunnel for ${name}:`, err.message)
+        );
+      }
+    }, 5000);
+  });
+}
+
+export function stopTunnel(name: string): boolean {
+  const proc = tunnels.get(name);
+  if (!proc) return false;
+  proc.kill();
+  tunnels.delete(name);
+  console.log(`[tunnel] closed tunnel to ${name}`);
+  return true;
+}
+
+export function isTunnelRunning(name: string): boolean {
+  return tunnels.has(name);
+}
+
+export function stopAllTunnels(): void {
+  for (const [name, proc] of tunnels) {
+    proc.kill();
+    console.log(`[tunnel] closed tunnel to ${name}`);
+  }
+  tunnels.clear();
+}

package/src/api/routes/activities.ts

@@ -0,0 +1,27 @@
+import { Hono } from "hono";
+import { db } from "../db/client.js";
+
+export const activities = new Hono();
+
+activities.get("/", async (c) => {
+  const limit = Number(c.req.query("limit") ?? 50);
+  const since = c.req.query("since");
+
+  let q = db
+    .selectFrom("activities")
+    .innerJoin("agents", "agents.id", "activities.agent_id")
+    .select([
+      "activities.id", "activities.type", "activities.agent_id",
+      "activities.task_id", "activities.summary", "activities.created_at",
+      "agents.name as agent_name",
+    ])
+    .orderBy("activities.created_at", "desc")
+    .limit(limit);
+
+  if (since) {
+    q = q.where("activities.created_at", ">=", new Date(since));
+  }
+
+  const rows = await q.execute();
+  return c.json(rows);
+});

package/src/api/routes/agents.ts

@@ -0,0 +1,311 @@
+import { Hono } from "hono";
+import { db } from "../db/client.js";
+import { resolveAgent } from "../lib/resolve-agent.js";
+import {
+  writeAgentToFleet,
+  removeAgentFromFleet,
+} from "../lib/fleet-sync.js";
+import { startLocal, stopLocal } from "../lib/processes.js";
+import { startTunnel, stopTunnel } from "../lib/tunnels.js";
+import { readFleet } from "../lib/fleet-sync.js";
+
+const NAME_RE = /^[a-z][a-z0-9-]{1,30}$/;
+const VALID_LOCATIONS = new Set(["docker", "ec2", "local"]);
+
+// Map of allowed file names to role_config config_type values
+const FILE_TO_CONFIG_TYPE: Record<string, string> = {
+  "SOUL.md": "soul",
+  "USER.md": "identity",
+  "AGENTS.md": "agents",
+  "MEMORY.md": "soul", // memory is part of soul for now
+  "TOOLS.md": "tools",
+};
+
+export const agents = new Hono();
+
+// List available roles (from DB role_configs)
+agents.get("/roles", async (c) => {
+  const rows = await db
+    .selectFrom("role_configs")
+    .select("role")
+    .distinct()
+    .execute();
+  return c.json(rows.map((r) => r.role));
+});
+
+agents.get("/", async (c) => {
+  const rows = await db.selectFrom("agents").selectAll().execute();
+  return c.json(rows);
+});
+
+agents.get("/:name", async (c) => {
+  const agent = await resolveAgent(c.req.param("name"));
+  if (!agent) return c.json({ error: "not found" }, 404);
+  return c.json(agent);
+});
+
+// Get agent config file from DB
+agents.get("/:name/files/:filename", async (c) => {
+  const filename = c.req.param("filename");
+  const configType = FILE_TO_CONFIG_TYPE[filename];
+  if (!configType) {
+    return c.json({ error: "invalid filename" }, 400);
+  }
+  const agent = await resolveAgent(c.req.param("name"));
+  if (!agent) return c.json({ error: "not found" }, 404);
+
+  const config = await db
+    .selectFrom("role_configs")
+    .where("role", "=", agent.role)
+    .where("config_type", "=", configType)
+    .selectAll()
+    .executeTakeFirst();
+
+  if (!config) {
+    return c.json({ error: "file not found" }, 404);
+  }
+  return c.json({ filename, content: config.content });
+});
+
+// Get agent's role config by config_type directly
+agents.get("/:name/config/:configType", async (c) => {
+  const agent = await resolveAgent(c.req.param("name"));
+  if (!agent) return c.json({ error: "not found" }, 404);
+
+  const config = await db
+    .selectFrom("role_configs")
+    .where("role", "=", agent.role)
+    .where("config_type", "=", c.req.param("configType"))
+    .selectAll()
+    .executeTakeFirst();
+
+  if (!config) return c.json({ error: "not found" }, 404);
+  return c.json(config);
+});
+
+// Create agent
+agents.post("/", async (c) => {
+  const body = await c.req.json<{
+    name: string;
+    role: string;
+    location: string;
+    slack_bot_token?: string;
+    slack_app_token?: string;
+  }>();
+
+  if (!NAME_RE.test(body.name)) {
+    return c.json({ error: "invalid name: must match /^[a-z][a-z0-9-]{1,30}$/" }, 400);
+  }
+  if (!VALID_LOCATIONS.has(body.location)) {
+    return c.json({ error: "invalid location: must be docker, ec2, or local" }, 400);
+  }
+
+  const existing = await db
+    .selectFrom("agents")
+    .select("id")
+    .where("name", "=", body.name)
+    .executeTakeFirst();
+  if (existing) {
+    return c.json({ error: "agent already exists" }, 409);
+  }
+
+  // Write to fleet.json
+  await writeAgentToFleet(body.name, {
+    role: body.role,
+    location: body.location,
+    ...(body.slack_bot_token ? { slackBotToken: body.slack_bot_token } : {}),
+    ...(body.slack_app_token ? { slackAppToken: body.slack_app_token } : {}),
+  });
+
+  // Insert into DB
+  const agent = await db
+    .insertInto("agents")
+    .values({
+      id: crypto.randomUUID(),
+      name: body.name,
+      role: body.role,
+      location: body.location,
+      slack_bot_token: body.slack_bot_token ?? null,
+      slack_app_token: body.slack_app_token ?? null,
+      status: "idle",
+      current_task: null,
+      session_key: `agent:${body.name}:main`,
+    })
+    .returningAll()
+    .executeTakeFirstOrThrow();
+
+  return c.json(agent, 201);
+});
+
+// Update agent
+agents.patch("/:name", async (c) => {
+  const agent = await resolveAgent(c.req.param("name"));
+  if (!agent) return c.json({ error: "not found" }, 404);
+
+  const body = await c.req.json<{
+    status?: string;
+    current_task?: string | null;
+    role?: string;
+    location?: string;
+    slack_bot_token?: string | null;
+    slack_app_token?: string | null;
+  }>();
+
+  let q = db.updateTable("agents").where("id", "=", agent.id);
+  if (body.status !== undefined) q = q.set("status", body.status);
+  if (body.current_task !== undefined) q = q.set("current_task", body.current_task);
+  if (body.role !== undefined) q = q.set("role", body.role);
+  if (body.location !== undefined) {
+    if (!VALID_LOCATIONS.has(body.location)) {
+      return c.json({ error: "invalid location" }, 400);
+    }
+    q = q.set("location", body.location);
+  }
+  if (body.slack_bot_token !== undefined) q = q.set("slack_bot_token", body.slack_bot_token);
+  if (body.slack_app_token !== undefined) q = q.set("slack_app_token", body.slack_app_token);
+  q = q.set("updated_at", new Date().toISOString());
+
+  const updated = await q.returningAll().executeTakeFirstOrThrow();
+
+  // Sync config fields to fleet.json
+  if (body.role !== undefined || body.location !== undefined ||
+      body.slack_bot_token !== undefined ||
+      body.slack_app_token !== undefined) {
+    await writeAgentToFleet(agent.name, {
+      role: updated.role,
+      location: updated.location ?? "local",
+      ...(updated.slack_bot_token ? { slackBotToken: updated.slack_bot_token } : {}),
+      ...(updated.slack_app_token ? { slackAppToken: updated.slack_app_token } : {}),
+    });
+  }
+
+  return c.json(updated);
+});
+
+// Delete agent
+agents.delete("/:name", async (c) => {
+  const agent = await resolveAgent(c.req.param("name"));
+  if (!agent) return c.json({ error: "not found" }, 404);
+
+  // Stop docker container if running
+  if (agent.location === "docker") {
+    try {
+      const proc = Bun.spawn(
+        ["docker", "compose", "-f", "docker-compose.agents.yml", "stop", `agent-${agent.name}`],
+        { cwd: process.cwd(), stdout: "inherit", stderr: "inherit" }
+      );
+      await proc.exited;
+    } catch {}
+  }
+
+  await db.deleteFrom("agents").where("id", "=", agent.id).execute();
+  await removeAgentFromFleet(agent.name);
+
+  return c.json({ ok: true });
+});
+
+// Deploy agent
+agents.post("/:name/deploy", async (c) => {
+  const agent = await resolveAgent(c.req.param("name"));
+  if (!agent) return c.json({ error: "not found" }, 404);
+
+  if (agent.location === "local") {
+    startLocal(agent.name, agent.role);
+    await db
+      .updateTable("agents")
+      .where("id", "=", agent.id)
+      .set({ status: "active", updated_at: new Date().toISOString() })
+      .execute();
+    return c.json({ status: "deployed", method: "local" });
+  }
+
+  if (agent.location === "ec2") {
+    const fleet = readFleet();
+    const fleetAgent = fleet.agents[agent.name];
+    const host = fleetAgent?.host;
+    if (!host) {
+      return c.json({ error: "No host configured for EC2 agent. Set 'host' in fleet.json or agent config." }, 400);
+    }
+
+    // Open reverse SSH tunnel so agent can reach our API at localhost:3100
+    try {
+      await startTunnel(agent.name, host);
+    } catch (err: any) {
+      return c.json({ error: `Failed to open SSH tunnel: ${err.message}` }, 500);
+    }
+
+    await db
+      .updateTable("agents")
+      .where("id", "=", agent.id)
+      .set({ status: "active", updated_at: new Date().toISOString() })
+      .execute();
+    return c.json({ status: "deployed", method: "ec2", tunnel: true });
+  }
+
+  if (agent.location === "docker") {
+    const proc = Bun.spawn(
+      ["docker", "compose", "-f", "docker-compose.agents.yml", "up", "-d", `agent-${agent.name}`],
+      { cwd: process.cwd(), stdout: "inherit", stderr: "inherit" }
+    );
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      return c.json({ error: "docker compose up failed" }, 500);
+    }
+    await db
+      .updateTable("agents")
+      .where("id", "=", agent.id)
+      .set({ status: "active", updated_at: new Date().toISOString() })
+      .execute();
+    return c.json({ status: "deployed", method: "docker" });
+  }
+
+  return c.json({ error: "unsupported location" }, 400);
+});
+
+// Stop agent
+agents.post("/:name/stop", async (c) => {
+  const agent = await resolveAgent(c.req.param("name"));
+  if (!agent) return c.json({ error: "not found" }, 404);
+
+  if (agent.location === "local") {
+    const stopped = stopLocal(agent.name);
+    if (!stopped) {
+      return c.json({ error: "no local process found" }, 400);
+    }
+    await db
+      .updateTable("agents")
+      .where("id", "=", agent.id)
+      .set({ status: "idle", updated_at: new Date().toISOString() })
+      .execute();
+    return c.json({ status: "stopped" });
+  }
+
+  if (agent.location === "docker") {
+    const proc = Bun.spawn(
+      ["docker", "compose", "-f", "docker-compose.agents.yml", "stop", `agent-${agent.name}`],
+      { cwd: process.cwd(), stdout: "inherit", stderr: "inherit" }
+    );
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      return c.json({ error: "docker compose stop failed" }, 500);
+    }
+    await db
+      .updateTable("agents")
+      .where("id", "=", agent.id)
+      .set({ status: "idle", updated_at: new Date().toISOString() })
+      .execute();
+    return c.json({ status: "stopped" });
+  }
+
+  if (agent.location === "ec2") {
+    stopTunnel(agent.name);
+    await db
+      .updateTable("agents")
+      .where("id", "=", agent.id)
+      .set({ status: "idle", updated_at: new Date().toISOString() })
+      .execute();
+    return c.json({ status: "stopped", tunnel: "closed" });
+  }
+
+  return c.json({ error: "stop not supported for this agent location" }, 400);
+});