@flyingrobots/graft 0.7.0 → 0.7.1

package/src/mcp/daemon-server.ts

@@ -1,172 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as http from "node:http";
-import * as path from "node:path";
-import { CanonicalJsonCodec } from "../adapters/canonical-json.js";
-import { nodeFs } from "../adapters/node-fs.js";
-import { nodeGit } from "../adapters/node-git.js";
-import { DaemonControlPlane, type DaemonStatusView } from "./daemon-control-plane.js";
-import { DaemonJobScheduler } from "./daemon-job-scheduler.js";
-import { ChildProcessDaemonWorkerPool } from "./daemon-worker-pool.js";
-import { PersistentMonitorRuntime } from "./persistent-monitor-runtime.js";
-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";
-
-export type DaemonHealthStatus = DaemonStatusView;
-
-export interface StartDaemonServerOptions {
-  readonly socketPath?: string | undefined;
-  readonly graftDir?: string | undefined;
-  readonly env?: Readonly<Record<string, string | undefined>> | undefined;
-  readonly runCapture?: Partial<RunCaptureConfig> | undefined;
-  readonly runtimeObservability?: Partial<RuntimeObservabilityState> | undefined;
-  readonly workerPoolSize?: number | undefined;
-  readonly persistedLocalHistoryGraph?: boolean | undefined;
-}
-
-export interface GraftDaemonServer {
-  readonly socketPath: string;
-  readonly healthPath: typeof HEALTH_PATH;
-  readonly mcpPath: typeof MCP_PATH;
-  close(): Promise<void>;
-  getHealthStatus(): DaemonHealthStatus;
-}
-
-export async function startDaemonServer(options: StartDaemonServerOptions = {}): Promise<GraftDaemonServer> {
-  const graftDir = path.resolve(options.graftDir ?? defaultDaemonRoot());
-  const socketPath = resolveSocketPath(options.socketPath, graftDir);
-  const warpPool = new InMemoryWarpPool((cwd) => openWarp({ cwd }));
-  const controlPlane = new DaemonControlPlane({
-    fs: nodeFs,
-    codec: new CanonicalJsonCodec(),
-    git: nodeGit,
-    graftDir,
-  });
-  const daemonScheduler = new DaemonJobScheduler();
-  const daemonWorkerPool = new ChildProcessDaemonWorkerPool({
-    ...(options.workerPoolSize !== undefined ? { size: options.workerPoolSize } : {}),
-  });
-  const monitorRuntime = new PersistentMonitorRuntime({
-    fs: nodeFs,
-    codec: new CanonicalJsonCodec(),
-    git: nodeGit,
-    graftDir,
-    controlPlane,
-    scheduler: daemonScheduler,
-    workerPool: daemonWorkerPool,
-  });
-  const startedAt = new Date().toISOString();
-  const transportKind = isNamedPipePath(socketPath) ? "named_pipe" : "unix_socket";
-
-  const getHealthStatus = (): DaemonHealthStatus => {
-    return controlPlane.getStatus({
-      transport: transportKind,
-      sameUserOnly: true,
-      socketPath,
-      mcpPath: MCP_PATH,
-      healthPath: HEALTH_PATH,
-      activeWarpRepos: warpPool.size(),
-      startedAt,
-    }, monitorRuntime.getCounts(), daemonScheduler.getCounts(), daemonWorkerPool.getCounts());
-  };
-
-  await ensurePrivateDirectory(graftDir);
-  await ensurePrivateDirectory(path.join(graftDir, "sessions"));
-  await controlPlane.initialize();
-  await monitorRuntime.initialize();
-  await prepareSocketPath(socketPath);
-  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 }
-      : {}),
-    ...(options.persistedLocalHistoryGraph !== undefined
-      ? { persistedLocalHistoryGraph: options.persistedLocalHistoryGraph }
-      : {}),
-  });
-
-  const httpServer = http.createServer((req, res) => {
-    void sessionHost.handleRequest(req, res);
-  });
-
-  await new Promise<void>((resolve, reject) => {
-    const onError = (error: Error): void => {
-      httpServer.off("listening", onListening);
-      reject(error);
-    };
-    const onListening = (): void => {
-      httpServer.off("error", onError);
-      resolve();
-    };
-    httpServer.once("error", onError);
-    httpServer.once("listening", onListening);
-    httpServer.listen(socketPath);
-  });
-  await tightenSocketPermissions(socketPath);
-
-  let closing: Promise<void> | null = null;
-
-  const shutdown = (): void => {
-    void daemon.close().finally(() => {
-      process.exitCode = process.exitCode ?? 0;
-    });
-  };
-
-  process.once("SIGINT", shutdown);
-  process.once("SIGTERM", shutdown);
-
-  const daemon: GraftDaemonServer = {
-    socketPath,
-    healthPath: HEALTH_PATH,
-    mcpPath: MCP_PATH,
-    getHealthStatus(): DaemonHealthStatus {
-      return getHealthStatus();
-    },
-    async close(): Promise<void> {
-      if (closing !== null) return closing;
-      closing = (async () => {
-        process.off("SIGINT", shutdown);
-        process.off("SIGTERM", shutdown);
-        await sessionHost.close();
-        await monitorRuntime.close();
-        await daemonWorkerPool.close();
-        await closeHttpServer(httpServer);
-        if (!isNamedPipePath(socketPath)) {
-          await fs.unlink(socketPath).catch(() => {
-            return undefined;
-          });
-        }
-      })();
-      return closing;
-    },
-  };
-
-  return daemon;
-}

package/src/mcp/daemon-session-host.ts

@@ -1,234 +0,0 @@
-import * as crypto from "node:crypto";
-import * as fs from "node:fs/promises";
-import * as http from "node:http";
-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 { createGraftServer, type GraftServer } from "./server.js";
-import type { DaemonControlPlane, DaemonStatusView } from "./daemon-control-plane.js";
-import type { DaemonJobScheduler } from "./daemon-job-scheduler.js";
-import type { ChildProcessDaemonWorkerPool } from "./daemon-worker-pool.js";
-import type { PersistentMonitorRuntime } from "./persistent-monitor-runtime.js";
-import type { RunCaptureConfig } from "./run-capture-config.js";
-import type { RuntimeObservabilityState } from "./runtime-observability.js";
-import type { WarpPool } from "./warp-pool.js";
-import { ensurePrivateDirectory } from "./daemon-bootstrap.js";
-
-const MAX_BODY_BYTES = 1024 * 1024;
-
-interface DaemonSession {
-  readonly id: string;
-  readonly graftDir: string;
-  readonly transport: StreamableHTTPServerTransport;
-  readonly server: GraftServer;
-}
-
-export interface CreateDaemonSessionHostOptions {
-  readonly graftDir: string;
-  readonly socketPath: string;
-  readonly transportKind: "unix_socket" | "named_pipe";
-  readonly healthPath: string;
-  readonly mcpPath: string;
-  readonly startedAt: string;
-  readonly warpPool: WarpPool;
-  readonly controlPlane: DaemonControlPlane;
-  readonly daemonScheduler: DaemonJobScheduler;
-  readonly daemonWorkerPool: ChildProcessDaemonWorkerPool;
-  readonly monitorRuntime: PersistentMonitorRuntime;
-  readonly getHealthStatus: () => DaemonStatusView;
-  readonly env?: Readonly<Record<string, string | undefined>> | undefined;
-  readonly runCapture?: Partial<RunCaptureConfig> | undefined;
-  readonly runtimeObservability?: Partial<RuntimeObservabilityState> | undefined;
-  readonly persistedLocalHistoryGraph?: boolean | undefined;
-}
-
-export interface DaemonSessionHost {
-  handleRequest(req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;
-  close(): Promise<void>;
-}
-
-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 removeSessionDirectory(sessionGraftDir: string): Promise<void> {
-  try {
-    await fs.rm(sessionGraftDir, { recursive: true, force: true });
-  } catch (error: unknown) {
-    const code = error instanceof Error && "code" in error ? (error as NodeJS.ErrnoException).code : undefined;
-    if (code !== "ENOENT") {
-      console.error(`[graft] failed to remove session directory ${sessionGraftDir}: ${String(error)}`);
-    }
-  }
-}
-
-async function createDaemonSession(
-  newSessionId: string,
-  options: CreateDaemonSessionHostOptions,
-  sessions: Map<string, DaemonSession>,
-): Promise<DaemonSession> {
-  const sessionGraftDir = path.join(options.graftDir, "sessions", newSessionId);
-  await ensurePrivateDirectory(sessionGraftDir);
-  const transport = new StreamableHTTPServerTransport({
-    sessionIdGenerator: () => newSessionId,
-  });
-  const server = createGraftServer({
-    mode: "daemon",
-    sessionId: newSessionId,
-    graftDir: sessionGraftDir,
-    warpPool: options.warpPool,
-    daemonControlPlane: options.controlPlane,
-    daemonScheduler: options.daemonScheduler,
-    daemonWorkerPool: options.daemonWorkerPool,
-    daemonRuntime: () => ({
-      transport: options.transportKind,
-      sameUserOnly: true,
-      socketPath: options.socketPath,
-      mcpPath: options.mcpPath,
-      healthPath: options.healthPath,
-      activeWarpRepos: options.warpPool.size(),
-      startedAt: options.startedAt,
-    }),
-    monitorRuntime: options.monitorRuntime,
-    ...(options.env !== undefined ? { env: options.env } : {}),
-    ...(options.runCapture !== undefined ? { runCapture: options.runCapture } : {}),
-    ...(options.runtimeObservability !== undefined
-      ? { runtimeObservability: options.runtimeObservability }
-      : {}),
-    ...(options.persistedLocalHistoryGraph !== undefined
-      ? { persistedLocalHistoryGraph: options.persistedLocalHistoryGraph }
-      : {}),
-  });
-  const session: DaemonSession = {
-    id: newSessionId,
-    graftDir: sessionGraftDir,
-    transport,
-    server,
-  };
-  transport.onclose = () => {
-    sessions.delete(newSessionId);
-    options.controlPlane.unregisterTransport(newSessionId);
-    void removeSessionDirectory(sessionGraftDir);
-  };
-  transport.onerror = () => {
-    sessions.delete(newSessionId);
-    options.controlPlane.unregisterTransport(newSessionId);
-    void removeSessionDirectory(sessionGraftDir);
-  };
-  sessions.set(newSessionId, session);
-  options.controlPlane.registerTransport(
-    newSessionId,
-    () => server.getWorkspaceStatus(),
-    () => server.getRuntimeCausalContext(),
-  );
-  await server.getMcpServer().connect(transport as Transport);
-  return session;
-}
-
-export function createDaemonSessionHost(options: CreateDaemonSessionHostOptions): DaemonSessionHost {
-  const sessions = new Map<string, DaemonSession>();
-
-  return {
-    async handleRequest(req, res): Promise<void> {
-      try {
-        const url = new URL(req.url ?? "/", "http://localhost");
-        if (req.method === "GET" && url.pathname === options.healthPath) {
-          sendJson(res, 200, { ...options.getHealthStatus() });
-          return;
-        }
-
-        if (url.pathname !== options.mcpPath) {
-          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;
-            }
-            session = await createDaemonSession(crypto.randomUUID(), options, sessions);
-          }
-
-          options.controlPlane.touchTransport(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;
-          }
-          options.controlPlane.touchTransport(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));
-      }
-    },
-
-    async close(): Promise<void> {
-      for (const session of [...sessions.values()]) {
-        options.controlPlane.unregisterTransport(session.id);
-        await session.transport.close().catch(() => {
-          return undefined;
-        });
-        await removeSessionDirectory(session.graftDir);
-      }
-      sessions.clear();
-    },
-  };
-}

package/src/mcp/daemon-stdio-bridge.ts

@@ -1,262 +0,0 @@
-import * as http from "node:http";
-import { spawn, type ChildProcess } from "node:child_process";
-import { fileURLToPath } from "node:url";
-import { dirname, resolve } from "node:path";
-import { Readable } from "node:stream";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import {
-  isInitializeRequest,
-  isJSONRPCRequest,
-  type JSONRPCMessage,
-  type JSONRPCRequest,
-} from "@modelcontextprotocol/sdk/types.js";
-import { defaultDaemonRoot, resolveSocketPath } from "./daemon-bootstrap.js";
-
-const DEFAULT_READY_TIMEOUT_MS = 5_000;
-const DEFAULT_POLL_INTERVAL_MS = 100;
-const MCP_PATH = "/mcp";
-const HEALTH_PATH = "/healthz";
-
-function toNodeHeaders(headers: Headers): http.OutgoingHttpHeaders {
-  const outgoing: http.OutgoingHttpHeaders = {};
-  for (const [name, value] of headers.entries()) {
-    outgoing[name] = value;
-  }
-  return outgoing;
-}
-
-function toResponseHeaders(headers: http.IncomingHttpHeaders): Headers {
-  const responseHeaders = new Headers();
-  for (const [name, value] of Object.entries(headers)) {
-    if (value === undefined) continue;
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        responseHeaders.append(name, item);
-      }
-      continue;
-    }
-    responseHeaders.append(name, value);
-  }
-  return responseHeaders;
-}
-
-export function createLocalSocketFetch(socketPath: string): typeof fetch {
-  return async (input: string | URL | Request, init?: RequestInit): Promise<Response> => {
-    const request = input instanceof Request ? input : new Request(input, init);
-    const url = new URL(request.url);
-    const body = request.body === null ? undefined : Buffer.from(await request.arrayBuffer());
-
-    return await new Promise<Response>((resolvePromise, reject) => {
-      const req = http.request({
-        socketPath,
-        path: `${url.pathname}${url.search}`,
-        method: request.method,
-        headers: toNodeHeaders(request.headers),
-        signal: request.signal,
-      }, (res) => {
-        const bodyStream = Readable.toWeb(res) as ReadableStream<Uint8Array>;
-        resolvePromise(new Response(bodyStream, {
-          status: res.statusCode ?? 0,
-          statusText: res.statusMessage ?? "",
-          headers: toResponseHeaders(res.headers),
-        }));
-      });
-      req.once("error", reject);
-      if (body !== undefined && body.byteLength > 0) {
-        req.write(body);
-      }
-      req.end();
-    });
-  };
-}
-
-async function isDaemonHealthy(socketPath: string): Promise<boolean> {
-  try {
-    const response = await createLocalSocketFetch(socketPath)(
-      new URL(`http://graft${HEALTH_PATH}`),
-      {
-        method: "GET",
-        headers: {
-          accept: "application/json",
-        },
-      },
-    );
-    await response.arrayBuffer();
-    return response.ok;
-  } catch {
-    return false;
-  }
-}
-
-function resolveGraftBinPath(): string {
-  return resolve(dirname(fileURLToPath(import.meta.url)), "../../bin/graft.js");
-}
-
-function spawnDaemonProcess(socketPath: string): ChildProcess {
-  const child = spawn(
-    process.execPath,
-    [resolveGraftBinPath(), "daemon", "--socket", socketPath],
-    {
-      detached: true,
-      stdio: ["ignore", "ignore", "ignore"],
-      windowsHide: true,
-      env: { ...process.env },
-    },
-  );
-  child.unref();
-  return child;
-}
-
-function delay(ms: number): Promise<void> {
-  return new Promise((resolvePromise) => {
-    setTimeout(resolvePromise, ms);
-  });
-}
-
-export interface EnsureDaemonReadyOptions {
-  socketPath?: string;
-  timeoutMs?: number;
-  pollIntervalMs?: number;
-  spawnIfMissing?: boolean;
-  spawnDaemon?: ((socketPath: string) => ChildProcess | undefined) | undefined;
-  healthCheck?: ((socketPath: string) => Promise<boolean>) | undefined;
-}
-
-export async function ensureDaemonReady(options: EnsureDaemonReadyOptions = {}): Promise<string> {
-  const socketPath = resolveSocketPath(options.socketPath, defaultDaemonRoot());
-  const timeoutMs = options.timeoutMs ?? DEFAULT_READY_TIMEOUT_MS;
-  const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
-  const healthCheck = options.healthCheck ?? isDaemonHealthy;
-
-  if (await healthCheck(socketPath)) {
-    return socketPath;
-  }
-
-  if (options.spawnIfMissing === false) {
-    throw new Error(
-      `No graft daemon is listening on ${socketPath}. Start it with \`graft daemon --socket ${socketPath}\` or use repo-local \`graft serve\`.`,
-    );
-  }
-
-  let spawnError: unknown;
-  try {
-    (options.spawnDaemon ?? spawnDaemonProcess)(socketPath);
-  } catch (error) {
-    spawnError = error;
-  }
-
-  const deadline = Date.now() + timeoutMs;
-  while (Date.now() <= deadline) {
-    if (await healthCheck(socketPath)) {
-      return socketPath;
-    }
-    await delay(pollIntervalMs);
-  }
-
-  const suffix = spawnError instanceof Error
-    ? ` Auto-start failed: ${spawnError.message}`
-    : "";
-  throw new Error(`Timed out waiting for graft daemon readiness on ${socketPath}.${suffix}`);
-}
-
-function internalErrorResponse(
-  message: JSONRPCRequest,
-  error: unknown,
-): JSONRPCMessage {
-  return {
-    jsonrpc: "2.0",
-    id: message.id,
-    error: {
-      code: -32603,
-      message: error instanceof Error ? error.message : String(error),
-    },
-  };
-}
-
-export interface StartDaemonBackedStdioBridgeOptions {
-  socketPath?: string;
-  spawnIfMissing?: boolean;
-  ensureReady?: ((options?: EnsureDaemonReadyOptions) => Promise<string>) | undefined;
-}
-
-export async function startDaemonBackedStdioBridge(
-  options: StartDaemonBackedStdioBridgeOptions = {},
-): Promise<void> {
-  const socketPath = await (options.ensureReady ?? ensureDaemonReady)({
-    ...(options.socketPath !== undefined ? { socketPath: options.socketPath } : {}),
-    ...(options.spawnIfMissing !== undefined ? { spawnIfMissing: options.spawnIfMissing } : {}),
-  });
-  const stdioTransport = new StdioServerTransport();
-  const daemonTransport = new StreamableHTTPClientTransport(
-    new URL(`http://graft${MCP_PATH}`),
-    { fetch: createLocalSocketFetch(socketPath) },
-  );
-
-  let closed = false;
-  const close = async (): Promise<void> => {
-    if (closed) return;
-    closed = true;
-    process.stdin.off("end", onStdinEnd);
-    process.stdin.off("close", onStdinEnd);
-    process.off("SIGINT", onSignal);
-    process.off("SIGTERM", onSignal);
-    await daemonTransport.terminateSession().catch(() => {
-      return undefined;
-    });
-    await daemonTransport.close().catch(() => {
-      return undefined;
-    });
-    await stdioTransport.close().catch(() => {
-      return undefined;
-    });
-  };
-
-  const onSignal = (): void => {
-    void close().finally(() => {
-      process.exitCode = process.exitCode ?? 0;
-    });
-  };
-  const onStdinEnd = (): void => {
-    void close();
-  };
-
-  stdioTransport.onmessage = (message): void => {
-    if (isInitializeRequest(message)) {
-      daemonTransport.setProtocolVersion(message.params.protocolVersion);
-    }
-    void daemonTransport.send(message).catch(async (error: unknown) => {
-      if (!isJSONRPCRequest(message)) {
-        console.error(error);
-        return;
-      }
-      await stdioTransport.send(internalErrorResponse(message, error)).catch(() => {
-        return undefined;
-      });
-    });
-  };
-  stdioTransport.onerror = (error): void => {
-    console.error(error);
-    void close();
-  };
-  daemonTransport.onmessage = (message): void => {
-    void stdioTransport.send(message).catch((error: unknown) => {
-      console.error(error);
-      void close();
-    });
-  };
-  daemonTransport.onerror = (error): void => {
-    console.error(error);
-  };
-  daemonTransport.onclose = (): void => {
-    void close();
-  };
-
-  process.stdin.on("end", onStdinEnd);
-  process.stdin.on("close", onStdinEnd);
-  process.once("SIGINT", onSignal);
-  process.once("SIGTERM", onSignal);
-
-  await daemonTransport.start();
-  await stdioTransport.start();
-}