maestro-agent 0.0.1 → 0.0.2

package/src/api/sessions.ts

@@ -0,0 +1,479 @@
+import { appendFileSync, chmodSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { generateId, now } from "../core/db";
+import type { Router } from "../core/router";
+import { body, json } from "../core/router";
+import type { HubContext } from "../core/server";
+import { required } from "../core/validate";
+import { recordAgentExit } from "../ops";
+import { isAtCapacity, notifyNextInQueue } from "../ops/runtime-scheduler";
+import { assemblePrompt } from "../roles/prompt-assembler";
+import { parseTranscript } from "../session/output-parser";
+import { RealtimeParser, type SessionEvent } from "../session/realtime-parser";
+import type { TransportProcess } from "../transport";
+import { HttpApiTransport, SshTransport } from "../transport";
+import { getWorkflowForTask, isActiveTaskStatus, transitionTask } from "../workflows";
+
+export interface CreateSessionInput {
+  agent_id: string;
+  task_id?: string | null;
+  cmd?: string;
+  args?: string[];
+}
+
+interface RuntimeCommandPlan {
+  args: string[];
+  closeStdin: boolean;
+}
+
+export function registerSessionRoutes(router: Router, ctx: HubContext) {
+  router.post("/api/sessions", async (req) => {
+    const input = await body<CreateSessionInput>(req);
+    const result = await createSession(ctx, input);
+    if ("error" in result) return json({ error: result.error }, result.status);
+    return json(result.session, 201);
+  });
+
+  router.get("/api/sessions/:id", (_req, params) => {
+    const row = ctx.db.query("SELECT * FROM session WHERE id = ?").get(params.id);
+    if (!row) return json({ error: "Not found" }, 404);
+    return json(row);
+  });
+
+  // GET /api/sessions/:id/output?lines=N - get last N lines of terminal output
+  router.get("/api/sessions/:id/output", async (req, params) => {
+    const session = ctx.db.query("SELECT transcript_path FROM session WHERE id = ?").get(params.id) as any;
+    if (!session) return json({ error: "Not found" }, 404);
+    if (!session.transcript_path) return json({ lines: [] });
+    try {
+      const file = Bun.file(session.transcript_path);
+      const size = file.size;
+      if (size === 0) return json({ lines: [] });
+      const url = new URL(req.url, "http://localhost");
+      const maxLines = Math.min(parseInt(url.searchParams.get("lines") || "20", 10), 100);
+      // Only read last 32KB to avoid loading entire large transcript
+      const tailSize = Math.min(size, 32 * 1024);
+      const tailContent = await file.slice(size - tailSize, size).text();
+      const allLines = tailContent.split("\n").filter((l) => l.trim().length > 0);
+      const lines = allLines.slice(-maxLines);
+      return json({ lines });
+    } catch {
+      return json({ lines: [] });
+    }
+  });
+
+  // POST /api/sessions/:id/input - inject stdin via REST
+  router.post("/api/sessions/:id/input", async (req, params) => {
+    const { data } = await body<{ data: string }>(req);
+    if (!data) return json({ error: "data is required" }, 400);
+    const proc = ctx.sessions.get(params.id);
+    if (!proc) return json({ error: "Session not found or not running" }, 404);
+    if (!proc.stdin) return json({ error: "Session has no stdin" }, 400);
+    proc.stdin.write(data);
+    return json({ written: data.length });
+  });
+
+  router.delete("/api/sessions/:id", (_req, params) => {
+    const proc = ctx.sessions.get(params.id);
+    if (proc) {
+      proc.kill();
+      ctx.sessions.delete(params.id);
+    }
+    const ts = now();
+    ctx.db.run("UPDATE session SET status = 'ended', ended_at = ? WHERE id = ?", [ts, params.id]);
+    // Release queued session
+    const session = ctx.db.query("SELECT agent_id FROM session WHERE id = ?").get(params.id) as any;
+    if (session?.agent_id) {
+      const agentRow = ctx.db.query("SELECT runtime_id FROM agent WHERE id = ?").get(session.agent_id) as any;
+      if (agentRow?.runtime_id) {
+        notifyNextInQueue(ctx.sessionQueue, agentRow.runtime_id);
+      }
+    }
+    return json({ id: params.id, status: "ended" });
+  });
+}
+
+export async function createSession(ctx: HubContext, input: CreateSessionInput): Promise<
+  | { session: any }
+  | { error: string; status: number }
+> {
+  const { agent_id, task_id, cmd, args } = input;
+  required({ agent_id }, ["agent_id"]);
+  const agent = ctx.db.query("SELECT * FROM agent WHERE id = ?").get(agent_id) as any;
+  if (!agent) return { error: "Agent not found", status: 404 };
+
+  const runtime = ctx.db.query("SELECT * FROM agent_runtime WHERE id = ?").get(agent.runtime_id) as any;
+  if (!runtime) return { error: "Runtime not found", status: 404 };
+
+  // Check capacity with oversubscription factor
+  const factor = runtime.oversubscription_factor ?? 1.0;
+  if (isAtCapacity(ctx.db, runtime.id, Number(runtime.capacity ?? -1), factor)) {
+    return { error: `Runtime capacity exceeded: ${runtime.id}`, status: 409 };
+  }
+
+  const id = generateId("sess");
+  const transcriptDir = join(ctx.hubDir, "transcripts");
+  mkdirSync(transcriptDir, { recursive: true });
+  const transcriptPath = join(transcriptDir, `${id}.log`);
+
+  const hasExplicitCommand = Boolean(cmd);
+  const command = cmd || runtime.cmd || "echo";
+  const commandPlan = args
+    ? { args, closeStdin: false }
+    : (hasExplicitCommand ? { args: [], closeStdin: false } : getDefaultCommandPlan(runtime.type, input.task_id ? assemblePrompt(ctx, { agentId: agent_id, taskId: input.task_id }) : undefined));
+  const cwd = resolveWorkdir(ctx, agent, task_id || null);
+
+  return spawnSessionProcess(ctx, {
+    id,
+    agent_id,
+    task_id: task_id || null,
+    runtime,
+    command,
+    cmdArgs: commandPlan.args,
+    closeStdin: commandPlan.closeStdin,
+    cwd,
+    transcriptPath,
+  });
+}
+
+// 默认启动参数：无权限限制模式
+function getDefaultCommandPlan(runtimeType: string, prompt?: string): RuntimeCommandPlan {
+  switch (runtimeType) {
+    case "claude":
+      return { args: ["--print", "--dangerously-skip-permissions", ...(prompt ? [prompt] : [])], closeStdin: true };
+    case "codex":
+      return { args: ["exec", "--dangerously-bypass-approvals-and-sandbox", ...(prompt ? [prompt] : [])], closeStdin: true };
+    case "opencode":
+      return { args: ["run", "--dangerously-skip-permissions", ...(prompt ? [prompt] : [])], closeStdin: true };
+    case "blade":
+      return { args: ["--print", "--permission-mode=yolo", ...(prompt ? [prompt] : [])], closeStdin: true };
+    default:
+      return { args: prompt ? [prompt] : [], closeStdin: true };
+  }
+}
+
+function resolveWorkdir(ctx: HubContext, agent: any, taskId?: string | null): string {
+  const projectWorkdir = taskId ? resolveProjectWorkdir(ctx, taskId) : null;
+  const defaultWorkdir = join(ctx.hubDir, "workspaces", agent.id);
+  const dir = projectWorkdir || agent.workdir || defaultWorkdir;
+  mkdirSync(dir, { recursive: true });
+  if (!agent.workdir && !projectWorkdir) {
+    ctx.db.run("UPDATE agent SET workdir = ? WHERE id = ?", [defaultWorkdir, agent.id]);
+  }
+  return dir;
+}
+
+function resolveProjectWorkdir(ctx: HubContext, taskId: string): string | null {
+  const row = ctx.db.query(`
+    SELECT project.workdir
+    FROM task
+    JOIN project ON project.id = task.project_id
+    WHERE task.id = ?
+      AND project.workdir IS NOT NULL
+      AND project.workdir != ''
+    LIMIT 1
+  `).get(taskId) as any | null;
+  return row?.workdir || null;
+}
+
+function ensureMaestroBin(ctx: HubContext): string {
+  const binDir = join(ctx.hubDir, "bin");
+  mkdirSync(binDir, { recursive: true });
+  const binPath = join(binDir, "maestro");
+  const cliPath = join(ctx.workspaceRoot || process.cwd(), "bin", "maestro.ts");
+  writeFileSync(binPath, `#!/usr/bin/env sh\nexec bun run "${cliPath}" "$@" </dev/null\n`, "utf-8");
+  chmodSync(binPath, 0o755);
+  return binDir;
+}
+
+function streamProcessOutput(
+  ctx: HubContext,
+  sessionId: string,
+  stream: ReadableStream<Uint8Array>,
+  transcriptPath: string,
+  type: "stdout" | "stderr",
+  parser?: RealtimeParser,
+) {
+  (async () => {
+    const reader = stream.getReader();
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      const text = new TextDecoder().decode(value);
+      try {
+        appendFileSync(transcriptPath, text);
+      } catch (err) {
+        if (!isExpectedShutdownError(err)) console.warn("[session] transcript write skipped:", err);
+        break;
+      }
+      broadcast(ctx, sessionId, { type, data: text });
+      if (parser) parser.feed(text);
+    }
+  })();
+}
+
+async function spawnSessionProcess(
+  ctx: HubContext,
+  input: {
+    id: string;
+    agent_id: string;
+    task_id: string | null;
+    runtime: any;
+    command: string;
+    cmdArgs: string[];
+    closeStdin: boolean;
+    cwd: string;
+    transcriptPath: string;
+  },
+): Promise<{ session: any } | { error: string; status: number }> {
+  const ts = now();
+  // Assemble four-layer prompt and write to file
+  const promptDir = join(ctx.hubDir, "prompts");
+  mkdirSync(promptDir, { recursive: true });
+  const promptPath = join(promptDir, `${input.id}.md`);
+  const promptContent = assemblePrompt(ctx, { agentId: input.agent_id, taskId: input.task_id });
+  writeFileSync(promptPath, promptContent, "utf-8");
+
+  const hubEnv = {
+    MAESTRO_HUB_URL: `http://localhost:${ctx.port}`,
+    MAESTRO_AGENT_ID: input.agent_id,
+    MAESTRO_SESSION_ID: input.id,
+    MAESTRO_TASK_ID: input.task_id || "",
+    MAESTRO_HUB_DIR: ctx.hubDir,
+    MAESTRO_WORKDIR: input.cwd,
+    MAESTRO_PROMPT_FILE: promptPath,
+  };
+  let proc: TransportProcess;
+  try {
+    proc = await createTransportProcess(ctx, input.runtime, input.command, input.cmdArgs, { cwd: input.cwd, env: hubEnv });
+  } catch (err: any) {
+    return { error: err.message, status: 502 };
+  }
+  if (input.closeStdin) {
+    (proc.stdin as any)?.end?.();
+    (proc.stdin as any)?.close?.();
+  }
+
+  ctx.db.run(
+    "INSERT INTO session (id, agent_id, task_id, pty_pid, transcript_path, status, started_at) VALUES (?, ?, ?, ?, ?, 'running', ?)",
+    [input.id, input.agent_id, input.task_id, proc.pid, input.transcriptPath, ts]
+  );
+  ctx.db.run("UPDATE agent SET status = 'working', last_active_at = ? WHERE id = ?", [ts, input.agent_id]);
+  startTrackedProcess(ctx, input, proc);
+
+  return {
+    session: { id: input.id, agent_id: input.agent_id, task_id: input.task_id, pid: proc.pid, status: "running", started_at: ts },
+  };
+}
+
+function createTransportProcess(
+  ctx: HubContext,
+  runtime: any,
+  command: string,
+  args: string[],
+  opts: { cwd: string; env: Record<string, string> },
+): TransportProcess | Promise<TransportProcess> {
+  if (runtime.transport === "http-api") {
+    if (!runtime.target) throw new Error("HTTP API runtime requires target");
+    return new HttpApiTransport({ target: runtime.target }).spawn(command, args, opts);
+  }
+  if (runtime.transport === "ssh") {
+    if (!runtime.target) throw new Error("SSH runtime requires target");
+    return new SshTransport({ target: runtime.target }).spawn(command, args, opts);
+  }
+
+  const maestroBinDir = ensureMaestroBin(ctx);
+  const path = process.env.PATH ? `${maestroBinDir}:${process.env.PATH}` : maestroBinDir;
+  const proc = Bun.spawn([command, ...args], {
+    cwd: opts.cwd,
+    env: { ...process.env, PATH: path, ...opts.env },
+    stdin: "pipe",
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  return {
+    pid: proc.pid,
+    stdin: proc.stdin,
+    stdout: proc.stdout,
+    stderr: proc.stderr,
+    exited: proc.exited,
+    kill: () => proc.kill(),
+  };
+}
+
+function handleSessionEvent(
+  ctx: HubContext,
+  input: { id: string; agent_id: string; task_id: string | null },
+  evt: SessionEvent,
+) {
+  if (!input.task_id) return;
+  const ts = now();
+
+  switch (evt.type) {
+    case "progress":
+      ctx.bus.publish("task.progress", { task_id: input.task_id, session_id: input.id, ...evt });
+      break;
+
+    case "artifact": {
+      const content = `Artifact: ${evt.kind} ${evt.path || ""}`.trim();
+      ctx.db.run(
+        "INSERT INTO task_thread_item (id, task_id, kind, author, content, ref_id, created_at) VALUES (?, ?, 'artifact', ?, ?, ?, ?)",
+        [generateId("ti"), input.task_id, input.agent_id, content, input.id, ts]
+      );
+      ctx.bus.publish("task.artifact", { task_id: input.task_id, session_id: input.id, ...evt });
+      break;
+    }
+
+    case "request_transition":
+      ctx.bus.publish("task.request_transition", {
+        task_id: input.task_id,
+        session_id: input.id,
+        to_status: evt.to_status,
+      });
+      break;
+
+    case "summary":
+      ctx.db.run(
+        "INSERT INTO task_thread_item (id, task_id, kind, author, content, ref_id, created_at) VALUES (?, ?, 'agent_output', ?, ?, ?, ?)",
+        [generateId("ti"), input.task_id, input.agent_id, String(evt.content || "").slice(0, 2000), input.id, ts]
+      );
+      break;
+  }
+}
+
+function startTrackedProcess(
+  ctx: HubContext,
+  input: {
+    id: string;
+    agent_id: string;
+    task_id: string | null;
+    transcriptPath: string;
+  },
+  proc: TransportProcess,
+) {
+  ctx.sessions.set(input.id, proc);
+
+  // Create realtime parser to capture structured JSON-line events from stdout
+  const parser = new RealtimeParser();
+  if (input.task_id) {
+    parser.on("event", (evt: SessionEvent) => {
+      handleSessionEvent(ctx, input, evt);
+    });
+  }
+
+  streamProcessOutput(ctx, input.id, proc.stdout, input.transcriptPath, "stdout", parser);
+  streamProcessOutput(ctx, input.id, proc.stderr, input.transcriptPath, "stderr");
+
+  proc.exited.then((code) => {
+    parser.flush();
+    const endTs = now();
+    ctx.sessions.delete(input.id);
+
+    try {
+      ctx.db.run("UPDATE session SET status = 'ended', ended_at = ? WHERE id = ?", [endTs, input.id]);
+      ctx.db.run("UPDATE agent SET status = 'idle', last_active_at = ? WHERE id = ?", [endTs, input.agent_id]);
+
+      // Post-session transcript parse: extract summary and write to task thread
+      if (input.task_id) {
+        try {
+          const transcript = readFileSync(input.transcriptPath, "utf-8");
+          const parsed = parseTranscript(transcript);
+          if (parsed.summary) {
+            ctx.db.run(
+              "INSERT INTO task_thread_item (id, task_id, kind, author, content, ref_id, created_at) VALUES (?, ?, 'agent_output', ?, ?, ?, ?)",
+              [generateId("ti"), input.task_id, input.agent_id, parsed.summary, input.id, endTs]
+            );
+            ctx.bus.publish("task.agent_output", { task_id: input.task_id, session_id: input.id, summary: parsed.summary });
+          }
+        } catch { /* transcript read failure is non-fatal */ }
+      }
+
+      const exit = recordAgentExit(ctx.db, { agentId: input.agent_id, sessionId: input.id, code });
+      if (exit.restart) {
+        for (let i = exit.attempts; i < 3; i++) {
+          recordAgentExit(ctx.db, { agentId: input.agent_id, sessionId: input.id, code });
+        }
+      }
+      recordMissingTaskTransition(ctx, input, code, endTs);
+      ctx.bus.publish("session.ended", { id: input.id, agent_id: input.agent_id, code });
+
+      // Release next queued session waiting for this runtime
+      const agentRow = ctx.db.query("SELECT runtime_id FROM agent WHERE id = ?").get(input.agent_id) as any;
+      if (agentRow?.runtime_id) {
+        notifyNextInQueue(ctx.sessionQueue, agentRow.runtime_id);
+      }
+    } catch (err) {
+      if (!isExpectedShutdownError(err)) console.warn("[session] exit handling skipped:", err);
+    }
+    broadcast(ctx, input.id, { type: "exit", code });
+  });
+}
+
+function isExpectedShutdownError(err: unknown) {
+  const code = (err as any)?.code;
+  return code === "ENOENT" || code === "SQLITE_IOERR_VNODE" || code === "SQLITE_IOERR";
+}
+
+function recordMissingTaskTransition(
+  ctx: HubContext,
+  input: {
+    id: string;
+    agent_id: string;
+    task_id: string | null;
+  },
+  code: number | null,
+  ts: number,
+) {
+  if (!input.task_id) return;
+  const task = ctx.db.query("SELECT * FROM task WHERE id = ?").get(input.task_id) as any | null;
+  if (!task) return;
+  if (task.assignee_agent_id !== input.agent_id) return;
+  if (!isActiveTaskStatus(ctx.db, task)) return;
+  const transitioned = ctx.db.query(
+    "SELECT id FROM task_thread_item WHERE task_id = ? AND kind = 'workflow_transition' AND created_at >= (SELECT started_at FROM session WHERE id = ?) LIMIT 1",
+  ).get(input.task_id, input.id);
+  if (transitioned) return;
+
+  // If agent exited successfully (code 0), auto-complete the task
+  // Only auto-complete if the session ran for a meaningful duration (>5s)
+  // to avoid treating instant exits (startup failures) as "work completed"
+  if (code === 0) {
+    const session = ctx.db.query("SELECT started_at FROM session WHERE id = ?").get(input.id) as any;
+    const sessionDuration = session ? ts - session.started_at : 0;
+    if (sessionDuration > 5000) {
+      const workflow = getWorkflowForTask(ctx.db, input.task_id);
+      // Find an action that leads to the "done" status from current status
+      const completeAction = workflow.actions.find(
+        (a) => a.from.includes(task.status) && a.to === workflow.done_status
+      );
+      if (completeAction) {
+        // Provide default values for required fields so auto-complete doesn't fail validation
+        const defaults: Record<string, string> = {};
+        for (const field of completeAction.requires || []) {
+          defaults[field] = "Auto-completed: agent session exited successfully";
+        }
+        const result = transitionTask(ctx, input.task_id, completeAction.id, defaults, { actorId: input.agent_id });
+        if (result.ok) return; // Successfully auto-completed
+      }
+    }
+  }
+
+  // Fallback: record diagnostic (non-zero exit or no valid transition found)
+  const content = code === 0
+    ? `Session ${input.id} ended without a workflow transition. The agent likely finished or stopped before running maestro inbox task transition.`
+    : `Session ${input.id} exited with code ${code ?? "unknown"} before a workflow transition.`;
+  ctx.db.run(
+    "INSERT INTO task_thread_item (id, task_id, kind, author, content, ref_id, created_at) VALUES (?, ?, 'session_diagnostic', 'system', ?, ?, ?)",
+    [generateId("ti"), input.task_id, content, input.id, ts],
+  );
+  ctx.bus.publish("task.session_diagnostic", { task_id: input.task_id, session_id: input.id, agent_id: input.agent_id, code });
+}
+
+function broadcast(ctx: HubContext, sessionId: string, payload: unknown) {
+  const clients = ctx.wsClients.get(sessionId);
+  if (!clients) return;
+  const msg = JSON.stringify(payload);
+  for (const ws of clients) {
+    ws.send(msg);
+  }
+}