@jx0/agency 0.2.0

package/src/api/db/migrations/001_initial.ts

@@ -0,0 +1,193 @@
+import type { Kysely } from "kysely";
+import { sql } from "kysely";
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await db.schema
+    .createTable("agents")
+    .addColumn("id", "text", (col) => col.primaryKey())
+    .addColumn("name", "text", (col) => col.notNull().unique())
+    .addColumn("role", "text", (col) => col.notNull())
+    .addColumn("status", "text", (col) => col.notNull().defaultTo("idle"))
+    .addColumn("current_task", "text")
+    .addColumn("location", "text")
+    .addColumn("slack_bot_token", "text")
+    .addColumn("slack_app_token", "text")
+    .addColumn("session_key", "text", (col) => col.notNull().unique())
+    .addColumn("created_at", "text", (col) =>
+      col.notNull().defaultTo(sql`(datetime('now'))`)
+    )
+    .addColumn("updated_at", "text", (col) =>
+      col.notNull().defaultTo(sql`(datetime('now'))`)
+    )
+    .execute();
+
+  await db.schema
+    .createTable("tasks")
+    .addColumn("id", "text", (col) => col.primaryKey())
+    .addColumn("title", "text", (col) => col.notNull())
+    .addColumn("description", "text", (col) => col.notNull())
+    .addColumn("design", "text")
+    .addColumn("acceptance", "text")
+    .addColumn("status", "text", (col) => col.notNull().defaultTo("backlog"))
+    .addColumn("priority", "integer", (col) => col.notNull().defaultTo(0))
+    .addColumn("task_type", "text", (col) => col.notNull().defaultTo("task"))
+    .addColumn("parent_id", "text", (col) =>
+      col.references("tasks.id").onDelete("set null")
+    )
+    .addColumn("created_by", "text", (col) =>
+      col.notNull().references("agents.id")
+    )
+    .addColumn("created_at", "text", (col) =>
+      col.notNull().defaultTo(sql`(datetime('now'))`)
+    )
+    .addColumn("updated_at", "text", (col) =>
+      col.notNull().defaultTo(sql`(datetime('now'))`)
+    )
+    .execute();
+
+  await db.schema
+    .createTable("task_assignees")
+    .addColumn("task_id", "text", (col) =>
+      col.notNull().references("tasks.id").onDelete("cascade")
+    )
+    .addColumn("agent_id", "text", (col) =>
+      col.notNull().references("agents.id").onDelete("cascade")
+    )
+    .addPrimaryKeyConstraint("pk_task_assignees", ["task_id", "agent_id"])
+    .execute();
+
+  await db.schema
+    .createTable("messages")
+    .addColumn("id", "text", (col) => col.primaryKey())
+    .addColumn("task_id", "text", (col) =>
+      col.notNull().references("tasks.id").onDelete("cascade")
+    )
+    .addColumn("from_agent", "text", (col) =>
+      col.notNull().references("agents.id")
+    )
+    .addColumn("content", "text", (col) => col.notNull())
+    .addColumn("created_at", "text", (col) =>
+      col.notNull().defaultTo(sql`(datetime('now'))`)
+    )
+    .execute();
+
+  await db.schema
+    .createTable("activities")
+    .addColumn("id", "text", (col) => col.primaryKey())
+    .addColumn("type", "text", (col) => col.notNull())
+    .addColumn("agent_id", "text", (col) =>
+      col.notNull().references("agents.id")
+    )
+    .addColumn("task_id", "text", (col) =>
+      col.references("tasks.id").onDelete("set null")
+    )
+    .addColumn("summary", "text", (col) => col.notNull())
+    .addColumn("created_at", "text", (col) =>
+      col.notNull().defaultTo(sql`(datetime('now'))`)
+    )
+    .execute();
+
+  await db.schema
+    .createTable("notifications")
+    .addColumn("id", "text", (col) => col.primaryKey())
+    .addColumn("target_agent", "text", (col) =>
+      col.notNull().references("agents.id")
+    )
+    .addColumn("source_agent", "text", (col) =>
+      col.references("agents.id")
+    )
+    .addColumn("task_id", "text", (col) =>
+      col.references("tasks.id").onDelete("set null")
+    )
+    .addColumn("content", "text", (col) => col.notNull())
+    .addColumn("delivered", "integer", (col) =>
+      col.notNull().defaultTo(0)
+    )
+    .addColumn("created_at", "text", (col) =>
+      col.notNull().defaultTo(sql`(datetime('now'))`)
+    )
+    .execute();
+
+  await db.schema
+    .createTable("documents")
+    .addColumn("id", "text", (col) => col.primaryKey())
+    .addColumn("title", "text", (col) => col.notNull())
+    .addColumn("content", "text", (col) => col.notNull())
+    .addColumn("doc_type", "text", (col) => col.notNull())
+    .addColumn("task_id", "text", (col) =>
+      col.references("tasks.id").onDelete("set null")
+    )
+    .addColumn("created_by", "text", (col) =>
+      col.notNull().references("agents.id")
+    )
+    .addColumn("created_at", "text", (col) =>
+      col.notNull().defaultTo(sql`(datetime('now'))`)
+    )
+    .addColumn("updated_at", "text", (col) =>
+      col.notNull().defaultTo(sql`(datetime('now'))`)
+    )
+    .execute();
+
+  await db.schema
+    .createTable("knowledge")
+    .addColumn("id", "text", (col) => col.primaryKey())
+    .addColumn("key", "text", (col) => col.notNull().unique())
+    .addColumn("content", "text", (col) => col.notNull())
+    .addColumn("source", "text", (col) => col.notNull())
+    .addColumn("task_id", "text", (col) =>
+      col.references("tasks.id").onDelete("set null")
+    )
+    .addColumn("tags", "text", (col) => col.notNull().defaultTo("[]"))
+    .addColumn("created_at", "text", (col) =>
+      col.notNull().defaultTo(sql`(datetime('now'))`)
+    )
+    .execute();
+
+  // Indexes
+  await db.schema
+    .createIndex("idx_tasks_status")
+    .on("tasks")
+    .column("status")
+    .execute();
+
+  await db.schema
+    .createIndex("idx_tasks_parent")
+    .on("tasks")
+    .column("parent_id")
+    .execute();
+
+  await db.schema
+    .createIndex("idx_messages_task")
+    .on("messages")
+    .column("task_id")
+    .execute();
+
+  await db.schema
+    .createIndex("idx_activities_created")
+    .on("activities")
+    .column("created_at")
+    .execute();
+
+  await db.schema
+    .createIndex("idx_notifications_pending")
+    .on("notifications")
+    .columns(["target_agent", "delivered"])
+    .execute();
+
+  await db.schema
+    .createIndex("idx_knowledge_key")
+    .on("knowledge")
+    .column("key")
+    .execute();
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await db.schema.dropTable("knowledge").ifExists().execute();
+  await db.schema.dropTable("documents").ifExists().execute();
+  await db.schema.dropTable("notifications").ifExists().execute();
+  await db.schema.dropTable("activities").ifExists().execute();
+  await db.schema.dropTable("messages").ifExists().execute();
+  await db.schema.dropTable("task_assignees").ifExists().execute();
+  await db.schema.dropTable("tasks").ifExists().execute();
+  await db.schema.dropTable("agents").ifExists().execute();
+}

package/src/api/db/migrations/002_configs.ts

@@ -0,0 +1,76 @@
+import type { Kysely } from "kysely";
+import { sql } from "kysely";
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await db.schema
+    .createTable("settings")
+    .addColumn("key", "text", (col) => col.primaryKey())
+    .addColumn("value", "text", (col) => col.notNull())
+    .addColumn("category", "text", (col) => col.notNull().defaultTo("general"))
+    .addColumn("description", "text")
+    .addColumn("updated_at", "text", (col) =>
+      col.notNull().defaultTo(sql`(datetime('now'))`)
+    )
+    .execute();
+
+  await db.schema
+    .createTable("skills")
+    .addColumn("id", "text", (col) => col.primaryKey())
+    .addColumn("name", "text", (col) => col.notNull().unique())
+    .addColumn("body", "text", (col) => col.notNull())
+    .addColumn("category", "text", (col) => col.notNull().defaultTo("general"))
+    .addColumn("tags", "text", (col) => col.notNull().defaultTo("[]"))
+    .addColumn("created_at", "text", (col) =>
+      col.notNull().defaultTo(sql`(datetime('now'))`)
+    )
+    .addColumn("updated_at", "text", (col) =>
+      col.notNull().defaultTo(sql`(datetime('now'))`)
+    )
+    .execute();
+
+  await db.schema
+    .createTable("role_configs")
+    .addColumn("id", "text", (col) => col.primaryKey())
+    .addColumn("role", "text", (col) => col.notNull())
+    .addColumn("config_type", "text", (col) => col.notNull())
+    .addColumn("content", "text", (col) => col.notNull())
+    .addColumn("created_at", "text", (col) =>
+      col.notNull().defaultTo(sql`(datetime('now'))`)
+    )
+    .addColumn("updated_at", "text", (col) =>
+      col.notNull().defaultTo(sql`(datetime('now'))`)
+    )
+    .execute();
+
+  // Unique constraint on role + config_type
+  await db.schema
+    .createIndex("idx_role_configs_unique")
+    .on("role_configs")
+    .columns(["role", "config_type"])
+    .unique()
+    .execute();
+
+  await db.schema
+    .createIndex("idx_settings_category")
+    .on("settings")
+    .column("category")
+    .execute();
+
+  await db.schema
+    .createIndex("idx_skills_category")
+    .on("skills")
+    .column("category")
+    .execute();
+
+  await db.schema
+    .createIndex("idx_role_configs_role")
+    .on("role_configs")
+    .column("role")
+    .execute();
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  await db.schema.dropTable("role_configs").ifExists().execute();
+  await db.schema.dropTable("skills").ifExists().execute();
+  await db.schema.dropTable("settings").ifExists().execute();
+}

package/src/api/db/migrations/003_settings_columns.ts

@@ -0,0 +1,13 @@
+import type { Kysely } from "kysely";
+import { sql } from "kysely";
+
+export async function up(db: Kysely<any>): Promise<void> {
+  await sql`ALTER TABLE settings ADD COLUMN sensitive INTEGER NOT NULL DEFAULT 0`.execute(db);
+  await sql`ALTER TABLE settings ADD COLUMN input_type TEXT NOT NULL DEFAULT 'text'`.execute(db);
+}
+
+export async function down(db: Kysely<any>): Promise<void> {
+  // SQLite doesn't support DROP COLUMN before 3.35.0; recreate table if needed
+  await sql`ALTER TABLE settings DROP COLUMN sensitive`.execute(db);
+  await sql`ALTER TABLE settings DROP COLUMN input_type`.execute(db);
+}

package/src/api/db/seed.ts

@@ -0,0 +1,142 @@
+import { db } from "./client.js";
+import * as fs from "fs";
+import * as path from "path";
+
+const TEMPLATES_DIR = path.join(import.meta.dir, "../../templates");
+
+function readTemplate(...segments: string[]): string {
+  const filePath = path.join(TEMPLATES_DIR, ...segments);
+  return fs.readFileSync(filePath, "utf-8");
+}
+
+interface SeedOptions {
+  userName?: string;
+  teamName?: string;
+  roles?: string[];
+}
+
+export async function seedDefaults(options: SeedOptions = {}) {
+  const userName = options.userName ?? "Human";
+  const teamName = options.teamName ?? "My Team";
+  const roles = options.roles ?? ["orchestrator", "implementer"];
+
+  // Seed default settings
+  const defaultSettings: {
+    key: string;
+    value: string;
+    category: string;
+    description: string;
+    sensitive: number;
+    input_type: string;
+  }[] = [
+    // Identity
+    { key: "user.name", value: userName, category: "identity", description: "Human operator name", sensitive: 0, input_type: "text" },
+    { key: "user.email", value: "", category: "identity", description: "User email", sensitive: 0, input_type: "text" },
+    { key: "team.name", value: teamName, category: "identity", description: "Team name", sensitive: 0, input_type: "text" },
+    // AI
+    { key: "ai.anthropic_api_key", value: "", category: "ai", description: "Anthropic API key", sensitive: 1, input_type: "password" },
+    { key: "ai.auth_method", value: "api_key", category: "ai", description: "Auth method: api_key or oauth", sensitive: 0, input_type: "text" },
+    { key: "ai.oauth_access_token", value: "", category: "ai", description: "Claude OAuth access token", sensitive: 1, input_type: "password" },
+    { key: "ai.oauth_refresh_token", value: "", category: "ai", description: "Claude OAuth refresh token", sensitive: 1, input_type: "password" },
+    { key: "ai.oauth_expires_at", value: "", category: "ai", description: "Token expiry (ISO string)", sensitive: 0, input_type: "readonly" },
+    { key: "ai.oauth_subscription_type", value: "", category: "ai", description: "Subscription type (max, pro, etc.)", sensitive: 0, input_type: "readonly" },
+    // AWS
+    { key: "aws.access_key_id", value: "", category: "aws", description: "AWS Access Key ID", sensitive: 1, input_type: "password" },
+    { key: "aws.secret_access_key", value: "", category: "aws", description: "AWS Secret Access Key", sensitive: 1, input_type: "password" },
+    { key: "aws.region", value: "", category: "aws", description: "AWS region", sensitive: 0, input_type: "text" },
+    { key: "aws.ami_id", value: "", category: "aws", description: "AMI for EC2 agents", sensitive: 0, input_type: "text" },
+    { key: "aws.instance_type", value: "", category: "aws", description: "Default EC2 instance type", sensitive: 0, input_type: "text" },
+    { key: "aws.s3_bucket_prefix", value: "", category: "aws", description: "S3 bucket prefix", sensitive: 0, input_type: "text" },
+    // SSH
+    { key: "ssh.private_key", value: "", category: "ssh", description: "SSH private key content", sensitive: 1, input_type: "textarea" },
+    { key: "ssh.public_key", value: "", category: "ssh", description: "SSH public key (for display/copy)", sensitive: 0, input_type: "textarea" },
+    { key: "ssh.key_name", value: "", category: "ssh", description: "SSH key name", sensitive: 0, input_type: "text" },
+    { key: "ssh.user", value: "", category: "ssh", description: "SSH username", sensitive: 0, input_type: "text" },
+  ];
+
+  for (const s of defaultSettings) {
+    const existing = await db.selectFrom("settings").where("key", "=", s.key).selectAll().executeTakeFirst();
+    if (!existing) {
+      await db.insertInto("settings").values(s).execute();
+      console.log(`[seed] setting: ${s.key}`);
+    }
+  }
+
+  // Clean up removed settings
+  const removedKeys = ["slack.team_channel", "slack.human_user_id", "ssh.key_path", "aws.profile"];
+  for (const key of removedKeys) {
+    await db.deleteFrom("settings").where("key", "=", key).execute();
+  }
+
+  // Migrate old categories
+  await db.updateTable("settings").where("key", "=", "user.name").set({ category: "identity" }).execute();
+  await db.updateTable("settings").where("key", "=", "team.name").set({ category: "identity" }).execute();
+
+  // Helper to replace template variables
+  function interpolate(content: string): string {
+    return content
+      .replace(/\{\{user\.name\}\}/g, userName)
+      .replace(/\{\{team\.name\}\}/g, teamName);
+  }
+
+  // Seed role configs for each role
+  const ROLE_SPECIFIC = ["heartbeat", "agents-config", "tools", "agents"];
+  const SHARED_CONFIGS: { configType: string; template: string }[] = [
+    { configType: "environment", template: "environment.md" },
+    { configType: "soul", template: "soul.md" },
+    { configType: "identity", template: "user.md" },
+  ];
+
+  for (const role of roles) {
+    const templateRole = fs.existsSync(path.join(TEMPLATES_DIR, role)) ? role : "implementer";
+    const configs = [
+      ...ROLE_SPECIFIC.map((ct) => ({ configType: ct, segments: [templateRole, `${ct}.md`] })),
+      ...SHARED_CONFIGS.map((c) => ({ configType: c.configType, segments: ["shared", c.template] })),
+    ];
+
+    for (const { configType, segments } of configs) {
+      const existing = await db
+        .selectFrom("role_configs")
+        .where("role", "=", role)
+        .where("config_type", "=", configType)
+        .selectAll()
+        .executeTakeFirst();
+
+      if (!existing) {
+        const content = interpolate(readTemplate(...segments));
+        await db.insertInto("role_configs").values({
+          id: crypto.randomUUID(),
+          role,
+          config_type: configType,
+          content,
+        }).execute();
+        console.log(`[seed] role_config: ${role}/${configType}`);
+      }
+    }
+  }
+
+  // Ensure "human" agent exists
+  const humanExists = await db
+    .selectFrom("agents")
+    .where("name", "=", "human")
+    .selectAll()
+    .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("[seed] created human agent");
+  }
+}
+
+// Run directly if executed as a script
+if (import.meta.main) {
+  await seedDefaults();
+  await db.destroy();
+}

package/src/api/db/types.ts

@@ -0,0 +1,126 @@
+import type { Generated } from "kysely";
+
+export interface Database {
+  agents: AgentTable;
+  tasks: TaskTable;
+  task_assignees: TaskAssigneeTable;
+  messages: MessageTable;
+  activities: ActivityTable;
+  notifications: NotificationTable;
+  documents: DocumentTable;
+  knowledge: KnowledgeTable;
+  settings: SettingsTable;
+  skills: SkillsTable;
+  role_configs: RoleConfigsTable;
+}
+
+export interface AgentTable {
+  id: Generated<string>;
+  name: string;
+  role: string;
+  status: string;
+  current_task: string | null;
+  location: string | null;
+  slack_bot_token: string | null;
+  slack_app_token: string | null;
+  session_key: string;
+  created_at: Generated<string>;
+  updated_at: Generated<string>;
+}
+
+export interface TaskTable {
+  id: Generated<string>;
+  title: string;
+  description: string;
+  design: string | null;
+  acceptance: string | null;
+  status: string;
+  priority: number;
+  task_type: string;
+  parent_id: string | null;
+  created_by: string;
+  created_at: Generated<string>;
+  updated_at: Generated<string>;
+}
+
+export interface TaskAssigneeTable {
+  task_id: string;
+  agent_id: string;
+}
+
+export interface MessageTable {
+  id: Generated<string>;
+  task_id: string;
+  from_agent: string;
+  content: string;
+  created_at: Generated<string>;
+}
+
+export interface ActivityTable {
+  id: Generated<string>;
+  type: string;
+  agent_id: string;
+  task_id: string | null;
+  summary: string;
+  created_at: Generated<string>;
+}
+
+export interface NotificationTable {
+  id: Generated<string>;
+  target_agent: string;
+  source_agent: string | null;
+  task_id: string | null;
+  content: string;
+  delivered: Generated<number>;
+  created_at: Generated<string>;
+}
+
+export interface DocumentTable {
+  id: Generated<string>;
+  title: string;
+  content: string;
+  doc_type: string;
+  task_id: string | null;
+  created_by: string;
+  created_at: Generated<string>;
+  updated_at: Generated<string>;
+}
+
+export interface KnowledgeTable {
+  id: Generated<string>;
+  key: string;
+  content: string;
+  source: string;
+  task_id: string | null;
+  tags: string;
+  created_at: Generated<string>;
+}
+
+export interface SettingsTable {
+  key: string;
+  value: string;
+  category: string;
+  description: string | null;
+  sensitive: number;
+  input_type: string;
+  updated_at: Generated<string>;
+}
+
+export interface SkillsTable {
+  id: string;
+  name: string;
+  body: string;
+  category: string;
+  tags: string;
+  created_at: Generated<string>;
+  updated_at: Generated<string>;
+}
+
+export interface RoleConfigsTable {
+  id: string;
+  role: string;
+  config_type: string;
+  content: string;
+  created_at: Generated<string>;
+  updated_at: Generated<string>;
+}

package/src/api/index.ts

@@ -0,0 +1,73 @@
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { serveStatic } from "hono/bun";
+import * as path from "path";
+import { reconcileDbFromFleet, startWatcher } from "./lib/fleet-sync.js";
+import { agents } from "./routes/agents.js";
+import { tasks } from "./routes/tasks.js";
+import { messages } from "./routes/messages.js";
+import { notifications } from "./routes/notifications.js";
+import { activities } from "./routes/activities.js";
+import { documents } from "./routes/documents.js";
+import { knowledge } from "./routes/knowledge.js";
+import { settings } from "./routes/settings.js";
+import { oauth } from "./routes/oauth.js";
+import { skills } from "./routes/skills.js";
+import { roleConfigs } from "./routes/role-configs.js";
+
+const app = new Hono();
+
+// CORS — dashboard on :3001 hits API on :3100
+app.use("*", cors());
+
+// Global error handler — return 400/500 JSON instead of crashing
+app.onError((err, c) => {
+  const msg = err.message ?? "internal error";
+  const errMsg = String((err as any).message ?? "");
+  if (errMsg.includes("UNIQUE constraint") || errMsg.includes("FOREIGN KEY constraint") || errMsg.includes("NOT NULL constraint") || errMsg.includes("CHECK constraint")) {
+    return c.json({ error: msg }, 400);
+  }
+  console.error(err);
+  return c.json({ error: msg }, 500);
+});
+
+app.get("/health", (c) => c.json({ status: "ok" }));
+app.route("/agents", agents);
+app.route("/tasks", tasks);
+app.route("/tasks", messages);
+app.route("/notifications", notifications);
+app.route("/activities", activities);
+app.route("/documents", documents);
+app.route("/knowledge", knowledge);
+app.route("/settings", settings);
+app.route("/oauth", oauth);
+app.route("/skills", skills);
+app.route("/role-configs", roleConfigs);
+
+// Serve the dashboard static export
+const dashboardPaths = [
+  path.resolve(import.meta.dir, "../../dashboard/out"),
+  path.resolve(process.cwd(), "dashboard/out"),
+];
+const dashboardDir = dashboardPaths.find((p) => {
+  try { return Bun.file(path.join(p, "index.html")).size > 0; } catch { return false; }
+});
+
+if (dashboardDir) {
+  app.use("/assets/*", serveStatic({ root: dashboardDir }));
+  app.use("/_next/*", serveStatic({ root: dashboardDir }));
+  app.get("/", serveStatic({ root: dashboardDir, path: "/index.html" }));
+  // Fallback: serve index.html for any non-API route (SPA routing)
+  app.use("*", serveStatic({ root: dashboardDir, rewriteRequestPath: () => "/index.html" }));
+}
+
+// Reconcile fleet.json → DB on startup, then watch for changes
+reconcileDbFromFleet()
+  .then(() => startWatcher())
+  .catch((err) => console.error("[startup] fleet sync failed:", err));
+
+export default {
+  port: Number(process.env.PORT ?? 3100),
+  hostname: "0.0.0.0",
+  fetch: app.fetch,
+};

package/src/api/lib/activity.ts

@@ -0,0 +1,13 @@
+import { db } from "../db/client.js";
+
+export async function logActivity(
+  type: string,
+  agentId: string,
+  summary: string,
+  taskId?: string | null
+) {
+  await db.insertInto("activities").values({
+    id: crypto.randomUUID(),
+    type, agent_id: agentId, task_id: taskId ?? null, summary,
+  }).execute();
+}