sift-light 1.0.0

package/src/mcp-server.ts

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+import {
+  DEFAULT_MCP_HOST,
+  DEFAULT_MCP_MAX_SESSIONS,
+  DEFAULT_MCP_PORT,
+  DEFAULT_MCP_SESSION_IDLE_TIMEOUT_MS,
+  SIFT_LIGHT_MCP_PATH,
+  createDefaultSiftLightMcpService,
+  startSiftLightMcpServer,
+} from "./mcp.js";
+import {
+  createMcpSemanticJudgeIntegration,
+  mcpSemanticJudgeConfigSource,
+} from "./mcp-semantic-judge.js";
+import type { SemanticJudgeIntegration } from "./semantic-judge.js";
+import { parseSiftLightMcpTransport, SIFT_LIGHT_MCP_USAGE } from "./mcp-cli.js";
+import { parseSiftLightMcpOutputMode, type SiftLightMcpOutputMode } from "./mcp-output.js";
+import { startSiftLightMcpStdioServer } from "./mcp-stdio.js";
+
+function environmentInteger(
+  name: string,
+  fallback: number,
+  minimum: number,
+  maximum: number,
+): number {
+  const value = process.env[name];
+  if (value === undefined) return fallback;
+  const port = Number(value);
+  if (!Number.isSafeInteger(port) || port < minimum || port > maximum) {
+    throw new Error(
+      `${name} must be an integer from ${String(minimum)} through ${String(maximum)}`,
+    );
+  }
+  return port;
+}
+
+function allowedOrigins(): string[] {
+  return (process.env.SIFT_LIGHT_MCP_ALLOWED_ORIGINS ?? "")
+    .split(",")
+    .map((origin) => origin.trim())
+    .filter((origin) => origin.length > 0);
+}
+
+async function configuredSemanticJudge(): Promise<SemanticJudgeIntegration> {
+  return createMcpSemanticJudgeIntegration();
+}
+
+function logSemanticJudgeStatus(integration: SemanticJudgeIntegration): void {
+  const status = integration.config.enabled ? "enabled" : "disabled";
+  process.stderr.write(
+    `sift-light MCP semantic judge: ${status}; source=${mcpSemanticJudgeConfigSource()}\n`,
+  );
+}
+
+async function runHttpServer(
+  outputMode: SiftLightMcpOutputMode,
+  semanticJudge: SemanticJudgeIntegration | undefined,
+): Promise<void> {
+  const running = await startSiftLightMcpServer({
+    cwd: process.env.SIFT_LIGHT_MCP_CWD ?? process.cwd(),
+    host: process.env.SIFT_LIGHT_MCP_HOST ?? DEFAULT_MCP_HOST,
+    port: environmentInteger("SIFT_LIGHT_MCP_PORT", DEFAULT_MCP_PORT, 0, 65_535),
+    createService: () => createDefaultSiftLightMcpService(semanticJudge),
+    maxSessions: environmentInteger(
+      "SIFT_LIGHT_MCP_MAX_SESSIONS",
+      DEFAULT_MCP_MAX_SESSIONS,
+      1,
+      Number.MAX_SAFE_INTEGER,
+    ),
+    sessionIdleTimeoutMs: environmentInteger(
+      "SIFT_LIGHT_MCP_SESSION_IDLE_MS",
+      DEFAULT_MCP_SESSION_IDLE_TIMEOUT_MS,
+      1,
+      Number.MAX_SAFE_INTEGER,
+    ),
+    allowedOrigins: allowedOrigins(),
+    outputMode,
+  });
+
+  const address = running.httpServer.address();
+  if (!address || !(address instanceof Object)) {
+    throw new Error("MCP TCP listener is unavailable");
+  }
+  const displayHost = address.family === "IPv6" ? `[${address.address}]` : address.address;
+  process.stderr.write(
+    `sift-light MCP listening on http://${displayHost}:${String(address.port)}${SIFT_LIGHT_MCP_PATH}\n`,
+  );
+  process.stderr.write(`sift-light MCP working directory: ${running.cwd}\n`);
+
+  let shuttingDown = false;
+  const closeAfterSignal = async (): Promise<void> => {
+    try {
+      await running.close();
+    } catch (error) {
+      process.stderr.write(`sift-light MCP shutdown failed: ${String(error)}\n`);
+      process.exitCode = 1;
+    }
+  };
+  const shutdown = (): void => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    void closeAfterSignal();
+  };
+  process.once("SIGINT", shutdown);
+  process.once("SIGTERM", shutdown);
+}
+
+async function runStdioServer(
+  outputMode: SiftLightMcpOutputMode,
+  semanticJudge: SemanticJudgeIntegration | undefined,
+): Promise<void> {
+  const running = await startSiftLightMcpStdioServer({
+    cwd: process.env.SIFT_LIGHT_MCP_CWD ?? process.env.CLAUDE_PROJECT_DIR ?? process.cwd(),
+    outputMode,
+    createService: () => createDefaultSiftLightMcpService(semanticJudge),
+  });
+  process.stderr.write("sift-light MCP serving one local client over stdio\n");
+  process.stderr.write(`sift-light MCP working directory: ${running.cwd}\n`);
+
+  let shuttingDown = false;
+  const shutdown = (): void => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    void running.close();
+  };
+  process.once("SIGINT", shutdown);
+  process.once("SIGTERM", shutdown);
+  try {
+    await running.closed;
+  } finally {
+    process.off("SIGINT", shutdown);
+    process.off("SIGTERM", shutdown);
+  }
+}
+
+async function main(): Promise<void> {
+  const transport = parseSiftLightMcpTransport(process.argv.slice(2));
+  if (transport === "help") {
+    process.stdout.write(SIFT_LIGHT_MCP_USAGE);
+    return;
+  }
+  const outputMode = parseSiftLightMcpOutputMode(process.env.SIFT_LIGHT_MCP_OUTPUT_MODE);
+  const semanticJudge = await configuredSemanticJudge();
+  logSemanticJudgeStatus(semanticJudge);
+  if (transport === "stdio") {
+    await runStdioServer(outputMode, semanticJudge);
+    return;
+  }
+  await runHttpServer(outputMode, semanticJudge);
+}
+
+try {
+  await main();
+} catch (error) {
+  process.stderr.write(`sift-light MCP failed: ${String(error)}\n`);
+  process.exitCode = 1;
+}

package/src/mcp-stdio.ts

@@ -0,0 +1,114 @@
+import type { Readable, Writable } from "node:stream";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  createDefaultSiftLightMcpService,
+  createSiftLightMcpServer,
+  type SiftLightMcpService,
+} from "./mcp.js";
+import {
+  DEFAULT_MCP_OUTPUT_MODE,
+  parseSiftLightMcpOutputMode,
+  type SiftLightMcpOutputMode,
+} from "./mcp-output.js";
+
+export interface SiftLightMcpStdioOptions {
+  cwd?: string;
+  input?: Readable;
+  output?: Writable;
+  outputMode?: SiftLightMcpOutputMode;
+  createService?: () => SiftLightMcpService;
+}
+
+export interface RunningSiftLightMcpStdioServer {
+  readonly cwd: string;
+  readonly closed: Promise<void>;
+  close(): Promise<void>;
+}
+
+function rejectedReasons(results: readonly PromiseSettledResult<unknown>[]): unknown[] {
+  return results.flatMap((result) => (result.status === "rejected" ? [result.reason] : []));
+}
+
+export async function startSiftLightMcpStdioServer(
+  options: SiftLightMcpStdioOptions = {},
+): Promise<RunningSiftLightMcpStdioServer> {
+  const cwd = options.cwd ?? process.cwd();
+  const input = options.input ?? process.stdin;
+  const output = options.output ?? process.stdout;
+  const outputMode = parseSiftLightMcpOutputMode(options.outputMode ?? DEFAULT_MCP_OUTPUT_MODE);
+  const service = (options.createService ?? createDefaultSiftLightMcpService)();
+  const protocol = createSiftLightMcpServer(service, cwd, outputMode);
+
+  const lifecycle = Promise.withResolvers<void>();
+  let closePromise: Promise<void> | undefined;
+  let transportFailure: Error | undefined;
+  const requestClose = (): void => {
+    void close();
+  };
+  const requestFailure = (error: Error): void => {
+    transportFailure ??= error;
+    void close();
+  };
+  const removeLifecycleListeners = (): void => {
+    input.off("end", requestClose);
+    input.off("close", requestClose);
+    input.off("error", requestFailure);
+    output.off("error", requestFailure);
+  };
+  const close = (): Promise<void> => {
+    if (closePromise) return closePromise;
+    input.off("end", requestClose);
+    input.off("close", requestClose);
+    closePromise = lifecycle.promise;
+    const performClose = async (): Promise<void> => {
+      const cleanupErrors = rejectedReasons(
+        await Promise.allSettled([protocol.close(), service.shutdown()]),
+      );
+      removeLifecycleListeners();
+      const errors = transportFailure ? [transportFailure, ...cleanupErrors] : cleanupErrors;
+      if (errors.length > 0) {
+        lifecycle.reject(
+          new AggregateError(
+            errors,
+            transportFailure ? "MCP stdio transport failed" : "MCP stdio shutdown failed",
+          ),
+        );
+      } else {
+        lifecycle.resolve();
+      }
+    };
+    void performClose();
+    return closePromise;
+  };
+
+  const transport = new StdioServerTransport(input, output);
+  try {
+    // The upstream transport exposes a callback property rather than an EventTarget API.
+    if (!Reflect.set(transport, "onclose", requestClose)) {
+      throw new Error("Unable to attach the MCP stdio close handler");
+    }
+    input.once("end", requestClose);
+    input.once("close", requestClose);
+    input.once("error", requestFailure);
+    output.once("error", requestFailure);
+    await protocol.connect(transport);
+  } catch (error) {
+    let cleanupFailure: Error | undefined;
+    try {
+      await close();
+    } catch (closeError) {
+      cleanupFailure =
+        closeError instanceof Error
+          ? closeError
+          : new Error("MCP stdio startup cleanup failed", { cause: closeError });
+    }
+    if (cleanupFailure) {
+      throw new AggregateError([error, cleanupFailure], "MCP stdio startup failed", {
+        cause: error,
+      });
+    }
+    throw error;
+  }
+
+  return { cwd, closed: lifecycle.promise, close };
+}