@cubis/foundry 0.3.82 → 0.3.84

package/mcp/src/index.ts

@@ -1,271 +0,0 @@
-#!/usr/bin/env node
-/**
- * Cubis Foundry MCP Server – entry point.
- *
- * Usage:
- *   cubis-mcp                          # stdio (default)
- *   cubis-mcp --transport stdio        # explicit stdio
- *   cubis-mcp --transport http         # Streamable HTTP
- *   cubis-mcp --scope global           # default config scope for built-in config tools
- *   cubis-mcp --host 0.0.0.0 --port 3100
- *   cubis-mcp --scan-only              # scan vault and exit
- */
-
-import { loadServerConfig } from "./config/index.js";
-import { loadGeneratedRouteManifest } from "./routes/loadGeneratedRouteManifest.js";
-import { scanVaultRoots } from "./vault/scanner.js";
-import { buildManifest } from "./vault/manifest.js";
-import {
-  loadGeneratedSkillManifest,
-  mergeGeneratedSkillMetadata,
-} from "./vault/generatedManifest.js";
-import { createServer } from "./server.js";
-import { createStdioTransport } from "./transports/stdio.js";
-import {
-  createMultiSessionHttpServer,
-  type McpServerFactory,
-} from "./transports/streamableHttp.js";
-import { logger, setLogLevel } from "./utils/logger.js";
-import {
-  parsePostmanState,
-  parseStitchState,
-  readEffectiveConfig,
-} from "./cbxConfig/index.js";
-import { urlToMode } from "./tools/postmanModes.js";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-
-// ─── Arg parsing ─────────────────────────────────────────────
-
-function parseArgs(argv: string[]): {
-  transport: "stdio" | "http";
-  scope: "auto" | "global" | "project";
-  scanOnly: boolean;
-  debug: boolean;
-  port?: number;
-  host?: string;
-  configPath?: string;
-} {
-  let transport: "stdio" | "http" = "stdio";
-  let scope: "auto" | "global" | "project" = "auto";
-  let scanOnly = false;
-  let debug = false;
-  let port: number | undefined;
-  let host: string | undefined;
-  let configPath: string | undefined;
-
-  for (let i = 2; i < argv.length; i++) {
-    const arg = argv[i];
-    if (arg === "--transport" && argv[i + 1]) {
-      const val = argv[++i];
-      if (val === "http" || val === "streamable-http") {
-        transport = "http";
-      } else if (val === "stdio") {
-        transport = "stdio";
-      } else {
-        logger.error(`Unknown transport: ${val}. Use "stdio" or "http".`);
-        process.exit(1);
-      }
-    } else if (arg === "--scope" && argv[i + 1]) {
-      const val = argv[++i];
-      if (val === "auto" || val === "global" || val === "project") {
-        scope = val;
-      } else {
-        logger.error(
-          `Unknown scope: ${val}. Use "auto", "global", or "project".`,
-        );
-        process.exit(1);
-      }
-    } else if (arg === "--port" && argv[i + 1]) {
-      const val = Number.parseInt(argv[++i], 10);
-      if (!Number.isInteger(val) || val <= 0 || val > 65535) {
-        logger.error(
-          `Invalid port: ${argv[i]}. Use an integer from 1 to 65535.`,
-        );
-        process.exit(1);
-      }
-      port = val;
-    } else if (arg === "--host" && argv[i + 1]) {
-      host = argv[++i];
-    } else if (arg === "--scan-only") {
-      scanOnly = true;
-    } else if (arg === "--debug") {
-      debug = true;
-    } else if (arg === "--config" && argv[i + 1]) {
-      configPath = argv[++i];
-    }
-  }
-
-  return { transport, scope, scanOnly, debug, port, host, configPath };
-}
-
-// ─── Startup banner ──────────────────────────────────────────
-
-function printStartupBanner(
-  skillCount: number,
-  categoryCount: number,
-  transportName: string,
-): void {
-  logger.raw("┌──────────────────────────────────────────────┐");
-  logger.raw("│  Cubis Foundry MCP Server                    │");
-  logger.raw("├──────────────────────────────────────────────┤");
-  logger.raw(`│  Vault: 2004/35/~245/~80,160/99.7%           │`);
-  logger.raw(`│  Skills loaded: ${String(skillCount).padEnd(29)}│`);
-  logger.raw(`│  Categories: ${String(categoryCount).padEnd(32)}│`);
-  logger.raw(`│  Transport: ${transportName.padEnd(33)}│`);
-  logger.raw("└──────────────────────────────────────────────┘");
-}
-
-function printConfigStatus(scope: "auto" | "global" | "project"): void {
-  try {
-    const effective = readEffectiveConfig(scope);
-    if (!effective) {
-      logger.warn(
-        "cbx_config.json not found. Postman/Stitch tools will return config-not-found errors.",
-      );
-      return;
-    }
-
-    const config = effective.config;
-
-    // Postman status
-    const postmanState = parsePostmanState(config);
-    const postmanUrl = postmanState.mcpUrl;
-    if (postmanUrl) {
-      const mode = urlToMode(postmanUrl) ?? "unknown";
-      logger.info(`Postman mode: ${mode} (${postmanUrl})`);
-    } else {
-      logger.info("Postman: not configured");
-    }
-
-    // Stitch status
-    const stitchState = parseStitchState(config);
-    const stitchProfile = stitchState.activeProfileName;
-    if (stitchProfile && stitchState.activeProfile?.url) {
-      const url = stitchState.activeProfile.url ?? "(no URL)";
-      logger.info(`Stitch profile: ${stitchProfile} (${url})`);
-    } else {
-      logger.info("Stitch: not configured");
-    }
-
-    logger.info(`Config scope: ${effective.scope} (${effective.path})`);
-  } catch {
-    logger.warn("Failed to read cbx_config.json status");
-  }
-}
-
-// ─── Main ────────────────────────────────────────────────────
-
-async function main(): Promise<void> {
-  const args = parseArgs(process.argv);
-
-  if (args.debug) {
-    setLogLevel("debug");
-  }
-
-  // Load server config
-  const serverConfig = loadServerConfig(args.configPath);
-
-  // Resolve vault roots relative to the mcp package root.
-  // `index.ts` is in `<pkg>/src` during dev and `<pkg>/dist` after build.
-  const basePath = path.resolve(__dirname, "..");
-  const scannedSkills = await scanVaultRoots(serverConfig.vault.roots, basePath);
-  const generatedSkillManifest = await loadGeneratedSkillManifest(basePath);
-  const skills = mergeGeneratedSkillMetadata(
-    scannedSkills,
-    generatedSkillManifest,
-  );
-  const charsPerToken = serverConfig.telemetry.charsPerToken;
-  const manifest = buildManifest(skills, charsPerToken);
-  const routeManifest = await loadGeneratedRouteManifest(basePath);
-
-  // Scan-only mode: print and exit
-  if (args.scanOnly) {
-    logger.info(
-      `Scan complete: ${manifest.skills.length} skills in ${manifest.categories.length} categories`,
-    );
-    for (const cat of manifest.categories) {
-      const count = manifest.skills.filter((s) => s.category === cat).length;
-      logger.info(`  ${cat}: ${count} skills`);
-    }
-    process.exit(0);
-  }
-
-  // Print startup banner
-  const resolvedHttpPort =
-    args.port ?? serverConfig.transport.http?.port ?? 3100;
-  const transportName =
-    args.transport === "http"
-      ? `Streamable HTTP :${resolvedHttpPort}`
-      : "stdio";
-  printStartupBanner(
-    manifest.skills.length,
-    manifest.categories.length,
-    transportName,
-  );
-  printConfigStatus(args.scope);
-
-  // Connect transport
-  if (args.transport === "http") {
-    const httpOpts = {
-      port: resolvedHttpPort,
-      host: args.host ?? serverConfig.transport.http?.host ?? "127.0.0.1",
-    };
-
-    // Multi-session architecture: the factory is called once per initialize
-    // handshake. Vault/manifest/config are shared; only McpServer + tools
-    // registration is per-session (lightweight).
-    const serverFactory: McpServerFactory = async (transport) => {
-      const server = await createServer({
-        config: serverConfig,
-        manifest,
-        routeManifest,
-        defaultConfigScope: args.scope,
-      });
-      await server.connect(transport);
-      return server;
-    };
-
-    const { httpServer, closeAll } = createMultiSessionHttpServer(
-      httpOpts,
-      serverFactory,
-    );
-
-    // Graceful shutdown
-    const shutdown = async () => {
-      logger.info("Shutting down HTTP transport...");
-      await closeAll();
-      process.exit(0);
-    };
-    process.on("SIGINT", shutdown);
-    process.on("SIGTERM", shutdown);
-  } else {
-    // stdio is single-session; create one McpServer directly.
-    const mcpServer = await createServer({
-      config: serverConfig,
-      manifest,
-      routeManifest,
-      defaultConfigScope: args.scope,
-    });
-    const transport = createStdioTransport();
-    await mcpServer.connect(transport);
-
-    // Graceful shutdown
-    const shutdown = async () => {
-      logger.info("Shutting down stdio transport...");
-      await mcpServer.close();
-      process.exit(0);
-    };
-    process.on("SIGINT", shutdown);
-    process.on("SIGTERM", shutdown);
-  }
-
-  logger.info("MCP server ready. Waiting for connections...");
-}
-
-main().catch((err) => {
-  logger.error(`Fatal startup error: ${err}`);
-  process.exit(1);
-});

package/mcp/src/routes/loadGeneratedRouteManifest.ts

@@ -1,45 +0,0 @@
-/**
- * Cubis Foundry MCP Server – generated route manifest loader.
- */
-
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import type { RouteManifest } from "./types.js";
-import { logger } from "../utils/logger.js";
-
-export function createEmptyRouteManifest(): RouteManifest {
-  return {
-    $schema: "cubis-foundry-route-manifest-v1",
-    generatedAt: new Date(0).toISOString(),
-    contentHash: "missing",
-    summary: {
-      totalRoutes: 0,
-      workflows: 0,
-      agents: 0,
-    },
-    routes: [],
-  };
-}
-
-export async function loadGeneratedRouteManifest(
-  mcpPackageRoot: string,
-): Promise<RouteManifest> {
-  const filePath = path.resolve(
-    mcpPackageRoot,
-    "../workflows/workflows/agent-environment-setup/generated/route-manifest.json",
-  );
-
-  try {
-    const raw = await readFile(filePath, "utf8");
-    const parsed = JSON.parse(raw) as RouteManifest;
-    if (!Array.isArray(parsed.routes)) {
-      throw new Error("missing routes array");
-    }
-    return parsed;
-  } catch (error) {
-    logger.warn(
-      `Generated route manifest unavailable at ${filePath}: ${String(error)}`,
-    );
-    return createEmptyRouteManifest();
-  }
-}

package/mcp/src/routes/types.ts

@@ -1,42 +0,0 @@
-/**
- * Cubis Foundry MCP Server – generated route manifest types.
- */
-
-export interface RoutePlatformArtifacts {
-  workflowFile?: string;
-  promptFile?: string;
-  commandFile?: string;
-  agentFile?: string;
-  compatibilityAlias?: string;
-}
-
-export interface RouteEntry {
-  kind: "workflow" | "agent";
-  id: string;
-  command: string | null;
-  displayName: string;
-  description: string;
-  triggers: string[];
-  primaryAgent: string;
-  supportingAgents: string[];
-  primarySkills: string[];
-  supportingSkills: string[];
-  artifacts: {
-    codex?: RoutePlatformArtifacts;
-    copilot?: RoutePlatformArtifacts;
-    antigravity?: RoutePlatformArtifacts;
-    claude?: RoutePlatformArtifacts;
-  };
-}
-
-export interface RouteManifest {
-  $schema: string;
-  generatedAt: string;
-  contentHash: string;
-  summary: {
-    totalRoutes: number;
-    workflows: number;
-    agents: number;
-  };
-  routes: RouteEntry[];
-}

package/mcp/src/server.ts

@@ -1,163 +0,0 @@
-/**
- * Cubis Foundry MCP Server – server factory.
- *
- * Creates and configures the McpServer instance with built-in tools
- * (via declarative registry) plus dynamic Postman/Stitch/Playwright passthrough namespaces.
- */
-
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
-import { z } from "zod";
-import type { ServerConfig } from "./config/schema.js";
-import type { ConfigScope } from "./cbxConfig/types.js";
-import type { VaultManifest } from "./vault/types.js";
-import type { RouteManifest } from "./routes/types.js";
-import { TOOL_REGISTRY, type ToolRuntimeContext } from "./tools/registry.js";
-import {
-  callUpstreamTool,
-  discoverUpstreamCatalogs,
-} from "./upstream/passthrough.js";
-import { logger } from "./utils/logger.js";
-
-export interface CreateServerOptions {
-  config: ServerConfig;
-  manifest: VaultManifest;
-  routeManifest: RouteManifest;
-  defaultConfigScope?: ConfigScope | "auto";
-}
-
-function toolCallErrorResult({
-  service,
-  namespacedName,
-  error,
-}: {
-  service: "postman" | "stitch" | "playwright";
-  namespacedName: string;
-  error: unknown;
-}) {
-  return {
-    isError: true as const,
-    content: [
-      {
-        type: "text" as const,
-        text: JSON.stringify(
-          {
-            service,
-            tool: namespacedName,
-            error: String(error),
-          },
-          null,
-          2,
-        ),
-      },
-    ],
-  };
-}
-
-export async function createServer({
-  config,
-  manifest,
-  routeManifest,
-  defaultConfigScope = "auto",
-}: CreateServerOptions): Promise<McpServer> {
-  const server = new McpServer({
-    name: config.server.name,
-    version: config.server.version,
-  });
-
-  // ─── Built-in tools from declarative registry ─────────────
-
-  const runtimeCtx: ToolRuntimeContext = {
-    manifest,
-    routeManifest,
-    charsPerToken: config.telemetry?.charsPerToken ?? 4,
-    summaryMaxLength: config.vault.summaryMaxLength,
-    defaultConfigScope,
-  };
-
-  for (const entry of TOOL_REGISTRY) {
-    const handler = entry.createHandler(runtimeCtx);
-    // Use registerTool() with explicit config object — avoids the
-    // overload ambiguity in the deprecated tool() where empty `{}`
-    // schemas can be misinterpreted as annotations, causing tools
-    // to appear "not exposed" on some clients (e.g. Codex, Gemini).
-    server.registerTool(
-      entry.name,
-      {
-        description: entry.description,
-        inputSchema: entry.schema,
-        annotations: {},
-      },
-      handler,
-    );
-  }
-
-  logger.debug(
-    `Registered ${TOOL_REGISTRY.length} built-in tools from registry`,
-  );
-
-  // ─── Dynamic upstream passthrough tools ────────────────────
-  const upstreamCatalogs = await discoverUpstreamCatalogs(defaultConfigScope);
-  const dynamicSchema = z.object({}).passthrough();
-  const registeredDynamicToolNames = new Set<string>();
-
-  for (const catalog of [
-    upstreamCatalogs.postman,
-    upstreamCatalogs.stitch,
-    upstreamCatalogs.playwright,
-  ]) {
-    for (const tool of catalog.tools) {
-      const registrationNames = [
-        tool.namespacedName,
-        ...(tool.aliasNames || []),
-      ];
-      const uniqueRegistrationNames = [...new Set(registrationNames)];
-      for (const registrationName of uniqueRegistrationNames) {
-        if (registeredDynamicToolNames.has(registrationName)) {
-          logger.warn(
-            `Skipping duplicate dynamic tool registration name '${registrationName}' from ${catalog.service}.${tool.name}`,
-          );
-          continue;
-        }
-        registeredDynamicToolNames.add(registrationName);
-        server.registerTool(
-          registrationName,
-          {
-            description: `[${catalog.service} passthrough] ${tool.description || tool.name}`,
-            inputSchema: dynamicSchema,
-            annotations: {},
-          },
-          async (
-            args: Record<string, unknown>,
-            _extra,
-          ): Promise<CallToolResult> => {
-            try {
-              const result = await callUpstreamTool({
-                service: catalog.service,
-                name: tool.name,
-                argumentsValue:
-                  args && typeof args === "object"
-                    ? args
-                    : ({} as Record<string, unknown>),
-                scope: defaultConfigScope,
-              });
-              return {
-                ...result,
-                content: result.content ?? [],
-                isError: Boolean(result.isError),
-              };
-            } catch (error) {
-              return toolCallErrorResult({
-                service: catalog.service,
-                namespacedName: registrationName,
-                error,
-              });
-            }
-          },
-        );
-      }
-    }
-  }
-
-  return server;
-}

package/mcp/src/telemetry/tokenBudget.ts

@@ -1,120 +0,0 @@
-/**
- * Cubis Foundry MCP Server – deterministic token budget estimator.
- *
- * Estimates tokens by character count using a configurable chars/token ratio.
- * This is intentionally model-agnostic and marked as estimated.
- */
-
-export const TOKEN_ESTIMATOR_VERSION = "char-estimator-v1";
-
-export function normalizeCharsPerToken(value: number): number {
-  if (!Number.isFinite(value) || value <= 0) return 4;
-  return value;
-}
-
-export function estimateTokensFromCharCount(
-  charCount: number,
-  charsPerToken: number,
-): number {
-  const safeChars = Math.max(0, Math.ceil(charCount));
-  const ratio = normalizeCharsPerToken(charsPerToken);
-  return Math.ceil(safeChars / ratio);
-}
-
-export function estimateTokensFromText(
-  text: string,
-  charsPerToken: number,
-): number {
-  return estimateTokensFromCharCount(text.length, charsPerToken);
-}
-
-/**
- * Byte-size estimation is used for pointer-only operations where file content
- * is intentionally not loaded.
- */
-export function estimateTokensFromBytes(
-  byteCount: number,
-  charsPerToken: number,
-): number {
-  return estimateTokensFromCharCount(byteCount, charsPerToken);
-}
-
-export function estimateSavings(
-  fullCatalogEstimatedTokens: number,
-  usedEstimatedTokens: number,
-): { estimatedSavingsTokens: number; estimatedSavingsPercent: number } {
-  const full = Math.max(0, Math.ceil(fullCatalogEstimatedTokens));
-  const used = Math.max(0, Math.ceil(usedEstimatedTokens));
-  if (full <= 0) {
-    return {
-      estimatedSavingsTokens: 0,
-      estimatedSavingsPercent: 0,
-    };
-  }
-
-  const estimatedSavingsTokens = Math.max(0, full - used);
-  const estimatedSavingsPercent = Number(
-    ((estimatedSavingsTokens / full) * 100).toFixed(2),
-  );
-  return {
-    estimatedSavingsTokens,
-    estimatedSavingsPercent,
-  };
-}
-
-export interface SkillToolMetrics {
-  estimatorVersion: string;
-  charsPerToken: number;
-  fullCatalogEstimatedTokens: number;
-  responseEstimatedTokens: number;
-  responseCharacterCount: number;
-  selectedSkillsEstimatedTokens: number | null;
-  loadedSkillEstimatedTokens: number | null;
-  estimatedSavingsVsFullCatalog: number;
-  estimatedSavingsVsFullCatalogPercent: number;
-  estimated: true;
-}
-
-export function buildSkillToolMetrics({
-  charsPerToken,
-  fullCatalogEstimatedTokens,
-  responseEstimatedTokens,
-  selectedSkillsEstimatedTokens = null,
-  loadedSkillEstimatedTokens = null,
-  responseCharacterCount = 0,
-}: {
-  charsPerToken: number;
-  fullCatalogEstimatedTokens: number;
-  responseEstimatedTokens: number;
-  selectedSkillsEstimatedTokens?: number | null;
-  loadedSkillEstimatedTokens?: number | null;
-  responseCharacterCount?: number;
-}): SkillToolMetrics {
-  const usedEstimatedTokens =
-    loadedSkillEstimatedTokens ??
-    selectedSkillsEstimatedTokens ??
-    responseEstimatedTokens;
-  const savings = estimateSavings(
-    fullCatalogEstimatedTokens,
-    usedEstimatedTokens,
-  );
-
-  return {
-    estimatorVersion: TOKEN_ESTIMATOR_VERSION,
-    charsPerToken: normalizeCharsPerToken(charsPerToken),
-    fullCatalogEstimatedTokens: Math.max(0, fullCatalogEstimatedTokens),
-    responseEstimatedTokens: Math.max(0, responseEstimatedTokens),
-    responseCharacterCount: Math.max(0, responseCharacterCount),
-    selectedSkillsEstimatedTokens:
-      selectedSkillsEstimatedTokens === null
-        ? null
-        : Math.max(0, selectedSkillsEstimatedTokens),
-    loadedSkillEstimatedTokens:
-      loadedSkillEstimatedTokens === null
-        ? null
-        : Math.max(0, loadedSkillEstimatedTokens),
-    estimatedSavingsVsFullCatalog: savings.estimatedSavingsTokens,
-    estimatedSavingsVsFullCatalogPercent: savings.estimatedSavingsPercent,
-    estimated: true,
-  };
-}