@flyingrobots/graft 0.7.0 → 0.7.1

package/src/mcp/control-plane/session-registry.ts

@@ -1,115 +0,0 @@
-import type { RuntimeCausalContext } from "../runtime-causal-context.js";
-import type { WorkspaceStatus } from "../workspace-router.js";
-import { cloneCapabilityProfile } from "./authz-storage.js";
-import type {
-  DaemonSessionView,
-  RegisteredTransport,
-  SharedAttachSource,
-} from "./types.js";
-
-// ---------------------------------------------------------------------------
-// Session view projection
-// ---------------------------------------------------------------------------
-
-export function toDaemonSessionView(
-  session: RegisteredTransport,
-  readWorkspaceStatus: (s: RegisteredTransport) => WorkspaceStatus,
-  readRuntimeCausalContext: (s: RegisteredTransport) => RuntimeCausalContext | null,
-): DaemonSessionView {
-  const status = readWorkspaceStatus(session);
-  const causalContext = readRuntimeCausalContext(session);
-  return {
-    sessionId: session.sessionId,
-    sessionMode: "daemon",
-    bindState: status.bindState,
-    repoId: status.repoId,
-    worktreeId: status.worktreeId,
-    worktreeRoot: status.worktreeRoot,
-    causalSessionId: causalContext?.causalSessionId ?? null,
-    checkoutEpochId: causalContext?.checkoutEpochId ?? null,
-    capabilityProfile: status.capabilityProfile === null ? null : cloneCapabilityProfile(status.capabilityProfile),
-    startedAt: session.startedAt,
-    lastActivityAt: session.lastActivityAt,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Workspace status & causal context safe readers
-// ---------------------------------------------------------------------------
-
-export function readWorkspaceStatus(session: RegisteredTransport): WorkspaceStatus {
-  try {
-    return session.getWorkspaceStatus();
-  } catch {
-    return {
-      sessionMode: "daemon",
-      bindState: "unbound",
-      repoId: null,
-      worktreeId: null,
-      worktreeRoot: null,
-      gitCommonDir: null,
-      graftDir: null,
-      capabilityProfile: null,
-    };
-  }
-}
-
-export function readRuntimeCausalContext(session: RegisteredTransport): RuntimeCausalContext | null {
-  try {
-    return session.getRuntimeCausalContext();
-  } catch {
-    return null;
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Shared attach resolution
-// ---------------------------------------------------------------------------
-
-export function resolveSharedAttachSource(
-  sessions: ReadonlyMap<string, RegisteredTransport>,
-  input: {
-    readonly sessionId: string;
-    readonly repoId: string;
-    readonly worktreeId: string;
-  },
-): SharedAttachSource | null {
-  const candidates = [...sessions.values()]
-    .filter((session) => session.sessionId !== input.sessionId)
-    .flatMap((session) => {
-      const status = readWorkspaceStatus(session);
-      if (
-        status.bindState !== "bound" ||
-        status.repoId !== input.repoId ||
-        status.worktreeId !== input.worktreeId
-      ) {
-        return [];
-      }
-      const causalContext = readRuntimeCausalContext(session);
-      if (causalContext === null) {
-        return [];
-      }
-      return [{
-        sourceSessionId: session.sessionId,
-        causalSessionId: causalContext.causalSessionId,
-        strandId: causalContext.strandId,
-        lastActivityAt: session.lastActivityAt,
-      }];
-    })
-    .sort((left, right) => right.lastActivityAt.localeCompare(left.lastActivityAt));
-
-  if (candidates.length !== 1) {
-    return null;
-  }
-
-  const [source] = candidates;
-  if (source === undefined) {
-    return null;
-  }
-
-  return {
-    sourceSessionId: source.sourceSessionId,
-    causalSessionId: source.causalSessionId,
-    strandId: source.strandId,
-  };
-}

package/src/mcp/control-plane/status-projection.ts

@@ -1,76 +0,0 @@
-import type { DaemonSchedulerCounts } from "../daemon-job-scheduler.js";
-import type { DaemonWorkerCounts } from "../daemon-worker-pool.js";
-import type { WorkspaceCapabilityProfile } from "../workspace-router.js";
-import { cloneCapabilityProfile } from "./authz-storage.js";
-import type {
-  AuthorizedWorkspaceRecord,
-  AuthorizedWorkspaceView,
-  DaemonMonitorCounts,
-  DaemonRuntimeDescriptor,
-  DaemonSessionView,
-  DaemonStatusView,
-} from "./types.js";
-
-// ---------------------------------------------------------------------------
-// Zero-value defaults
-// ---------------------------------------------------------------------------
-
-export const ZERO_MONITOR_COUNTS: DaemonMonitorCounts = Object.freeze({
-  totalMonitors: 0,
-  runningMonitors: 0,
-  pausedMonitors: 0,
-  stoppedMonitors: 0,
-  failingMonitors: 0,
-  backlogMonitors: 0,
-});
-
-// ---------------------------------------------------------------------------
-// Status view assembly
-// ---------------------------------------------------------------------------
-
-export function buildStatusView(
-  runtime: DaemonRuntimeDescriptor,
-  sessions: readonly DaemonSessionView[],
-  authorizedWorkspaces: ReadonlyMap<string, AuthorizedWorkspaceRecord>,
-  defaultCapabilityProfile: WorkspaceCapabilityProfile,
-  monitorCounts: DaemonMonitorCounts,
-  schedulerCounts: DaemonSchedulerCounts,
-  workerCounts: DaemonWorkerCounts,
-): DaemonStatusView {
-  const boundSessions = sessions.filter((session) => session.bindState === "bound").length;
-  return {
-    ok: true,
-    sessionMode: "daemon",
-    activeSessions: sessions.length,
-    boundSessions,
-    unboundSessions: sessions.length - boundSessions,
-    authorizedWorkspaces: authorizedWorkspaces.size,
-    authorizedRepos: new Set([...authorizedWorkspaces.values()].map((record) => record.repoId)).size,
-    workspaceBindRequiresAuthorization: true,
-    defaultCapabilityProfile: cloneCapabilityProfile(defaultCapabilityProfile),
-    totalMonitors: monitorCounts.totalMonitors,
-    runningMonitors: monitorCounts.runningMonitors,
-    pausedMonitors: monitorCounts.pausedMonitors,
-    stoppedMonitors: monitorCounts.stoppedMonitors,
-    failingMonitors: monitorCounts.failingMonitors,
-    backlogMonitors: monitorCounts.backlogMonitors,
-    scheduler: schedulerCounts,
-    workers: workerCounts,
-    ...runtime,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Authorized workspace view projection
-// ---------------------------------------------------------------------------
-
-export function toAuthorizedWorkspaceView(
-  record: AuthorizedWorkspaceRecord,
-  activeSessionCount: number,
-): AuthorizedWorkspaceView {
-  return {
-    ...record,
-    capabilityProfile: cloneCapabilityProfile(record.capabilityProfile),
-    activeSessions: activeSessionCount,
-  };
-}

package/src/mcp/control-plane/types.ts

@@ -1,144 +0,0 @@
-import type { DaemonSchedulerCounts } from "../daemon-job-scheduler.js";
-import type { DaemonWorkerCounts } from "../daemon-worker-pool.js";
-import type { RuntimeCausalContext } from "../runtime-causal-context.js";
-import type {
-  WorkspaceBindRequest,
-  WorkspaceCapabilityProfile,
-  WorkspaceStatus,
-} from "../workspace-router.js";
-
-// ---------------------------------------------------------------------------
-// Internal: session tracking
-// ---------------------------------------------------------------------------
-
-export interface RegisteredTransport {
-  readonly sessionId: string;
-  readonly startedAt: string;
-  readonly getWorkspaceStatus: () => WorkspaceStatus;
-  readonly getRuntimeCausalContext: () => RuntimeCausalContext | null;
-  lastActivityAt: string;
-}
-
-// ---------------------------------------------------------------------------
-// Authorization types
-// ---------------------------------------------------------------------------
-
-export interface AuthorizedWorkspaceRecord {
-  readonly repoId: string;
-  readonly worktreeId: string;
-  readonly worktreeRoot: string;
-  readonly gitCommonDir: string;
-  readonly capabilityProfile: WorkspaceCapabilityProfile;
-  readonly authorizedAt: string;
-  readonly lastBoundAt: string | null;
-}
-
-export interface AuthorizedWorkspaceView extends AuthorizedWorkspaceRecord {
-  readonly activeSessions: number;
-}
-
-export interface WorkspaceAuthorizeRequest extends WorkspaceBindRequest {
-  readonly runCapture?: boolean | undefined;
-}
-
-export interface WorkspaceAuthorizeResult {
-  readonly ok: boolean;
-  readonly changed: boolean;
-  readonly authorization?: AuthorizedWorkspaceView;
-  readonly errorCode?: string;
-  readonly error?: string;
-}
-
-export interface WorkspaceRevokeResult {
-  readonly ok: boolean;
-  readonly revoked: boolean;
-  readonly repoId?: string | null;
-  readonly worktreeId?: string | null;
-  readonly worktreeRoot?: string | null;
-  readonly activeSessions?: number;
-  readonly errorCode?: string;
-  readonly error?: string;
-}
-
-// ---------------------------------------------------------------------------
-// Session view
-// ---------------------------------------------------------------------------
-
-export interface DaemonSessionView {
-  readonly sessionId: string;
-  readonly sessionMode: "daemon";
-  readonly bindState: WorkspaceStatus["bindState"];
-  readonly repoId: string | null;
-  readonly worktreeId: string | null;
-  readonly worktreeRoot: string | null;
-  readonly causalSessionId: string | null;
-  readonly checkoutEpochId: string | null;
-  readonly capabilityProfile: WorkspaceCapabilityProfile | null;
-  readonly startedAt: string;
-  readonly lastActivityAt: string;
-}
-
-// ---------------------------------------------------------------------------
-// Daemon runtime & status projection
-// ---------------------------------------------------------------------------
-
-export interface DaemonRuntimeDescriptor {
-  readonly transport: "unix_socket" | "named_pipe";
-  readonly sameUserOnly: true;
-  readonly socketPath: string;
-  readonly mcpPath: string;
-  readonly healthPath: string;
-  readonly activeWarpRepos: number;
-  readonly startedAt: string;
-}
-
-export interface SharedAttachSource {
-  readonly sourceSessionId: string;
-  readonly causalSessionId: string;
-  readonly strandId: string;
-}
-
-export interface DaemonMonitorCounts {
-  readonly totalMonitors: number;
-  readonly runningMonitors: number;
-  readonly pausedMonitors: number;
-  readonly stoppedMonitors: number;
-  readonly failingMonitors: number;
-  readonly backlogMonitors: number;
-}
-
-export interface DaemonStatusView extends DaemonRuntimeDescriptor {
-  readonly ok: true;
-  readonly sessionMode: "daemon";
-  readonly activeSessions: number;
-  readonly boundSessions: number;
-  readonly unboundSessions: number;
-  readonly authorizedWorkspaces: number;
-  readonly authorizedRepos: number;
-  readonly workspaceBindRequiresAuthorization: true;
-  readonly defaultCapabilityProfile: WorkspaceCapabilityProfile;
-  readonly totalMonitors: number;
-  readonly runningMonitors: number;
-  readonly pausedMonitors: number;
-  readonly stoppedMonitors: number;
-  readonly failingMonitors: number;
-  readonly backlogMonitors: number;
-  readonly scheduler: DaemonSchedulerCounts;
-  readonly workers: DaemonWorkerCounts;
-}
-
-// ---------------------------------------------------------------------------
-// Control plane constructor options
-// ---------------------------------------------------------------------------
-
-export interface DaemonControlPlaneOptions {
-  readonly fs: FileSystem;
-  readonly codec: JsonCodec;
-  readonly git: GitClient;
-  readonly graftDir: string;
-}
-
-// Re-import port types so consumers don't need to reach into ports/
-import type { FileSystem } from "../../ports/filesystem.js";
-import type { JsonCodec } from "../../ports/codec.js";
-import type { GitClient } from "../../ports/git.js";

package/src/mcp/daemon-bootstrap.ts

@@ -1,100 +0,0 @@
-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";
-
-const DIRECTORY_MODE = 0o700;
-const SOCKET_MODE = 0o600;
-
-export function isNamedPipePath(socketPath: string): boolean {
-  return process.platform === "win32" && socketPath.startsWith("\\\\.\\pipe\\");
-}
-
-export 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");
-}
-
-export function resolveSocketPath(socketPath: string | undefined, graftDir: string): string {
-  if (socketPath === undefined) return defaultSocketPath(graftDir);
-  if (isNamedPipePath(socketPath)) return socketPath;
-  return path.resolve(socketPath);
-}
-
-export 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);
-    });
-  });
-}
-
-export 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);
-}
-
-export async function tightenSocketPermissions(socketPath: string): Promise<void> {
-  if (process.platform === "win32" || isNamedPipePath(socketPath)) return;
-  await fs.chmod(socketPath, SOCKET_MODE).catch(() => {
-    return undefined;
-  });
-}
-
-export async function closeHttpServer(server: http.Server): Promise<void> {
-  await new Promise<void>((resolve, reject) => {
-    server.close((error) => {
-      if (error) {
-        reject(error);
-        return;
-      }
-      resolve();
-    });
-  });
-}