@sudajs/cli 0.15.0 → 0.16.0

package/dist/index.js

@@ -15,6 +15,7 @@ import { build } from 'esbuild';
 import { z } from 'zod';
 import os from 'os';
 import pc from 'picocolors';
+import readline from 'readline';
 
 var style = {
   success: pc.green,
@@ -24,7 +25,8 @@ var style = {
   url: pc.cyan,
   code: pc.bold,
   value: pc.bold,
-  path: pc.magenta
+  path: pc.magenta,
+  selected: (value) => pc.bgCyan(pc.black(value))
 };
 function success(message) {
   return style.success(message);
@@ -41,72 +43,306 @@ function info(message) {
 function themeRef(key, version) {
   return style.value(`${key}@${version}`);
 }
+var selectChoice = async (message, choices, defaultValue) => {
+  if (choices.length === 0) {
+    throw new Error("No choices are available.");
+  }
+  const defaultIndex = Math.max(
+    0,
+    choices.findIndex((choice) => choice.value === defaultValue)
+  );
+  const fallback = choices[defaultIndex];
+  if (choices.length === 1 || !process.stdin.isTTY || !process.stdout.isTTY) {
+    return fallback.value;
+  }
+  const input = process.stdin;
+  const output = process.stdout;
+  const wasRaw = input.isRaw;
+  const wasFlowing = input.readableFlowing;
+  let selectedIndex = defaultIndex;
+  readline.emitKeypressEvents(input);
+  input.setRawMode(true);
+  input.resume();
+  const render = (replace) => {
+    if (replace) {
+      readline.moveCursor(output, 0, -(choices.length + 1));
+      readline.cursorTo(output, 0);
+      readline.clearScreenDown(output);
+    }
+    output.write(`${style.info("?")} ${message}
+`);
+    for (const [index, choice] of choices.entries()) {
+      if (index === selectedIndex) {
+        output.write(`${style.info("\u276F")} ${style.selected(` ${choice.label} `)}
+`);
+      } else {
+        output.write(`  ${choice.label}
+`);
+      }
+    }
+  };
+  render(false);
+  return new Promise((resolve, reject) => {
+    const cleanup = () => {
+      input.off("keypress", onKeypress);
+      input.setRawMode(wasRaw);
+      if (wasFlowing !== true) {
+        input.pause();
+      }
+    };
+    const finish = () => {
+      readline.moveCursor(output, 0, -(choices.length + 1));
+      readline.cursorTo(output, 0);
+      readline.clearScreenDown(output);
+      const selected = choices[selectedIndex];
+      output.write(`${success("\u2714")} ${message} ${style.url(selected.value)}
+`);
+      cleanup();
+      resolve(selected.value);
+    };
+    const onKeypress = (_character, key) => {
+      if (key.ctrl === true && key.name === "c") {
+        cleanup();
+        reject(new Error("Host selection cancelled."));
+        return;
+      }
+      if (key.name === "return" || key.name === "enter") {
+        finish();
+        return;
+      }
+      if (key.name === "up") {
+        selectedIndex = (selectedIndex - 1 + choices.length) % choices.length;
+        render(true);
+        return;
+      }
+      if (key.name === "down") {
+        selectedIndex = (selectedIndex + 1) % choices.length;
+        render(true);
+      }
+    };
+    input.on("keypress", onKeypress);
+  });
+};
 
 // src/auth.ts
+var DEFAULT_HOST = "app.sudayun.cn";
+var GLOBAL_HOST = "app.sudaweb.ai";
+var officialHostChoices = [
+  { label: `\u56FD\u5185(${DEFAULT_HOST})`, value: DEFAULT_HOST },
+  { label: `\u6D77\u5916(${GLOBAL_HOST})`, value: GLOBAL_HOST }
+];
+var credentialSchema = z.object({
+  sessionToken: z.string().min(1)
+});
+var authStoreSchema = z.object({
+  currentHost: z.string().min(1).optional(),
+  hosts: z.record(z.string().min(1), credentialSchema)
+});
+var legacyAuthConfigSchema = z.object({
+  sessionToken: z.string().min(1),
+  host: z.string().min(1)
+});
 function getConfigPath() {
   return path2.join(os.homedir(), ".config", "suda", "config.json");
 }
-async function readAuthConfig() {
+function normalizeHost(value) {
+  const host = value.trim();
+  if (host.length === 0 || host.includes("://") || /[/?#@]/.test(host)) {
+    throw new Error(`Invalid host "${value}". Use a bare host name such as ${DEFAULT_HOST}.`);
+  }
+  try {
+    return new URL(`https://${host}`).host;
+  } catch {
+    throw new Error(`Invalid host "${value}". Use a bare host name such as ${DEFAULT_HOST}.`);
+  }
+}
+function protocolForHost(host) {
+  const hostname = new URL(`https://${host}`).hostname;
+  return hostname === "localhost" || hostname === "127.0.0.1" ? "http" : "https";
+}
+function baseUrlForHost(host) {
+  return `${protocolForHost(host)}://${host}`;
+}
+function parseAuthStore(value) {
+  const current = authStoreSchema.safeParse(value);
+  if (current.success) {
+    const hosts = {};
+    for (const [host2, credential] of Object.entries(current.data.hosts)) {
+      hosts[normalizeHost(host2)] = credential;
+    }
+    const store = { hosts };
+    if (current.data.currentHost !== void 0) {
+      store.currentHost = normalizeHost(current.data.currentHost);
+    }
+    return store;
+  }
+  const legacy = legacyAuthConfigSchema.parse(value);
+  const host = normalizeHost(legacy.host);
+  return {
+    currentHost: host,
+    hosts: {
+      [host]: { sessionToken: legacy.sessionToken }
+    }
+  };
+}
+async function readAuthStore() {
   try {
-    const configPath = getConfigPath();
-    const content = await fs.readFile(configPath, "utf-8");
-    return JSON.parse(content);
+    const content = await fs.readFile(getConfigPath(), "utf8");
+    return parseAuthStore(JSON.parse(content));
   } catch {
     return null;
   }
 }
-async function writeAuthConfig(config) {
+async function writeAuthStore(store) {
+  const validated = authStoreSchema.parse(store);
   const configPath = getConfigPath();
   await fs.mkdir(path2.dirname(configPath), { recursive: true });
   await fs.chmod(path2.dirname(configPath), 448).catch(() => void 0);
-  await fs.writeFile(configPath, JSON.stringify(config, null, 2), { mode: 384 });
+  await fs.writeFile(configPath, `${JSON.stringify(validated, null, 2)}
+`, { mode: 384 });
+  await fs.chmod(configPath, 384).catch(() => void 0);
 }
-async function clearAuthConfig() {
-  const configPath = getConfigPath();
+async function removeConfigFile() {
   try {
-    await fs.unlink(configPath);
+    await fs.unlink(getConfigPath());
   } catch (err) {
     if (err instanceof Error && "code" in err && err.code !== "ENOENT") {
       throw err;
     }
   }
 }
-function protocolForHost(host) {
-  return host.includes("localhost") || host.includes("127.0.0.1") ? "http" : "https";
+async function saveCredential(hostValue, sessionToken) {
+  const host = normalizeHost(hostValue);
+  const store = await readAuthStore() ?? { hosts: {} };
+  store.hosts[host] = credentialSchema.parse({ sessionToken });
+  store.currentHost = host;
+  await writeAuthStore(store);
+  return { host, sessionToken, baseUrl: baseUrlForHost(host) };
 }
-var CliAuthExpiredError = class extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.name = "CliAuthExpiredError";
-    this.code = code;
+async function removeCredential(hostValue) {
+  const host = normalizeHost(hostValue);
+  const store = await readAuthStore();
+  if (!store?.hosts[host]) {
+    return;
   }
-};
-async function cliAuthFetch(pathname, init = {}) {
-  const config = await readAuthConfig();
-  if (!config) {
+  delete store.hosts[host];
+  if (store.currentHost === host) {
+    delete store.currentHost;
+  }
+  if (Object.keys(store.hosts).length === 0) {
+    await removeConfigFile();
+    return;
+  }
+  await writeAuthStore(store);
+}
+function hostLabel(host) {
+  if (host === DEFAULT_HOST) {
+    return `\u56FD\u5185(${host})`;
+  }
+  if (host === GLOBAL_HOST) {
+    return `\u6D77\u5916(${host})`;
+  }
+  return host;
+}
+function createHostChoices(hosts) {
+  return hosts.map((host) => ({ label: hostLabel(host), value: host }));
+}
+async function resolveLoginHost(hostValue, prompt = selectChoice) {
+  if (hostValue !== void 0) {
+    return normalizeHost(hostValue);
+  }
+  const store = await readAuthStore();
+  const hosts = new Set(officialHostChoices.map((choice) => choice.value));
+  for (const host of Object.keys(store?.hosts ?? {})) {
+    hosts.add(host);
+  }
+  const defaultHost = store?.currentHost ?? DEFAULT_HOST;
+  return prompt("Select a SudaCloud host to log in to:", createHostChoices([...hosts]), defaultHost);
+}
+async function resolveAuthenticatedHost(hostValue, message, prompt = selectChoice) {
+  if (hostValue !== void 0) {
+    return normalizeHost(hostValue);
+  }
+  const store = await readAuthStore();
+  const hosts = Object.keys(store?.hosts ?? {}).sort();
+  if (hosts.length === 0) {
+    return void 0;
+  }
+  return prompt(message, createHostChoices(hosts), store?.currentHost ?? hosts[0]);
+}
+async function readAuthConfig(hostValue) {
+  const store = await readAuthStore();
+  if (!store) {
+    return null;
+  }
+  const host = hostValue !== void 0 ? normalizeHost(hostValue) : store.currentHost;
+  if (host === void 0) {
+    return null;
+  }
+  const credential = store.hosts[host];
+  if (!credential) {
+    return null;
+  }
+  return {
+    host,
+    sessionToken: credential.sessionToken,
+    baseUrl: baseUrlForHost(host)
+  };
+}
+async function requireAuthConfig(hostValue) {
+  const config = await readAuthConfig(hostValue);
+  if (config) {
+    return config;
+  }
+  if (hostValue !== void 0) {
+    const host = normalizeHost(hostValue);
+    throw new Error(
+      `Not logged in to ${host}. Run \`suda auth login --host ${host}\` to authenticate first.`
+    );
+  }
+  throw new Error(
+    "No current authenticated host. Run `suda auth login` or `suda host switch <host>` first."
+  );
+}
+async function selectAuthConfig(hostValue, message) {
+  const host = await resolveAuthenticatedHost(hostValue, message);
+  return requireAuthConfig(host);
+}
+async function cliAuthFetch(pathname, init = {}, hostValue) {
+  let config;
+  try {
+    config = await requireAuthConfig(hostValue);
+  } catch (err) {
     throw new CliAuthExpiredError(
       "unauthorized",
-      "Not logged in. Run `suda auth login` to authenticate first."
+      err instanceof Error ? err.message : "Not logged in. Run `suda auth login` first."
     );
   }
-  const baseUrl = `${protocolForHost(config.host)}://${config.host}`;
   const headers = new Headers(init.headers);
   headers.set("Authorization", `Bearer ${config.sessionToken}`);
-  const res = await fetch(`${baseUrl}${pathname}`, { ...init, headers });
+  const res = await fetch(`${config.baseUrl}${pathname}`, { ...init, headers });
   if (res.status === 401) {
     const body = await res.clone().json().catch(() => ({}));
     const code = ["token_invalid", "token_revoked", "token_expired"].includes(body.error ?? "") ? body.error : "unauthorized";
-    await clearAuthConfig();
+    await removeCredential(config.host);
     throw new CliAuthExpiredError(
       code,
-      body.message ?? "Authentication is no longer valid. Run `suda auth login` to authenticate again."
+      body.message ?? `Authentication for ${config.host} is no longer valid. Run \`suda auth login --host ${config.host}\` to authenticate again.`
     );
   }
   return res;
 }
-async function login(host = "app.sudayun.cn") {
-  const baseUrl = `${protocolForHost(host)}://${host}`;
+var CliAuthExpiredError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "CliAuthExpiredError";
+    this.code = code;
+  }
+};
+async function login(hostValue) {
+  const host = await resolveLoginHost(hostValue);
+  const baseUrl = baseUrlForHost(host);
   console.log(`Requesting device authorization from ${style.url(baseUrl)}...`);
   const deviceRes = await fetch(`${baseUrl}/api/cli-auth/device`, {
     method: "POST"
@@ -116,9 +352,7 @@ async function login(host = "app.sudayun.cn") {
   }
   const { deviceCode, userCode, verificationUri, interval, expiresIn } = await deviceRes.json();
   const authUrl = `${verificationUri}?code=${userCode}`;
-  console.log(`
-Please open the following URL in your browser to authorize Suda CLI:
-`);
+  console.log("\nPlease open the following URL in your browser to authorize Suda CLI:\n");
   console.log(`  ${style.url(authUrl)}
 `);
   console.log(`Your confirmation code is: ${style.code(userCode)}
@@ -141,8 +375,8 @@ Please open the following URL in your browser to authorize Suda CLI:
     });
     const data = await pollRes.json();
     if (pollRes.ok && data.status === "approved" && data.token) {
-      await writeAuthConfig({ sessionToken: data.token, host });
-      console.log(success("Successfully authorized!"));
+      await saveCredential(host, data.token);
+      console.log(success(`Successfully authorized ${style.url(host)} and set it as current.`));
       return;
     }
     if (data.error === "authorization_pending") {
@@ -152,15 +386,17 @@ Please open the following URL in your browser to authorize Suda CLI:
   }
   throw new Error("Authorization timed out.");
 }
-async function status() {
-  const config = await readAuthConfig();
-  if (!config) {
-    console.log(warning("Not logged in. Run `suda auth login` to authenticate."));
+async function status(hostValue) {
+  let config;
+  try {
+    config = await selectAuthConfig(hostValue, "Select a host to check:");
+  } catch (err) {
+    console.log(warning(err instanceof Error ? err.message : "Not logged in."));
     return;
   }
   let res;
   try {
-    res = await cliAuthFetch("/api/cli-auth/whoami");
+    res = await cliAuthFetch("/api/cli-auth/whoami", {}, config.host);
   } catch (err) {
     if (err instanceof CliAuthExpiredError) {
       console.log(warning(err.message));
@@ -171,7 +407,9 @@ async function status() {
   }
   if (!res.ok) {
     console.error(
-      error(`Failed to verify session (${res.status} ${res.statusText}). Try again later.`)
+      error(
+        `Failed to verify session on ${config.host} (${res.status} ${res.statusText}). Try again later.`
+      )
     );
     return;
   }
@@ -179,27 +417,65 @@ async function status() {
   const label = data.user?.email ?? data.user?.name ?? "your account";
   console.log(success(`Logged in as ${style.value(label)} on ${style.url(config.host)}`));
 }
-async function logout() {
-  const config = await readAuthConfig();
-  if (!config) {
-    console.log(warning("Not logged in."));
+async function logout(hostValue) {
+  let config;
+  try {
+    config = await selectAuthConfig(hostValue, "Select a host to log out from:");
+  } catch (err) {
+    console.log(warning(err instanceof Error ? err.message : "Not logged in."));
     return;
   }
   try {
-    await cliAuthFetch("/api/cli-auth/revoke", { method: "POST" });
+    await cliAuthFetch("/api/cli-auth/revoke", { method: "POST" }, config.host);
   } catch (err) {
     if (err instanceof CliAuthExpiredError) {
-      console.log(warning("Logged out (token was already invalid)."));
+      console.log(warning(`Logged out from ${config.host} (token was already invalid).`));
       return;
     }
     console.warn(
       warning(
-        `Could not contact ${config.host} to revoke token. The token will be cleared locally only.`
+        `Could not contact ${config.host} to revoke token. Its credential will be cleared locally only.`
       )
     );
   }
-  await clearAuthConfig();
-  console.log(success("Logged out successfully."));
+  await removeCredential(config.host);
+  console.log(success(`Logged out from ${style.url(config.host)} successfully.`));
+}
+async function showCurrentHost() {
+  const store = await readAuthStore();
+  if (!store?.currentHost || !store.hosts[store.currentHost]) {
+    console.log(
+      warning("No current authenticated host. Run `suda auth login` or `suda host switch <host>` first.")
+    );
+    return;
+  }
+  console.log(`Current host: ${style.url(store.currentHost)}`);
+}
+async function listHosts() {
+  const store = await readAuthStore();
+  const hosts = Object.keys(store?.hosts ?? {}).sort();
+  if (hosts.length === 0) {
+    console.log(warning("No authenticated hosts. Run `suda auth login` first."));
+    return;
+  }
+  console.log("Authenticated hosts:");
+  for (const host of hosts) {
+    const marker = host === store?.currentHost ? success("*") : " ";
+    const suffix = host === store?.currentHost ? style.value(" (current)") : "";
+    console.log(`  ${marker} ${style.url(host)}${suffix}`);
+  }
+}
+async function switchHost(hostValue) {
+  const host = normalizeHost(hostValue);
+  const store = await readAuthStore();
+  if (!store?.hosts[host]) {
+    throw new Error(
+      `Not logged in to ${host}. Run \`suda auth login --host ${host}\` to authenticate first.`
+    );
+  }
+  store.currentHost = host;
+  await writeAuthStore(store);
+  console.log(success(`Switched current host to ${style.url(host)}.`));
 }
 
 // src/index.ts
@@ -732,16 +1008,10 @@ async function readJsonIfExists(filePath) {
   }
   return readJson(filePath);
 }
-function protocolForHost2(host) {
-  return host.includes("localhost") || host.includes("127.0.0.1") ? "http" : "https";
-}
 async function requireCliBaseUrl() {
-  const config = await readAuthConfig();
-  if (!config) {
-    throw new Error("Not logged in. Run `suda auth login` to authenticate first.");
-  }
+  const config = await requireAuthConfig();
   return {
-    baseUrl: `${protocolForHost2(config.host)}://${config.host}`,
+    baseUrl: config.baseUrl,
     token: config.sessionToken
   };
 }
@@ -2881,7 +3151,7 @@ ${lines.join("\n")}`;
   }
   return message;
 }
-async function publishTheme(root, skipBuild, force) {
+async function publishTheme(root, skipBuild, force, host) {
   const theme = skipBuild ? await finalizeTheme(root) : await buildTheme(root);
   const ok = await runThemeCheck(theme);
   if (!ok) {
@@ -2899,13 +3169,11 @@ async function publishTheme(root, skipBuild, force) {
       );
     }
   }
-  const config = await readAuthConfig();
-  if (!config) {
-    throw new Error("Not logged in. Run `suda auth login` to authenticate first.");
-  }
-  const baseUrl = `${protocolForHost2(config.host)}://${config.host}`;
+  const config = await selectAuthConfig(host, "Select a host to publish to:");
+  const baseUrl = config.baseUrl;
   const { key, version } = theme.module.manifest;
   const digest = await checksum(files);
+  console.log(info(`publishing ${themeRef(key, version)} to ${style.url(baseUrl)}`));
   if (force) {
     const forceRes = await fetch(`${baseUrl}/api/cli/themes/publish-force`, {
       method: "POST",
@@ -2988,7 +3256,7 @@ async function publishTheme(root, skipBuild, force) {
   if (!completeRes.ok) {
     throw new Error(`Failed to complete publish: ${await formatHttpErrorBody(completeRes)}`);
   }
-  console.log(success(`published ${themeRef(key, version)}`));
+  console.log(success(`published ${themeRef(key, version)} to ${style.url(baseUrl)}`));
 }
 var cachedCliPackageVersions;
 async function readCliPackageVersions() {
@@ -3226,14 +3494,15 @@ function buildProgram() {
   ).option("--output <path>", "Output PNG path relative to theme root. Requires exactly one device.").option("--width <px>", "Override viewport width in pixels.").option("--height <px>", "Override viewport height in pixels.").option("--full-page", "Capture the full page instead of the viewport.").option("--port <port>", "Preview server port used during capture.", "4178").action(async (options) => {
     await screenshotTheme(resolveThemeRoot(options), options);
   });
-  theme.command("publish").description("Upload artifact to S3 and upsert ThemePackage/ThemeVersion.").option("--theme-root <path>", "Theme source/artifact root.").option("--skip-build", "Publish existing dist files without rebuilding.").option(
+  theme.command("publish").description("Upload artifact to S3 and upsert ThemePackage/ThemeVersion.").option("--theme-root <path>", "Theme source/artifact root.").option("--skip-build", "Publish existing dist files without rebuilding.").option("--host <host>", "Publish to this authenticated SudaCloud workspace host.").option(
     "--force",
     "Development recovery only: clear the existing themes/<key>/<version>/ prefix and ThemeVersion row before republishing. Re-published clients pinned to this version are unavailable until the new publish completes."
   ).action(async (options) => {
     await publishTheme(
       resolveThemeRoot(options),
       options.skipBuild === true,
-      options.force === true
+      options.force === true,
+      options.host
     );
   });
   const agent = program.command("agent").description("Agent-friendly theme and page tooling.");
@@ -3299,19 +3568,28 @@ function buildProgram() {
   program.command("mcp").description("Run the Suda local MCP server over stdio.").action(async () => {
     await startMcpServer();
   });
+  const hostCmd = program.command("host").description("Manage the current SudaCloud workspace host.");
+  hostCmd.command("current").description("Show the current authenticated workspace host.").action(async () => {
+    await showCurrentHost();
+  });
+  hostCmd.command("list").description("List authenticated workspace hosts.").action(async () => {
+    await listHosts();
+  });
+  hostCmd.command("switch").description("Switch the current workspace host.").argument("<host>", "An existing authenticated SudaCloud workspace host.").action(async (host) => {
+    await switchHost(host);
+  });
   const authCmd = program.command("auth").description("Manage Suda authentication.");
   authCmd.command("login").description("Authenticate Suda CLI with a SudaCloud workspace.").option(
     "--host <host>",
-    "The SudaCloud workspace host to authenticate against.",
-    "app.sudayun.cn"
+    "The SudaCloud workspace host to authenticate against."
   ).action(async (options) => {
     await login(options.host);
   });
-  authCmd.command("status").description("Check current authentication status.").action(async () => {
-    await status();
+  authCmd.command("status").description("Check current authentication status.").option("--host <host>", "Check authentication for this workspace host.").action(async (options) => {
+    await status(options.host);
   });
-  authCmd.command("logout").description("Clear local authentication configuration.").action(async () => {
-    await logout();
+  authCmd.command("logout").description("Revoke and remove a workspace host credential.").option("--host <host>", "Log out from this workspace host.").action(async (options) => {
+    await logout(options.host);
   });
   program.showHelpAfterError();
   return program;