@sudajs/cli 0.14.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
@@ -580,85 +856,105 @@ export const { createRoot, hydrateRoot, version } = ReactDOMClient;
     }
   };
 }
-function createHostPuckCoreShimPlugin() {
+function createRejectEditorRuntimeDependencyPlugin() {
   return {
-    name: "suda-host-puck-core-shim",
+    name: "suda-reject-editor-runtime-dependency",
     setup(build) {
-      build.onResolve({ filter: /^@puckeditor\/core$/ }, () => ({
-        path: "puck-core-host-shim",
-        namespace: "suda-shim"
-      }));
-      build.onLoad({ filter: /^puck-core-host-shim$/, namespace: "suda-shim" }, () => ({
-        loader: "js",
-        contents: `
-const PuckCore = globalThis.__SUDA_PUCK_CORE__;
-if (!PuckCore) {
-  throw new Error("Missing host Puck core runtime (__SUDA_PUCK_CORE__).");
-}
-export default PuckCore;
-export const {
-  Action,
-  ActionBar,
-  AutoField,
-  Button,
-  Drawer,
-  DropZone,
-  FieldLabel,
-  Group,
-  IconButton,
-  Label,
-  Puck,
-  Render,
-  RichTextMenu,
-  Separator,
-  blocksPlugin,
-  createUsePuck,
-  fieldsPlugin,
-  legacySideBarPlugin,
-  migrate,
-  outlinePlugin,
-  overrideKeys,
-  registerOverlayPortal,
-  renderContext,
-  resolveAllData,
-  setDeep,
-  transformProps,
-  useGetPuck,
-  usePuck,
-  walkTree,
-} = PuckCore;
-`
+      build.onResolve({ filter: /^@puckeditor\/(?:core|plugin-ai)(?:\/.*)?$/ }, (args) => ({
+        errors: [
+          {
+            text: `${args.path} is an editor dependency and cannot be imported by the public theme client runtime.`
+          }
+        ]
       }));
     }
   };
 }
-function createThemeEngineRuntimeAliasPlugin(root) {
+function createHostThemeRuntimeShimPlugin() {
   return {
-    name: "suda-theme-engine-runtime-alias",
+    name: "suda-host-theme-runtime-shim",
     setup(build) {
-      const themeRequire = createRequire(path2.join(root, "package.json"));
-      const runtimeEntry = themeRequire.resolve("@sudajs/theme-engine/runtime");
       build.onResolve({ filter: /^@sudajs\/theme-engine\/runtime$/ }, () => ({
-        path: runtimeEntry
+        path: "theme-runtime-host-shim",
+        namespace: "suda-shim"
+      }));
+      build.onLoad({ filter: /^theme-runtime-host-shim$/, namespace: "suda-shim" }, () => ({
+        loader: "js",
+        contents: `
+const ThemeRuntime = globalThis.__SUDA_THEME_RUNTIME__;
+if (!ThemeRuntime) {
+  throw new Error("Missing host theme runtime (__SUDA_THEME_RUNTIME__).");
+}
+export const {
+  SudaLucideIcon,
+  isSudaLucideIconName,
+  normalizeSudaLucideIconName,
+  colorSchemeField,
+  createColorSchemeDefault,
+  createThemeCssVariables,
+  designSystemField,
+  resolveColorSchemeTokens,
+  SUDA_COLOR_TOKEN_KEYS,
+  createThemeDesignCssVariables,
+  createThemeDesignDefault,
+  resolveThemeDesignTokens,
+  SUDA_CUSTOM_DESIGN_PRESET_ID,
+  SUDA_DESIGN_COLOR_KEYS,
+  SUDA_DESIGN_RADIUS_KEYS,
+  compileSudaBlockSlots,
+  isSudaLocalBlockComponent,
+  SUDA_LOCAL_BLOCK_CATEGORY,
+  SUDA_LOCAL_BLOCK_TYPE_PREFIX,
+  cmsPaginationUrl,
+  getIcpRecord,
+  getCmsContent,
+  getContactForm,
+  getPostResource,
+  getWhiteLabel,
+  resolveAsset,
+  postResourceKey,
+  getPageSlot,
+  THEME_PAGE_SLOT,
+  createThemeAsset,
+  createThemeAssetPath,
+  createThemeAssetResolver,
+  resolveThemeClientRuntimeUrl,
+  resolveThemeRuntimeUrl,
+  resolveAssetPath,
+  THEME_CLIENT_RUNTIME_ARTIFACT,
+  clearThemeLocale,
+  createThemeTranslate,
+  installThemeLocale,
+  clearThemePreviewLocale,
+  createThemePreviewTranslate,
+  installThemePreviewLocale,
+} = ThemeRuntime;
+`
       }));
     }
   };
 }
-function createThemeEngineIconAliasPlugin(root) {
+function createHostThemeIconsShimPlugin() {
   return {
-    name: "suda-theme-engine-icon-alias",
+    name: "suda-host-theme-icons-shim",
     setup(build) {
-      const themeRequire = createRequire(path2.join(root, "package.json"));
-      const themeEngineEntry = themeRequire.resolve("@sudajs/theme-engine");
-      const entryDir = path2.dirname(themeEngineEntry);
-      const packageRoot2 = path2.basename(entryDir) === "dist" || path2.basename(entryDir) === "src" ? path2.dirname(entryDir) : entryDir;
-      const sourceEntry = path2.join(packageRoot2, "src", "icons", "lucide-icon.hydrate.client.tsx");
       build.onResolve({ filter: /^@sudajs\/theme-engine\/icons$/ }, () => {
-        if (existsSync(sourceEntry)) {
-          return { path: sourceEntry };
-        }
-        return { path: themeRequire.resolve("@sudajs/theme-engine/icons") };
+        return { path: "theme-icons-host-shim", namespace: "suda-shim" };
       });
+      build.onLoad({ filter: /^theme-icons-host-shim$/, namespace: "suda-shim" }, () => ({
+        loader: "js",
+        contents: `
+const ThemeIcons = globalThis.__SUDA_THEME_ICONS__;
+if (!ThemeIcons) {
+  throw new Error("Missing host theme icon runtime (__SUDA_THEME_ICONS__).");
+}
+export const {
+  SudaLucideIcon,
+  isSudaLucideIconName,
+  normalizeSudaLucideIconName,
+} = ThemeIcons;
+`
+      }));
     }
   };
 }
@@ -712,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
   };
 }
@@ -779,9 +1069,9 @@ ${issues}`);
   if (module.manifest.entry !== "index.js") {
     throw new Error('manifest.entry must be artifact-local: "index.js".');
   }
-  if (module.manifest.clientEntry !== void 0 && module.manifest.clientEntry !== "runtime.client.js") {
+  if ("clientEntry" in module.manifest) {
     throw new Error(
-      'manifest.clientEntry must be artifact-local: "runtime.client.js" when provided.'
+      "manifest.clientEntry is no longer supported. The CLI owns the runtime.client.js artifact."
     );
   }
   assertRecord(module.pageConfig?.components, "pageConfig.components");
@@ -1001,18 +1291,6 @@ async function loadThemeVite(root) {
   }
   return await import(pathToFileURL(viteEntry).href);
 }
-async function findClientEntry(root) {
-  const candidates = [
-    path2.join(root, "src", "runtime.client.tsx"),
-    path2.join(root, "src", "runtime.client.ts")
-  ];
-  for (const candidate of candidates) {
-    if (await pathExists(candidate)) {
-      return candidate;
-    }
-  }
-  throw new Error(`Missing runtime entry. Add src/runtime.client.ts(x) in ${root}.`);
-}
 async function findServerEntry(root) {
   const candidates = [path2.join(root, "src", "index.tsx"), path2.join(root, "src", "index.ts")];
   for (const candidate of candidates) {
@@ -1113,38 +1391,74 @@ async function copyThemeLocales(root) {
   await copyDirectory(sourceLocales, path2.join(root, "dist", "locales"));
 }
 async function buildClientRuntime(root, minify) {
-  const entryPoint = await findClientEntry(root);
-  if (!await pathExists(entryPoint)) {
-    throw new Error(`Missing client entry: ${entryPoint}`);
+  const legacyEntries = [
+    path2.join(root, "src", "runtime.client.ts"),
+    path2.join(root, "src", "runtime.client.tsx")
+  ];
+  if (legacyEntries.some((entry) => existsSync(entry))) {
+    throw new Error(
+      "Theme-authored src/runtime.client.ts(x) is no longer supported. Move optional browser setup to src/client.ts as clientHooks; the CLI owns runtime.client.js."
+    );
   }
   const packageJson = JSON.parse(await readFile(path2.join(root, "package.json"), "utf8"));
   const themeVersion = typeof packageJson.version === "string" ? packageJson.version : "0.0.0";
+  const clientHooksPath = path2.join(root, "src", "client.ts");
+  const generatedEntry = path2.join(root, ".suda-build", "runtime.client.ts");
+  const clientHooksImport = await pathExists(clientHooksPath) ? 'import { clientHooks } from "../src/client.js";' : "const clientHooks = {};";
+  await mkdir(path2.dirname(generatedEntry), { recursive: true });
+  await writeFile(
+    generatedEntry,
+    [
+      '"use client";',
+      'import type { ThemeClientHooks, ThemeClientRuntime, ThemeRenderModule } from "@sudajs/theme-engine/runtime";',
+      'import * as themeConfig from "../src/config.js";',
+      clientHooksImport,
+      "const theme: ThemeRenderModule = {",
+      "  pageConfig: themeConfig.pageConfig,",
+      "  layoutConfig: themeConfig.layoutConfig,",
+      "};",
+      'if ("rendering" in themeConfig && themeConfig.rendering !== undefined) {',
+      "  theme.rendering = themeConfig.rendering;",
+      "}",
+      "const hooks: ThemeClientHooks = clientHooks;",
+      "const runtime: ThemeClientRuntime = { theme };",
+      "if (hooks.initialize !== undefined) {",
+      "  runtime.initialize = hooks.initialize;",
+      "}",
+      "export default runtime;",
+      ""
+    ].join("\n"),
+    "utf8"
+  );
   await mkdir(path2.join(root, "dist"), { recursive: true });
   const hostReactShimPlugin = createHostReactShimPlugin();
-  const hostPuckCoreShimPlugin = createHostPuckCoreShimPlugin();
-  const themeEngineRuntimeAliasPlugin = createThemeEngineRuntimeAliasPlugin(root);
-  const themeEngineIconAliasPlugin = createThemeEngineIconAliasPlugin(root);
+  const rejectEditorRuntimeDependencyPlugin = createRejectEditorRuntimeDependencyPlugin();
+  const hostThemeRuntimeShimPlugin = createHostThemeRuntimeShimPlugin();
+  const hostThemeIconsShimPlugin = createHostThemeIconsShimPlugin();
   const themeDependencyResolverPlugin = createThemeDependencyResolverPlugin(root);
   await build({
     bundle: true,
-    entryPoints: [entryPoint],
+    entryPoints: { "runtime.client": generatedEntry },
     external: ["react", "react/*", "react-dom", "react-dom/*"],
     format: "esm",
     jsx: "automatic",
+    logOverride: { "import-is-undefined": "silent" },
     minify,
-    outfile: path2.join(root, "dist", "runtime.client.js"),
+    outdir: path2.join(root, "dist"),
     platform: "browser",
     define: {
       __SUDA_THEME_VERSION__: JSON.stringify(themeVersion)
     },
     plugins: [
       hostReactShimPlugin,
-      hostPuckCoreShimPlugin,
-      themeEngineRuntimeAliasPlugin,
-      themeEngineIconAliasPlugin,
+      rejectEditorRuntimeDependencyPlugin,
+      hostThemeRuntimeShimPlugin,
+      hostThemeIconsShimPlugin,
       themeDependencyResolverPlugin
     ],
     sourcemap: false,
+    splitting: true,
+    chunkNames: "chunks/[name]-[hash]",
     target: "es2022",
     treeShaking: true
   });
@@ -2837,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) {
@@ -2855,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",
@@ -2944,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() {
@@ -3182,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.");
@@ -3255,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;