@agentscope-ai/platform-cli 1.0.0

package/dist/cli.js

@@ -0,0 +1,2380 @@
+#!/usr/bin/env node
+import {
+  CLIENT_ID,
+  CLI_API_PREFIX,
+  CLI_VERSION,
+  DEFAULT_SCOPE,
+  PLATFORM_URL,
+  clearCredentials,
+  credentialsFromTokenResponse,
+  getAspConfigDir,
+  isTokenExpired,
+  loadCredentials,
+  resolveConfig,
+  saveCredentials
+} from "./chunk-YKR5C7LX.js";
+
+// src/cli.ts
+import { Command } from "commander";
+
+// src/utils/errors.ts
+var AspError = class _AspError extends Error {
+  code;
+  hint;
+  requestId;
+  statusCode;
+  exitCode;
+  constructor(message, options = {}) {
+    super(message, { cause: options.cause });
+    this.name = "AspError";
+    this.code = options.code ?? "UNKNOWN";
+    this.hint = options.hint;
+    this.requestId = options.requestId;
+    this.statusCode = options.statusCode;
+    this.exitCode = options.exitCode ?? 1;
+  }
+  static fromResponse(status, body) {
+    const parsed = body;
+    if (parsed?.error) {
+      const exitCode = mapErrorCodeToExit(parsed.error.code, status);
+      let hint = parsed.error.hint ?? parsed.error.detail;
+      if (parsed.error.code === "ASP.COMM.NOT_FOUND") {
+        hint = hint ?? "The API endpoint is not available on this Platform environment.";
+      }
+      return new _AspError(parsed.error.message, {
+        code: parsed.error.code,
+        hint,
+        requestId: parsed.request_id,
+        statusCode: status,
+        exitCode
+      });
+    }
+    return new _AspError(`HTTP ${status}`, {
+      code: "HTTP_ERROR",
+      statusCode: status,
+      exitCode: status >= 500 ? 2 : 1
+    });
+  }
+};
+function mapErrorCodeToExit(code, status) {
+  if (code === "UNAUTHORIZED" || code === "UNAUTHENTICATED" || code === "ASP.AUTH.UNAUTHORIZED" || code === "ASP.AUTH.SESSION_INVALID" || code === "SESSION_INVALID") {
+    return 3;
+  }
+  if (code === "FORBIDDEN") return 4;
+  if (status >= 500) return 2;
+  return 1;
+}
+function maskSecrets(text) {
+  return text.replace(/Bearer\s+[A-Za-z0-9._-]+/gi, "Bearer [REDACTED]").replace(/"access_token"\s*:\s*"[^"]+"/gi, '"access_token":"[REDACTED]"').replace(/"refresh_token"\s*:\s*"[^"]+"/gi, '"refresh_token":"[REDACTED]"').replace(/"token"\s*:\s*"[^"]+"/gi, '"token":"[REDACTED]"');
+}
+
+// src/auth/session.ts
+function isSessionInvalidError(err) {
+  if (!(err instanceof AspError)) return false;
+  return err.code === "ASP.AUTH.SESSION_INVALID" || err.code === "SESSION_INVALID";
+}
+async function refreshStoredSession(config, refreshToken, platformUrl) {
+  const client = new CliApiClient({
+    ...config,
+    token: void 0,
+    platformUrl: platformUrl.replace(/\/$/, "")
+  });
+  const refreshed = await client.refresh(refreshToken);
+  const creds = credentialsFromTokenResponse(platformUrl, refreshed);
+  await saveCredentials(creds);
+  return creds;
+}
+async function finalizeLogin(config, loginResponse) {
+  if (!loginResponse.refresh_token) {
+    const creds = credentialsFromTokenResponse(config.platformUrl, loginResponse);
+    await saveCredentials(creds);
+    return creds;
+  }
+  try {
+    return await refreshStoredSession(
+      config,
+      loginResponse.refresh_token,
+      config.platformUrl
+    );
+  } catch {
+    const creds = credentialsFromTokenResponse(config.platformUrl, loginResponse);
+    await saveCredentials(creds);
+    return creds;
+  }
+}
+
+// src/api/client.ts
+var HttpClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  config;
+  async request(opts) {
+    try {
+      return await this.doRequest(opts);
+    } catch (err) {
+      if (opts.auth !== false && !opts._retried && isSessionInvalidError(err) && !this.config.token) {
+        const creds = await loadCredentials();
+        if (creds?.refresh_token) {
+          await refreshStoredSession(configWithPlatform(this.config, creds), creds.refresh_token, creds.platform_url);
+          return this.doRequest({ ...opts, _retried: true });
+        }
+      }
+      throw err;
+    }
+  }
+  async doRequest(opts) {
+    const creds = opts.auth !== false && !this.config.token ? await loadCredentials() : null;
+    const platformUrl = creds?.platform_url ?? this.config.platformUrl;
+    const prefix = opts.prefix ?? "";
+    const url = `${platformUrl}${prefix}${opts.path}`;
+    const headers = {
+      Accept: "application/json",
+      ...opts.headers
+    };
+    if (opts.body !== void 0) {
+      headers["Content-Type"] = "application/json";
+    }
+    if (opts.auth !== false) {
+      const token = await this.resolveAccessToken(creds);
+      if (token) {
+        headers.Authorization = `Bearer ${token}`;
+      }
+    }
+    if (this.config.verbose) {
+      console.error(`[verbose] ${opts.method ?? "GET"} ${url}`);
+      if (opts.body) console.error(maskSecrets(JSON.stringify(opts.body)));
+    }
+    const res = await fetch(url, {
+      method: opts.method ?? "GET",
+      headers,
+      body: opts.body !== void 0 ? JSON.stringify(opts.body) : void 0
+    });
+    const text = await res.text();
+    let data = {};
+    if (text) {
+      try {
+        data = JSON.parse(text);
+      } catch {
+        data = { raw: text };
+      }
+    }
+    if (this.config.verbose) {
+      console.error(`[verbose] ${res.status}`, maskSecrets(text.slice(0, 2e3)));
+    }
+    if (!res.ok) {
+      throw AspError.fromResponse(res.status, data);
+    }
+    return data;
+  }
+  async resolveAccessToken(existing) {
+    if (this.config.token) return this.config.token;
+    const creds = existing ?? await loadCredentials();
+    if (!creds) return void 0;
+    if (isTokenExpired(creds) && creds.refresh_token) {
+      const refreshed = await refreshStoredSession(
+        configWithPlatform(this.config, creds),
+        creds.refresh_token,
+        creds.platform_url
+      );
+      return refreshed.access_token;
+    }
+    return creds.access_token;
+  }
+};
+function configWithPlatform(config, creds) {
+  return { ...config, platformUrl: creds.platform_url || config.platformUrl };
+}
+
+// src/api/cli-api.ts
+var CliApiClient = class {
+  http;
+  constructor(config) {
+    this.http = new HttpClient(config);
+  }
+  req(opts) {
+    return this.http.request({ ...opts, prefix: CLI_API_PREFIX });
+  }
+  getMeta() {
+    return this.req({ path: "/meta", auth: false });
+  }
+  getMe() {
+    return this.req({ path: "/me" });
+  }
+  login(account, password) {
+    return this.req({
+      method: "POST",
+      path: "/auth/login",
+      auth: false,
+      body: { account, password }
+    });
+  }
+  refresh(refreshToken) {
+    return this.req({
+      method: "POST",
+      path: "/auth/refresh",
+      auth: false,
+      body: { refresh_token: refreshToken }
+    });
+  }
+  oauthToken(body) {
+    return this.req({ method: "POST", path: "/oauth/token", auth: false, body });
+  }
+  oauthRevoke(token, tokenTypeHint = "refresh_token") {
+    return this.req({
+      method: "POST",
+      path: "/oauth/revoke",
+      body: { token, token_type_hint: tokenTypeHint }
+    });
+  }
+  async logout() {
+    try {
+      return await this.req({ method: "POST", path: "/auth/logout" });
+    } catch {
+      return this.oauthRevoke("", "access_token");
+    }
+  }
+  getRequestLogs(params) {
+    const query = new URLSearchParams();
+    if (params?.page_size !== void 0) query.set("page_size", String(params.page_size));
+    if (params?.cursor) query.set("cursor", params.cursor);
+    const suffix = query.toString();
+    return this.req({ path: `/request-logs${suffix ? `?${suffix}` : ""}` });
+  }
+  searchPlugins(params) {
+    const query = new URLSearchParams();
+    if (params?.q) query.set("q", params.q);
+    if (params?.category) query.set("category", params.category);
+    if (params?.source) query.set("source", params.source);
+    if (params?.sort) query.set("sort", params.sort);
+    if (params?.page_size !== void 0) query.set("page_size", String(params.page_size));
+    if (params?.cursor) query.set("cursor", params.cursor);
+    const suffix = query.toString();
+    return this.req({ path: `/plugins${suffix ? `?${suffix}` : ""}`, auth: false });
+  }
+  getPluginInfo(pluginId, version) {
+    const query = new URLSearchParams();
+    if (version) query.set("version", version);
+    const suffix = query.toString();
+    return this.req({
+      path: `/plugins/${encodeURIComponent(pluginId)}${suffix ? `?${suffix}` : ""}`,
+      auth: false
+    });
+  }
+  getPluginVersions(pluginId) {
+    return this.req({
+      path: `/plugins/${encodeURIComponent(pluginId)}/versions`,
+      auth: false
+    });
+  }
+  createInstallIntent(pluginId, version) {
+    return this.req({
+      method: "POST",
+      path: `/plugins/${encodeURIComponent(pluginId)}/install-intent`,
+      body: version ? { version } : {}
+    });
+  }
+  searchSkills(params) {
+    const query = new URLSearchParams();
+    if (params?.q) query.set("q", params.q);
+    if (params?.category) query.set("category", params.category);
+    if (params?.source) query.set("source", params.source);
+    if (params?.tag) query.set("tag", params.tag);
+    if (params?.sort) query.set("sort", params.sort);
+    if (params?.page_size !== void 0) query.set("page_size", String(params.page_size));
+    if (params?.cursor) query.set("cursor", params.cursor);
+    const suffix = query.toString();
+    return this.req({ path: `/skills${suffix ? `?${suffix}` : ""}`, auth: false });
+  }
+  getSkillInfo(skillId, version) {
+    const query = new URLSearchParams();
+    if (version) query.set("version", version);
+    const suffix = query.toString();
+    return this.req({
+      path: `/skills/${encodeURIComponent(skillId)}${suffix ? `?${suffix}` : ""}`,
+      auth: false
+    });
+  }
+  getSkillVersions(skillId) {
+    return this.req({
+      path: `/skills/${encodeURIComponent(skillId)}/versions`,
+      auth: false
+    });
+  }
+  createSkillInstallIntent(skillId, version) {
+    return this.req({
+      method: "POST",
+      path: `/skills/${encodeURIComponent(skillId)}/install-intent`,
+      body: version ? { version } : {}
+    });
+  }
+  createArtifactSubmission(body) {
+    return this.req({
+      method: "POST",
+      path: "/artifact-submissions",
+      body
+    });
+  }
+  completeArtifactSubmission(submissionId, body) {
+    return this.req({
+      method: "POST",
+      path: `/artifact-submissions/${encodeURIComponent(submissionId)}/complete`,
+      body
+    });
+  }
+  getArtifactSubmission(submissionId) {
+    return this.req({
+      path: `/artifact-submissions/${encodeURIComponent(submissionId)}`
+    });
+  }
+  getArtifactSubmissionLogs(submissionId) {
+    return this.req({
+      path: `/artifact-submissions/${encodeURIComponent(submissionId)}/logs`
+    });
+  }
+};
+
+// src/auth/browser-login.ts
+import { createServer } from "http";
+import open from "open";
+
+// src/auth/pkce.ts
+import { randomBytes, createHash } from "crypto";
+function base64Url(buf) {
+  return buf.toString("base64url");
+}
+function generatePkce() {
+  const codeVerifier = base64Url(randomBytes(32));
+  const codeChallenge = base64Url(createHash("sha256").update(codeVerifier).digest());
+  const state = `state_${base64Url(randomBytes(16))}`;
+  const nonce = `nonce_${base64Url(randomBytes(16))}`;
+  return { codeVerifier, codeChallenge, state, nonce };
+}
+
+// src/utils/platform.ts
+function detectPlatformEnv(url) {
+  const normalized = url.replace(/\/$/, "");
+  if (normalized === PLATFORM_URL) return "default";
+  return "custom";
+}
+function formatPlatformLabel(url) {
+  const env = detectPlatformEnv(url);
+  if (env === "default") return `platform (${PLATFORM_URL})`;
+  return url;
+}
+function withPlatformUrl(config, platformUrl) {
+  return { ...config, platformUrl: platformUrl.replace(/\/$/, "") };
+}
+async function requireCredentials(config, targetPlatformUrl) {
+  if (config.token) {
+    return {
+      config: withPlatformUrl(config, targetPlatformUrl),
+      creds: {
+        access_token: config.token,
+        token_type: "Bearer",
+        platform_url: targetPlatformUrl
+      }
+    };
+  }
+  const creds = await loadCredentials();
+  if (!creds?.access_token) {
+    throw new AspError("Not logged in.", {
+      code: "UNAUTHORIZED",
+      hint: "Run `asp auth login`.",
+      exitCode: 3
+    });
+  }
+  const credsUrl = creds.platform_url.replace(/\/$/, "");
+  const targetUrl = targetPlatformUrl.replace(/\/$/, "");
+  if (credsUrl !== targetUrl) {
+    const loggedIn = formatPlatformLabel(credsUrl);
+    const target = formatPlatformLabel(targetUrl);
+    throw new AspError(`Credential environment mismatch: logged in to ${loggedIn}, command targets ${target}.`, {
+      code: "ENV_MISMATCH",
+      hint: "Run `asp auth login` for the current target platform.",
+      exitCode: 1
+    });
+  }
+  return {
+    config: withPlatformUrl(config, targetUrl),
+    creds
+  };
+}
+
+// src/utils/output.ts
+import chalk from "chalk";
+function printJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+function printSuccess(message) {
+  console.log(chalk.green("\u2713"), message);
+}
+function printInfo(message) {
+  console.log(chalk.blue("\u2139"), message);
+}
+function printWarn(message) {
+  console.log(chalk.yellow("\u26A0"), message);
+}
+function printError(message) {
+  console.error(chalk.red("\u2717"), message);
+}
+function printTable(headers, rows) {
+  const widths = headers.map(
+    (h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length))
+  );
+  const headerLine = headers.map((h, i) => h.padEnd(widths[i])).join("  ");
+  console.log(chalk.bold(headerLine));
+  for (const row of rows) {
+    console.log(row.map((c, i) => (c ?? "").padEnd(widths[i])).join("  "));
+  }
+}
+function formatDateTime(iso) {
+  const date = new Date(iso);
+  if (Number.isNaN(date.getTime())) return iso;
+  const pad = (n) => String(n).padStart(2, "0");
+  return [
+    date.getFullYear(),
+    pad(date.getMonth() + 1),
+    pad(date.getDate())
+  ].join("-") + " " + [pad(date.getHours()), pad(date.getMinutes()), pad(date.getSeconds())].join(":");
+}
+
+// src/auth/browser-login.ts
+var LOGIN_TIMEOUT_MS = 3e5;
+async function browserPkceLogin(config) {
+  const pkce = generatePkce();
+  const port = await pickPort();
+  const redirectUri = `http://127.0.0.1:${port}/callback/${pkce.nonce}`;
+  const loginUrl = new URL(`${config.platformUrl}/cli/login`);
+  loginUrl.searchParams.set("client_id", CLIENT_ID);
+  loginUrl.searchParams.set("redirect_uri", redirectUri);
+  loginUrl.searchParams.set("response_type", "code");
+  loginUrl.searchParams.set("code_challenge", pkce.codeChallenge);
+  loginUrl.searchParams.set("code_challenge_method", "S256");
+  loginUrl.searchParams.set("state", pkce.state);
+  loginUrl.searchParams.set("scope", DEFAULT_SCOPE);
+  const code = await waitForCallback(port, pkce.nonce, pkce.state, loginUrl.toString());
+  const client = new CliApiClient(config);
+  const token = await client.oauthToken({
+    grant_type: "authorization_code",
+    client_id: CLIENT_ID,
+    code,
+    code_verifier: pkce.codeVerifier,
+    redirect_uri: redirectUri
+  });
+  await finalizeLogin(config, token);
+  const display = token.user?.email ?? token.user?.display_name ?? "user";
+  printSuccess(`Logged in as ${display} (${formatPlatformLabel(config.platformUrl)})`);
+}
+async function pickPort() {
+  return new Promise((resolve, reject) => {
+    const server = createServer();
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      if (!addr || typeof addr === "string") {
+        server.close();
+        reject(new Error("Failed to bind callback port"));
+        return;
+      }
+      const port = addr.port;
+      server.close(() => resolve(port));
+    });
+    server.on("error", reject);
+  });
+}
+function waitForCallback(port, nonce, expectedState, loginUrl) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let timeoutId;
+    let server;
+    const stopServer = () => {
+      if (timeoutId !== void 0) {
+        clearTimeout(timeoutId);
+        timeoutId = void 0;
+      }
+      server.closeAllConnections?.();
+      server.close();
+    };
+    const finish = (handler) => {
+      if (settled) return;
+      settled = true;
+      stopServer();
+      handler();
+    };
+    server = createServer(async (req, res) => {
+      try {
+        const url = new URL(req.url ?? "/", `http://127.0.0.1:${port}`);
+        if (url.pathname !== `/callback/${nonce}`) {
+          res.writeHead(404);
+          res.end("Not found");
+          return;
+        }
+        const code = url.searchParams.get("code");
+        const state = url.searchParams.get("state");
+        if (!code || state !== expectedState) {
+          res.writeHead(400);
+          res.end("Invalid callback");
+          finish(
+            () => reject(new Error("Invalid OAuth callback: state mismatch or missing code"))
+          );
+          return;
+        }
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        res.end("<html><body><h2>Login successful. You can close this window.</h2></body></html>");
+        finish(() => resolve(code));
+      } catch (err) {
+        finish(() => reject(err));
+      }
+    });
+    server.listen(port, "127.0.0.1", () => {
+      printInfo("Opening browser to authorize AgentScope Platform CLI...");
+      printInfo(`If the browser does not open, visit:
+  ${loginUrl}`);
+      printInfo("Waiting for authorization...");
+      void open(loginUrl).catch(() => {
+      });
+    });
+    timeoutId = setTimeout(() => {
+      finish(() => reject(new Error("Login timed out")));
+    }, LOGIN_TIMEOUT_MS);
+  });
+}
+
+// src/utils/prompt.ts
+import { createInterface } from "readline/promises";
+import { stdin as input, stdout as output } from "process";
+async function promptLine(message) {
+  const rl = createInterface({ input, output });
+  try {
+    const value = (await rl.question(message)).trim();
+    if (!value) {
+      throw new Error("Input is required.");
+    }
+    return value;
+  } finally {
+    rl.close();
+  }
+}
+async function promptPassword(message = "Password: ") {
+  return new Promise((resolve, reject) => {
+    const stdin = process.stdin;
+    const wasRaw = stdin.isRaw;
+    const wasPaused = stdin.isPaused();
+    if (!stdin.isTTY) {
+      reject(new Error("Password prompt requires an interactive terminal."));
+      return;
+    }
+    output.write(message);
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    let password = "";
+    const cleanup = () => {
+      stdin.removeListener("data", onData);
+      stdin.setRawMode(wasRaw ?? false);
+      if (wasPaused) stdin.pause();
+      else stdin.resume();
+    };
+    const onData = (char) => {
+      switch (char) {
+        case "\n":
+        case "\r":
+        case "":
+          cleanup();
+          output.write("\n");
+          if (!password) {
+            reject(new Error("Password is required."));
+            return;
+          }
+          resolve(password);
+          break;
+        case "":
+          cleanup();
+          output.write("\n");
+          reject(new Error("Login cancelled."));
+          break;
+        case "\x7F":
+        case "\b":
+          if (password.length > 0) {
+            password = password.slice(0, -1);
+            output.write("\b \b");
+          }
+          break;
+        default:
+          if (char < " " && char !== "	") return;
+          password += char;
+          output.write("*");
+          break;
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+async function promptCredentials(options) {
+  const account = options.account ?? await promptLine("Email: ");
+  const password = options.password ?? await promptPassword();
+  return { account, password };
+}
+async function promptLoginMethod() {
+  printLoginMethodMenu();
+  const rl = createInterface({ input, output });
+  try {
+    const answer = (await rl.question("Enter choice [1]: ")).trim();
+    if (!answer || answer === "1") return "browser";
+    if (answer === "2") return "password";
+    throw new Error("Invalid choice. Enter 1 or 2.");
+  } finally {
+    rl.close();
+  }
+}
+function printLoginMethodMenu() {
+  console.log("How would you like to log in?");
+  console.log("  1. Browser authorization (recommended)");
+  console.log("  2. Email and password");
+}
+
+// src/commands/auth.ts
+var LOGIN_OPTIONS = [
+  ["--browser", "Login via browser authorization (opens /cli/login, PKCE)"],
+  ["--password", "Login with email and password"],
+  ["--token <token>", "Save and validate an existing access token"],
+  ["--account <email>", "Account email (non-interactive, use with --pass)"],
+  ["--pass <password>", "Account password (non-interactive, use with --account)"]
+];
+function wantsPasswordLogin(opts) {
+  return !!(opts.password || opts.account || opts.pass);
+}
+async function ensureBrowserLoginEnabled(config) {
+  const meta = await new CliApiClient(config).getMeta().catch(() => null);
+  if (meta?.features?.browser_pkce_login === false) {
+    throw new AspError("Browser authorization login is not enabled on this platform.", {
+      code: "FEATURE_DISABLED",
+      hint: "Use `asp auth login --password` instead."
+    });
+  }
+}
+async function runPasswordLogin(config, opts) {
+  const { account, password } = await promptCredentials({
+    account: opts.account,
+    password: opts.pass
+  });
+  const loginResponse = await new CliApiClient(config).login(account, password);
+  await finalizeLogin(config, loginResponse);
+  const me = await new CliApiClient(config).getMe();
+  const display = me.user?.email ?? me.email ?? me.user?.display_name ?? me.account ?? account;
+  printSuccess(`Logged in as ${display} (${formatPlatformLabel(config.platformUrl)})`);
+}
+async function runBrowserLogin(config) {
+  await ensureBrowserLoginEnabled(config);
+  await browserPkceLogin(config);
+}
+async function runLogin(config, opts) {
+  if (opts.token) {
+    await saveTokenLogin(config, opts.token);
+    return;
+  }
+  if (opts.browser && wantsPasswordLogin(opts)) {
+    throw new AspError("Cannot use --browser together with --password, --account, or --pass.", {
+      code: "INVALID_REQUEST",
+      hint: "Choose one login method."
+    });
+  }
+  if (opts.browser) {
+    await runBrowserLogin(config);
+    return;
+  }
+  if (wantsPasswordLogin(opts)) {
+    await runPasswordLogin(config, opts);
+    return;
+  }
+  if (!process.stdin.isTTY) {
+    throw new AspError("Non-interactive login requires a login method flag.", {
+      code: "INVALID_REQUEST",
+      hint: "Use `asp auth login --browser` or `asp auth login --password --account <email> --pass <password>`."
+    });
+  }
+  const method = await promptLoginMethod();
+  if (method === "browser") {
+    await runBrowserLogin(config);
+    return;
+  }
+  await runPasswordLogin(config, opts);
+}
+async function saveTokenLogin(config, token) {
+  const creds = credentialsFromTokenResponse(config.platformUrl, {
+    access_token: token,
+    token_type: "Bearer"
+  });
+  await saveCredentials(creds);
+  const me = await new CliApiClient({ ...config, token }).getMe();
+  const display = me.user?.email ?? me.email ?? me.user?.display_name ?? me.account ?? me.user_id;
+  printSuccess(`Token saved. Logged in as ${display} (${formatPlatformLabel(config.platformUrl)})`);
+}
+async function runStatus(getConfig2) {
+  const base = getConfig2();
+  const creds = await loadCredentials();
+  if (!base.token && !creds) {
+    printInfo("Not logged in.");
+    printInfo("Run `asp auth login` to sign in.");
+    return;
+  }
+  const { config: apiConfig } = await requireCredentials(base, base.platformUrl);
+  const client = new CliApiClient(apiConfig);
+  const me = await client.getMe();
+  const latestCreds = await loadCredentials() ?? creds;
+  if (base.json) {
+    printJson({
+      logged_in: true,
+      environment: formatPlatformLabel(apiConfig.platformUrl),
+      user: me.user ?? {
+        id: me.user_id,
+        email: me.email,
+        display_name: me.username ?? me.account
+      },
+      scopes: me.scopes,
+      expires_at: latestCreds?.expires_at,
+      platform_url: apiConfig.platformUrl
+    });
+    return;
+  }
+  const user = me.user ?? {
+    id: me.user_id ?? "",
+    email: me.email,
+    display_name: me.username ?? me.account
+  };
+  printInfo(`Environment: ${formatPlatformLabel(apiConfig.platformUrl)}`);
+  printInfo(`User: ${user.display_name ?? user.email ?? user.id}`);
+  if (user.email) printInfo(`Email: ${user.email}`);
+  if (me.scopes?.length) printInfo(`Scopes: ${me.scopes.join(", ")}`);
+  if (latestCreds?.expires_at) {
+    printInfo(`Token expires: ${formatDateTime(latestCreds.expires_at)}`);
+  }
+}
+async function runRefresh(getConfig2) {
+  const base = getConfig2();
+  const { config, creds } = await requireCredentials(base, base.platformUrl);
+  if (!creds.refresh_token) {
+    throw new AspError("No refresh token available.", {
+      code: "UNAUTHORIZED",
+      hint: "Run `asp auth login`.",
+      exitCode: 3
+    });
+  }
+  await refreshStoredSession(config, creds.refresh_token, config.platformUrl);
+  printSuccess(`Token refreshed (${formatPlatformLabel(config.platformUrl)}).`);
+}
+async function runLogout(getConfig2) {
+  const base = getConfig2();
+  const platformUrl = base.platformUrl;
+  const creds = await loadCredentials();
+  if (!creds) {
+    printInfo(`Not logged in to ${formatPlatformLabel(platformUrl)}.`);
+    return;
+  }
+  if (creds.refresh_token) {
+    const client = new CliApiClient({ ...base, platformUrl: creds.platform_url });
+    await client.logout().catch(() => {
+    });
+  }
+  await clearCredentials();
+  printSuccess(`Logged out from ${formatPlatformLabel(creds.platform_url)}.`);
+}
+async function runLogs(getConfig2, opts) {
+  const base = getConfig2();
+  const { config } = await requireCredentials(base, base.platformUrl);
+  const response = await new CliApiClient(config).getRequestLogs({
+    page_size: opts.pageSize,
+    cursor: opts.cursor
+  });
+  if (base.json) {
+    printJson(response);
+    return;
+  }
+  if (response.items.length === 0) {
+    printInfo("No request logs.");
+    return;
+  }
+  const rows = response.items.map((item) => [
+    item.created_at,
+    item.method,
+    item.path,
+    String(item.response_status ?? "-"),
+    String(item.duration_ms ?? "-")
+  ]);
+  printTable(["time", "method", "path", "status", "ms"], rows);
+  if (response.next_cursor) {
+    printInfo(`Next cursor: ${response.next_cursor}`);
+  }
+}
+function registerAuthCommands(program2, getConfig2) {
+  const auth = program2.command("auth").description("Authentication commands");
+  let login = auth.command("login").description("Log in (default platform is pre environment)");
+  for (const [flags, desc] of LOGIN_OPTIONS) {
+    login = login.option(flags, desc);
+  }
+  login.action(async (opts) => {
+    await runLogin(getConfig2(), opts);
+  });
+  auth.command("status").description("Show login status").action(async () => {
+    await runStatus(getConfig2);
+  });
+  auth.command("refresh").description("Refresh access token").action(async () => {
+    await runRefresh(getConfig2);
+  });
+  auth.command("logout").description("Log out current account").action(async () => {
+    await runLogout(getConfig2);
+  });
+  auth.command("logs").description("Show CLI request audit logs").option("--page-size <n>", "Page size", (v) => Number.parseInt(v, 10)).option("--cursor <cursor>", "Cursor for next page").action(async (opts) => {
+    await runLogs(getConfig2, opts);
+  });
+}
+
+// src/commands/plugin.ts
+import { basename } from "path";
+import { createHash as createHash2 } from "crypto";
+import { readFile as readFile2 } from "fs/promises";
+import { spawn } from "child_process";
+import { createInterface as createInterface2 } from "readline/promises";
+import { stdin as input2, stdout as output2 } from "process";
+
+// src/utils/artifact-publish.ts
+function appendOptionalArtifactFields(body, fields) {
+  if (fields.artifactId) body.artifact_id = fields.artifactId;
+  if (fields.version) body.version = fields.version;
+  if (fields.repoUrl) body.repo_url = fields.repoUrl;
+  return body;
+}
+function looksLikeSubmissionId(id) {
+  return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id);
+}
+
+// src/utils/publish-registry.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { join } from "path";
+var REGISTRY_FILE = "publish-submissions.json";
+var MAX_ENTRIES = 200;
+function normalizePlatformUrl(url) {
+  return url.replace(/\/$/, "");
+}
+async function loadRegistry() {
+  try {
+    const path = join(getAspConfigDir(), REGISTRY_FILE);
+    const raw = await readFile(path, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return { entries: [] };
+  }
+}
+async function saveRegistry(registry) {
+  const dir = getAspConfigDir();
+  await mkdir(dir, { recursive: true });
+  const path = join(dir, REGISTRY_FILE);
+  await writeFile(path, `${JSON.stringify(registry, null, 2)}
+`, "utf8");
+}
+async function recordPluginPublish(opts) {
+  const registry = await loadRegistry();
+  const platform = normalizePlatformUrl(opts.platformUrl);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  registry.entries = registry.entries.filter((entry) => {
+    if (entry.platform_url !== platform) return true;
+    if (entry.submission_id === opts.submissionId) return false;
+    if (opts.pluginId && entry.plugin_id === opts.pluginId) return false;
+    return true;
+  });
+  registry.entries.unshift({
+    submission_id: opts.submissionId,
+    platform_url: platform,
+    plugin_id: opts.pluginId,
+    source_url: opts.sourceUrl,
+    updated_at: now
+  });
+  registry.entries = registry.entries.slice(0, MAX_ENTRIES);
+  await saveRegistry(registry);
+}
+async function lookupPluginSubmissionId(ref, platformUrl) {
+  return lookupArtifactSubmissionId(ref, platformUrl, "plugin");
+}
+async function recordSkillPublish(opts) {
+  const registry = await loadRegistry();
+  const platform = normalizePlatformUrl(opts.platformUrl);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  registry.entries = registry.entries.filter((entry) => {
+    if (entry.platform_url !== platform) return true;
+    if (entry.submission_id === opts.submissionId) return false;
+    if (opts.skillId && entry.skill_id === opts.skillId) return false;
+    return true;
+  });
+  registry.entries.unshift({
+    submission_id: opts.submissionId,
+    platform_url: platform,
+    skill_id: opts.skillId,
+    source_url: opts.sourceUrl,
+    updated_at: now
+  });
+  registry.entries = registry.entries.slice(0, MAX_ENTRIES);
+  await saveRegistry(registry);
+}
+async function lookupSkillSubmissionId(ref, platformUrl) {
+  return lookupArtifactSubmissionId(ref, platformUrl, "skill");
+}
+async function lookupArtifactSubmissionId(ref, platformUrl, artifactType) {
+  const registry = await loadRegistry();
+  const platform = normalizePlatformUrl(platformUrl);
+  const refLower = ref.toLowerCase();
+  for (const entry of registry.entries) {
+    if (entry.platform_url !== platform) continue;
+    if (entry.submission_id === ref) return entry.submission_id;
+    const artifactId = artifactType === "plugin" ? entry.plugin_id : entry.skill_id;
+    if (artifactId === ref) return entry.submission_id;
+    if (entry.source_url?.toLowerCase().includes(refLower)) return entry.submission_id;
+  }
+  return void 0;
+}
+
+// src/utils/submission-resolve.ts
+var SUBMISSION_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var SUBMISSION_ID_IN_PATH = /\/artifact-submissions\/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i;
+function requestBodyMatchesArtifact(body, artifactId) {
+  if (!body || typeof body !== "object") return false;
+  const record = body;
+  if (record.artifact_id === artifactId) return true;
+  if (typeof record.source_url !== "string") return false;
+  const url = record.source_url.toLowerCase();
+  const id = artifactId.toLowerCase();
+  if (url.includes(id)) return true;
+  const segments = url.split(/[/\\?&#]/).filter(Boolean);
+  return segments.some((segment) => segment === id);
+}
+function submissionMatchesPlugin(state, pluginId) {
+  const anyState = state;
+  if (anyState.artifact_id === pluginId) return true;
+  const pluginIdLower = pluginId.toLowerCase();
+  const publicUrl = state.publish?.public_url?.toLowerCase();
+  if (publicUrl?.includes(`/plugins/${pluginIdLower}`)) return true;
+  return false;
+}
+async function rememberResolvedSubmission(submissionId, platformUrl, state) {
+  const anyState = state;
+  if (!anyState.artifact_id) return;
+  await recordPluginPublish({
+    submissionId,
+    platformUrl,
+    pluginId: anyState.artifact_id
+  });
+}
+async function resolvePluginSubmissionId(client, pluginId, platformUrl) {
+  if (SUBMISSION_ID_PATTERN.test(pluginId)) return pluginId;
+  const cached = await lookupPluginSubmissionId(pluginId, platformUrl);
+  if (cached) return cached;
+  const latestSeenAt = /* @__PURE__ */ new Map();
+  let cursor;
+  for (let page = 0; page < 10; page += 1) {
+    const response = await client.getRequestLogs({ page_size: 100, cursor });
+    for (const item of response.items) {
+      const match = item.path.match(SUBMISSION_ID_IN_PATH);
+      if (match) {
+        const submissionId = match[1];
+        const previous = latestSeenAt.get(submissionId);
+        if (!previous || item.created_at > previous) {
+          latestSeenAt.set(submissionId, item.created_at);
+        }
+      }
+      if (item.method === "POST" && item.path.endsWith("/artifact-submissions") && requestBodyMatchesArtifact(item.request_body, pluginId)) {
+        const postMatch = item.path.match(SUBMISSION_ID_IN_PATH);
+        if (postMatch) {
+          latestSeenAt.set(postMatch[1], item.created_at);
+        }
+      }
+    }
+    if (!response.next_cursor) break;
+    cursor = response.next_cursor ?? void 0;
+  }
+  const candidates = [...latestSeenAt.entries()].sort((a, b) => b[1].localeCompare(a[1])).map(([submissionId]) => submissionId).slice(0, 50);
+  const pluginIdLower = pluginId.toLowerCase();
+  for (const candidate of candidates) {
+    try {
+      const state = await client.getArtifactSubmission(candidate);
+      if (submissionMatchesPlugin(state, pluginId)) {
+        await rememberResolvedSubmission(candidate, platformUrl, state);
+        return candidate;
+      }
+      const logs = await client.getArtifactSubmissionLogs(candidate);
+      const matched = logs.items.some(
+        (item) => item.message.toLowerCase().includes(pluginIdLower)
+      );
+      if (matched) {
+        await rememberResolvedSubmission(candidate, platformUrl, state);
+        return candidate;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return void 0;
+}
+function submissionMatchesSkill(state, skillId) {
+  const anyState = state;
+  if (anyState.artifact_id === skillId) return true;
+  const skillIdLower = skillId.toLowerCase();
+  const publicUrl = state.publish?.public_url?.toLowerCase();
+  if (publicUrl?.includes(`/skills/${skillIdLower}`)) return true;
+  return false;
+}
+async function rememberResolvedSkillSubmission(submissionId, platformUrl, state) {
+  const anyState = state;
+  if (!anyState.artifact_id) return;
+  await recordSkillPublish({
+    submissionId,
+    platformUrl,
+    skillId: anyState.artifact_id
+  });
+}
+async function resolveSkillSubmissionId(client, skillId, platformUrl) {
+  if (SUBMISSION_ID_PATTERN.test(skillId)) return skillId;
+  const cached = await lookupSkillSubmissionId(skillId, platformUrl);
+  if (cached) return cached;
+  const latestSeenAt = /* @__PURE__ */ new Map();
+  let cursor;
+  for (let page = 0; page < 10; page += 1) {
+    const response = await client.getRequestLogs({ page_size: 100, cursor });
+    for (const item of response.items) {
+      const match = item.path.match(SUBMISSION_ID_IN_PATH);
+      if (match) {
+        const submissionId = match[1];
+        const previous = latestSeenAt.get(submissionId);
+        if (!previous || item.created_at > previous) {
+          latestSeenAt.set(submissionId, item.created_at);
+        }
+      }
+      if (item.method === "POST" && item.path.endsWith("/artifact-submissions") && requestBodyMatchesArtifact(item.request_body, skillId)) {
+        const postMatch = item.path.match(SUBMISSION_ID_IN_PATH);
+        if (postMatch) {
+          latestSeenAt.set(postMatch[1], item.created_at);
+        }
+      }
+    }
+    if (!response.next_cursor) break;
+    cursor = response.next_cursor ?? void 0;
+  }
+  const candidates = [...latestSeenAt.entries()].sort((a, b) => b[1].localeCompare(a[1])).map(([submissionId]) => submissionId).slice(0, 50);
+  const skillIdLower = skillId.toLowerCase();
+  for (const candidate of candidates) {
+    try {
+      const state = await client.getArtifactSubmission(candidate);
+      if (submissionMatchesSkill(state, skillId)) {
+        await rememberResolvedSkillSubmission(candidate, platformUrl, state);
+        return candidate;
+      }
+      const logs = await client.getArtifactSubmissionLogs(candidate);
+      const matched = logs.items.some(
+        (item) => item.message.toLowerCase().includes(skillIdLower)
+      );
+      if (matched) {
+        await rememberResolvedSkillSubmission(candidate, platformUrl, state);
+        return candidate;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return void 0;
+}
+
+// src/utils/submission-poll.ts
+var SubmissionWaitInterruptedError = class extends Error {
+  submissionId;
+  constructor(submissionId) {
+    super("Submission wait interrupted");
+    this.name = "SubmissionWaitInterruptedError";
+    this.submissionId = submissionId;
+  }
+};
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal.aborted) {
+      reject(new Error("aborted"));
+      return;
+    }
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(new Error("aborted"));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function pollUntilTerminal(client, submissionId, watch) {
+  let lastStatus = "";
+  const controller = new AbortController();
+  const onInterrupt = () => {
+    controller.abort();
+  };
+  process.once("SIGINT", onInterrupt);
+  try {
+    while (!controller.signal.aborted) {
+      const current = await client.getArtifactSubmission(submissionId);
+      if (watch && current.status !== lastStatus) {
+        printInfo(`Submission ${submissionId}: ${current.status}`);
+        lastStatus = current.status;
+      }
+      if (current.terminal) return current;
+      const sleepSec = Math.max(current.next_poll_after_seconds ?? 15, 1);
+      try {
+        await sleep(sleepSec * 1e3, controller.signal);
+      } catch {
+        throw new SubmissionWaitInterruptedError(submissionId);
+      }
+    }
+    throw new SubmissionWaitInterruptedError(submissionId);
+  } finally {
+    process.removeListener("SIGINT", onInterrupt);
+  }
+}
+
+// src/utils/marketplace-display.ts
+function formatPluginListTechType(item) {
+  return item.tech_type ?? item.category ?? item.source ?? "-";
+}
+
+// src/commands/plugin.ts
+var PLUGIN_CATEGORY_OPTIONS = [
+  {
+    value: "tool",
+    label: "Agent Tool",
+    describe: "Functions, APIs, or capabilities that Agents can invoke"
+  },
+  {
+    value: "provider",
+    label: "Model Provider",
+    describe: "Connect custom LLM providers or model endpoints"
+  },
+  {
+    value: "command",
+    label: "Slash Command",
+    describe: "Register console commands in the form /xxx"
+  },
+  {
+    value: "hook",
+    label: "Lifecycle Hook",
+    describe: "Run code at key moments such as startup and shutdown"
+  },
+  {
+    value: "frontend",
+    label: "UI Extension",
+    describe: "Provide frontend JS bundles loaded dynamically by the UI"
+  },
+  {
+    value: "general",
+    label: "General Plugin",
+    describe: "Does not fit the categories above, or combines multiple capabilities"
+  }
+];
+async function runCommand(command, args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += String(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += String(chunk);
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) resolve(stdout);
+      else reject(new Error(stderr || `Command failed: ${command} ${args.join(" ")}`));
+    });
+  });
+}
+async function readPluginManifestFromZip(zipPath) {
+  if (!zipPath) return void 0;
+  try {
+    const stdout = await runCommand("unzip", ["-p", zipPath, "plugin.json"]);
+    return JSON.parse(stdout);
+  } catch {
+    return void 0;
+  }
+}
+function getClient(getConfig2) {
+  return new CliApiClient(getConfig2());
+}
+async function runSearch(getConfig2, query, opts) {
+  const config = getConfig2();
+  const client = getClient(getConfig2);
+  const response = await client.searchPlugins({
+    q: query,
+    category: opts.category,
+    source: opts.source,
+    sort: opts.sort,
+    page_size: opts.pageSize,
+    cursor: opts.cursor
+  });
+  if (config.json) {
+    printJson(response);
+    return;
+  }
+  if (response.items.length === 0) {
+    printInfo("No plugins found.");
+    return;
+  }
+  const rows = response.items.map((item) => [
+    item.plugin_id,
+    String(item.latest_version ?? "-"),
+    formatPluginListTechType(item),
+    String(item.name ?? "-")
+  ]);
+  printTable(["plugin_id", "version", "tech_type", "name"], rows);
+  if (response.next_cursor) {
+    printInfo(`Next cursor: ${response.next_cursor}`);
+  }
+}
+async function runInfo(getConfig2, pluginId, opts) {
+  const config = getConfig2();
+  const client = getClient(getConfig2);
+  const response = await client.getPluginInfo(pluginId, opts.version);
+  if (config.json) {
+    printJson(response);
+    return;
+  }
+  printInfo(`Plugin: ${response.plugin_id}`);
+  if (response.latest_version) printInfo(`Version: ${response.latest_version}`);
+  if (response.scan_status) printInfo(`Scan: ${response.scan_status}`);
+  if (response.install_command) printInfo(`Install: ${response.install_command}`);
+  if (response.public_url) printInfo(`URL: ${response.public_url}`);
+}
+async function runVersions(getConfig2, pluginId) {
+  const config = getConfig2();
+  const client = getClient(getConfig2);
+  const response = await client.getPluginVersions(pluginId);
+  if (config.json) {
+    printJson(response);
+    return;
+  }
+  if (response.items.length === 0) {
+    printInfo("No published versions.");
+    return;
+  }
+  const rows = response.items.map((item) => [
+    item.version,
+    item.published_at ?? "-",
+    item.deprecated ? "yes" : "no"
+  ]);
+  printTable(["version", "published_at", "deprecated"], rows);
+}
+async function runInstall(getConfig2, pluginId, opts) {
+  const base = getConfig2();
+  const { config } = await requireCredentials(base, base.platformUrl);
+  const client = new CliApiClient(config);
+  const intent = await client.createInstallIntent(pluginId, opts.version);
+  if (base.json) {
+    printJson(intent);
+    return;
+  }
+  if (opts.via !== void 0 && opts.via !== "qwenpaw") {
+    throw new AspError("Only --via qwenpaw is supported now.", {
+      code: "INVALID_REQUEST"
+    });
+  }
+  const installCmd = `qwenpaw plugin install ${intent.download_url}`;
+  printInfo(`Run to install:
+  ${installCmd}`);
+  if (intent.sha512) printInfo(`sha512: ${intent.sha512}`);
+  if (intent.expires_at) printInfo(`URL expires at: ${intent.expires_at}`);
+  const child = spawn("qwenpaw", ["plugin", "install", intent.download_url], {
+    stdio: "inherit"
+  });
+  await new Promise((resolve, reject) => {
+    child.on("exit", (code) => {
+      if (code === 0) resolve();
+      else reject(new AspError(`qwenpaw exited with code ${code ?? 1}`, { code: "QWENPAW_FAILED" }));
+    });
+    child.on("error", reject);
+  });
+}
+async function uploadZipToSignedUrl(upload, fileBuffer) {
+  const response = await fetch(upload.url, {
+    method: upload.method ?? "PUT",
+    headers: upload.headers ?? {},
+    body: fileBuffer
+  });
+  if (!response.ok) {
+    throw new AspError(`Upload failed with HTTP ${response.status}`, {
+      code: "UPLOAD_FAILED",
+      statusCode: response.status
+    });
+  }
+}
+function buildZipBody(filePath, fileBuffer, sha512, opts) {
+  return appendOptionalArtifactFields(
+    {
+      artifact_type: "plugin",
+      package_source: "zip",
+      category: opts.category,
+      filename: basename(filePath),
+      size_bytes: fileBuffer.byteLength,
+      sha512,
+      publish_mode: opts.publishMode ?? "auto_after_scan",
+      client: {
+        name: "agentscope-platform-cli",
+        version: CLI_VERSION
+      }
+    },
+    {
+      artifactId: opts.artifactId,
+      version: opts.version,
+      repoUrl: opts.repoUrl
+    }
+  );
+}
+function buildUrlBody(opts) {
+  return appendOptionalArtifactFields(
+    {
+      artifact_type: "plugin",
+      package_source: "url",
+      source_url: opts.url,
+      category: opts.category,
+      publish_mode: opts.publishMode ?? "auto_after_scan",
+      client: {
+        name: "agentscope-platform-cli",
+        version: CLI_VERSION
+      }
+    },
+    {
+      artifactId: opts.artifactId,
+      version: opts.version,
+      repoUrl: opts.repoUrl
+    }
+  );
+}
+function parseCategory(inputValue) {
+  if (!inputValue) return void 0;
+  const normalized = inputValue.trim().toLowerCase();
+  if (PLUGIN_CATEGORY_OPTIONS.some((item) => item.value === normalized)) {
+    return normalized;
+  }
+  return void 0;
+}
+function tryParseCategoryFromUrl(urlValue) {
+  if (!urlValue) return void 0;
+  try {
+    const parsed = new URL(urlValue);
+    const queryCategory = parseCategory(parsed.searchParams.get("category") ?? void 0);
+    if (queryCategory) return queryCategory;
+    const segments = parsed.pathname.split("/").map((item) => item.trim().toLowerCase()).filter(Boolean);
+    for (let i = 0; i < segments.length; i += 1) {
+      const current = parseCategory(segments[i]);
+      if (current) return current;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+function tryParsePluginIdFromUrl(urlValue) {
+  if (!urlValue) return void 0;
+  try {
+    const parsed = new URL(urlValue);
+    const segments = parsed.pathname.split("/").map((item) => item.trim()).filter(Boolean);
+    const pluginsIdx = segments.findIndex((item) => item.toLowerCase() === "plugins");
+    if (pluginsIdx >= 0 && segments[pluginsIdx + 2]) {
+      return segments[pluginsIdx + 2];
+    }
+    const last = segments[segments.length - 1];
+    if (last?.toLowerCase().endsWith(".zip")) {
+      return last.replace(/-\d+\.\d+\.\d+.*\.zip$/i, "").replace(/\.zip$/i, "");
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function tryParseCategoryFromZip(zipPath, manifest) {
+  const parsed = manifest ?? await readPluginManifestFromZip(zipPath);
+  return parseCategory(parsed?.type);
+}
+function printManifestPreview(manifest, jsonOutput) {
+  if (jsonOutput || !manifest) return;
+  if (manifest.id) {
+    printInfo(`Package plugin id: ${manifest.id} (parsed on complete if --artifact-id is omitted)`);
+  }
+  if (manifest.version) {
+    printInfo(`Package version: ${manifest.version} (parsed on complete if --version is omitted)`);
+  }
+}
+function validateExplicitManifestOverrides(opts, manifest) {
+  if (opts.artifactId && manifest?.id && opts.artifactId !== manifest.id) {
+    throw new AspError(
+      `artifact_id mismatch: --artifact-id=${opts.artifactId}, plugin.json id=${manifest.id}`,
+      {
+        code: "ARTIFACT_ID_MISMATCH",
+        hint: "Remove --artifact-id to let the server parse from package, or fix the value."
+      }
+    );
+  }
+  if (opts.version && manifest?.version && opts.version !== manifest.version) {
+    throw new AspError(
+      `version mismatch: --version=${opts.version}, plugin.json version=${manifest.version}`,
+      {
+        code: "VERSION_MISMATCH",
+        hint: "Remove --version to let the server parse from package, or fix the value."
+      }
+    );
+  }
+}
+async function resolvePublishCategoryWithAutoDetect(opts, zipPath, jsonOutput, manifest) {
+  const fromArg = parseCategory(opts.category);
+  if (fromArg) return fromArg;
+  if (opts.category && !fromArg) {
+    throw new AspError(`Invalid --category: ${opts.category}`, {
+      code: "INVALID_REQUEST",
+      hint: `Use one of: ${PLUGIN_CATEGORY_OPTIONS.map((item) => item.value).join(", ")}`
+    });
+  }
+  const fromZip = await tryParseCategoryFromZip(zipPath, manifest);
+  if (fromZip) {
+    if (!jsonOutput) printInfo(`Detected category from plugin package: ${fromZip}`);
+    return fromZip;
+  }
+  const fromUrl = tryParseCategoryFromUrl(opts.url);
+  if (fromUrl) {
+    if (!jsonOutput) printInfo(`Detected category from source URL: ${fromUrl}`);
+    return fromUrl;
+  }
+  return resolvePublishCategory(opts, jsonOutput);
+}
+async function resolvePublishCategory(opts, jsonOutput) {
+  const fromArg = parseCategory(opts.category);
+  if (fromArg) return fromArg;
+  if (opts.category && !fromArg) {
+    throw new AspError(`Invalid --category: ${opts.category}`, {
+      code: "INVALID_REQUEST",
+      hint: `Use one of: ${PLUGIN_CATEGORY_OPTIONS.map((item) => item.value).join(", ")}`
+    });
+  }
+  if (jsonOutput || !input2.isTTY || !output2.isTTY) {
+    throw new AspError("Plugin publish requires --category.", {
+      code: "INVALID_REQUEST",
+      hint: `Use --category with one of: ${PLUGIN_CATEGORY_OPTIONS.map((item) => item.value).join(", ")}`
+    });
+  }
+  printInfo("Select plugin category:");
+  for (const [index, item] of PLUGIN_CATEGORY_OPTIONS.entries()) {
+    printInfo(`${index + 1}) ${item.value} - ${item.label}`);
+    printInfo(`   ${item.describe}`);
+  }
+  const rl = createInterface2({ input: input2, output: output2 });
+  try {
+    while (true) {
+      const answer = (await rl.question("Enter category number or value: ")).trim();
+      const index = Number.parseInt(answer, 10);
+      if (!Number.isNaN(index) && index >= 1 && index <= PLUGIN_CATEGORY_OPTIONS.length) {
+        const selected = PLUGIN_CATEGORY_OPTIONS[index - 1].value;
+        printInfo(`Selected category: ${selected}`);
+        return selected;
+      }
+      const byValue = parseCategory(answer);
+      if (byValue) {
+        printInfo(`Selected category: ${byValue}`);
+        return byValue;
+      }
+      printWarn(`Invalid choice. Use 1-${PLUGIN_CATEGORY_OPTIONS.length} or category value.`);
+    }
+  } finally {
+    rl.close();
+  }
+}
+function isMissingCategoryError(err) {
+  if (!(err instanceof AspError)) return false;
+  if (err.code !== "INVALID_REQUEST") return false;
+  const message = `${err.message} ${err.hint ?? ""}`.toLowerCase();
+  return message.includes("category") || message.includes("\u6280\u672F\u7C7B\u578B");
+}
+async function showPublishedPluginStatus(client, pluginId, jsonOutput) {
+  try {
+    const info = await client.getPluginInfo(pluginId);
+    if (jsonOutput) {
+      printJson({
+        plugin_id: info.plugin_id,
+        status: "published",
+        terminal: true,
+        latest_version: info.latest_version,
+        scan_status: info.scan_status,
+        public_url: info.public_url,
+        install_command: info.install_command
+      });
+      return;
+    }
+    printInfo(`Plugin: ${info.plugin_id}`);
+    printInfo("Status: published");
+    printInfo("Terminal: yes");
+    if (info.latest_version) printInfo(`Version: ${info.latest_version}`);
+    if (info.scan_status) printInfo(`Scan: ${info.scan_status}`);
+    if (info.public_url) printInfo(`URL: ${info.public_url}`);
+    if (info.install_command) printInfo(`Install: ${info.install_command}`);
+  } catch (err) {
+    if (err instanceof AspError && err.statusCode === 404) {
+      throw new AspError(`No submission or published plugin found: ${pluginId}`, {
+        code: "NOT_FOUND",
+        hint: "If the plugin is still scanning, use submission_id from publish output. Republish on this machine to cache plugin_id mapping locally."
+      });
+    }
+    throw err;
+  }
+}
+async function runPublish(getConfig2, zipPath, opts) {
+  const base = getConfig2();
+  const { config } = await requireCredentials(base, base.platformUrl);
+  const client = new CliApiClient(config);
+  const useUrlMode = Boolean(opts.url);
+  const manifest = useUrlMode ? void 0 : await readPluginManifestFromZip(zipPath);
+  printManifestPreview(manifest, base.json);
+  validateExplicitManifestOverrides(opts, manifest);
+  let publishOpts;
+  try {
+    const category = await resolvePublishCategoryWithAutoDetect(
+      opts,
+      zipPath,
+      base.json,
+      manifest
+    );
+    publishOpts = { ...opts, category };
+  } catch (err) {
+    if (!isMissingCategoryError(err)) throw err;
+    const category = await resolvePublishCategory({ ...opts, category: void 0 }, base.json);
+    publishOpts = { ...opts, category };
+  }
+  if (useUrlMode && zipPath) {
+    throw new AspError("Do not pass zip path when using --url.", {
+      code: "INVALID_REQUEST",
+      hint: "Use either `asp plugin publish ./plugin.zip` or `asp plugin publish --url <url>`."
+    });
+  }
+  if (!useUrlMode && !zipPath) {
+    throw new AspError("Zip path is required unless --url is provided.", {
+      code: "INVALID_REQUEST",
+      hint: "Use `asp plugin publish ./plugin.zip`."
+    });
+  }
+  let submission;
+  const tryCreateSubmission = async () => {
+    if (useUrlMode) {
+      return client.createArtifactSubmission(buildUrlBody(publishOpts));
+    }
+    const fileBuffer = await readFile2(zipPath);
+    const sha512 = createHash2("sha512").update(fileBuffer).digest("hex");
+    let localSubmission = await client.createArtifactSubmission(
+      buildZipBody(zipPath, fileBuffer, sha512, publishOpts)
+    );
+    if (!localSubmission.upload?.url) {
+      throw new AspError("Missing upload URL for zip submission.", {
+        code: "UPLOAD_URL_MISSING"
+      });
+    }
+    printInfo("Uploading plugin zip to object storage...");
+    await uploadZipToSignedUrl(localSubmission.upload, fileBuffer);
+    localSubmission = await client.completeArtifactSubmission(localSubmission.submission_id, {
+      sha512,
+      size_bytes: fileBuffer.byteLength
+    });
+    return localSubmission;
+  };
+  try {
+    submission = await tryCreateSubmission();
+  } catch (err) {
+    if (!isMissingCategoryError(err) || base.json || !input2.isTTY || !output2.isTTY) {
+      throw err;
+    }
+    printWarn("Publish failed due to missing category, please choose one and retrying...");
+    const category = await resolvePublishCategory({ ...opts, category: void 0 }, base.json);
+    publishOpts = { ...opts, category };
+    submission = await tryCreateSubmission();
+  }
+  const urlPluginId = useUrlMode ? tryParsePluginIdFromUrl(publishOpts.url) : void 0;
+  await recordPluginPublish({
+    submissionId: submission.submission_id,
+    platformUrl: config.platformUrl,
+    pluginId: publishOpts.artifactId ?? manifest?.id ?? urlPluginId,
+    sourceUrl: useUrlMode ? publishOpts.url : void 0
+  });
+  if (base.json) {
+    printJson(submission);
+    return;
+  }
+  printSuccess(`Submission created: ${submission.submission_id}`);
+  printInfo(`Initial status: ${submission.status}`);
+  const trackRef = publishOpts.artifactId ?? manifest?.id ?? urlPluginId ?? submission.submission_id;
+  if (opts.noWait) {
+    printInfo(`Track progress: asp plugin publish status ${trackRef}`);
+    printInfo(`Show logs: asp plugin publish logs ${trackRef}`);
+    return;
+  }
+  if (!submission.terminal) {
+    printSuccess("Upload submitted successfully. Scanning continues asynchronously.");
+    printInfo(`Track progress: asp plugin publish status ${trackRef} --watch`);
+    printInfo(`Show logs: asp plugin publish logs ${trackRef}`);
+    return;
+  }
+  if (submission.status === "published") {
+    printSuccess(`Published successfully (${formatPlatformLabel(config.platformUrl)})`);
+    if (submission.publish?.public_url) {
+      printInfo(`URL: ${submission.publish.public_url}`);
+    }
+    return;
+  }
+  printWarn(`Submission ended with status: ${submission.status}`);
+  if (submission.failure?.message) {
+    printWarn(`Failure: ${submission.failure.message}`);
+  }
+  printInfo(`Inspect logs: asp plugin publish logs ${trackRef}`);
+}
+async function runPublishStatus(getConfig2, pluginRef, opts) {
+  const base = getConfig2();
+  const { config } = await requireCredentials(base, base.platformUrl);
+  const client = new CliApiClient(config);
+  if (looksLikeSubmissionId(pluginRef)) {
+    const state2 = opts.watch ? await pollUntilTerminal(client, pluginRef, true) : await client.getArtifactSubmission(pluginRef);
+    if (base.json) {
+      printJson(state2);
+      return;
+    }
+    printInfo(`Submission: ${state2.submission_id}`);
+    printInfo(`Status: ${state2.status}`);
+    printInfo(`Terminal: ${state2.terminal ? "yes" : "no"}`);
+    if (state2.scan?.status) printInfo(`Scan: ${state2.scan.status}`);
+    if (state2.publish?.public_url) printInfo(`URL: ${state2.publish.public_url}`);
+    if (state2.failure?.message) printWarn(`Failure: ${state2.failure.message}`);
+    return;
+  }
+  const submissionId = await resolvePluginSubmissionId(client, pluginRef, config.platformUrl);
+  if (!submissionId) {
+    await showPublishedPluginStatus(client, pluginRef, base.json);
+    return;
+  }
+  if (!base.json) {
+    printInfo(`Resolved plugin id "${pluginRef}" -> submission ${submissionId}`);
+  }
+  const current = await client.getArtifactSubmission(submissionId);
+  if (current.terminal && current.status === "published") {
+    await showPublishedPluginStatus(client, pluginRef, base.json);
+    return;
+  }
+  const state = opts.watch ? await pollUntilTerminal(client, submissionId, true) : current;
+  if (base.json) {
+    printJson(state);
+    return;
+  }
+  printInfo(`Submission: ${state.submission_id}`);
+  printInfo(`Status: ${state.status}`);
+  printInfo(`Terminal: ${state.terminal ? "yes" : "no"}`);
+  if (state.scan?.status) printInfo(`Scan: ${state.scan.status}`);
+  if (state.publish?.public_url) printInfo(`URL: ${state.publish.public_url}`);
+  if (state.failure?.message) printWarn(`Failure: ${state.failure.message}`);
+}
+async function runPublishLogs(getConfig2, pluginRef, _opts) {
+  const base = getConfig2();
+  const { config } = await requireCredentials(base, base.platformUrl);
+  const client = new CliApiClient(config);
+  const submissionId = await resolvePluginSubmissionId(client, pluginRef, config.platformUrl);
+  if (!submissionId) {
+    throw new AspError(`No publish logs found for plugin id: ${pluginRef}`, {
+      code: "NOT_FOUND",
+      hint: "Use submission_id from publish output, or republish on this machine to cache the mapping."
+    });
+  }
+  if (submissionId !== pluginRef && !base.json) {
+    printInfo(`Resolved plugin id "${pluginRef}" -> submission ${submissionId}`);
+  }
+  const logs = await client.getArtifactSubmissionLogs(submissionId);
+  if (base.json) {
+    printJson(logs);
+    return;
+  }
+  if (logs.items.length === 0) {
+    printInfo("No logs yet.");
+    return;
+  }
+  const rows = logs.items.map((item) => [item.timestamp, item.level, item.message]);
+  printTable(["timestamp", "level", "message"], rows);
+}
+function registerPluginCommands(program2, getConfig2) {
+  const plugin = program2.command("plugin").description("Plugin marketplace and publish commands");
+  plugin.command("search [query]").description("Search plugins").option("--category <code>", "Tech type/category code").option("--source <source>", "official | verified | community").option("--sort <sort>", "recommended | downloads | updated_at").option("--page-size <n>", "Page size", (v) => Number.parseInt(v, 10)).option("--cursor <cursor>", "Cursor for next page").action(async (query, opts) => {
+    await runSearch(getConfig2, query, opts);
+  });
+  plugin.command("info <pluginId>").description("Show plugin details").option("--version <version>", "Specify version").action(async (pluginId, opts) => {
+    await runInfo(getConfig2, pluginId, opts);
+  });
+  plugin.command("versions <pluginId>").description("List published versions").action(async (pluginId) => {
+    await runVersions(getConfig2, pluginId);
+  });
+  plugin.command("install <pluginId>").description("Install plugin via qwenpaw").option("--version <version>", "Specify version").option("--via <tool>", "Install tool (qwenpaw)", "qwenpaw").action(async (pluginId, opts) => {
+    await runInstall(getConfig2, pluginId, opts);
+  });
+  const publish = plugin.command("publish [zipPath]").description("Publish plugin from local zip or URL").option("--url <url>", "Publish from remote zip URL").option("--artifact-id <id>", "Optional plugin id override (must match plugin.json in zip mode)").option("--version <version>", "Optional version override").option("--category <code>", "Plugin category code (tool|provider|command|hook|frontend|general)").option("--repo-url <url>", "Repository URL").option("--publish-mode <mode>", "Publish mode", "auto_after_scan").option("--no-wait", "Do not wait for terminal status").action(async (zipPath, opts) => {
+    await runPublish(getConfig2, zipPath, opts);
+  });
+  publish.command("status <pluginId>").description("Show publish status by plugin id or submission id").option("--watch", "Poll until terminal status", false).action(async (pluginId, opts) => {
+    await runPublishStatus(getConfig2, pluginId, opts);
+  });
+  publish.command("logs <pluginId>").description("Show publish logs by plugin id or submission id").action(async (pluginId, opts) => {
+    await runPublishLogs(getConfig2, pluginId, opts);
+  });
+}
+
+// src/commands/skill.ts
+import { basename as basename2 } from "path";
+import { createHash as createHash3 } from "crypto";
+import { readFile as readFile3 } from "fs/promises";
+import { spawn as spawn3 } from "child_process";
+import { createInterface as createInterface3 } from "readline/promises";
+import { stdin as input3, stdout as output3 } from "process";
+
+// src/utils/skill-manifest.ts
+import { spawn as spawn2 } from "child_process";
+async function runCommand2(command, args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn2(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) resolve(stdout);
+      else reject(new Error(stderr || `Command failed: ${command} ${args.join(" ")}`));
+    });
+  });
+}
+function parseSkillFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return {};
+  const yaml = match[1];
+  const manifest = {};
+  const nameMatch = yaml.match(/^name:\s*["']?([^"'\n]+)["']?\s*$/m);
+  if (nameMatch) manifest.name = nameMatch[1].trim();
+  const versionMatch = yaml.match(/^version:\s*["']?([^"'\n]+)["']?\s*$/m);
+  if (versionMatch) {
+    manifest.version = versionMatch[1].trim();
+    return manifest;
+  }
+  const metadataVersionMatch = yaml.match(/^\s+version:\s*["']?([^"'\n]+)["']?\s*$/m);
+  if (metadataVersionMatch) {
+    manifest.version = metadataVersionMatch[1].trim();
+  }
+  return manifest;
+}
+async function findSkillMdPathInZip(zipPath) {
+  const listing = await runCommand2("unzip", ["-Z1", zipPath]);
+  const paths = listing.split("\n").map((item) => item.trim()).filter(Boolean);
+  const matches = paths.filter((item) => /(^|\/)SKILL\.md$/i.test(item));
+  if (matches.length === 0) return void 0;
+  return matches.sort((a, b) => a.length - b.length)[0];
+}
+async function readSkillManifestFromZip(zipPath) {
+  if (!zipPath) return void 0;
+  try {
+    const skillMdPath = await findSkillMdPathInZip(zipPath);
+    if (!skillMdPath) return void 0;
+    const stdout = await runCommand2("unzip", ["-p", zipPath, skillMdPath]);
+    return parseSkillFrontmatter(stdout);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/commands/skill.ts
+var SKILL_CATEGORY_OPTIONS = [
+  { value: "engineering development", label: "\u5DE5\u7A0B\u5F00\u53D1" },
+  { value: "data research", label: "\u6570\u636E\u7814\u7A76" },
+  { value: "document office", label: "\u6587\u6863\u529E\u516C" },
+  { value: "design creation", label: "\u8BBE\u8BA1\u521B\u4F5C" },
+  { value: "automation integration", label: "\u81EA\u52A8\u5316\u96C6\u6210" },
+  { value: "product management", label: "\u4EA7\u54C1\u7BA1\u7406" },
+  { value: "marketing growth", label: "\u8425\u9500\u589E\u957F" },
+  { value: "security compliance", label: "\u5B89\u5168\u5408\u89C4" },
+  { value: "education knowledge", label: "\u6559\u80B2\u77E5\u8BC6" },
+  { value: "plugin development", label: "Plugin \u5F00\u53D1" },
+  { value: "skills management", label: "Skills \u7BA1\u7406" },
+  { value: "others", label: "\u5176\u5B83" }
+];
+function getClient2(getConfig2) {
+  return new CliApiClient(getConfig2());
+}
+function parseTags(tags) {
+  if (!tags) return void 0;
+  return tags.split(",").map((item) => item.trim()).filter(Boolean).slice(0, 3);
+}
+async function runSearch2(getConfig2, query, opts) {
+  const config = getConfig2();
+  const client = getClient2(getConfig2);
+  const response = await client.searchSkills({
+    q: query,
+    category: opts.category,
+    source: opts.source,
+    tag: opts.tag,
+    sort: opts.sort,
+    page_size: opts.pageSize,
+    cursor: opts.cursor
+  });
+  if (config.json) {
+    printJson(response);
+    return;
+  }
+  if (response.items.length === 0) {
+    printInfo("No skills found.");
+    return;
+  }
+  const rows = response.items.map((item) => [
+    item.skill_id,
+    String(item.latest_version ?? "-"),
+    String(item.category ?? "-"),
+    String(item.source ?? "-")
+  ]);
+  printTable(["skill_id", "version", "category", "source"], rows);
+  if (response.next_cursor) {
+    printInfo(`Next cursor: ${response.next_cursor}`);
+  }
+}
+async function runInfo2(getConfig2, skillId, opts) {
+  const config = getConfig2();
+  const client = getClient2(getConfig2);
+  const response = await client.getSkillInfo(skillId, opts.version);
+  if (config.json) {
+    printJson(response);
+    return;
+  }
+  printInfo(`Skill: ${response.skill_id}`);
+  if (response.latest_version) printInfo(`Version: ${response.latest_version}`);
+  if (response.scan_status) printInfo(`Scan: ${response.scan_status}`);
+  if (response.install_command) printInfo(`Install: ${response.install_command}`);
+  if (response.public_url) printInfo(`URL: ${response.public_url}`);
+}
+async function runVersions2(getConfig2, skillId) {
+  const config = getConfig2();
+  const client = getClient2(getConfig2);
+  const response = await client.getSkillVersions(skillId);
+  if (config.json) {
+    printJson(response);
+    return;
+  }
+  if (response.items.length === 0) {
+    printInfo("No published versions.");
+    return;
+  }
+  const rows = response.items.map((item) => [
+    item.version,
+    item.published_at ?? "-",
+    item.deprecated ? "yes" : "no"
+  ]);
+  printTable(["version", "published_at", "deprecated"], rows);
+}
+async function runInstall2(getConfig2, skillId, opts) {
+  const base = getConfig2();
+  const { config } = await requireCredentials(base, base.platformUrl);
+  const client = new CliApiClient(config);
+  const intent = await client.createSkillInstallIntent(skillId, opts.version);
+  if (base.json) {
+    printJson(intent);
+    return;
+  }
+  if (opts.via !== void 0 && opts.via !== "qwenpaw") {
+    throw new AspError("Only --via qwenpaw is supported now.", {
+      code: "INVALID_REQUEST"
+    });
+  }
+  const installCmd = `qwenpaw skill install ${intent.download_url}`;
+  printInfo(`Run to install:
+  ${installCmd}`);
+  if (intent.sha512) printInfo(`sha512: ${intent.sha512}`);
+  if (intent.expires_at) printInfo(`URL expires at: ${intent.expires_at}`);
+  const child = spawn3("qwenpaw", ["skill", "install", intent.download_url], {
+    stdio: "inherit"
+  });
+  await new Promise((resolve, reject) => {
+    child.on("exit", (code) => {
+      if (code === 0) resolve();
+      else reject(new AspError(`qwenpaw exited with code ${code ?? 1}`, { code: "QWENPAW_FAILED" }));
+    });
+    child.on("error", reject);
+  });
+}
+async function uploadZipToSignedUrl2(upload, fileBuffer) {
+  const response = await fetch(upload.url, {
+    method: upload.method ?? "PUT",
+    headers: upload.headers ?? {},
+    body: fileBuffer
+  });
+  if (!response.ok) {
+    throw new AspError(`Upload failed with HTTP ${response.status}`, {
+      code: "UPLOAD_FAILED",
+      statusCode: response.status
+    });
+  }
+}
+function buildZipBody2(filePath, fileBuffer, sha512, opts) {
+  const body = appendOptionalArtifactFields(
+    {
+      artifact_type: "skill",
+      package_source: "zip",
+      category: opts.category,
+      tags: parseTags(opts.tags),
+      filename: basename2(filePath),
+      size_bytes: fileBuffer.byteLength,
+      sha512,
+      publish_mode: opts.publishMode ?? "auto_after_scan",
+      client: {
+        name: "agentscope-platform-cli",
+        version: CLI_VERSION
+      }
+    },
+    {
+      artifactId: opts.artifactId,
+      version: opts.version,
+      repoUrl: opts.repoUrl
+    }
+  );
+  return body;
+}
+function buildUrlBody2(opts) {
+  return appendOptionalArtifactFields(
+    {
+      artifact_type: "skill",
+      package_source: "url",
+      source_url: opts.url,
+      category: opts.category,
+      tags: parseTags(opts.tags),
+      publish_mode: opts.publishMode ?? "auto_after_scan",
+      client: {
+        name: "agentscope-platform-cli",
+        version: CLI_VERSION
+      }
+    },
+    {
+      artifactId: opts.artifactId,
+      version: opts.version,
+      repoUrl: opts.repoUrl
+    }
+  );
+}
+function parseCategory2(inputValue) {
+  if (!inputValue) return void 0;
+  const normalized = inputValue.trim().toLowerCase();
+  if (SKILL_CATEGORY_OPTIONS.some((item) => item.value === normalized)) {
+    return normalized;
+  }
+  return void 0;
+}
+async function resolvePublishCategory2(opts, jsonOutput) {
+  const fromArg = parseCategory2(opts.category);
+  if (fromArg) return fromArg;
+  if (opts.category && !fromArg) {
+    throw new AspError(`Invalid --category: ${opts.category}`, {
+      code: "INVALID_REQUEST",
+      hint: `Use one of: ${SKILL_CATEGORY_OPTIONS.map((item) => item.value).join(", ")}`
+    });
+  }
+  if (jsonOutput || !input3.isTTY || !output3.isTTY) {
+    throw new AspError("Skill publish requires --category.", {
+      code: "INVALID_REQUEST",
+      hint: `Use --category with one of: ${SKILL_CATEGORY_OPTIONS.map((item) => item.value).join(", ")}`
+    });
+  }
+  printInfo("Select skill category:");
+  for (const [index, item] of SKILL_CATEGORY_OPTIONS.entries()) {
+    printInfo(`${index + 1}) ${item.value} - ${item.label}`);
+  }
+  const rl = createInterface3({ input: input3, output: output3 });
+  try {
+    while (true) {
+      const answer = (await rl.question("Enter category number or value: ")).trim();
+      const index = Number.parseInt(answer, 10);
+      if (!Number.isNaN(index) && index >= 1 && index <= SKILL_CATEGORY_OPTIONS.length) {
+        const selected = SKILL_CATEGORY_OPTIONS[index - 1].value;
+        printInfo(`Selected category: ${selected}`);
+        return selected;
+      }
+      const byValue = parseCategory2(answer);
+      if (byValue) {
+        printInfo(`Selected category: ${byValue}`);
+        return byValue;
+      }
+      printWarn(`Invalid choice. Use 1-${SKILL_CATEGORY_OPTIONS.length} or category value.`);
+    }
+  } finally {
+    rl.close();
+  }
+}
+async function resolvePublishVersion(jsonOutput) {
+  if (jsonOutput || !input3.isTTY || !output3.isTTY) {
+    throw new AspError("Skill publish requires version.", {
+      code: "INVALID_REQUEST",
+      hint: "Add `version: 1.0.0` to SKILL.md frontmatter, or pass --version 1.0.0."
+    });
+  }
+  const rl = createInterface3({ input: input3, output: output3 });
+  try {
+    while (true) {
+      const answer = (await rl.question("Enter skill version (e.g. 1.0.0): ")).trim();
+      if (answer) {
+        printInfo(`Using version: ${answer}`);
+        return answer;
+      }
+      printWarn("Version is required. Example: 1.0.0");
+    }
+  } finally {
+    rl.close();
+  }
+}
+function isMissingVersionError(err) {
+  if (!(err instanceof AspError)) return false;
+  if (err.code !== "INVALID_REQUEST") return false;
+  const message = `${err.message} ${err.hint ?? ""}`.toLowerCase();
+  return message.includes("version") || message.includes("skill.md");
+}
+function printSkillManifestPreview(manifest, jsonOutput) {
+  if (jsonOutput || !manifest) return;
+  if (manifest.name) {
+    printInfo(`Package skill id: ${manifest.name}`);
+  }
+  if (manifest.version) {
+    printInfo(`Package version: ${manifest.version}`);
+  }
+}
+function validateExplicitSkillOverrides(opts, manifest) {
+  if (opts.artifactId && manifest?.name && opts.artifactId !== manifest.name) {
+    throw new AspError(
+      `artifact_id mismatch: --artifact-id=${opts.artifactId}, SKILL.md name=${manifest.name}`,
+      {
+        code: "ARTIFACT_ID_MISMATCH",
+        hint: "Remove --artifact-id or fix the value to match SKILL.md."
+      }
+    );
+  }
+  if (opts.version && manifest?.version && opts.version !== manifest.version) {
+    throw new AspError(
+      `version mismatch: --version=${opts.version}, SKILL.md version=${manifest.version}`,
+      {
+        code: "VERSION_MISMATCH",
+        hint: "Remove --version or fix the value to match SKILL.md."
+      }
+    );
+  }
+}
+function resolveSkillPublishFields(opts, manifest) {
+  return {
+    ...opts,
+    artifactId: opts.artifactId ?? manifest?.name,
+    version: opts.version ?? manifest?.version
+  };
+}
+function isMissingCategoryError2(err) {
+  if (!(err instanceof AspError)) return false;
+  if (err.code !== "INVALID_REQUEST") return false;
+  const message = `${err.message} ${err.hint ?? ""}`.toLowerCase();
+  return message.includes("category") || message.includes("\u6280\u672F\u7C7B\u578B") || message.includes("\u5927\u7C7B");
+}
+function tryParseSkillIdFromUrl(urlValue) {
+  if (!urlValue) return void 0;
+  try {
+    const parsed = new URL(urlValue);
+    const segments = parsed.pathname.split("/").map((item) => item.trim()).filter(Boolean);
+    const skillsIdx = segments.findIndex((item) => item.toLowerCase() === "skills");
+    if (skillsIdx >= 0 && segments[skillsIdx + 1]) {
+      return segments[skillsIdx + 1];
+    }
+    const last = segments[segments.length - 1];
+    if (last?.toLowerCase().endsWith(".zip")) {
+      return last.replace(/-\d+\.\d+\.\d+.*\.zip$/i, "").replace(/\.zip$/i, "");
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function showPublishedSkillStatus(client, skillId, jsonOutput) {
+  try {
+    const info = await client.getSkillInfo(skillId);
+    if (jsonOutput) {
+      printJson({
+        skill_id: info.skill_id,
+        status: "published",
+        terminal: true,
+        latest_version: info.latest_version,
+        scan_status: info.scan_status,
+        public_url: info.public_url,
+        install_command: info.install_command
+      });
+      return;
+    }
+    printInfo(`Skill: ${info.skill_id}`);
+    printInfo("Status: published");
+    printInfo("Terminal: yes");
+    if (info.latest_version) printInfo(`Version: ${info.latest_version}`);
+    if (info.scan_status) printInfo(`Scan: ${info.scan_status}`);
+    if (info.public_url) printInfo(`URL: ${info.public_url}`);
+    if (info.install_command) printInfo(`Install: ${info.install_command}`);
+  } catch (err) {
+    if (err instanceof AspError && err.statusCode === 404) {
+      throw new AspError(`No submission or published skill found: ${skillId}`, {
+        code: "NOT_FOUND",
+        hint: "If the skill is still scanning, use submission_id from publish output. Republish on this machine to cache skill_id mapping locally."
+      });
+    }
+    throw err;
+  }
+}
+async function runPublish2(getConfig2, zipPath, opts) {
+  const base = getConfig2();
+  const { config } = await requireCredentials(base, base.platformUrl);
+  const client = new CliApiClient(config);
+  let publishOpts;
+  try {
+    const category = await resolvePublishCategory2(opts, base.json);
+    publishOpts = { ...opts, category };
+  } catch (err) {
+    if (!isMissingCategoryError2(err)) throw err;
+    const category = await resolvePublishCategory2({ ...opts, category: void 0 }, base.json);
+    publishOpts = { ...opts, category };
+  }
+  const useUrlMode = Boolean(opts.url);
+  if (useUrlMode && zipPath) {
+    throw new AspError("Do not pass zip path when using --url.", {
+      code: "INVALID_REQUEST",
+      hint: "Use either `asp skill publish ./skill.zip` or `asp skill publish --url <url>`."
+    });
+  }
+  if (!useUrlMode && !zipPath) {
+    throw new AspError("Zip path is required unless --url is provided.", {
+      code: "INVALID_REQUEST",
+      hint: "Use `asp skill publish ./skill.zip`."
+    });
+  }
+  const manifest = useUrlMode ? void 0 : await readSkillManifestFromZip(zipPath);
+  printSkillManifestPreview(manifest, base.json);
+  validateExplicitSkillOverrides(publishOpts, manifest);
+  publishOpts = resolveSkillPublishFields(publishOpts, manifest);
+  if (!publishOpts.version) {
+    publishOpts.version = await resolvePublishVersion(base.json);
+  }
+  let submission;
+  const tryCreateSubmission = async () => {
+    if (useUrlMode) {
+      return client.createArtifactSubmission(buildUrlBody2(publishOpts));
+    }
+    const fileBuffer = await readFile3(zipPath);
+    const sha512 = createHash3("sha512").update(fileBuffer).digest("hex");
+    let localSubmission = await client.createArtifactSubmission(
+      buildZipBody2(zipPath, fileBuffer, sha512, publishOpts)
+    );
+    if (!localSubmission.upload?.url) {
+      throw new AspError("Missing upload URL for zip submission.", {
+        code: "UPLOAD_URL_MISSING"
+      });
+    }
+    printInfo("Uploading skill zip to object storage...");
+    await uploadZipToSignedUrl2(localSubmission.upload, fileBuffer);
+    localSubmission = await client.completeArtifactSubmission(localSubmission.submission_id, {
+      sha512,
+      size_bytes: fileBuffer.byteLength
+    });
+    return localSubmission;
+  };
+  try {
+    submission = await tryCreateSubmission();
+  } catch (err) {
+    if (isMissingVersionError(err)) {
+      if (base.json || !input3.isTTY || !output3.isTTY) {
+        throw new AspError("SKILL.md in zip is missing version.", {
+          code: "INVALID_REQUEST",
+          hint: "Add `version: 1.0.0` to SKILL.md frontmatter (between --- markers), or pass --version 1.0.0."
+        });
+      }
+      printWarn("Publish failed due to missing version, please enter one and retrying...");
+      publishOpts.version = await resolvePublishVersion(base.json);
+      submission = await tryCreateSubmission();
+    } else if (!isMissingCategoryError2(err) || base.json || !input3.isTTY || !output3.isTTY) {
+      throw err;
+    } else {
+      printWarn("Publish failed due to missing category, please choose one and retrying...");
+      const category = await resolvePublishCategory2({ ...opts, category: void 0 }, base.json);
+      publishOpts = { ...publishOpts, category };
+      submission = await tryCreateSubmission();
+    }
+  }
+  const urlSkillId = useUrlMode ? tryParseSkillIdFromUrl(publishOpts.url) : void 0;
+  await recordSkillPublish({
+    submissionId: submission.submission_id,
+    platformUrl: config.platformUrl,
+    skillId: publishOpts.artifactId ?? urlSkillId,
+    sourceUrl: useUrlMode ? publishOpts.url : void 0
+  });
+  if (base.json) {
+    printJson(submission);
+    return;
+  }
+  printSuccess(`Submission created: ${submission.submission_id}`);
+  printInfo(`Initial status: ${submission.status}`);
+  const trackRef = publishOpts.artifactId ?? urlSkillId ?? submission.submission_id;
+  if (opts.noWait) {
+    printInfo(`Track progress: asp skill publish status ${trackRef}`);
+    printInfo(`Show logs: asp skill publish logs ${trackRef}`);
+    return;
+  }
+  if (!submission.terminal) {
+    printSuccess("Upload submitted successfully. Scanning continues asynchronously.");
+    printInfo(`Track progress: asp skill publish status ${trackRef} --watch`);
+    printInfo(`Show logs: asp skill publish logs ${trackRef}`);
+    return;
+  }
+  if (submission.status === "published") {
+    printSuccess(`Published successfully (${formatPlatformLabel(config.platformUrl)})`);
+    if (submission.publish?.public_url) {
+      printInfo(`URL: ${submission.publish.public_url}`);
+    }
+    return;
+  }
+  printWarn(`Submission ended with status: ${submission.status}`);
+  if (submission.failure?.message) {
+    printWarn(`Failure: ${submission.failure.message}`);
+  }
+  printInfo(`Inspect logs: asp skill publish logs ${trackRef}`);
+}
+async function runPublishStatus2(getConfig2, skillRef, opts) {
+  const base = getConfig2();
+  const { config } = await requireCredentials(base, base.platformUrl);
+  const client = new CliApiClient(config);
+  if (looksLikeSubmissionId(skillRef)) {
+    const state2 = opts.watch ? await pollUntilTerminal(client, skillRef, true) : await client.getArtifactSubmission(skillRef);
+    if (base.json) {
+      printJson(state2);
+      return;
+    }
+    printInfo(`Submission: ${state2.submission_id}`);
+    printInfo(`Status: ${state2.status}`);
+    printInfo(`Terminal: ${state2.terminal ? "yes" : "no"}`);
+    if (state2.scan?.status) printInfo(`Scan: ${state2.scan.status}`);
+    if (state2.publish?.public_url) printInfo(`URL: ${state2.publish.public_url}`);
+    if (state2.failure?.message) printWarn(`Failure: ${state2.failure.message}`);
+    return;
+  }
+  const submissionId = await resolveSkillSubmissionId(client, skillRef, config.platformUrl);
+  if (!submissionId) {
+    await showPublishedSkillStatus(client, skillRef, base.json);
+    return;
+  }
+  if (!base.json) {
+    printInfo(`Resolved skill id "${skillRef}" -> submission ${submissionId}`);
+  }
+  const current = await client.getArtifactSubmission(submissionId);
+  if (current.terminal && current.status === "published") {
+    await showPublishedSkillStatus(client, skillRef, base.json);
+    return;
+  }
+  const state = opts.watch ? await pollUntilTerminal(client, submissionId, true) : current;
+  if (base.json) {
+    printJson(state);
+    return;
+  }
+  printInfo(`Submission: ${state.submission_id}`);
+  printInfo(`Status: ${state.status}`);
+  printInfo(`Terminal: ${state.terminal ? "yes" : "no"}`);
+  if (state.scan?.status) printInfo(`Scan: ${state.scan.status}`);
+  if (state.publish?.public_url) printInfo(`URL: ${state.publish.public_url}`);
+  if (state.failure?.message) printWarn(`Failure: ${state.failure.message}`);
+}
+async function runPublishLogs2(getConfig2, skillRef) {
+  const base = getConfig2();
+  const { config } = await requireCredentials(base, base.platformUrl);
+  const client = new CliApiClient(config);
+  const submissionId = await resolveSkillSubmissionId(client, skillRef, config.platformUrl);
+  if (!submissionId) {
+    throw new AspError(`No publish logs found for skill id: ${skillRef}`, {
+      code: "NOT_FOUND",
+      hint: "Use submission_id from publish output, or republish on this machine to cache the mapping."
+    });
+  }
+  if (submissionId !== skillRef && !base.json) {
+    printInfo(`Resolved skill id "${skillRef}" -> submission ${submissionId}`);
+  }
+  const logs = await client.getArtifactSubmissionLogs(submissionId);
+  if (base.json) {
+    printJson(logs);
+    return;
+  }
+  if (logs.items.length === 0) {
+    printInfo("No logs yet.");
+    return;
+  }
+  const rows = logs.items.map((item) => [item.timestamp, item.level, item.message]);
+  printTable(["timestamp", "level", "message"], rows);
+}
+function registerSkillCommands(program2, getConfig2) {
+  const skill = program2.command("skill").description("Skill marketplace and publish commands");
+  skill.command("search [query]").description("Search skills").option("--category <code>", "Skill category code").option("--source <source>", "official | verified | community").option("--tag <tag>", "Tag filter").option("--sort <sort>", "recommended | downloads | updated_at").option("--page-size <n>", "Page size", (v) => Number.parseInt(v, 10)).option("--cursor <cursor>", "Cursor for next page").action(async (query, opts) => {
+    await runSearch2(getConfig2, query, opts);
+  });
+  skill.command("info <skillId>").description("Show skill details").option("--version <version>", "Specify version").action(async (skillId, opts) => {
+    await runInfo2(getConfig2, skillId, opts);
+  });
+  skill.command("versions <skillId>").description("List published versions").action(async (skillId) => {
+    await runVersions2(getConfig2, skillId);
+  });
+  skill.command("install <skillId>").description("Install skill via qwenpaw").option("--version <version>", "Specify version").option("--via <tool>", "Install tool (qwenpaw)", "qwenpaw").action(async (skillId, opts) => {
+    await runInstall2(getConfig2, skillId, opts);
+  });
+  const publish = skill.command("publish [zipPath]").description("Publish skill from local zip or URL").option("--url <url>", "Publish from remote zip URL").option("--artifact-id <id>", "Optional skill id override (must match SKILL.md in zip mode)").option("--version <version>", "Skill version (prompted if SKILL.md has no version)").option(
+    "--category <code>",
+    "Skill category code (engineering development|data research|document office|design creation|automation integration|product management|marketing growth|security compliance|education knowledge|plugin development|skills management|others)"
+  ).option("--tags <csv>", "Optional tags, comma-separated, max 3").option("--repo-url <url>", "Repository URL").option("--publish-mode <mode>", "Publish mode", "auto_after_scan").option("--no-wait", "Do not wait for terminal status").action(async (zipPath, opts) => {
+    await runPublish2(getConfig2, zipPath, opts);
+  });
+  publish.command("status <skillId>").description("Show publish status by skill id or submission id").option("--watch", "Poll until terminal status", false).action(async (skillId, opts) => {
+    await runPublishStatus2(getConfig2, skillId, opts);
+  });
+  publish.command("logs <skillId>").description("Show publish logs by skill id or submission id").action(async (skillId) => {
+    await runPublishLogs2(getConfig2, skillId);
+  });
+}
+
+// src/cli.ts
+var globalOpts = {};
+var program = new Command().name("asp").description("AgentScope Platform CLI").version(CLI_VERSION).option("--platform-url <url>", "Custom Platform base URL (advanced)").option("--token <token>", "Access token (overrides stored credentials)").option("-v, --verbose", "Verbose logging").option("--json", "Output JSON").hook("preAction", (thisCommand) => {
+  const opts = thisCommand.opts();
+  globalOpts.platformUrl = opts.platformUrl;
+  globalOpts.token = opts.token;
+  globalOpts.verbose = opts.verbose;
+  globalOpts.json = opts.json;
+});
+var getConfig = () => resolveConfig(globalOpts);
+registerAuthCommands(program, getConfig);
+registerPluginCommands(program, getConfig);
+registerSkillCommands(program, getConfig);
+async function main() {
+  try {
+    await program.parseAsync(process.argv);
+  } catch (err) {
+    if (err instanceof AspError) {
+      printError(`${err.message} [${err.code}]`);
+      if (err.hint) printError(`Hint: ${err.hint}`);
+      if (err.requestId) printError(`Request ID: ${err.requestId}`);
+      process.exit(err.exitCode);
+    }
+    if (err instanceof Error) {
+      printError(err.message);
+      if (globalOpts.verbose && err.stack) console.error(err.stack);
+      process.exit(1);
+    }
+    throw err;
+  }
+}
+main();
+//# sourceMappingURL=cli.js.map