@mcp-use/cli 3.3.2-canary.6 → 3.4.0-canary.0

package/dist/index.js

@@ -1369,6 +1369,80 @@ var McpUseAPI = class _McpUseAPI {
       body: JSON.stringify(body)
     });
   }
+  /** Multipart helper: POST/PUT a tarball + fields without the JSON Content-Type. */
+  async uploadMultipart(endpoint, form, timeout = 12e4) {
+    const url = `${this.baseUrl}${endpoint}`;
+    const headers = {
+      "x-mcp-creation-location": "cli"
+    };
+    if (this.apiKey) headers["x-api-key"] = this.apiKey;
+    if (this.orgId) headers["x-profile-id"] = this.orgId;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: form,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (response.status === 401) throw new ApiUnauthorizedError();
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`API request failed: ${response.status} ${errorText}`);
+      }
+      return response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error.name === "AbortError") {
+        throw new Error(`Request timeout after ${timeout / 1e3}s.`);
+      }
+      throw error;
+    }
+  }
+  /**
+   * Create a server from a source tarball deployed into the platform-managed
+   * GitHub org (no user GitHub connection required).
+   */
+  async createServerFromManagedUpload(input) {
+    const form = new FormData();
+    form.set(
+      "sourceFile",
+      new Blob([new Uint8Array(input.tarball)], { type: "application/gzip" }),
+      "source.tar.gz"
+    );
+    form.set("organizationId", input.organizationId);
+    form.set("managed", "true");
+    form.set("name", input.name);
+    form.set("repoName", input.repoName);
+    form.set("private", "true");
+    form.set("branch", input.branch ?? "main");
+    form.set("commitMessage", input.commitMessage ?? "Deploy from mcp-use CLI");
+    if (input.port != null) form.set("port", String(input.port));
+    if (input.env && Object.keys(input.env).length > 0) {
+      form.set("env", JSON.stringify(input.env));
+    }
+    return this.uploadMultipart("/servers", form);
+  }
+  /** Push a new source tarball as a commit on an existing server's repo. */
+  async pushSourceToServer(serverId, input) {
+    const form = new FormData();
+    form.set(
+      "sourceFile",
+      new Blob([new Uint8Array(input.tarball)], { type: "application/gzip" }),
+      "source.tar.gz"
+    );
+    form.set("branch", input.branch ?? "main");
+    form.set(
+      "commitMessage",
+      input.commitMessage ?? "Redeploy from mcp-use CLI"
+    );
+    return this.uploadMultipart(
+      `/servers/${encodeURIComponent(serverId)}/source`,
+      form
+    );
+  }
   async listServers(params) {
     const response = await this.request(`/servers${buildPaginationQuery(params)}`);
     return normalizePaginatedResponse(response, params);
@@ -1687,7 +1761,7 @@ async function loginCommand(options) {
       }
       return;
     }
-    if (await isLoggedIn()) {
+    if (!options?.deviceCode && await isLoggedIn()) {
       let needsReauth = false;
       try {
         await (await McpUseAPI.create()).testAuth();
@@ -1717,29 +1791,33 @@ async function loginCommand(options) {
     }
     console.log(source_default.cyan.bold("Logging in to Manufact cloud...\n"));
     const authBaseUrl = await getAuthBaseUrl();
-    const deviceResp = await requestDeviceCode(authBaseUrl);
-    const {
-      device_code,
-      user_code,
-      verification_uri,
-      verification_uri_complete,
-      interval
-    } = deviceResp;
-    const displayCode = user_code.length === 8 ? `${user_code.slice(0, 4)}-${user_code.slice(4)}` : user_code;
-    console.log(source_default.white("  Visit: ") + source_default.cyan(verification_uri));
-    console.log(source_default.white("  Code:  ") + source_default.bold.white(displayCode));
-    console.log();
-    const urlToOpen = verification_uri_complete || verification_uri;
-    try {
-      await open_default(urlToOpen);
-      console.log(source_default.gray("  Browser opened. Waiting for approval..."));
-    } catch {
-      console.log(source_default.gray("  Open the URL above in your browser."));
+    let device_code;
+    let interval;
+    if (options?.deviceCode) {
+      device_code = options.deviceCode.trim();
+      interval = 2;
+      console.log(source_default.gray("  Authenticating with provided device code..."));
+    } else {
+      const deviceResp = await requestDeviceCode(authBaseUrl);
+      device_code = deviceResp.device_code;
+      interval = deviceResp.interval || 5;
+      const { user_code, verification_uri, verification_uri_complete } = deviceResp;
+      const displayCode = user_code.length === 8 ? `${user_code.slice(0, 4)}-${user_code.slice(4)}` : user_code;
+      console.log(source_default.white("  Visit: ") + source_default.cyan(verification_uri));
+      console.log(source_default.white("  Code:  ") + source_default.bold.white(displayCode));
+      console.log();
+      const urlToOpen = verification_uri_complete || verification_uri;
+      try {
+        await open_default(urlToOpen);
+        console.log(source_default.gray("  Browser opened. Waiting for approval..."));
+      } catch {
+        console.log(source_default.gray("  Open the URL above in your browser."));
+      }
     }
     const accessToken = await pollForDeviceToken(
       authBaseUrl,
       device_code,
-      interval || 5
+      interval
     );
     console.log(source_default.gray("\n  Creating persistent API key..."));
     const api = await McpUseAPI.create();
@@ -4699,6 +4777,49 @@ ${MCP_USE_DIR}
   }
 }
 
+// src/utils/tarball.ts
+import { create } from "tar";
+var EXCLUDE_DIRS = /* @__PURE__ */ new Set([
+  ".git",
+  "node_modules",
+  "dist",
+  "build",
+  ".next",
+  ".turbo",
+  ".vercel",
+  ".cache",
+  "coverage",
+  ".mcp-use"
+]);
+async function packProjectTarball(projectDir, prefix = "app") {
+  const stream = create(
+    {
+      gzip: true,
+      cwd: projectDir,
+      prefix,
+      portable: true,
+      filter: (entryPath) => {
+        const segments = entryPath.split(/[/\\]/).filter((s) => s && s !== ".");
+        if (segments.some((seg) => EXCLUDE_DIRS.has(seg))) return false;
+        const base = segments[segments.length - 1] ?? "";
+        if (base === ".DS_Store") return false;
+        if (base === ".env" || base.startsWith(".env.")) return false;
+        return true;
+      }
+    },
+    ["."]
+  );
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks);
+}
+function sanitizeRepoName(name) {
+  const cleaned = name.trim().replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^[-.]+|[-.]+$/g, "").slice(0, 80);
+  return cleaned || "mcp-server";
+}
+
 // src/commands/deploy.ts
 async function parseEnvFile(filePath) {
   try {
@@ -5200,6 +5321,106 @@ Opening browser...`));
     return { ok: false, api: client };
   }
 }
+async function deployViaManagedUpload(api, options, ctx) {
+  const { cwd, organizationId } = ctx;
+  const projectDir = options.rootDir ? path8.resolve(cwd, options.rootDir) : cwd;
+  try {
+    await fs9.access(projectDir);
+  } catch {
+    console.log(source_default.red(`\u2717 Project directory not found: ${projectDir}`));
+    process.exit(1);
+  }
+  const isMcp = await isMcpProject(projectDir);
+  if (!isMcp && !options.yes) {
+    console.log(
+      source_default.yellow("\u26A0\uFE0F  This doesn't look like an MCP server project.")
+    );
+    const shouldContinue = await prompt(
+      source_default.white("Continue anyway? (y/n): ")
+    );
+    if (!shouldContinue) process.exit(0);
+    console.log();
+  }
+  const envVars = await buildEnvVars(options);
+  const branch = "main";
+  const projectName = options.name || await getProjectName(projectDir);
+  console.log(source_default.gray("Packaging project source..."));
+  const tarball = await packProjectTarball(projectDir);
+  console.log(
+    source_default.gray(
+      `  Archive size: ${(tarball.length / 1024 / 1024).toFixed(2)} MB`
+    )
+  );
+  if (tarball.length > 80 * 1024 * 1024) {
+    console.log(
+      source_default.red(
+        "\u2717 Project archive exceeds 80 MB. Add large/derived files to .gitignore and retry."
+      )
+    );
+    process.exit(1);
+  }
+  const existingLink = !options.new ? await getProjectLink(cwd) : null;
+  let serverId = existingLink?.serverId;
+  if (serverId) {
+    try {
+      const linked = await api.getServer(serverId);
+      if (linked.organizationId !== organizationId) serverId = void 0;
+    } catch {
+      serverId = void 0;
+    }
+  }
+  let deploymentId;
+  if (serverId) {
+    console.log(source_default.gray("Uploading source and redeploying..."));
+    if (Object.keys(envVars).length > 0) {
+      await syncEnvVarsToServer(api, serverId, envVars);
+    }
+    await api.pushSourceToServer(serverId, {
+      tarball,
+      branch,
+      commitMessage: "Redeploy from mcp-use CLI"
+    });
+    const dep = await api.createDeployment({
+      serverId,
+      branch,
+      trigger: "redeploy"
+    });
+    deploymentId = dep.id;
+    await saveProjectLink(cwd, {
+      deploymentId: dep.id,
+      deploymentName: projectName,
+      serverId,
+      linkedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  } else {
+    console.log(source_default.gray("Uploading source (no GitHub required)..."));
+    const result = await api.createServerFromManagedUpload({
+      organizationId,
+      name: projectName,
+      repoName: sanitizeRepoName(projectName),
+      tarball,
+      branch,
+      commitMessage: "Deploy from mcp-use CLI",
+      port: options.port,
+      env: Object.keys(envVars).length > 0 ? envVars : void 0
+    });
+    deploymentId = result.deploymentId ?? void 0;
+    if (result.server?.id && deploymentId) {
+      await saveProjectLink(cwd, {
+        deploymentId,
+        deploymentName: projectName,
+        serverId: result.server.id,
+        linkedAt: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  }
+  if (!deploymentId) {
+    console.log(source_default.red("\u2717 No deployment was created."));
+    process.exit(1);
+  }
+  console.log(source_default.green("\u2713 Deployment created: ") + source_default.gray(deploymentId));
+  await displayDeploymentProgress(api, deploymentId, { yes: options.yes });
+}
 async function deployCommand(options) {
   try {
     const cwd = process.cwd();
@@ -5317,6 +5538,22 @@ async function deployCommand(options) {
     }
     api = await ensureApiSessionForDeploy(api, options, resolvedOrgId);
     console.log(source_default.cyan.bold("\n\u{1F680} Deploying to Manufact cloud...\n"));
+    let useNoGithubDeploy = !!options.noGithub;
+    if (!useNoGithubDeploy && !options.new) {
+      const link = await getProjectLink(cwd);
+      if (link?.serverId) {
+        try {
+          const linked = await api.getServer(link.serverId);
+          if (linked.connectedRepository?.isManaged) useNoGithubDeploy = true;
+        } catch {
+        }
+      }
+    }
+    if (useNoGithubDeploy) {
+      const organizationId = resolvedOrgId ?? await api.resolveOrganizationId();
+      await deployViaManagedUpload(api, options, { cwd, organizationId });
+      return;
+    }
     const reauth = () => promptReauthenticateOn401(options, resolvedOrgId);
     let ghConn = await getGitHubConnectionStatusWith401Retry(
       api,
@@ -9381,18 +9618,27 @@ Looked for:
 program.command("login").description("Login to Manufact cloud").option(
   "--api-key <key>",
   "Login with an API key directly (non-interactive, for CI/CD)"
-).option("--org <slug|id|name>", "Select an organization non-interactively").action(async (opts) => {
-  try {
-    await loginCommand({ apiKey: opts.apiKey, org: opts.org });
-    process.exit(0);
-  } catch (error) {
-    console.error(
-      source_default.red.bold("\n\u2717 Login failed:"),
-      source_default.red(error instanceof Error ? error.message : "Unknown error")
-    );
-    process.exit(1);
+).option("--org <slug|id|name>", "Select an organization non-interactively").option(
+  "--device-code <code>",
+  "Authenticate with a pre-approved device code (non-interactive; e.g. from the web onboarding flow)"
+).action(
+  async (opts) => {
+    try {
+      await loginCommand({
+        apiKey: opts.apiKey,
+        org: opts.org,
+        deviceCode: opts.deviceCode
+      });
+      process.exit(0);
+    } catch (error) {
+      console.error(
+        source_default.red.bold("\n\u2717 Login failed:"),
+        source_default.red(error instanceof Error ? error.message : "Unknown error")
+      );
+      process.exit(1);
+    }
   }
-});
+);
 program.command("logout").description("Logout from Manufact cloud").action(async () => {
   await logoutCommand();
 });
@@ -9427,6 +9673,9 @@ program.command("deploy").description("Deploy MCP server from GitHub to Manufact
 ).option(
   "--start-command <cmd>",
   "Custom start command (overrides auto-detection)"
+).option(
+  "--no-github",
+  "Upload local source without connecting GitHub (repo hosted in the platform-managed org)"
 ).action(async (options) => {
   await deployCommand({
     open: options.open,
@@ -9441,7 +9690,8 @@ program.command("deploy").description("Deploy MCP server from GitHub to Manufact
     yes: options.yes,
     region: options.region,
     buildCommand: options.buildCommand,
-    startCommand: options.startCommand
+    startCommand: options.startCommand,
+    noGithub: options.github === false
   });
 });
 program.addCommand(createClientCommand());