@mintmcp/hosted-cli 0.0.18 → 0.0.20

package/src/containerBuilder.ts

@@ -2,6 +2,9 @@ import { type ChildProcess, execFileSync, spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import net from "node:net";
 import { setTimeout as delay } from "node:timers/promises";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 
 export interface BuildOptions {
   dockerfile?: string;
@@ -66,10 +69,7 @@ const SIZE_REJECT_BYTES = 1024 * 1024 * 1024;
 const DEFAULT_BUILD_PLATFORM = "linux/amd64";
 const DEFAULT_PROBE_PATH = "/mcp";
 const DEFAULT_PROBE_TIMEOUT_MS = 30_000;
-const LOCAL_TEST_REQUEST_TIMEOUT_MS = 5_000;
 const LOCAL_TEST_IMAGE_PREFIX = "mintmcp-local-test";
-const LOCAL_TEST_PROBE_ID = "mintmcp-local-test";
-const LOCAL_TEST_PROTOCOL_VERSION = "2025-06-18";
 const LOCAL_TEST_POLL_INTERVAL_MS = 500;
 
 export function defaultBuildPlatform(): string {
@@ -273,18 +273,14 @@ export async function smokeTestImage(
   const { logs, exitInfo } = captureContainerLogs(container);
 
   try {
-    await waitForMcpReady(
-      {
-        url,
-        probeTimeoutMs,
-      },
+    await mcpSmokeTest(
+      { url, probeTimeoutMs },
       {
         fetch: deps.fetch,
         sleep: deps.sleep,
         getExitInfo: () => exitInfo.value,
       },
     );
-    console.log(`Local MCP probe succeeded: ${url}`);
     return { containerName, imageRef: options.imageRef, url };
   } catch (error) {
     const message = formatSmokeTestFailureMessage(error, logs.join(""));
@@ -426,7 +422,7 @@ function captureContainerLogs(container: ChildProcess): {
   return { logs, exitInfo };
 }
 
-async function waitForMcpReady(
+async function mcpSmokeTest(
   params: { url: string; probeTimeoutMs: number },
   deps: {
     fetch: typeof fetch;
@@ -437,6 +433,8 @@ async function waitForMcpReady(
   },
 ): Promise<void> {
   const deadline = Date.now() + params.probeTimeoutMs;
+  const requiredSessions = 2;
+
   while (Date.now() < deadline) {
     const exitInfo = deps.getExitInfo();
     if (exitInfo) {
@@ -446,61 +444,38 @@ async function waitForMcpReady(
     }
 
     try {
-      const response = await deps.fetch(params.url, {
-        method: "POST",
-        headers: {
-          "content-type": "application/json",
-          accept: "application/json, text/event-stream",
-          connection: "close",
-        },
-        signal: AbortSignal.timeout(
-          Math.min(
-            LOCAL_TEST_REQUEST_TIMEOUT_MS,
-            Math.max(1, deadline - Date.now()),
-          ),
-        ),
-        body: JSON.stringify({
-          jsonrpc: "2.0",
-          id: LOCAL_TEST_PROBE_ID,
-          method: "initialize",
-          params: {
-            protocolVersion: LOCAL_TEST_PROTOCOL_VERSION,
-            capabilities: {},
-            clientInfo: {
-              name: "MintMCP Local Probe",
-              version: "1.0.0",
-            },
+      for (
+        let sessionIndex = 0;
+        sessionIndex < requiredSessions;
+        sessionIndex++
+      ) {
+        const client = new Client({
+          name: "MintMCP Local Probe",
+          version: "1.0.0",
+        });
+        const transport = new StreamableHTTPClientTransport(
+          new URL(params.url),
+          {
+            fetch: deps.fetch,
           },
-        }),
-      });
-      if (response.status !== 200 && response.status !== 202) {
-        throw new Error(`Probe returned HTTP ${response.status}`);
-      }
+        );
 
-      let responseBody = "";
-      if (response.body != undefined) {
-        const reader = response.body.getReader();
         try {
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) {
-              break;
-            }
-            responseBody += Buffer.from(value).toString("utf8");
-            if (isInitializeSuccessResponse(responseBody)) {
-              await reader.cancel().catch(() => undefined);
-              return;
-            }
-          }
+          await client.connect(transport as Transport);
+          console.log(
+            `Local MCP initialize succeeded (${sessionIndex + 1}/${requiredSessions}): ${params.url}`,
+          );
+
+          const toolsResult = await client.listTools();
+          console.log(
+            `Local tools/list succeeded (${sessionIndex + 1}/${requiredSessions}): ${toolsResult.tools.length} tool(s) found`,
+          );
         } finally {
-          reader.releaseLock();
+          await client.close();
         }
       }
 
-      if (isInitializeSuccessResponse(responseBody)) {
-        return;
-      }
-      throw new Error("Probe returned an unexpected JSON-RPC payload");
+      return;
     } catch {
       const exitInfo = deps.getExitInfo();
       if (exitInfo) {
@@ -517,43 +492,6 @@ async function waitForMcpReady(
   );
 }
 
-function isInitializeSuccessResponse(bodyText: string): boolean {
-  const parseCandidate = (candidate: string): boolean => {
-    try {
-      const parsed = JSON.parse(candidate) as {
-        jsonrpc?: unknown;
-        id?: unknown;
-        result?: unknown;
-        error?: unknown;
-      };
-      return (
-        parsed.jsonrpc === "2.0" &&
-        parsed.id === LOCAL_TEST_PROBE_ID &&
-        parsed.error == undefined &&
-        typeof parsed.result === "object" &&
-        parsed.result != undefined
-      );
-    } catch {
-      return false;
-    }
-  };
-
-  const trimmed = bodyText.trim();
-  if (trimmed.length === 0) {
-    return false;
-  }
-  if (parseCandidate(trimmed)) {
-    return true;
-  }
-
-  const lines = trimmed
-    .split(/\r?\n/)
-    .map((line) => line.trim())
-    .filter((line) => line.length > 0)
-    .map((line) => (line.startsWith("data:") ? line.slice(5).trim() : line));
-  return lines.some((line) => parseCandidate(line));
-}
-
 async function stopContainer(
   containerName: string,
   deps: ContainerBuilderDeps,

package/src/index.ts

@@ -14,6 +14,7 @@ import z, { ZodSchema } from "zod";
 import {
   type AppRouter,
   type GatewayId,
+  GatewayIdSchema,
   HostedIdSchema,
   type HostedTransport,
   UserConfigUpdateSchema,
@@ -86,6 +87,10 @@ const HOSTED_CONFIG_PATHS: Record<Env, string> = {
 const HostedConfigBaseSchema = z.object({
   hostedId: HostedIdSchema,
 
+  // Gateway ID for this hosted server. Newer config files include this;
+  // older ones may omit it. Eventually this becomes the primary identifier.
+  gatewayId: GatewayIdSchema.optional(),
+
   // Organization that owns this hosted server. Older config files may omit it.
   organizationId: z.string().optional(),
 });
@@ -112,11 +117,27 @@ type DeployResult = {
 
 type RegistryPushSession =
   CliClientAppRouterOutputs["mcpHost"]["createRegistryPushSession"];
+type RegistryPushImageRefInput = Pick<
+  RegistryPushSession,
+  "registryHost" | "repository" | "imageTag"
+>;
 
 function storedTransport(config: HostedConfig): Transport | undefined {
   return "mode" in config ? config.transport : undefined;
 }
 
+function localTransportFromHostedTransport(
+  transport: HostedTransport,
+): Transport {
+  return transport.type;
+}
+
+function rejectBuildAndPushTransportChange(transport: Transport): never {
+  throw new Error(
+    `--transport ${transport} is only supported when creating a new managed connector with build-and-push. To change transport on an existing connector, use deploy or build-and-deploy.`,
+  );
+}
+
 function canUseDirectImageStartup(params: {
   transport: Transport | undefined;
   mntDataDir: string | undefined;
@@ -316,6 +337,7 @@ async function createNew(
   return {
     config: HostedConfigSchema.parse({
       hostedId: createdServer.hostedId,
+      gatewayId: createdServer.gatewayId,
       ...(image != undefined
         ? { mode: "container" as const, image, transport }
         : {}),
@@ -332,6 +354,7 @@ async function updateExisting(
   config: HostedConfig,
   organizationId: string,
   options: DeployOptions,
+  gatewayId?: GatewayId,
 ): Promise<DeployResult> {
   if (
     config.organizationId != undefined &&
@@ -390,12 +413,18 @@ async function updateExisting(
       : undefined;
   const updatedServer = await client.mcpHost.partialUpdateServer.mutate({
     hostedId: config.hostedId,
+    ...(gatewayId != undefined ? { gatewayId } : {}),
     update: buildPartialUpdate(options, upload?.secretDataZipGcsPath, {
       clearCommand,
     }),
   });
   return {
-    config: newConfig,
+    config: HostedConfigSchema.parse({
+      ...newConfig,
+      ...(updatedServer.gatewayId != undefined
+        ? { gatewayId: updatedServer.gatewayId }
+        : {}),
+    }),
     ...(updatedServer.gatewayId != undefined
       ? { gatewayId: updatedServer.gatewayId }
       : {}),
@@ -437,7 +466,7 @@ function updateConfigAfterManagedPush(
   });
 }
 
-function managedRegistryImageRef(session: RegistryPushSession): string {
+function managedRegistryImageRef(session: RegistryPushImageRefInput): string {
   return `${session.registryHost}/${session.repository}:${session.imageTag}`;
 }
 
@@ -445,6 +474,7 @@ async function buildAndPushManagedImage(params: {
   client: AuthenticatedClient;
   organizationId: string;
   config: HostedConfig;
+  gatewayId?: GatewayId;
   dockerfile: string;
   context: string;
   buildArg: string[];
@@ -462,6 +492,7 @@ async function buildAndPushManagedImage(params: {
 
   const session = await params.client.mcpHost.createRegistryPushSession.mutate({
     hostedId: params.config.hostedId,
+    ...(params.gatewayId != undefined ? { gatewayId: params.gatewayId } : {}),
   });
 
   const deployImageRef = managedRegistryImageRef(session);
@@ -479,15 +510,22 @@ async function buildAndPushManagedImage(params: {
 
   const finalized = await params.client.mcpHost.finalizeRegistryPush.mutate({
     hostedId: params.config.hostedId,
+    ...(params.gatewayId != undefined ? { gatewayId: params.gatewayId } : {}),
     finalizeToken: session.finalizeToken,
   });
 
+  const updatedConfig = updateConfigAfterManagedPush(
+    params.config,
+    params.organizationId,
+    deployImageRef,
+  );
   return {
-    config: updateConfigAfterManagedPush(
-      params.config,
-      params.organizationId,
-      deployImageRef,
-    ),
+    config: HostedConfigSchema.parse({
+      ...updatedConfig,
+      ...(finalized.gatewayId != undefined
+        ? { gatewayId: finalized.gatewayId }
+        : {}),
+    }),
     ...(finalized.gatewayId != undefined
       ? { gatewayId: finalized.gatewayId }
       : {}),
@@ -567,6 +605,7 @@ async function buildAndPushManagedImageForCreate(params: {
   return {
     config: HostedConfigSchema.parse({
       hostedId: finalized.hostedId,
+      gatewayId: finalized.gatewayId,
       organizationId: params.organizationId,
       mode: "container" as const,
       image: deployImageRef,
@@ -582,24 +621,71 @@ async function deployWithOptions(
   env: Env,
   base: string,
   options: DeployOptions,
+  gatewayId?: GatewayId,
 ): Promise<void> {
   const auth = await getAuth(env);
 
   await withAuthRetry(env, async (client) => {
     const configPath = path.join(base, HOSTED_CONFIG_PATHS[env]);
+    const hasExistingConfig = fs.existsSync(configPath);
 
     let result: DeployResult;
-    if (fs.existsSync(configPath)) {
-      console.log("Updating existing server...");
+    if (hasExistingConfig) {
       const configData = fs.readFileSync(configPath, "utf8");
+      const config = HostedConfigSchema.parse(JSON.parse(configData));
+      if (
+        gatewayId != undefined &&
+        config.gatewayId != undefined &&
+        config.gatewayId !== gatewayId
+      ) {
+        throw new Error(
+          `--gateway-id ${gatewayId} does not match the gatewayId in ${configPath} (${config.gatewayId}). Remove ${configPath} or omit --gateway-id.`,
+        );
+      }
+      console.log("Updating existing server...");
       result = await updateExisting(
         client,
         base,
-        HostedConfigSchema.parse(JSON.parse(configData)),
+        config,
         auth.organizationId,
         options,
+        gatewayId,
       );
       logDeployResult(env, "Updated", result);
+    } else if (gatewayId != undefined) {
+      console.log(`Updating existing server via gateway ${gatewayId}...`);
+      const upload =
+        options.mntDataDir != undefined
+          ? await uploadData(client, path.join(base, options.mntDataDir))
+          : undefined;
+      const updatedServer = await client.mcpHost.partialUpdateServer.mutate({
+        gatewayId,
+        update: buildPartialUpdate(options, upload?.secretDataZipGcsPath),
+      });
+      const resolvedGatewayId = updatedServer.gatewayId ?? gatewayId;
+      const finalImage = updatedServer.config.image;
+      const finalTransport = localTransportFromHostedTransport(
+        updatedServer.config.transport,
+      );
+      result = {
+        config: HostedConfigSchema.parse({
+          hostedId: updatedServer.hostedId,
+          gatewayId: resolvedGatewayId,
+          organizationId: auth.organizationId,
+          ...(finalImage != undefined
+            ? {
+                mode: "container" as const,
+                image: finalImage,
+                transport: finalTransport,
+              }
+            : {}),
+          ...(options.mntDataDir != undefined
+            ? { mntDataDir: options.mntDataDir }
+            : {}),
+        }),
+        gatewayId: resolvedGatewayId,
+      };
+      logDeployResult(env, "Updated", result);
     } else {
       console.log("Creating new server...");
       result = await createNew(client, base, auth.organizationId, options);
@@ -750,9 +836,14 @@ program
     "--mnt-data-dir <directory>",
     `Directory to copy to /mnt on the server. ${makeDefaultMessage("mntDataDir")}`,
   )
+  .option(
+    "--gateway-id <id>",
+    "Gateway ID of an existing connector to update. Use when no local hosted config exists.",
+    argParser(GatewayIdSchema),
+  )
   .action(async (options) => {
     const { env, base } = program.opts();
-    await deployWithOptions(env, base, options);
+    await deployWithOptions(env, base, options, options.gatewayId);
   });
 
 program
@@ -858,6 +949,11 @@ program
     "--startup-command <command>",
     "Startup command to configure when creating a new managed connector",
   )
+  .option(
+    "--gateway-id <id>",
+    "Gateway ID of an existing connector to update. Use when no local hosted config exists.",
+    argParser(GatewayIdSchema),
+  )
   .action(async (options) => {
     const { env, base } = program.opts();
 
@@ -876,13 +972,28 @@ program
 
     const result = await withAuthRetry(env, async (client) => {
       if (hasExistingConfig) {
+        if (options.transport != undefined) {
+          rejectBuildAndPushTransportChange(options.transport);
+        }
         const config = HostedConfigSchema.parse(
           JSON.parse(fs.readFileSync(configPath, "utf8")),
         );
+        if (
+          options.gatewayId != undefined &&
+          config.gatewayId != undefined &&
+          config.gatewayId !== options.gatewayId
+        ) {
+          throw new Error(
+            `--gateway-id ${options.gatewayId} does not match the gatewayId in ${configPath} (${config.gatewayId}). Remove ${configPath} or omit --gateway-id.`,
+          );
+        }
         return await buildAndPushManagedImage({
           client,
           organizationId: auth.organizationId,
           config,
+          ...(options.gatewayId != undefined
+            ? { gatewayId: options.gatewayId }
+            : {}),
           dockerfile: options.dockerfile,
           context: options.context,
           buildArg: options.buildArg,
@@ -891,6 +1002,49 @@ program
         });
       }
 
+      if (options.gatewayId != undefined) {
+        if (options.transport != undefined) {
+          rejectBuildAndPushTransportChange(options.transport);
+        }
+        const gwId = options.gatewayId;
+        const session = await client.mcpHost.createRegistryPushSession.mutate({
+          gatewayId: gwId,
+        });
+        const deployImageRef = managedRegistryImageRef(session);
+        const buildResult = buildImage({
+          dockerfile: options.dockerfile,
+          context: options.context,
+          buildArgs: options.buildArg,
+          ...(options.target != undefined ? { target: options.target } : {}),
+          platform: options.platform,
+          imageRef: deployImageRef,
+        });
+        loginToRegistry(
+          session.registryHost,
+          session.username,
+          session.password,
+        );
+        pushImage(buildResult.imageRef);
+        const finalized = await client.mcpHost.finalizeRegistryPush.mutate({
+          gatewayId: gwId,
+          finalizeToken: session.finalizeToken,
+        });
+        const resolvedGatewayId = finalized.gatewayId ?? gwId;
+        return {
+          config: HostedConfigSchema.parse({
+            hostedId: finalized.hostedId,
+            gatewayId: resolvedGatewayId,
+            organizationId: auth.organizationId,
+            mode: "container" as const,
+            image: deployImageRef,
+            transport: localTransportFromHostedTransport(
+              session.currentConfig.transport,
+            ),
+          }),
+          gatewayId: resolvedGatewayId,
+        };
+      }
+
       return await buildAndPushManagedImageForCreate({
         client,
         organizationId: auth.organizationId,
@@ -954,6 +1108,11 @@ program
     "--mnt-data-dir <directory>",
     `Directory to copy to /mnt on the server. ${makeDefaultMessage("mntDataDir")}`,
   )
+  .option(
+    "--gateway-id <id>",
+    "Gateway ID of an existing connector to update. Use when no local hosted config exists.",
+    argParser(GatewayIdSchema),
+  )
   .action(async (options) => {
     const { env, base } = program.opts();
 
@@ -978,19 +1137,24 @@ program
     pushImage(buildResult.imageRef);
     assertImageSupportsPlatform(buildResult.imageRef, options.platform);
 
-    await deployWithOptions(env, base, {
-      image: buildResult.imageRef,
-      ...(options.name != undefined ? { name: options.name } : {}),
-      ...(options.transport != undefined
-        ? { transport: options.transport }
-        : {}),
-      ...(options.startupCommand != undefined
-        ? { startupCommand: options.startupCommand }
-        : {}),
-      ...(options.mntDataDir != undefined
-        ? { mntDataDir: options.mntDataDir }
-        : {}),
-    });
+    await deployWithOptions(
+      env,
+      base,
+      {
+        image: buildResult.imageRef,
+        ...(options.name != undefined ? { name: options.name } : {}),
+        ...(options.transport != undefined
+          ? { transport: options.transport }
+          : {}),
+        ...(options.startupCommand != undefined
+          ? { startupCommand: options.startupCommand }
+          : {}),
+        ...(options.mntDataDir != undefined
+          ? { mntDataDir: options.mntDataDir }
+          : {}),
+      },
+      options.gatewayId,
+    );
   });
 
 program
@@ -1031,4 +1195,14 @@ program
     }
   });
 
-program.parse();
+function cliErrorMessage(error: unknown): string {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
+
+void program.parseAsync(process.argv).catch((error: unknown) => {
+  console.error(cliErrorMessage(error));
+  process.exitCode = 1;
+});