iflow-mcp-deeflect-smart-spawn 0.1.0

package/package.json

@@ -0,0 +1 @@
+{"name": "iflow-mcp-deeflect-smart-spawn", "version": "0.1.0", "type": "module", "bin": {"iflow-mcp-deeflect-smart-spawn": "src/index.ts"}, "scripts": {"dev": "bun run --hot src/index.ts", "start": "bun run src/index.ts", "typecheck": "bunx tsc -p tsconfig.json --noEmit", "test": "bun test", "live:smoke": "bun run scripts/live-smoke.ts"}, "dependencies": {"@modelcontextprotocol/sdk": "^1.18.1"}, "devDependencies": {"@types/bun": "latest", "tsx": "^4.21.0"}}

package/scripts/live-smoke.ts

@@ -0,0 +1,121 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { rmSync } from "node:fs";
+import { join } from "node:path";
+
+function parseTextPayload(result: any): any {
+  const part = result?.content?.find((x: any) => x?.type === "text");
+  if (!part?.text) throw new Error("No text payload in tool response");
+  return JSON.parse(part.text);
+}
+
+async function waitForCompletion(client: Client, runId: string, timeoutMs: number): Promise<any> {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    const status = await client.callTool({
+      name: "smartspawn_run_status",
+      arguments: { run_id: runId },
+    });
+    const payload = parseTextPayload(status);
+    const state = String(payload.status ?? "");
+    const pct = Number(payload?.progress?.percent ?? 0);
+    const done = Number(payload?.progress?.done_nodes ?? 0);
+    const total = Number(payload?.progress?.total_nodes ?? 0);
+    console.log(`[status] ${state} ${done}/${total} (${pct}%)`);
+    if (["completed", "failed", "canceled"].includes(state)) return payload;
+    await Bun.sleep(3500);
+  }
+  throw new Error(`Run timed out after ${timeoutMs}ms`);
+}
+
+async function main(): Promise<void> {
+  if (!process.env["OPENROUTER_API_KEY"]) {
+    throw new Error("OPENROUTER_API_KEY is not set in environment");
+  }
+
+  const mcpHome = join(process.cwd(), ".smart-spawn-mcp-live");
+  rmSync(mcpHome, { recursive: true, force: true });
+
+  const transport = new StdioClientTransport({
+    command: "bun",
+    args: ["run", "src/index.ts"],
+    cwd: process.cwd(),
+    env: {
+      OPENROUTER_API_KEY: process.env["OPENROUTER_API_KEY"]!,
+      SMART_SPAWN_API_URL: process.env["SMART_SPAWN_API_URL"] ?? "https://ss.deeflect.com/api",
+      SMART_SPAWN_MCP_HOME: process.env["SMART_SPAWN_MCP_HOME"] ?? mcpHome,
+      MAX_PARALLEL_RUNS: process.env["MAX_PARALLEL_RUNS"] ?? "2",
+      MAX_PARALLEL_NODES_PER_RUN: process.env["MAX_PARALLEL_NODES_PER_RUN"] ?? "4",
+      MAX_USD_PER_RUN: process.env["MAX_USD_PER_RUN"] ?? "2",
+      NODE_TIMEOUT_SECONDS: process.env["NODE_TIMEOUT_SECONDS"] ?? "180",
+      RUN_TIMEOUT_SECONDS: process.env["RUN_TIMEOUT_SECONDS"] ?? "900",
+    },
+    stderr: "pipe",
+  });
+
+  const client = new Client({
+    name: "smart-spawn-live-smoke",
+    version: "1.0.0",
+  });
+
+  transport.stderr?.on("data", (chunk) => {
+    const text = String(chunk ?? "").trim();
+    if (text) console.log(`[server] ${text}`);
+  });
+
+  await client.connect(transport);
+
+  try {
+    const tools = await client.listTools();
+    console.log(`[tools] ${tools.tools.length} tools available`);
+
+    const create = await client.callTool({
+      name: "smartspawn_run_create",
+      arguments: {
+        task: "Build a tiny Node.js hello-world API, add 3 curl tests, and provide final implementation summary.",
+        mode: "swarm",
+        budget: "low",
+        context: "nodejs,typescript,api,testing",
+        merge: { style: "concise" },
+      },
+    });
+    const created = parseTextPayload(create);
+    const runId = String(created.run_id ?? "");
+    if (!runId) throw new Error("run_create did not return run_id");
+    console.log(`[run] created ${runId}`);
+
+    const finalStatus = await waitForCompletion(client, runId, 6 * 60 * 1000);
+    console.log(`[run] final status: ${finalStatus.status}`);
+    if (finalStatus.status !== "completed") {
+      throw new Error(`Run ended in non-completed state: ${finalStatus.status}`);
+    }
+
+    const resultRes = await client.callTool({
+      name: "smartspawn_run_result",
+      arguments: { run_id: runId, include_raw: true },
+    });
+    const result = parseTextPayload(resultRes);
+
+    console.log(`[result] artifacts=${Array.isArray(result.artifacts) ? result.artifacts.length : 0}`);
+    console.log(
+      `[cost] prompt=${result?.cost?.prompt_tokens ?? 0}, completion=${result?.cost?.completion_tokens ?? 0}, usd_estimate=${result?.cost?.usd_estimate ?? 0}`
+    );
+    const merged = String(result?.merged_output ?? "");
+    console.log(`[merged-preview]\n${merged.slice(0, 900)}${merged.length > 900 ? "\n...[truncated]" : ""}`);
+
+    const mergedArtifact = await client.callTool({
+      name: "smartspawn_artifact_get",
+      arguments: { run_id: runId, node_id: "merged" },
+    });
+    const mergedArtifactPayload = parseTextPayload(mergedArtifact);
+    console.log(`[artifact] merged bytes=${mergedArtifactPayload?.metadata?.bytes ?? 0} path=${mergedArtifactPayload?.metadata?.path ?? "n/a"}`);
+  } finally {
+    await client.close();
+  }
+}
+
+main().catch((error) => {
+  const message = error instanceof Error ? error.stack ?? error.message : String(error);
+  console.error(message);
+  process.exit(1);
+});

package/src/config.ts

@@ -0,0 +1,55 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export interface McpConfig {
+  openRouterApiKey: string;
+  smartSpawnApiUrl: string;
+  homeDir: string;
+  dbPath: string;
+  artifactsDir: string;
+  maxParallelRuns: number;
+  maxParallelNodesPerRun: number;
+  maxUsdPerRun: number;
+  nodeTimeoutSeconds: number;
+  runTimeoutSeconds: number;
+  pollIntervalMs: number;
+}
+
+function parsePositiveInt(raw: string | undefined, fallback: number): number {
+  const n = Number(raw);
+  if (!Number.isFinite(n) || n <= 0) return fallback;
+  return Math.floor(n);
+}
+
+function parsePositiveFloat(raw: string | undefined, fallback: number): number {
+  const n = Number(raw);
+  if (!Number.isFinite(n) || n <= 0) return fallback;
+  return n;
+}
+
+function resolveHomePath(raw: string | undefined): string {
+  if (!raw || !raw.trim()) return join(process.cwd(), ".smart-spawn-mcp");
+  if (raw.startsWith("~/")) return join(homedir(), raw.slice(2));
+  return raw;
+}
+
+export function loadConfig(env: NodeJS.ProcessEnv = process.env): McpConfig {
+  const openRouterApiKey = env["OPENROUTER_API_KEY"] ?? "";
+  const homeDir = resolveHomePath(env["SMART_SPAWN_MCP_HOME"]);
+  const dbPath = join(homeDir, "db.sqlite");
+  const artifactsDir = join(homeDir, "artifacts");
+
+  return {
+    openRouterApiKey,
+    smartSpawnApiUrl: env["SMART_SPAWN_API_URL"] ?? "https://ss.deeflect.com/api",
+    homeDir,
+    dbPath,
+    artifactsDir,
+    maxParallelRuns: parsePositiveInt(env["MAX_PARALLEL_RUNS"], 2),
+    maxParallelNodesPerRun: parsePositiveInt(env["MAX_PARALLEL_NODES_PER_RUN"], 4),
+    maxUsdPerRun: parsePositiveFloat(env["MAX_USD_PER_RUN"], 5),
+    nodeTimeoutSeconds: parsePositiveInt(env["NODE_TIMEOUT_SECONDS"], 180),
+    runTimeoutSeconds: parsePositiveInt(env["RUN_TIMEOUT_SECONDS"], 1800),
+    pollIntervalMs: parsePositiveInt(env["POLL_INTERVAL_MS"], 1200),
+  };
+}

package/src/db.ts

@@ -0,0 +1,448 @@
+import { Database } from "bun:sqlite";
+import { randomUUID } from "node:crypto";
+import type { ArtifactRecord, NodeRecord, PlannedNode, RunCreateInput, RunRecord, RunStatus } from "./types.ts";
+
+function nowIso(): string {
+  return new Date().toISOString();
+}
+
+function parseJson<T>(raw: string): T {
+  return JSON.parse(raw) as T;
+}
+
+export class McpStore {
+  private db: Database;
+
+  constructor(dbPath: string) {
+    this.db = new Database(dbPath, { create: true, strict: false });
+    this.initSchema();
+  }
+
+  initSchema(): void {
+    this.db.exec(`
+      PRAGMA journal_mode = WAL;
+      PRAGMA synchronous = NORMAL;
+
+      CREATE TABLE IF NOT EXISTS runs (
+        id TEXT PRIMARY KEY,
+        task TEXT NOT NULL,
+        mode TEXT NOT NULL,
+        budget TEXT NOT NULL,
+        context TEXT,
+        params_json TEXT NOT NULL,
+        status TEXT NOT NULL,
+        error TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        started_at TEXT,
+        finished_at TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS nodes (
+        id TEXT PRIMARY KEY,
+        run_id TEXT NOT NULL,
+        kind TEXT NOT NULL,
+        wave INTEGER NOT NULL,
+        depends_on_json TEXT NOT NULL,
+        task TEXT NOT NULL,
+        model TEXT NOT NULL,
+        prompt TEXT NOT NULL,
+        meta_json TEXT NOT NULL,
+        status TEXT NOT NULL,
+        retry_count INTEGER NOT NULL DEFAULT 0,
+        max_retries INTEGER NOT NULL DEFAULT 2,
+        error TEXT,
+        started_at TEXT,
+        finished_at TEXT,
+        tokens_prompt INTEGER NOT NULL DEFAULT 0,
+        tokens_completion INTEGER NOT NULL DEFAULT 0,
+        cost_usd REAL NOT NULL DEFAULT 0,
+        FOREIGN KEY (run_id) REFERENCES runs(id)
+      );
+
+      CREATE TABLE IF NOT EXISTS events (
+        id TEXT PRIMARY KEY,
+        run_id TEXT NOT NULL,
+        node_id TEXT,
+        level TEXT NOT NULL,
+        message TEXT NOT NULL,
+        ts TEXT NOT NULL,
+        FOREIGN KEY (run_id) REFERENCES runs(id)
+      );
+
+      CREATE TABLE IF NOT EXISTS artifacts (
+        id TEXT PRIMARY KEY,
+        run_id TEXT NOT NULL,
+        node_id TEXT NOT NULL,
+        type TEXT NOT NULL,
+        path TEXT NOT NULL,
+        bytes INTEGER NOT NULL,
+        sha256 TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        FOREIGN KEY (run_id) REFERENCES runs(id)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_runs_status ON runs(status);
+      CREATE INDEX IF NOT EXISTS idx_nodes_run_id ON nodes(run_id);
+      CREATE INDEX IF NOT EXISTS idx_nodes_status ON nodes(status);
+      CREATE INDEX IF NOT EXISTS idx_artifacts_run_id ON artifacts(run_id);
+      CREATE INDEX IF NOT EXISTS idx_events_run_id ON events(run_id, ts);
+    `);
+  }
+
+  createRun(input: RunCreateInput): RunRecord {
+    const id = randomUUID();
+    const now = nowIso();
+    const budget = input.budget ?? "medium";
+    const context = input.context ?? null;
+    const params = JSON.stringify(input);
+
+    this.db
+      .query(
+        `INSERT INTO runs (id, task, mode, budget, context, params_json, status, error, created_at, updated_at, started_at, finished_at)
+         VALUES (?, ?, ?, ?, ?, ?, 'queued', NULL, ?, ?, NULL, NULL)`
+      )
+      .run(id, input.task, input.mode, budget, context, params, now, now);
+
+    return this.getRun(id)!;
+  }
+
+  getRun(runId: string): RunRecord | null {
+    const row = this.db
+      .query(
+        `SELECT id, task, mode, budget, context, params_json, status, error, created_at, updated_at, started_at, finished_at
+         FROM runs WHERE id = ? LIMIT 1`
+      )
+      .get(runId) as any;
+    if (!row) return null;
+    return this.mapRun(row);
+  }
+
+  listRuns(status?: RunStatus, limit = 20): RunRecord[] {
+    const safeLimit = Math.max(1, Math.min(limit, 200));
+    const rows = status
+      ? (this.db
+          .query(
+            `SELECT id, task, mode, budget, context, params_json, status, error, created_at, updated_at, started_at, finished_at
+             FROM runs WHERE status = ? ORDER BY created_at DESC LIMIT ?`
+          )
+          .all(status, safeLimit) as any[])
+      : (this.db
+          .query(
+            `SELECT id, task, mode, budget, context, params_json, status, error, created_at, updated_at, started_at, finished_at
+             FROM runs ORDER BY created_at DESC LIMIT ?`
+          )
+          .all(safeLimit) as any[]);
+
+    return rows.map((r) => this.mapRun(r));
+  }
+
+  listActiveRuns(limit: number): RunRecord[] {
+    const rows = this.db
+      .query(
+        `SELECT id, task, mode, budget, context, params_json, status, error, created_at, updated_at, started_at, finished_at
+         FROM runs WHERE status IN ('queued', 'running') ORDER BY created_at ASC LIMIT ?`
+      )
+      .all(limit) as any[];
+    return rows.map((r) => this.mapRun(r));
+  }
+
+  updateRunStatus(runId: string, status: RunStatus, error: string | null = null): void {
+    const now = nowIso();
+    if (status === "running") {
+      this.db
+        .query(
+          `UPDATE runs
+           SET status = ?, error = ?, updated_at = ?, started_at = COALESCE(started_at, ?)
+           WHERE id = ?`
+        )
+        .run(status, error, now, now, runId);
+      return;
+    }
+
+    if (status === "completed" || status === "failed" || status === "canceled") {
+      this.db
+        .query(
+          `UPDATE runs
+           SET status = ?, error = ?, updated_at = ?, finished_at = ?
+           WHERE id = ?`
+        )
+        .run(status, error, now, now, runId);
+      return;
+    }
+
+    this.db
+      .query(`UPDATE runs SET status = ?, error = ?, updated_at = ? WHERE id = ?`)
+      .run(status, error, now, runId);
+  }
+
+  getRunInput(runId: string): RunCreateInput | null {
+    const row = this.db
+      .query(`SELECT params_json FROM runs WHERE id = ? LIMIT 1`)
+      .get(runId) as any;
+    if (!row) return null;
+    return parseJson<RunCreateInput>(row.params_json);
+  }
+
+  createNodes(runId: string, nodes: PlannedNode[]): void {
+    const insert = this.db.query(
+      `INSERT INTO nodes
+      (id, run_id, kind, wave, depends_on_json, task, model, prompt, meta_json, status, retry_count, max_retries, error, started_at, finished_at, tokens_prompt, tokens_completion, cost_usd)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'queued', 0, ?, NULL, NULL, NULL, 0, 0, 0)`
+    );
+    const tx = this.db.transaction(() => {
+      const idMap = new Map<string, string>();
+      for (const node of nodes) {
+        idMap.set(node.id, `${runId}:${node.id}`);
+      }
+
+      for (const node of nodes) {
+        const nodeId = idMap.get(node.id)!;
+        const mappedDependsOn = node.dependsOn.map((dep) => idMap.get(dep) ?? `${runId}:${dep}`);
+        insert.run(
+          nodeId,
+          runId,
+          node.kind,
+          node.wave,
+          JSON.stringify(mappedDependsOn),
+          node.task,
+          node.model,
+          node.prompt,
+          JSON.stringify(node.meta ?? {}),
+          node.maxRetries ?? 2
+        );
+      }
+    });
+    tx();
+  }
+
+  listNodes(runId: string): NodeRecord[] {
+    const rows = this.db
+      .query(
+        `SELECT id, run_id, kind, wave, depends_on_json, task, model, prompt, meta_json, status, retry_count, max_retries, error, started_at, finished_at, tokens_prompt, tokens_completion, cost_usd
+         FROM nodes WHERE run_id = ? ORDER BY wave ASC, id ASC`
+      )
+      .all(runId) as any[];
+    return rows.map((r) => this.mapNode(r));
+  }
+
+  getNode(nodeId: string): NodeRecord | null {
+    const row = this.db
+      .query(
+        `SELECT id, run_id, kind, wave, depends_on_json, task, model, prompt, meta_json, status, retry_count, max_retries, error, started_at, finished_at, tokens_prompt, tokens_completion, cost_usd
+         FROM nodes WHERE id = ? LIMIT 1`
+      )
+      .get(nodeId) as any;
+    if (!row) return null;
+    return this.mapNode(row);
+  }
+
+  startNode(nodeId: string): void {
+    const now = nowIso();
+    this.db
+      .query(
+        `UPDATE nodes
+         SET status = 'running', started_at = COALESCE(started_at, ?) 
+         WHERE id = ?`
+      )
+      .run(now, nodeId);
+  }
+
+  markNodeCompleted(nodeId: string, tokensPrompt: number, tokensCompletion: number, costUsd: number): void {
+    const now = nowIso();
+    this.db
+      .query(
+        `UPDATE nodes
+         SET status = 'completed', finished_at = ?, tokens_prompt = ?, tokens_completion = ?, cost_usd = ?, error = NULL
+         WHERE id = ?`
+      )
+      .run(now, tokensPrompt, tokensCompletion, costUsd, nodeId);
+  }
+
+  markNodeSkipped(nodeId: string, reason: string): void {
+    const now = nowIso();
+    this.db
+      .query(
+        `UPDATE nodes
+         SET status = 'skipped', finished_at = ?, error = ?
+         WHERE id = ?`
+      )
+      .run(now, reason, nodeId);
+  }
+
+  markNodeFailed(nodeId: string, error: string): void {
+    const now = nowIso();
+    this.db
+      .query(
+        `UPDATE nodes
+         SET status = 'failed', finished_at = ?, error = ?
+         WHERE id = ?`
+      )
+      .run(now, error.slice(0, 5000), nodeId);
+  }
+
+  incrementNodeRetry(nodeId: string, error: string): void {
+    this.db
+      .query(
+        `UPDATE nodes
+         SET status = 'queued', retry_count = retry_count + 1, error = ?
+         WHERE id = ?`
+      )
+      .run(error.slice(0, 5000), nodeId);
+  }
+
+  addEvent(runId: string, level: "info" | "warn" | "error", message: string, nodeId?: string): void {
+    this.db
+      .query(
+        `INSERT INTO events (id, run_id, node_id, level, message, ts)
+         VALUES (?, ?, ?, ?, ?, ?)`
+      )
+      .run(randomUUID(), runId, nodeId ?? null, level, message.slice(0, 5000), nowIso());
+  }
+
+  listRecentEvents(runId: string, limit = 20): Array<{ level: string; message: string; ts: string; nodeId: string | null }> {
+    const safeLimit = Math.max(1, Math.min(limit, 200));
+    const rows = this.db
+      .query(
+        `SELECT level, message, ts, node_id
+         FROM events WHERE run_id = ? ORDER BY ts DESC LIMIT ?`
+      )
+      .all(runId, safeLimit) as Array<{ level: string; message: string; ts: string; node_id: string | null }>;
+    return rows.map((row) => ({
+      level: row.level,
+      message: row.message,
+      ts: row.ts,
+      nodeId: row.node_id,
+    }));
+  }
+
+  createArtifact(input: Omit<ArtifactRecord, "id">): ArtifactRecord {
+    const id = randomUUID();
+    this.db
+      .query(
+        `INSERT INTO artifacts (id, run_id, node_id, type, path, bytes, sha256, created_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+      )
+      .run(id, input.runId, input.nodeId, input.type, input.path, input.bytes, input.sha256, input.createdAt);
+
+    return {
+      id,
+      ...input,
+    };
+  }
+
+  listArtifacts(runId: string): ArtifactRecord[] {
+    const rows = this.db
+      .query(
+        `SELECT id, run_id, node_id, type, path, bytes, sha256, created_at
+         FROM artifacts WHERE run_id = ? ORDER BY created_at ASC`
+      )
+      .all(runId) as any[];
+
+    return rows.map((r) => ({
+      id: r.id,
+      runId: r.run_id,
+      nodeId: r.node_id,
+      type: r.type,
+      path: r.path,
+      bytes: r.bytes,
+      sha256: r.sha256,
+      createdAt: r.created_at,
+    }));
+  }
+
+  getArtifact(runId: string, nodeId: string): ArtifactRecord | null {
+    const row = this.db
+      .query(
+        `SELECT id, run_id, node_id, type, path, bytes, sha256, created_at
+         FROM artifacts WHERE run_id = ? AND node_id = ? ORDER BY created_at DESC LIMIT 1`
+      )
+      .get(runId, nodeId) as any;
+    if (!row) return null;
+    return {
+      id: row.id,
+      runId: row.run_id,
+      nodeId: row.node_id,
+      type: row.type,
+      path: row.path,
+      bytes: row.bytes,
+      sha256: row.sha256,
+      createdAt: row.created_at,
+    };
+  }
+
+  getRunCost(runId: string): { promptTokens: number; completionTokens: number; usdEstimate: number } {
+    const row = this.db
+      .query(
+        `SELECT
+           COALESCE(SUM(tokens_prompt), 0) AS prompt_tokens,
+           COALESCE(SUM(tokens_completion), 0) AS completion_tokens,
+           COALESCE(SUM(cost_usd), 0) AS usd_estimate
+         FROM nodes WHERE run_id = ?`
+      )
+      .get(runId) as any;
+
+    return {
+      promptTokens: Number(row.prompt_tokens ?? 0),
+      completionTokens: Number(row.completion_tokens ?? 0),
+      usdEstimate: Number(row.usd_estimate ?? 0),
+    };
+  }
+
+  pingWritable(): boolean {
+    try {
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS _health_probe (id INTEGER PRIMARY KEY, ts TEXT NOT NULL);
+        INSERT INTO _health_probe (ts) VALUES (datetime('now'));
+        DELETE FROM _health_probe WHERE id = (SELECT MAX(id) FROM _health_probe);
+      `);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  close(): void {
+    this.db.close();
+  }
+
+  private mapRun(row: any): RunRecord {
+    return {
+      id: row.id,
+      task: row.task,
+      mode: row.mode,
+      budget: row.budget,
+      context: row.context,
+      paramsJson: row.params_json,
+      status: row.status,
+      error: row.error,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      startedAt: row.started_at,
+      finishedAt: row.finished_at,
+    };
+  }
+
+  private mapNode(row: any): NodeRecord {
+    return {
+      id: row.id,
+      runId: row.run_id,
+      kind: row.kind,
+      wave: row.wave,
+      dependsOnJson: row.depends_on_json,
+      task: row.task,
+      model: row.model,
+      prompt: row.prompt,
+      metaJson: row.meta_json,
+      status: row.status,
+      retryCount: row.retry_count,
+      maxRetries: row.max_retries,
+      error: row.error,
+      startedAt: row.started_at,
+      finishedAt: row.finished_at,
+      tokensPrompt: row.tokens_prompt,
+      tokensCompletion: row.tokens_completion,
+      costUsd: Number(row.cost_usd ?? 0),
+    };
+  }
+}

package/src/index.ts

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+import { mkdirSync } from "node:fs";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { loadConfig } from "./config.ts";
+import { McpStore } from "./db.ts";
+import { OpenRouterClient } from "./openrouter-client.ts";
+import { RuntimeQueue } from "./runtime/queue.ts";
+import { SmartSpawnClient } from "./smart-spawn-client.ts";
+import { ArtifactStorage } from "./storage.ts";
+import { registerToolHandlers } from "./tools.ts";
+
+async function main(): Promise<void> {
+  const config = loadConfig();
+
+  mkdirSync(config.homeDir, { recursive: true });
+  const store = new McpStore(config.dbPath);
+  const storage = new ArtifactStorage(config.homeDir, config.artifactsDir);
+  const smartSpawn = new SmartSpawnClient(config.smartSpawnApiUrl);
+  const openRouter = new OpenRouterClient(config.openRouterApiKey);
+  const runtime = new RuntimeQueue(config, store, storage, smartSpawn, openRouter);
+  await runtime.start();
+
+  const server = new Server(
+    {
+      name: "smart-spawn-mcp",
+      version: "0.1.0",
+    },
+    {
+      capabilities: {
+        tools: {},
+      },
+    }
+  );
+
+  registerToolHandlers(server, runtime);
+
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch((error) => {
+  const message = error instanceof Error ? error.stack ?? error.message : String(error);
+  console.error(message);
+  process.exit(1);
+});