@mcp-use/cli 3.0.1 → 3.0.2-canary.1

package/dist/index.js

@@ -1202,6 +1202,13 @@ var GitHubAuthRequiredError = class extends Error {
     this.authorizeUrl = authorizeUrl;
   }
 };
+var ApiUnauthorizedError = class extends Error {
+  status = 401;
+  constructor(message = "Your session has expired or your API key is invalid.") {
+    super(message);
+    this.name = "ApiUnauthorizedError";
+  }
+};
 var McpUseAPI = class _McpUseAPI {
   baseUrl;
   apiKey;
@@ -1243,11 +1250,7 @@ var McpUseAPI = class _McpUseAPI {
       });
       clearTimeout(timeoutId);
       if (response.status === 401) {
-        const err = new Error(
-          "Your session has expired or your API key is invalid."
-        );
-        err.status = 401;
-        throw err;
+        throw new ApiUnauthorizedError();
       }
       if (!response.ok) {
         const errorText = await response.text();
@@ -2803,23 +2806,54 @@ import { promises as fs9 } from "fs";
 import path5 from "path";
 
 // src/utils/git.ts
-import { exec } from "child_process";
+import { execFile as execFile7 } from "child_process";
 import { promisify as promisify7 } from "util";
-var execAsync = promisify7(exec);
-async function gitCommand(command, cwd = process.cwd()) {
+var execFileAsync5 = promisify7(execFile7);
+async function gitCommand(args, cwd = process.cwd()) {
   try {
-    const { stdout } = await execAsync(command, { cwd });
+    const { stdout } = await execFileAsync5("git", args, { cwd });
     return stdout.trim();
   } catch (error) {
     return null;
   }
 }
+var GitCommandError = class extends Error {
+  command;
+  stderr;
+  stdout;
+  exitCode;
+  constructor(opts) {
+    const trimmed = opts.stderr.trim() || opts.stdout.trim() || "unknown error";
+    super(`git command failed: \`${opts.command}\`
+${trimmed}`);
+    this.name = "GitCommandError";
+    this.command = opts.command;
+    this.stderr = opts.stderr;
+    this.stdout = opts.stdout;
+    this.exitCode = opts.exitCode;
+  }
+};
+async function gitCommandOrThrow(args, cwd = process.cwd()) {
+  const command = `git ${args.join(" ")}`;
+  try {
+    const { stdout } = await execFileAsync5("git", args, { cwd });
+    return stdout.trim();
+  } catch (error) {
+    const e = error;
+    throw new GitCommandError({
+      command,
+      stderr: (e.stderr ?? "").toString(),
+      stdout: (e.stdout ?? "").toString(),
+      exitCode: typeof e.code === "number" ? e.code : null
+    });
+  }
+}
 async function isGitRepo(cwd = process.cwd()) {
-  const result = await gitCommand("git rev-parse --is-inside-work-tree", cwd);
+  const result = await gitCommand(["rev-parse", "--is-inside-work-tree"], cwd);
   return result === "true";
 }
 async function getRemoteUrl(cwd = process.cwd()) {
-  return gitCommand("git config --get remote.origin.url", cwd);
+  return gitCommand(["config", "--get", "remote.origin.url"], cwd);
 }
 function parseGitHubUrl(url) {
   const sshMatch = url.match(/git@github\.com:([^/]+)\/(.+?)(?:\.git)?$/);
@@ -2834,16 +2868,16 @@ function parseGitHubUrl(url) {
   };
 }
 async function getCurrentBranch(cwd = process.cwd()) {
-  return gitCommand("git rev-parse --abbrev-ref HEAD", cwd);
+  return gitCommand(["rev-parse", "--abbrev-ref", "HEAD"], cwd);
 }
 async function getCommitSha(cwd = process.cwd()) {
-  return gitCommand("git rev-parse HEAD", cwd);
+  return gitCommand(["rev-parse", "HEAD"], cwd);
 }
 async function getCommitMessage(cwd = process.cwd()) {
-  return gitCommand("git log -1 --pretty=%B", cwd);
+  return gitCommand(["log", "-1", "--pretty=%B"], cwd);
 }
 async function hasUncommittedChanges(cwd = process.cwd()) {
-  const result = await gitCommand("git status --porcelain", cwd);
+  const result = await gitCommand(["status", "--porcelain"], cwd);
   return result !== null && result.length > 0;
 }
 async function getGitInfo(cwd = process.cwd()) {
@@ -2877,18 +2911,20 @@ async function getGitInfo(cwd = process.cwd()) {
   };
 }
 async function gitInit(cwd, message = "Initial commit") {
-  await gitCommand("git init", cwd);
-  await gitCommand("git add .", cwd);
-  await gitCommand(`git commit -m "${message}"`, cwd);
+  await gitCommandOrThrow(["init"], cwd);
+  await gitCommandOrThrow(["add", "."], cwd);
+  await gitCommandOrThrow(["commit", "-m", message], cwd);
+  await gitCommandOrThrow(["branch", "-M", "main"], cwd);
+  await gitCommandOrThrow(["rev-parse", "HEAD"], cwd);
 }
 async function gitAddRemoteAndPush(cwd, cloneUrl, branch = "main") {
-  await gitCommand(`git remote add origin ${cloneUrl}`, cwd);
-  await gitCommand(`git push -u origin ${branch}`, cwd);
+  await gitCommandOrThrow(["remote", "add", "origin", cloneUrl], cwd);
+  await gitCommandOrThrow(["push", "-u", "origin", branch], cwd);
 }
 async function gitCommitAndPush(cwd, message, branch = "main") {
-  await gitCommand("git add .", cwd);
-  await gitCommand(`git commit -m "${message}"`, cwd);
-  await gitCommand(`git push origin ${branch}`, cwd);
+  await gitCommandOrThrow(["add", "."], cwd);
+  await gitCommandOrThrow(["commit", "-m", message], cwd);
+  await gitCommandOrThrow(["push", "origin", branch], cwd);
 }
 function isGitHubUrl(url) {
   try {
@@ -3289,6 +3325,58 @@ async function displayDeploymentProgress(api, deploymentId, progressOptions) {
     source_default.gray("Check status with: ") + source_default.white(`mcp-use deployments get ${deploymentId}`)
   );
 }
+async function promptReauthenticateOn401(options, orgIdToRestore) {
+  console.log(source_default.red("\n\u2717 Session expired or API key invalid."));
+  if (options.yes) {
+    console.log(
+      source_default.gray("  Run mcp-use login to re-authenticate, then retry.")
+    );
+    process.exit(1);
+  }
+  const should = await prompt(source_default.white("Log in again? (Y/n): "), "y");
+  if (!should) {
+    process.exit(1);
+  }
+  await loginCommand({ silent: false });
+  if (!await isLoggedIn()) {
+    console.log(source_default.red("\u2717 Login failed. Please try again."));
+    process.exit(1);
+  }
+  const fresh = await McpUseAPI.create();
+  if (orgIdToRestore) {
+    fresh.setOrgId(orgIdToRestore);
+  }
+  return fresh;
+}
+async function ensureApiSessionForDeploy(api, options, orgIdToRestore) {
+  let client = api;
+  for (; ; ) {
+    try {
+      await client.testAuth();
+      return client;
+    } catch (e) {
+      if (!(e instanceof ApiUnauthorizedError)) throw e;
+      client = await promptReauthenticateOn401(options, orgIdToRestore);
+    }
+  }
+}
+async function getGitHubConnectionStatusWith401Retry(api, options, orgIdToRestore) {
+  let client = api;
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const status = await client.getGitHubConnectionStatus();
+      return { api: client, status };
+    } catch (e) {
+      if (e instanceof ApiUnauthorizedError && attempt === 0) {
+        client = await promptReauthenticateOn401(options, orgIdToRestore);
+        await client.testAuth();
+        continue;
+      }
+      throw e;
+    }
+  }
+  throw new Error("Unreachable");
+}
 async function checkRepoAccess(api, owner, repo) {
   try {
     const resp = await api.getGitHubRepos(true);
@@ -3299,6 +3387,7 @@ async function checkRepoAccess(api, owner, repo) {
 }
 async function promptGitHubInstallation(api, reason, repoName, opts) {
   const yes = !!opts?.yes;
+  const reauth = opts?.reauth;
   console.log();
   if (reason === "not_connected") {
     console.log(source_default.yellow("\u26A0\uFE0F  GitHub account not connected"));
@@ -3322,9 +3411,23 @@ async function promptGitHubInstallation(api, reason, repoName, opts) {
     ),
     "y"
   );
-  if (!shouldInstall) return false;
+  if (!shouldInstall) return { ok: false, api };
+  let client = api;
   try {
-    const appName = await api.getGitHubAppName();
+    let appName;
+    for (; ; ) {
+      try {
+        appName = await client.getGitHubAppName();
+        break;
+      } catch (e) {
+        if (e instanceof ApiUnauthorizedError && reauth) {
+          client = await reauth();
+          await client.testAuth();
+          continue;
+        }
+        throw e;
+      }
+    }
     const installUrl = `https://github.com/apps/${appName}/installations/new`;
     console.log(source_default.cyan(`
 Opening browser...`));
@@ -3348,23 +3451,34 @@ Opening browser...`));
       while (Date.now() < deadline) {
         await new Promise((r) => setTimeout(r, 2e3));
         try {
-          const status = await api.getGitHubConnectionStatus();
+          const status = await client.getGitHubConnectionStatus();
           if (status.is_connected) {
-            if (!repoName) return true;
+            if (!repoName) return { ok: true, api: client };
             const [o, r] = repoName.split("/");
-            if (o && r && await checkRepoAccess(api, o, r)) return true;
+            if (o && r && await checkRepoAccess(client, o, r)) {
+              return { ok: true, api: client };
+            }
+          }
+        } catch (e) {
+          if (e instanceof ApiUnauthorizedError && reauth) {
+            client = await reauth();
+            await client.testAuth();
+            continue;
           }
-        } catch {
         }
       }
     }
-    return true;
-  } catch {
+    return { ok: true, api: client };
+  } catch (e) {
+    if (e instanceof ApiUnauthorizedError) {
+      console.log(source_default.red("\n\u2717 Session expired or API key invalid."));
+      process.exit(1);
+    }
     console.log(source_default.yellow("\n\u26A0\uFE0F  Unable to open browser automatically"));
     console.log(
       source_default.white("Please visit: ") + source_default.cyan("https://manufact.com/cloud/settings")
     );
-    return false;
+    return { ok: false, api: client };
   }
 }
 async function deployCommand(options) {
@@ -3407,7 +3521,8 @@ async function deployCommand(options) {
         process.exit(1);
       }
     }
-    const api = await McpUseAPI.create();
+    let api = await McpUseAPI.create();
+    let resolvedOrgId;
     if (options.org) {
       const authInfo = await api.testAuth();
       const match = (authInfo.orgs ?? []).find(
@@ -3415,6 +3530,7 @@ async function deployCommand(options) {
       );
       if (match) {
         api.setOrgId(match.id);
+        resolvedOrgId = match.id;
         const slug = match.slug ? source_default.gray(` (${match.slug})`) : "";
         console.log(
           source_default.gray("Organization: ") + source_default.cyan(match.name) + slug
@@ -3453,6 +3569,7 @@ async function deployCommand(options) {
           process.exit(1);
         }
         api.setOrgId(selectedOrg.id);
+        resolvedOrgId = selectedOrg.id;
         await writeConfig({
           ...config,
           orgId: selectedOrg.id,
@@ -3463,6 +3580,8 @@ async function deployCommand(options) {
           source_default.gray("Organization: ") + source_default.cyan(selectedOrg.name)
         );
       } else {
+        resolvedOrgId = config.orgId;
+        api.setOrgId(config.orgId);
         if (config.orgName) {
           const slug = config.orgSlug ? source_default.gray(` (${config.orgSlug})`) : "";
           console.log(
@@ -3471,21 +3590,39 @@ 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 connectionStatus = await api.getGitHubConnectionStatus().catch(() => null);
-    if (!connectionStatus?.is_connected) {
+    const reauth = () => promptReauthenticateOn401(options, resolvedOrgId);
+    let ghConn = await getGitHubConnectionStatusWith401Retry(
+      api,
+      options,
+      resolvedOrgId
+    );
+    api = ghConn.api;
+    let connectionStatus = ghConn.status;
+    if (!connectionStatus.is_connected) {
       const installed = await promptGitHubInstallation(
         api,
         "not_connected",
         void 0,
-        { yes: options.yes }
+        {
+          yes: options.yes,
+          reauth
+        }
       );
-      if (!installed) {
+      if (!installed.ok) {
         console.log(source_default.gray("Deployment cancelled."));
         process.exit(0);
       }
-      connectionStatus = await api.getGitHubConnectionStatus().catch(() => null);
-      if (!connectionStatus?.is_connected) {
+      api = installed.api;
+      ghConn = await getGitHubConnectionStatusWith401Retry(
+        api,
+        options,
+        resolvedOrgId
+      );
+      api = ghConn.api;
+      connectionStatus = ghConn.status;
+      if (!connectionStatus.is_connected) {
         console.log(source_default.red("\n\u2717 GitHub connection could not be verified."));
         console.log(
           source_default.cyan(
@@ -3652,27 +3789,56 @@ async function deployCommand(options) {
         }
       }
       console.log(source_default.green(`\u2713 Created ${source_default.cyan(repoResult.fullName)}`));
-      if (!gitInfo.isGitRepo) {
-        await ensureGitignore(cwd);
-        console.log(source_default.gray("Initializing git..."));
-        await gitInit(cwd, "Initial commit");
-        console.log(source_default.gray("Pushing to GitHub..."));
-        await gitAddRemoteAndPush(cwd, repoResult.cloneUrl, "main");
-      } else {
-        if (await hasUncommittedChanges(cwd)) {
-          console.log(
-            source_default.red(
-              "\u2717 You have uncommitted changes. Commit and push before deploying."
-            )
+      try {
+        if (!gitInfo.isGitRepo) {
+          await ensureGitignore(cwd);
+          console.log(source_default.gray("Initializing git..."));
+          await gitInit(cwd, "Initial commit");
+          console.log(source_default.gray("Pushing to GitHub..."));
+          await gitAddRemoteAndPush(cwd, repoResult.cloneUrl, "main");
+        } else {
+          if (await hasUncommittedChanges(cwd)) {
+            console.log(
+              source_default.red(
+                "\u2717 You have uncommitted changes. Commit and push before deploying."
+              )
+            );
+            process.exit(1);
+          }
+          console.log(source_default.gray("Adding remote and pushing..."));
+          await gitAddRemoteAndPush(
+            cwd,
+            repoResult.cloneUrl,
+            gitInfo.branch || "main"
           );
+        }
+      } catch (err) {
+        if (err instanceof GitCommandError) {
+          console.log(source_default.red(`
+\u2717 Git step failed: \`${err.command}\``));
+          const stderrTrimmed = (err.stderr || err.stdout).trim();
+          if (stderrTrimmed) {
+            console.log(source_default.gray(stderrTrimmed));
+          }
+          if (/tell me who you are|user\.email|user\.name/i.test(err.stderr)) {
+            console.log(
+              source_default.yellow(
+                `
+  Set your git identity for this project and retry:
+    git -C ${JSON.stringify(cwd)} config user.email "you@example.com"
+    git -C ${JSON.stringify(cwd)} config user.name  "Your Name"`
+              )
+            );
+          } else if (/non-fast-forward|rejected|unrelated histories/i.test(err.stderr)) {
+            console.log(
+              source_default.yellow(
+                "\n  The remote branch already has commits. Either delete the empty GitHub repo and retry, or reconcile manually:\n    git pull --rebase origin main --allow-unrelated-histories\n    git push -u origin main"
+              )
+            );
+          }
           process.exit(1);
         }
-        console.log(source_default.gray("Adding remote and pushing..."));
-        await gitAddRemoteAndPush(
-          cwd,
-          repoResult.cloneUrl,
-          gitInfo.branch || "main"
-        );
+        throw err;
       }
       console.log(source_default.green("\u2713 Code pushed to GitHub\n"));
       gitInfo = await getGitInfo(cwd);
@@ -3735,11 +3901,16 @@ async function deployCommand(options) {
           api,
           "no_access",
           repoFullName,
-          { yes: options.yes, installationId: githubInstallationId }
+          {
+            yes: options.yes,
+            installationId: githubInstallationId,
+            reauth: () => promptReauthenticateOn401(options, resolvedOrgId)
+          }
         );
-        if (!configured) {
+        if (!configured.ok) {
           process.exit(0);
         }
+        api = configured.api;
         const retry = await checkRepoAccess(api, gitInfo.owner, gitInfo.repo);
         if (!retry) {
           const appName = await api.getGitHubAppName();