dxcomplete 0.2.1 → 0.2.2

package/src/cli.ts

@@ -1,268 +0,0 @@
-#!/usr/bin/env node
-import { initProject } from "./init.js";
-import { checkRuntime } from "./runtime/check.js";
-import { upgradeProject } from "./upgrade.js";
-import { validateScaffold } from "./validate.js";
-import { DXCOMPLETE_PACKAGE_VERSION } from "./version.js";
-
-type ParsedArgs = {
-  command?: string;
-  targetDir: string;
-  envFile?: string;
-  force: boolean;
-  dryRun: boolean;
-  apply: boolean;
-  includeGithubWorkflow: boolean;
-  packageLayout: boolean;
-  help: boolean;
-  version: boolean;
-};
-
-main(process.argv.slice(2)).catch((error: unknown) => {
-  const message = error instanceof Error ? error.message : String(error);
-  console.error(`dxcomplete: ${message}`);
-  process.exitCode = 1;
-});
-
-async function main(argv: string[]): Promise<void> {
-  const args = parseArgs(argv);
-
-  if (args.version) {
-    console.log(DXCOMPLETE_PACKAGE_VERSION);
-    return;
-  }
-
-  if (args.help || !args.command) {
-    printHelp();
-    return;
-  }
-
-  if (args.command === "init") {
-    const result = await initProject({
-      targetDir: args.targetDir,
-      force: args.force,
-      dryRun: args.dryRun,
-      includeGithubWorkflow: args.includeGithubWorkflow
-    });
-
-    if (args.dryRun) {
-      console.log(`Would initialize DX Complete scaffold in ${result.targetDir}`);
-      printList("Would write", result.planned);
-      printList("Would skip existing", result.skipped);
-      return;
-    }
-
-    console.log(`Initialized DX Complete scaffold in ${result.targetDir}`);
-    printList("Written", result.written);
-    printList("Skipped existing", result.skipped);
-    console.log("Review dxcomplete/docs/open-questions.md before treating the draft model as policy.");
-    return;
-  }
-
-  if (args.command === "upgrade") {
-    const result = await upgradeProject({
-      targetDir: args.targetDir,
-      apply: args.apply,
-      force: args.force
-    });
-
-    if (args.apply) {
-      console.log(
-        result.manualReview.length > 0
-          ? `DX Complete upgrade requires manual review in ${result.targetDir}`
-          : `Upgraded DX Complete scaffold in ${result.targetDir}`
-      );
-      printList("Written", result.written);
-      printList("Already current", result.unchanged);
-      printList("Manual review required", result.manualReview);
-      printList("User-owned scaffold drift", result.userOwnedDrift);
-      if (result.manualReview.length > 0) {
-        process.exitCode = 1;
-      }
-      return;
-    }
-
-    console.log(`Would upgrade DX Complete scaffold in ${result.targetDir}`);
-    console.log(
-      `Package version ${result.packageVersion}; workspace compatibility ${result.workspaceCompatibility}.`
-    );
-    printList("Would write", result.planned);
-    printList("Already current", result.unchanged);
-    printList("Manual review required", result.manualReview);
-    printList("User-owned scaffold drift", result.userOwnedDrift);
-    console.log("Run dxcomplete upgrade --apply to write compatibility-critical scaffold updates.");
-    return;
-  }
-
-  if (args.command === "validate") {
-    const result = await validateScaffold({
-      targetDir: args.targetDir,
-      packageLayout: args.packageLayout
-    });
-
-    if (result.ok) {
-      console.log(`DX Complete scaffold shape is valid in ${result.targetDir}`);
-      return;
-    }
-
-    console.error(`DX Complete scaffold is missing ${result.missing.length} required file(s):`);
-    for (const file of result.missing) {
-      console.error(`- ${file}`);
-    }
-    process.exitCode = 1;
-    return;
-  }
-
-  if (args.command === "check-runtime") {
-    const result = await checkRuntime({ envFile: args.envFile });
-    console.log(JSON.stringify(result, null, 2));
-    return;
-  }
-
-  throw new Error(`Unknown command "${args.command}".`);
-}
-
-function parseArgs(argv: string[]): ParsedArgs {
-  const parsed: ParsedArgs = {
-    targetDir: process.cwd(),
-    force: false,
-    dryRun: false,
-    apply: false,
-    includeGithubWorkflow: true,
-    packageLayout: false,
-    help: false,
-    version: false
-  };
-
-  const positionals: string[] = [];
-
-  for (let index = 0; index < argv.length; index += 1) {
-    const arg = argv[index];
-
-    if (arg === "--help" || arg === "-h") {
-      parsed.help = true;
-      continue;
-    }
-
-    if (arg === "--apply") {
-      parsed.apply = true;
-      continue;
-    }
-
-    if (arg === "--version" || arg === "-v") {
-      parsed.version = true;
-      continue;
-    }
-
-    if (arg === "--target") {
-      const value = argv[index + 1];
-      if (!value) {
-        throw new Error("--target requires a directory.");
-      }
-      parsed.targetDir = value;
-      index += 1;
-      continue;
-    }
-
-    if (arg.startsWith("--target=")) {
-      parsed.targetDir = arg.slice("--target=".length);
-      continue;
-    }
-
-    if (arg === "--env") {
-      const value = argv[index + 1];
-      if (!value) {
-        throw new Error("--env requires a file path.");
-      }
-      parsed.envFile = value;
-      index += 1;
-      continue;
-    }
-
-    if (arg.startsWith("--env=")) {
-      parsed.envFile = arg.slice("--env=".length);
-      continue;
-    }
-
-    if (arg === "--force") {
-      parsed.force = true;
-      continue;
-    }
-
-    if (arg === "--dry-run") {
-      parsed.dryRun = true;
-      continue;
-    }
-
-    if (arg === "--no-github-workflow") {
-      parsed.includeGithubWorkflow = false;
-      continue;
-    }
-
-    if (arg === "--package-layout") {
-      parsed.packageLayout = true;
-      continue;
-    }
-
-    if (arg.startsWith("-")) {
-      throw new Error(`Unknown option "${arg}".`);
-    }
-
-    positionals.push(arg);
-  }
-
-  parsed.command = positionals[0];
-
-  if (positionals.length > 1) {
-    throw new Error(`Unexpected argument "${positionals[1]}".`);
-  }
-
-  if (parsed.apply && parsed.command !== "upgrade") {
-    throw new Error("--apply is only supported by upgrade.");
-  }
-
-  if (parsed.command === "upgrade" && parsed.apply && parsed.dryRun) {
-    throw new Error("upgrade cannot combine --apply and --dry-run.");
-  }
-
-  return parsed;
-}
-
-function printHelp(): void {
-  console.log(`dxcomplete
-
-Usage:
-  dxcomplete init [--target <dir>] [--force] [--dry-run] [--no-github-workflow]
-  dxcomplete upgrade [--target <dir>] [--apply] [--force]
-  dxcomplete validate [--target <dir>]
-  dxcomplete check-runtime [--env <file>]
-
-Commands:
-  init            Install the editable draft scaffold into a project.
-  upgrade         Preview or apply compatibility-critical scaffold updates.
-  validate        Validate the expected scaffold file shape.
-  check-runtime   Verify MongoDB connectivity and required collections.
-
-Options:
-  --target <dir>          Target project directory. Defaults to the current directory.
-  --env <file>            Runtime env file. Defaults to .env.local when present.
-  --apply                 Write upgrade changes. Upgrade previews by default.
-  --force                 Overwrite existing scaffold files.
-  --dry-run               Show what would be written without changing files.
-  --no-github-workflow    Skip installing .github/workflows/dxcomplete.yml.
-  --package-layout        Validate this package repository layout instead of an installed scaffold.
-  --help                  Show help.
-  --version               Show version.
-`);
-}
-
-function printList(label: string, values: string[]): void {
-  if (values.length === 0) {
-    return;
-  }
-
-  console.log(`${label}:`);
-  for (const value of values) {
-    console.log(`- ${value}`);
-  }
-}

package/src/http/server.ts

@@ -1,314 +0,0 @@
-import type { IncomingHttpHeaders, IncomingMessage, ServerResponse } from "node:http";
-import { loadWorkspaceConfig, parseWorkspaceConfig, type WorkspaceConfig } from "../runtime/workspace.js";
-
-const MCP_PATH = "/api/mcp";
-const GOOGLE_CALLBACK_PATH = "/api/auth/callback/google";
-const MCP_SCOPE = "mcp:tools";
-
-type WorkspaceServiceConfig = {
-  serviceUrl: string;
-  serviceClientId: string;
-  serviceClientSecret: string;
-};
-
-let workspaceConfigPromise: Promise<WorkspaceConfig> | undefined;
-
-export function configureDxcompleteWorkspace(config: unknown): void {
-  workspaceConfigPromise = Promise.resolve(parseWorkspaceConfig(config, "DX Complete workspace config"));
-}
-
-export async function closeDxcompleteHttpRuntime(): Promise<void> {
-  workspaceConfigPromise = undefined;
-}
-
-export default async function handleDxcompleteHttpRequest(
-  req: IncomingMessage & { body?: unknown; query?: Record<string, unknown> },
-  res: ServerResponse
-): Promise<void> {
-  try {
-    setCorsHeaders(res);
-
-    if (req.method === "OPTIONS") {
-      res.writeHead(204).end();
-      return;
-    }
-
-    const baseUrl = getBaseUrl(req);
-    const requestUrl = new URL(req.url ?? "/", baseUrl);
-    const path = normalizePath(requestUrl.pathname);
-
-    if (isProtectedResourceMetadataPath(path)) {
-      writeJson(res, 200, protectedResourceMetadata(baseUrl));
-      return;
-    }
-
-    if (isAuthorizationServerMetadataPath(path)) {
-      writeJson(res, 200, authorizationServerMetadata(baseUrl));
-      return;
-    }
-
-    if (path === MCP_PATH && !readBearerToken(req)) {
-      await drainRequestBody(req);
-      writeOAuthChallenge(res, baseUrl);
-      return;
-    }
-
-    const servicePath = servicePathForPublicPath(path);
-    if (!servicePath) {
-      writeJson(res, 404, { error: "not_found" });
-      return;
-    }
-
-    const workspaceConfig = await getWorkspaceConfig();
-    const serviceConfig = getWorkspaceServiceConfig();
-    await proxyToCentralService(req, res, {
-      serviceConfig,
-      workspaceConfig,
-      baseUrl,
-      servicePath,
-      search: requestUrl.search
-    });
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (!res.headersSent) {
-      writeJson(res, 500, { error: "server_error", error_description: message });
-    } else {
-      res.end();
-    }
-  }
-}
-
-async function proxyToCentralService(
-  req: IncomingMessage,
-  res: ServerResponse,
-  input: {
-    serviceConfig: WorkspaceServiceConfig;
-    workspaceConfig: WorkspaceConfig;
-    baseUrl: string;
-    servicePath: string;
-    search: string;
-  }
-): Promise<void> {
-  const targetUrl = new URL(input.servicePath + input.search, input.serviceConfig.serviceUrl);
-  const body = req.method === "GET" || req.method === "HEAD" ? undefined : await readRequestBody(req);
-  const response = await fetch(targetUrl, {
-    method: req.method,
-    headers: serviceHeaders(req.headers, input),
-    body,
-    redirect: "manual"
-  });
-
-  const responseBody = Buffer.from(await response.arrayBuffer());
-  const headers: Record<string, string> = {};
-  response.headers.forEach((value, key) => {
-    if (!shouldForwardResponseHeader(key)) {
-      return;
-    }
-    headers[key] = value;
-  });
-  headers["content-length"] = String(responseBody.byteLength);
-
-  res.writeHead(response.status, headers);
-  res.end(responseBody);
-}
-
-function serviceHeaders(
-  headers: IncomingHttpHeaders,
-  input: {
-    serviceConfig: WorkspaceServiceConfig;
-    workspaceConfig: WorkspaceConfig;
-    baseUrl: string;
-  }
-): Headers {
-  const forwarded = new Headers();
-
-  for (const key of [
-    "accept",
-    "authorization",
-    "content-type",
-    "mcp-protocol-version",
-    "mcp-session-id",
-    "last-event-id",
-    "user-agent"
-  ]) {
-    const value = firstHeader(headers[key]);
-    if (value) {
-      forwarded.set(key, value);
-    }
-  }
-
-  forwarded.set("x-dxc-service-client-id", input.serviceConfig.serviceClientId);
-  forwarded.set("x-dxc-service-client-secret", input.serviceConfig.serviceClientSecret);
-  forwarded.set("x-dxc-workspace-id", input.workspaceConfig.workspaceId);
-  forwarded.set("x-dxc-workspace-name", input.workspaceConfig.name);
-  forwarded.set("x-dxc-forwarded-base-url", input.baseUrl);
-
-  return forwarded;
-}
-
-function shouldForwardResponseHeader(key: string): boolean {
-  const lowerKey = key.toLowerCase();
-  return !["connection", "content-encoding", "content-length", "keep-alive", "transfer-encoding"].includes(lowerKey);
-}
-
-function servicePathForPublicPath(pathname: string): string | undefined {
-  switch (pathname) {
-    case MCP_PATH:
-      return "/api/dxcomplete/service/mcp";
-    case "/api/dxcomplete/auth/register":
-      return "/api/dxcomplete/service/auth/register";
-    case "/api/dxcomplete/auth/authorize":
-      return "/api/dxcomplete/service/auth/authorize";
-    case GOOGLE_CALLBACK_PATH:
-      return "/api/dxcomplete/service/auth/google/callback";
-    case "/api/dxcomplete/auth/token":
-      return "/api/dxcomplete/service/auth/token";
-    default:
-      return undefined;
-  }
-}
-
-function getWorkspaceServiceConfig(env: NodeJS.ProcessEnv = process.env): WorkspaceServiceConfig {
-  return {
-    serviceUrl: readRequiredEnv(env, "DXC_SERVICE_URL"),
-    serviceClientId: readRequiredEnv(env, "DXC_SERVICE_CLIENT_ID"),
-    serviceClientSecret: readRequiredEnv(env, "DXC_SERVICE_CLIENT_SECRET")
-  };
-}
-
-async function getWorkspaceConfig(): Promise<WorkspaceConfig> {
-  workspaceConfigPromise ??= loadWorkspaceConfig();
-  return workspaceConfigPromise;
-}
-
-function protectedResourceMetadata(baseUrl: string): Record<string, unknown> {
-  return {
-    resource: mcpResourceUrl(baseUrl),
-    authorization_servers: [baseUrl],
-    scopes_supported: [MCP_SCOPE],
-    resource_name: "DX Complete"
-  };
-}
-
-function authorizationServerMetadata(baseUrl: string): Record<string, unknown> {
-  return {
-    issuer: baseUrl,
-    authorization_endpoint: `${baseUrl}/api/dxcomplete/auth/authorize`,
-    token_endpoint: `${baseUrl}/api/dxcomplete/auth/token`,
-    registration_endpoint: `${baseUrl}/api/dxcomplete/auth/register`,
-    response_types_supported: ["code"],
-    code_challenge_methods_supported: ["S256"],
-    token_endpoint_auth_methods_supported: ["none"],
-    grant_types_supported: ["authorization_code", "refresh_token"],
-    scopes_supported: [MCP_SCOPE]
-  };
-}
-
-function writeOAuthChallenge(res: ServerResponse, baseUrl: string): void {
-  res.setHeader(
-    "www-authenticate",
-    `Bearer resource_metadata="${protectedResourceMetadataUrl(baseUrl)}", scope="${MCP_SCOPE}"`
-  );
-  writeJson(res, 401, { error: "unauthorized" });
-}
-
-function setCorsHeaders(res: ServerResponse): void {
-  res.setHeader("access-control-allow-origin", "*");
-  res.setHeader(
-    "access-control-allow-headers",
-    "authorization,content-type,mcp-protocol-version,mcp-session-id,last-event-id"
-  );
-  res.setHeader("access-control-allow-methods", "GET,POST,DELETE,OPTIONS");
-  res.setHeader("access-control-expose-headers", "mcp-session-id,www-authenticate");
-}
-
-function writeJson(res: ServerResponse, status: number, value: unknown): void {
-  const body = JSON.stringify(value);
-  if (!res.headersSent) {
-    res.writeHead(status, {
-      "content-type": "application/json",
-      "content-length": String(Buffer.byteLength(body))
-    });
-  }
-  res.end(body);
-}
-
-function getBaseUrl(req: IncomingMessage): string {
-  const forwardedProto = firstHeader(req.headers["x-forwarded-proto"]);
-  const forwardedHost = firstHeader(req.headers["x-forwarded-host"]);
-  const host = forwardedHost || firstHeader(req.headers.host);
-  const protocol = forwardedProto || "http";
-
-  if (!host) {
-    throw new Error("Host header is required.");
-  }
-
-  return `${protocol}://${host}`;
-}
-
-function firstHeader(value: string | string[] | undefined): string | undefined {
-  return Array.isArray(value) ? value[0] : value;
-}
-
-function normalizePath(pathname: string): string {
-  if (pathname === "/api/mcp" || pathname === "/api/dxcomplete" || pathname === "/api/dxcomplete/mcp") {
-    return MCP_PATH;
-  }
-
-  return pathname.endsWith("/") && pathname.length > 1 ? pathname.slice(0, -1) : pathname;
-}
-
-function isProtectedResourceMetadataPath(pathname: string): boolean {
-  return (
-    pathname === protectedResourceMetadataPath() ||
-    pathname === "/.well-known/oauth-protected-resource/api/dxcomplete/mcp" ||
-    pathname === `/api/dxcomplete${protectedResourceMetadataPath()}`
-  );
-}
-
-function isAuthorizationServerMetadataPath(pathname: string): boolean {
-  return (
-    pathname === "/.well-known/oauth-authorization-server" ||
-    pathname === "/api/dxcomplete/.well-known/oauth-authorization-server"
-  );
-}
-
-function protectedResourceMetadataPath(): string {
-  return `/.well-known/oauth-protected-resource${MCP_PATH}`;
-}
-
-function protectedResourceMetadataUrl(baseUrl: string): string {
-  return `${baseUrl}${protectedResourceMetadataPath()}`;
-}
-
-function mcpResourceUrl(baseUrl: string): string {
-  return `${baseUrl}${MCP_PATH}`;
-}
-
-async function readRequestBody(req: IncomingMessage): Promise<Buffer> {
-  const chunks: Buffer[] = [];
-  for await (const chunk of req) {
-    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-  }
-  return Buffer.concat(chunks);
-}
-
-async function drainRequestBody(req: IncomingMessage): Promise<void> {
-  for await (const _ of req) {
-    // Drain request body so clients can reuse the connection.
-  }
-}
-
-function readBearerToken(req: IncomingMessage): string | undefined {
-  const header = firstHeader(req.headers.authorization);
-  const match = header?.match(/^Bearer\s+(.+)$/i);
-  return match?.[1];
-}
-
-function readRequiredEnv(env: NodeJS.ProcessEnv, key: string): string {
-  const value = env[key]?.trim();
-  if (!value) {
-    throw new Error(`${key} is required for the workspace MCP proxy.`);
-  }
-  return value;
-}