maestro-agent 0.0.1 → 0.0.3

package/src/core/cli.ts

@@ -0,0 +1,333 @@
+import { cpSync, existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from "fs";
+import { join } from "path";
+import { runChatCommand } from "../chat";
+import { discoverRuntimes, formatRuntimeList, registerDiscoveredRuntimes } from "../discovery";
+import { runInboxCommand } from "../inbox";
+import { ensureBuiltinSkills } from "../skills/builtin";
+import { ensureDefaultWorkflow } from "../workflows";
+import { getDb, initSchema } from "./db";
+import { startServer } from "./server";
+
+const HUB_DIR = join(process.cwd(), ".hub");
+const VERSION = "0.0.1";
+const PID_FILE = join(HUB_DIR, "hub.pid");
+const LOG_FILE = join(HUB_DIR, "hub.log");
+
+export async function main(args: string[]) {
+  const command = args[0];
+
+  if (command === "-v" || command === "--version") {
+    console.log(`maestro v${VERSION}`);
+    return;
+  }
+
+  switch (command) {
+    case "init":
+      await cmdInit();
+      break;
+    case "start":
+      await cmdStart(args.slice(1));
+      break;
+    case "doctor":
+      await cmdDoctor();
+      break;
+    case "stop":
+      cmdStop();
+      break;
+    case "inbox":
+      await cmdInbox(args.slice(1));
+      break;
+    case "chat":
+      await cmdChat(args.slice(1));
+      break;
+    case "help":
+    case "--help":
+    case "-h":
+      printHelp();
+      break;
+    default:
+      if (command) {
+        console.error(`\x1b[31mError:\x1b[0m Unknown command "${command}"\n`);
+      }
+      printHelp();
+      if (command) process.exit(1);
+  }
+}
+
+async function cmdInit() {
+  if (existsSync(HUB_DIR)) {
+    console.log("\x1b[33m⚠\x1b[0m  .hub/ already exists, skipping initialization");
+    return;
+  }
+
+  console.log("\x1b[36m🎼\x1b[0m Initializing MAESTRO Hub...\n");
+
+  // 创建目录结构
+  mkdirSync(join(HUB_DIR, "transcripts"), { recursive: true });
+  mkdirSync(join(HUB_DIR, "artifacts"), { recursive: true });
+  mkdirSync(join(HUB_DIR, "roles"), { recursive: true });
+
+  // 复制出厂角色
+  const rolesSource = join(import.meta.dir, "../../roles");
+  if (existsSync(rolesSource)) {
+    cpSync(rolesSource, join(HUB_DIR, "roles"), { recursive: true });
+  }
+
+  // 初始化数据库
+  const db = getDb(HUB_DIR);
+  initSchema(db, HUB_DIR);
+  console.log("  \x1b[32m✓\x1b[0m Database initialized (16 tables)");
+
+  const builtinSkills = ensureBuiltinSkills(db, HUB_DIR);
+  ensureDefaultWorkflow(db);
+  if (builtinSkills.installed.length > 0 || builtinSkills.updated.length > 0) {
+    console.log(`  \x1b[32m✓\x1b[0m Built-in skills ready (${builtinSkills.installed.length + builtinSkills.updated.length})`);
+  }
+
+  await discoverAndRegisterRuntimes(db);
+
+  console.log(`\n\x1b[32m✨ Done!\x1b[0m Hub initialized.`);
+}
+
+async function cmdStart(args: string[]) {
+  // 首次启动时自动初始化
+  if (!existsSync(HUB_DIR)) {
+    await cmdInit();
+  }
+
+  // 自动构建前端（如果 dist/web 不存在）
+  const webDistDir = join(import.meta.dir, "../../dist/web");
+  if (!existsSync(webDistDir)) {
+    const webDir = join(import.meta.dir, "../../web");
+    if (existsSync(join(webDir, "package.json"))) {
+      console.log("\x1b[36m⟳\x1b[0m Building Web UI...");
+      const result = Bun.spawnSync(["bun", "run", "build"], { cwd: webDir, stdio: ["ignore", "pipe", "pipe"] });
+      if (result.exitCode === 0) {
+        console.log("\x1b[32m✓\x1b[0m Web UI built");
+      } else {
+        console.log("\x1b[33m⚠\x1b[0m Web UI build failed (API still works, no UI)");
+      }
+    }
+  }
+
+  const portFlag = args.indexOf("--port");
+  const port = portFlag !== -1 ? parseInt(args[portFlag + 1], 10) : 7423;
+
+  if (isNaN(port) || port < 1 || port > 65535) {
+    console.error("\x1b[31m✗\x1b[0m Invalid port number");
+    process.exit(1);
+  }
+
+  const db = getDb(HUB_DIR);
+  initSchema(db, HUB_DIR);
+  ensureBuiltinSkills(db, HUB_DIR);
+  ensureDefaultWorkflow(db);
+  await discoverAndRegisterRuntimes(db);
+
+  const isDaemon = args.includes("--daemon") || args.includes("-d");
+
+  if (isDaemon) {
+    const binPath = join(import.meta.dir, "../../bin/maestro.ts");
+
+    const child = Bun.spawn(["bun", "run", binPath, "start", "--port", String(port)], {
+      cwd: process.cwd(),
+      stdio: ["ignore", "ignore", "ignore"],
+      env: { ...process.env },
+    });
+
+    writeFileSync(PID_FILE, String(child.pid));
+    console.log(`\x1b[32m✓\x1b[0m Hub started in background (pid: ${child.pid})`);
+    console.log(`  Log: ${LOG_FILE}`);
+    console.log(`  PID: ${PID_FILE}`);
+    child.unref();
+    process.exit(0);
+  }
+
+  // Foreground mode — write pidfile for stop command
+  writeFileSync(PID_FILE, String(process.pid));
+  process.on("SIGTERM", () => {
+    try { unlinkSync(PID_FILE); } catch {}
+    process.exit(0);
+  });
+  process.on("SIGINT", () => {
+    try { unlinkSync(PID_FILE); } catch {}
+    process.exit(0);
+  });
+
+  try {
+    await startServer(HUB_DIR, port);
+  } catch (err) {
+    try { unlinkSync(PID_FILE); } catch {}
+    throw err;
+  }
+}
+
+async function cmdDoctor() {
+  console.log(`\x1b[36m🩺\x1b[0m MAESTRO Doctor (v${VERSION})\n`);
+
+  const hubExists = existsSync(HUB_DIR);
+  console.log(`  ${hubExists ? "\x1b[32m✓\x1b[0m" : "\x1b[31m✗\x1b[0m"} .hub/ directory ${hubExists ? "exists" : "NOT FOUND"}`);
+
+  if (!hubExists) {
+    console.log(`\n  Run \x1b[1mmaestro init\x1b[0m to create it.`);
+    return;
+  }
+
+  const dbPath = join(HUB_DIR, "maestro.db");
+  const dbExists = existsSync(dbPath);
+  console.log(`  ${dbExists ? "\x1b[32m✓\x1b[0m" : "\x1b[31m✗\x1b[0m"} maestro.db ${dbExists ? "ok" : "MISSING"}`);
+
+  if (dbExists) {
+    const db = getDb(HUB_DIR);
+    const tables = db.query("SELECT name FROM sqlite_master WHERE type='table'").all() as { name: string }[];
+    console.log(`  \x1b[32m✓\x1b[0m ${tables.length} tables`);
+
+    const runtimes = db.query("SELECT * FROM agent_runtime").all() as any[];
+    console.log(`  \x1b[32m✓\x1b[0m ${runtimes.length} agent runtime(s) registered`);
+  }
+
+  console.log("\n  \x1b[36mAgent Runtime Discovery:\x1b[0m");
+  const runtimes = await discoverRuntimes();
+  if (runtimes.length === 0) {
+    console.log("    \x1b[33m⚠\x1b[0m No CLI agents found");
+  } else {
+    for (const line of formatRuntimeList(runtimes)) {
+      console.log(`    \x1b[32m✓\x1b[0m ${line}`);
+    }
+  }
+
+  // Version & schema check
+  if (dbExists) {
+    const db = getDb(HUB_DIR);
+    const schemaVersion = (db.query("SELECT MAX(version) as v FROM schema_version").get() as any)?.v ?? -1;
+    const { migrations } = require("./migrations");
+    const latestMigration = migrations.length > 0 ? migrations[migrations.length - 1].version : 0;
+    const migrationStatus = schemaVersion >= latestMigration ? "\x1b[32m✓\x1b[0m" : "\x1b[33m⚠\x1b[0m";
+    console.log(`\n  \x1b[36mSchema:\x1b[0m`);
+    console.log(`    ${migrationStatus} schema_version: ${schemaVersion} (latest: ${latestMigration})`);
+  }
+
+  // Role diff detection
+  console.log(`\n  \x1b[36mRole Updates:\x1b[0m`);
+  const factoryRolesDir = join(import.meta.dir, "../../roles");
+  const hubRolesDir = join(HUB_DIR, "roles");
+  if (existsSync(factoryRolesDir) && existsSync(hubRolesDir)) {
+    const { createHash } = require("crypto");
+    const factoryFiles = readdirSync(factoryRolesDir).filter((f: string) => f.endsWith(".md"));
+    let diffs = 0;
+    for (const file of factoryFiles) {
+      const factoryPath = join(factoryRolesDir, file);
+      const hubPath = join(hubRolesDir, file);
+      if (!existsSync(hubPath)) {
+        console.log(`    \x1b[33m⚠\x1b[0m ${file} — new upstream role available`);
+        diffs++;
+        continue;
+      }
+      const factoryHash = createHash("md5").update(readFileSync(factoryPath)).digest("hex");
+      const hubHash = createHash("md5").update(readFileSync(hubPath)).digest("hex");
+      if (factoryHash !== hubHash) {
+        console.log(`    \x1b[33m⚠\x1b[0m ${file} — upstream has changes`);
+        diffs++;
+      }
+    }
+    if (diffs === 0) console.log(`    \x1b[32m✓\x1b[0m All roles up to date`);
+  } else {
+    console.log(`    \x1b[90m- Skipped (roles directory missing)\x1b[0m`);
+  }
+
+  console.log(`\n  \x1b[90mRuntime: Bun ${Bun.version} (${process.platform} ${process.arch})\x1b[0m`);
+}
+
+async function discoverAndRegisterRuntimes(db: ReturnType<typeof getDb>) {
+  console.log("  \x1b[36m⟳\x1b[0m Discovering agent runtimes...");
+  const result = await registerDiscoveredRuntimes(db);
+
+  if (result.discovered.length === 0) {
+    console.log("  \x1b[33m⚠\x1b[0m No CLI agents found (claude/claude-code/codex/opencode/openclaw/blade/hermes)");
+    console.log("    Install one of these CLIs or add a runtime manually with the API/UI.");
+    return;
+  }
+
+  for (const line of formatRuntimeList(result.added)) {
+    console.log(`  \x1b[32m✓\x1b[0m ${line}`);
+  }
+  if (result.added.length === 0) {
+    console.log(`  \x1b[32m✓\x1b[0m ${result.discovered.length} CLI agent runtime(s) already registered`);
+  } else if (result.skipped.length > 0) {
+    console.log(`  \x1b[90m-\x1b[0m ${result.skipped.length} discovered runtime(s) kept from existing configuration`);
+  }
+}
+
+function printHelp() {
+  console.log(`\x1b[1mMAESTRO\x1b[0m v${VERSION} — The Conductor for AI Agents
+
+\x1b[36mUsage:\x1b[0m
+  maestro <command> [options]
+
+\x1b[36mCommands:\x1b[0m
+  init              Initialize a new workspace (.hub/)
+  start [--port N]  Start the Hub (default: 7423)
+        [--daemon]  Run in background (detach)
+  stop              Stop the running Hub daemon
+  doctor            Run system diagnostics
+  inbox <command>   Run agent inbox commands
+  help              Show this help message
+
+\x1b[36mOptions:\x1b[0m
+  -v, --version     Show version number
+  -h, --help        Show help
+
+\x1b[90mDocs: https://github.com/user/maestro-agent\x1b[0m
+`);
+}
+
+function cmdStop() {
+  if (!existsSync(PID_FILE)) {
+    console.error("\x1b[31m✗\x1b[0m No pidfile found. Hub is not running (or was not started with pidfile).");
+    process.exit(1);
+  }
+  const pid = parseInt(readFileSync(PID_FILE, "utf-8").trim(), 10);
+  if (isNaN(pid)) {
+    console.error("\x1b[31m✗\x1b[0m Invalid pidfile content.");
+    unlinkSync(PID_FILE);
+    process.exit(1);
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+    console.log(`\x1b[32m✓\x1b[0m Sent SIGTERM to Hub (pid: ${pid})`);
+  } catch (err: any) {
+    if (err.code === "ESRCH") {
+      console.log(`\x1b[33m⚠\x1b[0m Process ${pid} not found (already stopped?)`);
+    } else {
+      throw err;
+    }
+  }
+  try { unlinkSync(PID_FILE); } catch {}
+}
+
+async function cmdInbox(args: string[]) {
+  if (!existsSync(HUB_DIR)) {
+    console.error("\x1b[31m✗\x1b[0m .hub/ not found. Run \x1b[1mmaestro start\x1b[0m first.");
+    process.exit(1);
+  }
+
+  const agentFlag = args.indexOf("--agent");
+  const agentId = agentFlag === -1 ? process.env.MAESTRO_AGENT_ID : args[agentFlag + 1];
+  const filteredArgs = agentFlag === -1 ? args : args.filter((_, index) => index !== agentFlag && index !== agentFlag + 1);
+  const result = await runInboxCommand(filteredArgs, { hubDir: HUB_DIR, agentId });
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+  if (result.status !== 0) process.exit(result.status);
+}
+
+async function cmdChat(args: string[]) {
+  if (!existsSync(HUB_DIR)) {
+    console.error("\x1b[31m✗\x1b[0m .hub/ not found. Run \x1b[1mmaestro start\x1b[0m first.");
+    process.exit(1);
+  }
+
+  const result = await runChatCommand(args, { hubDir: HUB_DIR });
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+  if (result.status !== 0) process.exit(result.status);
+}

package/src/core/db.ts

@@ -0,0 +1,53 @@
+import { Database } from "bun:sqlite";
+import { readFileSync } from "fs";
+import { join, resolve } from "path";
+import { runMigrations } from "./migrations";
+
+const dbCache = new Map<string, Database>();
+
+export function getDb(hubDir: string): Database {
+  const dbPath = resolve(join(hubDir, "maestro.db"));
+  const cached = dbCache.get(dbPath);
+  if (cached) {
+    try {
+      cached.query("SELECT 1").get();
+      return cached;
+    } catch {
+      dbCache.delete(dbPath);
+    }
+  }
+
+  const db = new Database(dbPath, { create: true });
+  db.exec("PRAGMA journal_mode=WAL");
+  db.exec("PRAGMA foreign_keys=ON");
+
+  const originalClose = db.close.bind(db);
+  db.close = () => {
+    dbCache.delete(dbPath);
+    return originalClose();
+  };
+
+  dbCache.set(dbPath, db);
+  return db;
+}
+
+export function initSchema(db: Database, hubDir?: string): void {
+  const schemaPath = join(import.meta.dir, "schema.sql");
+  const sql = readFileSync(schemaPath, "utf-8");
+  db.exec(sql);
+  runMigrations(db, hubDir);
+}
+
+export function closeDb(hubDir: string): void {
+  const dbPath = resolve(join(hubDir, "maestro.db"));
+  const cached = dbCache.get(dbPath);
+  if (cached) cached.close();
+}
+
+export function generateId(prefix: string): string {
+  return `${prefix}_${crypto.randomUUID().replace(/-/g, "").slice(0, 8)}`;
+}
+
+export function now(): number {
+  return Date.now();
+}

package/src/core/event-bus.ts

@@ -0,0 +1,33 @@
+import { EventEmitter } from "events";
+import type { Database } from "bun:sqlite";
+import { generateId, now } from "./db";
+
+export type BroadcastFn = (type: string, payload: unknown, ts: number) => void;
+
+export class EventBus extends EventEmitter {
+  private broadcast?: BroadcastFn;
+
+  constructor(private db: Database) {
+    super();
+    this.setMaxListeners(100);
+  }
+
+  setDb(db: Database) {
+    this.db = db;
+  }
+
+  setBroadcast(fn: BroadcastFn) {
+    this.broadcast = fn;
+  }
+
+  publish(type: string, payload: unknown): boolean {
+    const id = generateId("evt");
+    const ts = now();
+    this.db.run(
+      "INSERT INTO event_log (id, type, payload_json, created_at) VALUES (?, ?, ?, ?)",
+      [id, type, JSON.stringify(payload), ts]
+    );
+    this.broadcast?.(type, payload, ts);
+    return super.emit(type, payload);
+  }
+}

package/src/core/index.ts

@@ -0,0 +1,6 @@
+export { main } from "./cli";
+export { startServer } from "./server";
+export { getDb, initSchema, generateId, now } from "./db";
+export { Router, json, body } from "./router";
+export { EventBus } from "./event-bus";
+export type { HubContext } from "./server";