@flyingrobots/graft 0.5.0 → 0.6.1

package/src/mcp/daemon-repos.ts

@@ -1,87 +1,34 @@
 import type {
   AuthorizedWorkspaceRecord,
-  DaemonControlPlane,
   DaemonSessionView,
 } from "./daemon-control-plane.js";
-import type {
-  MonitorHealth,
-  MonitorLifecycleState,
-  MonitorStatusView,
-  MonitorWorkerKind,
-  PersistentMonitorRuntime,
-} from "./persistent-monitor-runtime.js";
-
-export interface DaemonRepoFilter {
-  readonly repoId?: string | undefined;
-  readonly cwd?: string | undefined;
-}
-
-export interface DaemonRepoWorktreeView {
-  readonly worktreeId: string;
-  readonly worktreeRoot: string;
-  readonly activeSessions: number;
-  readonly lastBoundAt: string | null;
-}
-
-export interface DaemonRepoMonitorView {
-  readonly workerKind: MonitorWorkerKind;
-  readonly lifecycleState: MonitorLifecycleState;
-  readonly health: MonitorHealth;
-  readonly lastTickAt: string | null;
-  readonly lastSuccessAt: string | null;
-  readonly lastError: string | null;
-}
-
-export interface DaemonRepoView {
-  readonly repoId: string;
-  readonly gitCommonDir: string;
-  readonly authorizedWorkspaces: number;
-  readonly boundSessions: number;
-  readonly activeWorktrees: number;
-  readonly backlogCommits: number;
-  readonly lastBoundAt: string | null;
-  readonly lastActivityAt: string | null;
-  readonly monitor: DaemonRepoMonitorView | null;
-  readonly worktrees: readonly DaemonRepoWorktreeView[];
-}
+import type { MonitorStatusView } from "./persistent-monitor-runtime.js";
 
-export interface DaemonRepoListView {
-  readonly repos: readonly DaemonRepoView[];
-  readonly filter?: DaemonRepoFilter | undefined;
-}
+import { buildResult, normalizeFilter, sortAuthorizedWorkspaces } from "./repo-overview/filter.js";
+import { toRepoView } from "./repo-overview/view-projection.js";
 
-export interface DaemonRepoOverviewOptions {
-  readonly controlPlane: DaemonControlPlane;
-  readonly monitorRuntime: PersistentMonitorRuntime;
-}
+// ---------------------------------------------------------------------------
+// Barrel re-exports — keep every public type available from this path
+// ---------------------------------------------------------------------------
 
-function normalizeFilter(filter: DaemonRepoFilter): DaemonRepoFilter {
-  const next: { repoId?: string; cwd?: string } = {};
-  if (typeof filter.repoId === "string" && filter.repoId.trim().length > 0) {
-    next.repoId = filter.repoId.trim();
-  }
-  if (typeof filter.cwd === "string" && filter.cwd.trim().length > 0) {
-    next.cwd = filter.cwd.trim();
-  }
-  return next;
-}
+export type {
+  DaemonRepoFilter,
+  DaemonRepoListView,
+  DaemonRepoMonitorView,
+  DaemonRepoOverviewOptions,
+  DaemonRepoView,
+  DaemonRepoWorktreeView,
+} from "./repo-overview/types.js";
 
-function maxIsoTimestamp(values: readonly (string | null | undefined)[]): string | null {
-  let latest: string | null = null;
-  for (const value of values) {
-    if (value === undefined || value === null || value.length === 0) continue;
-    if (latest === null || value.localeCompare(latest) > 0) {
-      latest = value;
-    }
-  }
-  return latest;
-}
+import type {
+  DaemonRepoFilter,
+  DaemonRepoListView,
+  DaemonRepoOverviewOptions,
+} from "./repo-overview/types.js";
 
-function sortAuthorizedWorkspaces(
-  records: readonly AuthorizedWorkspaceRecord[],
-): readonly AuthorizedWorkspaceRecord[] {
-  return [...records].sort((left, right) => left.worktreeRoot.localeCompare(right.worktreeRoot));
-}
+// ---------------------------------------------------------------------------
+// DaemonRepoOverview
+// ---------------------------------------------------------------------------
 
 export class DaemonRepoOverview {
   constructor(private readonly options: DaemonRepoOverviewOptions) {}
@@ -90,7 +37,7 @@ export class DaemonRepoOverview {
     const normalizedFilter = normalizeFilter(filter);
     const resolvedRepoId = await this.resolveRepoIdFilter(normalizedFilter);
     if (normalizedFilter.cwd !== undefined && resolvedRepoId === null) {
-      return this.buildResult(normalizedFilter, []);
+      return buildResult(normalizedFilter, []);
     }
 
     const repoIdFilter = resolvedRepoId ?? normalizedFilter.repoId;
@@ -98,12 +45,12 @@ export class DaemonRepoOverview {
       this.options.controlPlane.listAuthorizedWorkspaceRecords(),
       this.options.monitorRuntime.listStatuses(),
     ]);
-    const sessions = this.options.controlPlane.listSessions();
+    const sessions = this.options.controlPlane.listTransports();
     const visibleWorkspaces = authorizedWorkspaces.filter((workspace) => {
       return repoIdFilter === undefined || workspace.repoId === repoIdFilter;
     });
     if (visibleWorkspaces.length === 0) {
-      return this.buildResult(normalizedFilter, []);
+      return buildResult(normalizedFilter, []);
     }
 
     const workspacesByRepo = new Map<string, AuthorizedWorkspaceRecord[]>();
@@ -131,50 +78,13 @@ export class DaemonRepoOverview {
     const repos = [...workspacesByRepo.entries()]
       .map(([repoId, repoWorkspaces]) => {
         const sortedWorkspaces = sortAuthorizedWorkspaces(repoWorkspaces);
-        const firstWorkspace = sortedWorkspaces[0];
-        if (firstWorkspace === undefined) {
-          throw new Error(`DaemonRepoOverview: missing workspace for repo ${repoId}`);
-        }
         const repoSessions = sessionsByRepo.get(repoId) ?? [];
         const monitor = monitorsByRepo.get(repoId) ?? null;
-        const worktrees = sortedWorkspaces.map((workspace) => {
-          return this.toWorktreeView(workspace, repoSessions);
-        });
-        const boundSessions = repoSessions.filter((session) => session.bindState === "bound").length;
-        const lastBoundAt = maxIsoTimestamp(sortedWorkspaces.map((workspace) => workspace.lastBoundAt));
-        const lastActivityAt = maxIsoTimestamp([
-          ...sortedWorkspaces.map((workspace) => workspace.authorizedAt),
-          ...sortedWorkspaces.map((workspace) => workspace.lastBoundAt),
-          ...repoSessions.map((session) => session.lastActivityAt),
-          ...(monitor === null
-            ? []
-            : [monitor.lastStartedAt, monitor.lastTickAt, monitor.lastSuccessAt]),
-        ]);
-        return {
-          repoId,
-          gitCommonDir: firstWorkspace.gitCommonDir,
-          authorizedWorkspaces: sortedWorkspaces.length,
-          boundSessions,
-          activeWorktrees: worktrees.filter((worktree) => worktree.activeSessions > 0).length,
-          backlogCommits: monitor?.backlogCommits ?? 0,
-          lastBoundAt,
-          lastActivityAt,
-          monitor: monitor === null
-            ? null
-            : {
-              workerKind: monitor.workerKind,
-              lifecycleState: monitor.lifecycleState,
-              health: monitor.health,
-              lastTickAt: monitor.lastTickAt,
-              lastSuccessAt: monitor.lastSuccessAt,
-              lastError: monitor.lastError,
-            },
-          worktrees,
-        } satisfies DaemonRepoView;
+        return toRepoView(repoId, sortedWorkspaces, repoSessions, monitor);
       })
       .sort((left, right) => left.gitCommonDir.localeCompare(right.gitCommonDir));
 
-    return this.buildResult(normalizedFilter, repos);
+    return buildResult(normalizedFilter, repos);
   }
 
   private async resolveRepoIdFilter(filter: DaemonRepoFilter): Promise<string | null | undefined> {
@@ -186,31 +96,4 @@ export class DaemonRepoOverview {
     }
     return workspace.repoId;
   }
-
-  private buildResult(
-    filter: DaemonRepoFilter,
-    repos: readonly DaemonRepoView[],
-  ): DaemonRepoListView {
-    if (Object.keys(filter).length === 0) {
-      return { repos };
-    }
-    return {
-      repos,
-      filter,
-    };
-  }
-
-  private toWorktreeView(
-    workspace: AuthorizedWorkspaceRecord,
-    repoSessions: readonly DaemonSessionView[],
-  ): DaemonRepoWorktreeView {
-    return {
-      worktreeId: workspace.worktreeId,
-      worktreeRoot: workspace.worktreeRoot,
-      activeSessions: repoSessions.filter((session) => {
-        return session.bindState === "bound" && session.worktreeId === workspace.worktreeId;
-      }).length,
-      lastBoundAt: workspace.lastBoundAt,
-    };
-  }
 }

package/src/mcp/daemon-server.ts

@@ -1,16 +1,9 @@
-import * as crypto from "node:crypto";
 import * as fs from "node:fs/promises";
 import * as http from "node:http";
-import * as net from "node:net";
-import * as os from "node:os";
 import * as path from "node:path";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
-import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
 import { CanonicalJsonCodec } from "../adapters/canonical-json.js";
 import { nodeFs } from "../adapters/node-fs.js";
 import { nodeGit } from "../adapters/node-git.js";
-import { createGraftServer, type GraftServer } from "./server.js";
 import { DaemonControlPlane, type DaemonStatusView } from "./daemon-control-plane.js";
 import { DaemonJobScheduler } from "./daemon-job-scheduler.js";
 import { ChildProcessDaemonWorkerPool } from "./daemon-worker-pool.js";
@@ -19,19 +12,19 @@ import { InMemoryWarpPool } from "./warp-pool.js";
 import { openWarp } from "../warp/open.js";
 import type { RunCaptureConfig } from "./run-capture-config.js";
 import type { RuntimeObservabilityState } from "./runtime-observability.js";
+import {
+  closeHttpServer,
+  defaultDaemonRoot,
+  ensurePrivateDirectory,
+  isNamedPipePath,
+  prepareSocketPath,
+  resolveSocketPath,
+  tightenSocketPermissions,
+} from "./daemon-bootstrap.js";
+import { createDaemonSessionHost } from "./daemon-session-host.js";
 
 const HEALTH_PATH = "/healthz";
 const MCP_PATH = "/mcp";
-const DIRECTORY_MODE = 0o700;
-const SOCKET_MODE = 0o600;
-const MAX_BODY_BYTES = 1024 * 1024;
-
-interface DaemonSession {
-  readonly id: string;
-  readonly graftDir: string;
-  readonly transport: StreamableHTTPServerTransport;
-  readonly server: GraftServer;
-}
 
 export type DaemonHealthStatus = DaemonStatusView;
 
@@ -51,131 +44,6 @@ export interface GraftDaemonServer {
   getHealthStatus(): DaemonHealthStatus;
 }
 
-function isNamedPipePath(socketPath: string): boolean {
-  return process.platform === "win32" && socketPath.startsWith("\\\\.\\pipe\\");
-}
-
-function defaultDaemonRoot(): string {
-  return path.join(os.homedir(), ".graft", "daemon");
-}
-
-function defaultSocketPath(graftDir: string): string {
-  if (process.platform === "win32") {
-    const digest = crypto.createHash("sha256").update(os.homedir()).digest("hex").slice(0, 12);
-    return `\\\\.\\pipe\\graft-daemon-${digest}`;
-  }
-  return path.join(graftDir, "mcp.sock");
-}
-
-function resolveSocketPath(socketPath: string | undefined, graftDir: string): string {
-  if (socketPath === undefined) return defaultSocketPath(graftDir);
-  if (isNamedPipePath(socketPath)) return socketPath;
-  return path.resolve(socketPath);
-}
-
-async function ensurePrivateDirectory(dirPath: string): Promise<void> {
-  await fs.mkdir(dirPath, { recursive: true, mode: DIRECTORY_MODE });
-  if (process.platform !== "win32") {
-    await fs.chmod(dirPath, DIRECTORY_MODE).catch(() => {
-      return undefined;
-    });
-  }
-}
-
-async function socketHasActiveListener(socketPath: string): Promise<boolean> {
-  return new Promise<boolean>((resolve) => {
-    const socket = net.createConnection({ path: socketPath });
-    let settled = false;
-
-    const finish = (result: boolean): void => {
-      if (settled) return;
-      settled = true;
-      socket.destroy();
-      resolve(result);
-    };
-
-    socket.once("connect", () => {
-      finish(true);
-    });
-    socket.once("error", () => {
-      finish(false);
-    });
-    socket.setTimeout(200, () => {
-      finish(false);
-    });
-  });
-}
-
-async function prepareSocketPath(socketPath: string): Promise<void> {
-  if (isNamedPipePath(socketPath)) return;
-  await ensurePrivateDirectory(path.dirname(socketPath));
-  const existing = await fs.lstat(socketPath).catch((error: unknown) => {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT") return null;
-    throw error;
-  });
-  if (existing === null) return;
-  if (!existing.isSocket()) {
-    throw new Error(`Refusing to overwrite non-socket path: ${socketPath}`);
-  }
-  if (await socketHasActiveListener(socketPath)) {
-    throw new Error(`A graft daemon is already listening on ${socketPath}`);
-  }
-  await fs.unlink(socketPath);
-}
-
-async function tightenSocketPermissions(socketPath: string): Promise<void> {
-  if (process.platform === "win32" || isNamedPipePath(socketPath)) return;
-  await fs.chmod(socketPath, SOCKET_MODE).catch(() => {
-    return undefined;
-  });
-}
-
-function getHeader(req: http.IncomingMessage, name: string): string | undefined {
-  const value = req.headers[name];
-  return Array.isArray(value) ? value[0] : value;
-}
-
-async function readJsonBody(req: http.IncomingMessage): Promise<unknown> {
-  const chunks: Buffer[] = [];
-  let total = 0;
-  for await (const chunk of req as AsyncIterable<Buffer | string>) {
-    const buffer = typeof chunk === "string" ? Buffer.from(chunk, "utf-8") : chunk;
-    total += buffer.length;
-    if (total > MAX_BODY_BYTES) {
-      throw new Error(`Request body exceeds ${String(MAX_BODY_BYTES)} bytes`);
-    }
-    chunks.push(buffer);
-  }
-  if (chunks.length === 0) return undefined;
-  return JSON.parse(Buffer.concat(chunks).toString("utf-8")) as unknown;
-}
-
-function sendJson(res: http.ServerResponse, statusCode: number, body: Record<string, unknown>): void {
-  if (res.headersSent) return;
-  res.writeHead(statusCode, { "content-type": "application/json" });
-  res.end(JSON.stringify(body));
-}
-
-function sendJsonRpcError(res: http.ServerResponse, code: number, message: string): void {
-  sendJson(res, code === -32700 ? 400 : 500, {
-    jsonrpc: "2.0",
-    error: { code, message },
-    id: null,
-  });
-}
-
-async function closeHttpServer(server: http.Server): Promise<void> {
-  await new Promise<void>((resolve, reject) => {
-    server.close((error) => {
-      if (error) {
-        reject(error);
-        return;
-      }
-      resolve();
-    });
-  });
-}
-
 export async function startDaemonServer(options: StartDaemonServerOptions = {}): Promise<GraftDaemonServer> {
   const graftDir = path.resolve(options.graftDir ?? defaultDaemonRoot());
   const socketPath = resolveSocketPath(options.socketPath, graftDir);
@@ -197,7 +65,6 @@ export async function startDaemonServer(options: StartDaemonServerOptions = {}):
     scheduler: daemonScheduler,
     workerPool: daemonWorkerPool,
   });
-  const sessions = new Map<string, DaemonSession>();
   const startedAt = new Date().toISOString();
   const transportKind = isNamedPipePath(socketPath) ? "named_pipe" : "unix_socket";
 
@@ -218,120 +85,28 @@ export async function startDaemonServer(options: StartDaemonServerOptions = {}):
   await controlPlane.initialize();
   await monitorRuntime.initialize();
   await prepareSocketPath(socketPath);
-
-  const handleRequest = async (req: http.IncomingMessage, res: http.ServerResponse): Promise<void> => {
-    try {
-      const url = new URL(req.url ?? "/", "http://localhost");
-      if (req.method === "GET" && url.pathname === HEALTH_PATH) {
-        sendJson(res, 200, { ...getHealthStatus() });
-        return;
-      }
-
-      if (url.pathname !== MCP_PATH) {
-        sendJson(res, 404, { error: "Not found" });
-        return;
-      }
-
-      const sessionId = getHeader(req, "mcp-session-id");
-
-      if (req.method === "POST") {
-        const parsedBody = await readJsonBody(req);
-        let session = sessionId !== undefined ? sessions.get(sessionId) : undefined;
-        if (session === undefined) {
-          if (sessionId !== undefined) {
-            sendJsonRpcError(res, -32000, `Unknown MCP session: ${sessionId}`);
-            return;
-          }
-          if (!isInitializeRequest(parsedBody)) {
-            sendJsonRpcError(res, -32000, "Initialization requests must start a daemon session");
-            return;
-          }
-          const newSessionId = crypto.randomUUID();
-          const sessionGraftDir = path.join(graftDir, "sessions", newSessionId);
-          await ensurePrivateDirectory(sessionGraftDir);
-          const transport = new StreamableHTTPServerTransport({
-            sessionIdGenerator: () => newSessionId,
-          });
-          const server = createGraftServer({
-            mode: "daemon",
-            sessionId: newSessionId,
-            graftDir: sessionGraftDir,
-            warpPool,
-            daemonControlPlane: controlPlane,
-            daemonScheduler,
-            daemonWorkerPool,
-            daemonRuntime: () => ({
-              transport: transportKind,
-              sameUserOnly: true,
-              socketPath,
-              mcpPath: MCP_PATH,
-              healthPath: HEALTH_PATH,
-              activeWarpRepos: warpPool.size(),
-              startedAt,
-            }),
-            monitorRuntime,
-            ...(options.env !== undefined ? { env: options.env } : {}),
-            ...(options.runCapture !== undefined ? { runCapture: options.runCapture } : {}),
-            ...(options.runtimeObservability !== undefined
-              ? { runtimeObservability: options.runtimeObservability }
-              : {}),
-          });
-          const createdSession: DaemonSession = {
-            id: newSessionId,
-            graftDir: sessionGraftDir,
-            transport,
-            server,
-          };
-          session = createdSession;
-          transport.onclose = () => {
-            sessions.delete(newSessionId);
-            controlPlane.unregisterSession(newSessionId);
-          };
-          transport.onerror = () => {
-            sessions.delete(newSessionId);
-            controlPlane.unregisterSession(newSessionId);
-          };
-          sessions.set(newSessionId, createdSession);
-          controlPlane.registerSession(
-            newSessionId,
-            () => server.getWorkspaceStatus(),
-            () => server.getRuntimeCausalContext(),
-          );
-          await server.getMcpServer().connect(transport as Transport);
-        }
-
-        controlPlane.touchSession(session.id);
-        await session.transport.handleRequest(req, res, parsedBody);
-        return;
-      }
-
-      if (req.method === "GET" || req.method === "DELETE") {
-        if (sessionId === undefined) {
-          sendJson(res, 400, { error: "Missing MCP session header" });
-          return;
-        }
-        const session = sessions.get(sessionId);
-        if (session === undefined) {
-          sendJson(res, 404, { error: `Unknown MCP session: ${sessionId}` });
-          return;
-        }
-        controlPlane.touchSession(session.id);
-        await session.transport.handleRequest(req, res);
-        return;
-      }
-
-      sendJson(res, 405, { error: "Method not allowed" });
-    } catch (error) {
-      if (error instanceof SyntaxError) {
-        sendJsonRpcError(res, -32700, "Invalid JSON");
-        return;
-      }
-      sendJsonRpcError(res, -32603, error instanceof Error ? error.message : String(error));
-    }
-  };
+  const sessionHost = createDaemonSessionHost({
+    graftDir,
+    socketPath,
+    transportKind,
+    healthPath: HEALTH_PATH,
+    mcpPath: MCP_PATH,
+    startedAt,
+    warpPool,
+    controlPlane,
+    daemonScheduler,
+    daemonWorkerPool,
+    monitorRuntime,
+    getHealthStatus,
+    ...(options.env !== undefined ? { env: options.env } : {}),
+    ...(options.runCapture !== undefined ? { runCapture: options.runCapture } : {}),
+    ...(options.runtimeObservability !== undefined
+      ? { runtimeObservability: options.runtimeObservability }
+      : {}),
+  });
 
   const httpServer = http.createServer((req, res) => {
-    void handleRequest(req, res);
+    void sessionHost.handleRequest(req, res);
   });
 
   await new Promise<void>((resolve, reject) => {
@@ -372,13 +147,7 @@ export async function startDaemonServer(options: StartDaemonServerOptions = {}):
       closing = (async () => {
         process.off("SIGINT", shutdown);
         process.off("SIGTERM", shutdown);
-        for (const session of sessions.values()) {
-          controlPlane.unregisterSession(session.id);
-          await session.transport.close().catch(() => {
-            return undefined;
-          });
-        }
-        sessions.clear();
+        await sessionHost.close();
         await monitorRuntime.close();
         await daemonWorkerPool.close();
         await closeHttpServer(httpServer);