@zrhsh/wukong-cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,1718 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/constants/config.ts
+var API_ENDPOINTS, POLL_CONFIG;
+var init_config = __esm({
+  "src/constants/config.ts"() {
+    "use strict";
+    init_esm_shims();
+    API_ENDPOINTS = {
+      AUTH: {
+        DEVICE_AUTHORIZE: "/oceanet-auth/pkce/device/authorize",
+        DEVICE_TOKEN: "/oceanet-auth/pkce/device/token",
+        REFRESH_TOKEN: "/oceanet-auth/manage/refreshToken",
+        LOGOUT: "/oceanet-auth/manage/logout"
+      },
+      API: {
+        USER_INFO: "/oceanet-auth/web/userInfo"
+      }
+    };
+    POLL_CONFIG = {
+      INTERVAL: 3,
+      // 轮询间隔（秒）
+      TIMEOUT: 300
+      // 轮询超时（秒）
+    };
+  }
+});
+
+// src/config/environments.ts
+function isValidEnvironment(env) {
+  return env in ENVIRONMENTS;
+}
+var ENVIRONMENTS, DEFAULT_ENVIRONMENT;
+var init_environments = __esm({
+  "src/config/environments.ts"() {
+    "use strict";
+    init_esm_shims();
+    ENVIRONMENTS = {
+      dev: {
+        name: "dev",
+        displayName: "\u5F00\u53D1\u73AF\u5883 (Development)",
+        authBaseUrl: "https://portal-dev.zrhsh.com",
+        apiBaseUrl: "https://nrp-recode-dev.zrhsh.com",
+        clientId: "wukong-cli-dev"
+      },
+      beta: {
+        name: "beta",
+        displayName: "\u6D4B\u8BD5\u73AF\u5883 (Testing)",
+        authBaseUrl: "https://portal-beta.zrhsh.com",
+        apiBaseUrl: "https://nrp-recode.zrhsh.com",
+        clientId: "wukong-cli-beta"
+      },
+      uat: {
+        name: "uat",
+        displayName: "UAT\u73AF\u5883 (User Acceptance Testing)",
+        authBaseUrl: "https://portal-uat.zrhsh.com",
+        apiBaseUrl: "https://nrp-recode-uat.zrhsh.com",
+        clientId: "wukong-cli-uat"
+      },
+      prod: {
+        name: "prod",
+        displayName: "\u751F\u4EA7\u73AF\u5883 (Production)",
+        authBaseUrl: "https://portal.zrhsh.com",
+        apiBaseUrl: "https://nrp-recode-prod.zrhsh.com",
+        clientId: "wukong-cli-prod"
+      }
+    };
+    DEFAULT_ENVIRONMENT = "prod";
+  }
+});
+
+// src/config/config-loader.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function getUserConfigPath() {
+  return join(homedir(), "wukong-cli.json");
+}
+function createDefaultConfig() {
+  const configPath = getUserConfigPath();
+  if (existsSync(configPath)) {
+    return;
+  }
+  try {
+    const templatePath = join(getProjectRoot(), "wukong-cli.json.template");
+    if (!existsSync(templatePath)) {
+      console.warn(`Warning: Template config not found: ${templatePath}`);
+      return;
+    }
+    const templateContent = readFileSync(templatePath, "utf-8");
+    const defaultConfig = JSON.parse(templateContent);
+    const dir = dirname(configPath);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2), "utf-8");
+  } catch (error) {
+  }
+}
+function getProjectRoot() {
+  let currentDir = dirname(fileURLToPath2(import.meta.url));
+  while (currentDir !== dirname(currentDir)) {
+    if (existsSync(join(currentDir, "package.json"))) {
+      return currentDir;
+    }
+    currentDir = dirname(currentDir);
+  }
+  return process.cwd();
+}
+function findConfigFile() {
+  for (const filename of CONFIG_FILENAMES) {
+    const localPath = join(process.cwd(), filename);
+    if (existsSync(localPath)) {
+      return localPath;
+    }
+  }
+  const userConfigPath = getUserConfigPath();
+  if (existsSync(userConfigPath)) {
+    return userConfigPath;
+  }
+  return null;
+}
+function loadConfig() {
+  const configPath = findConfigFile();
+  if (!configPath) {
+    createDefaultConfig();
+    return {};
+  }
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    const config = JSON.parse(content);
+    return config;
+  } catch (error) {
+    console.warn(`Warning: Failed to load config from ${configPath}: ${error}`);
+    return {};
+  }
+}
+function getMergedEnvironmentConfig(env) {
+  const config = loadConfig();
+  const defaultConfig = ENVIRONMENTS[env] || ENVIRONMENTS[DEFAULT_ENVIRONMENT];
+  const envAuthUrl = process.env[`OCEANET_${env.toUpperCase()}_AUTH_URL`];
+  const envApiUrl = process.env[`OCEANET_${env.toUpperCase()}_API_URL`];
+  const envClientId = process.env[`OCEANET_${env.toUpperCase()}_CLIENT_ID`];
+  const customConfig = config.environments?.[env] || {};
+  return {
+    name: env,
+    displayName: defaultConfig.displayName,
+    authBaseUrl: envAuthUrl || customConfig.authBaseUrl || defaultConfig.authBaseUrl,
+    apiBaseUrl: envApiUrl || customConfig.apiBaseUrl || defaultConfig.apiBaseUrl,
+    clientId: envClientId || customConfig.clientId || defaultConfig.clientId
+  };
+}
+function getAllEnvironments() {
+  const config = loadConfig();
+  const result = { ...ENVIRONMENTS };
+  if (config.customEnvironments) {
+    for (const [name, customEnv] of Object.entries(config.customEnvironments)) {
+      result[name] = {
+        name,
+        displayName: customEnv.displayName || name,
+        authBaseUrl: customEnv.authBaseUrl,
+        apiBaseUrl: customEnv.apiBaseUrl,
+        clientId: customEnv.clientId
+      };
+    }
+  }
+  return result;
+}
+function getDefaultEnvironment() {
+  const envFromVar = process.env.WUKONG_CLI_ENV;
+  if (envFromVar && isValidEnvironment(envFromVar)) {
+    return envFromVar;
+  }
+  const config = loadConfig();
+  if (config.defaultEnv && isValidEnvironment(config.defaultEnv)) {
+    return config.defaultEnv;
+  }
+  return DEFAULT_ENVIRONMENT;
+}
+var CONFIG_FILENAMES;
+var init_config_loader = __esm({
+  "src/config/config-loader.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_environments();
+    CONFIG_FILENAMES = [
+      "wukong-cli.json",
+      ".wukong-cli.json",
+      ".wukongclirc"
+    ];
+  }
+});
+
+// src/config/oceanet.ts
+function setCurrentEnvironment(env) {
+  currentEnv = env;
+}
+function getCurrentEnvironment() {
+  const envFromVar = process.env.WUKONG_CLI_ENV;
+  if (envFromVar && isValidEnvironment(envFromVar)) {
+    return envFromVar;
+  }
+  return currentEnv;
+}
+function getEnvironmentConfig() {
+  return getMergedEnvironmentConfig(getCurrentEnvironment());
+}
+function getOceanetConfig() {
+  const envConfig = getEnvironmentConfig();
+  const env = getCurrentEnvironment();
+  return {
+    // 认证服务基础地址 (设备码授权、登录、登出等)
+    AUTH_BASE_URL: getEnv("OCEANET_AUTH_BASE_URL", envConfig.authBaseUrl),
+    // 业务 API 基础地址
+    API_BASE_URL: getEnv("OCEANET_API_BASE_URL", envConfig.apiBaseUrl),
+    // 客户端 ID
+    CLIENT_ID: getEnv("OCEANET_CLIENT_ID", envConfig.clientId),
+    // Token 存储服务名（不同环境分开存储）
+    SERVICE_NAME: `wukong-cli-${env}`,
+    // 轮询配置
+    POLL: POLL_CONFIG,
+    // 认证服务端点
+    AUTH_ENDPOINTS: API_ENDPOINTS.AUTH,
+    // 业务 API 端点
+    API_ENDPOINTS: API_ENDPOINTS.API,
+    // 调试模式
+    DEBUG: getEnv("WUKONG_CLI_DEBUG", "false") === "true",
+    // 当前环境信息
+    ENVIRONMENT: env,
+    ENVIRONMENT_DISPLAY: envConfig.displayName
+  };
+}
+var currentEnv, getEnv, OCEANET_CONFIG;
+var init_oceanet = __esm({
+  "src/config/oceanet.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_config();
+    init_environments();
+    init_config_loader();
+    currentEnv = getDefaultEnvironment();
+    getEnv = (key, defaultValue) => {
+      return process.env[key] || defaultValue;
+    };
+    OCEANET_CONFIG = getOceanetConfig();
+  }
+});
+
+// src/core/auth/device-flow-service.ts
+var device_flow_service_exports = {};
+__export(device_flow_service_exports, {
+  DeviceFlowService: () => DeviceFlowService,
+  getDeviceFlowService: () => getDeviceFlowService
+});
+function getDeviceFlowService() {
+  return new DeviceFlowService();
+}
+var DeviceFlowService;
+var init_device_flow_service = __esm({
+  "src/core/auth/device-flow-service.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_oceanet();
+    DeviceFlowService = class {
+      /**
+       * 获取设备授权码
+       */
+      async getDeviceCode() {
+        const config = getOceanetConfig();
+        const url = `${config.AUTH_BASE_URL}${config.AUTH_ENDPOINTS.DEVICE_AUTHORIZE}`;
+        const requestBody = {
+          param: {
+            clientId: config.CLIENT_ID
+          }
+        };
+        const response = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(requestBody)
+        });
+        const data = await response.json();
+        if (data.code !== 200) {
+          throw new Error(
+            `(${data.code}) ${data.message || "Failed to get device code"}`
+          );
+        }
+        const { verificationUri, expiresIn, interval } = data.result;
+        const urlObj = new URL(verificationUri);
+        const deviceCode = urlObj.searchParams.get("code") || "";
+        return {
+          verificationUri,
+          deviceCode,
+          expiresIn,
+          interval: interval || config.POLL.INTERVAL
+        };
+      }
+      /**
+       * 轮询获取 token
+       */
+      async pollToken(deviceCode) {
+        const startTime = Date.now();
+        const config = getOceanetConfig();
+        while (Date.now() - startTime < config.POLL.TIMEOUT * 1e3) {
+          const url = `${config.AUTH_BASE_URL}${config.AUTH_ENDPOINTS.DEVICE_TOKEN}`;
+          const requestBody = {
+            param: {
+              clientId: config.CLIENT_ID,
+              deviceCode
+            }
+          };
+          const response = await fetch(url, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify(requestBody)
+          });
+          const data = await response.json();
+          if (data.code !== 200) {
+            await new Promise(
+              (resolve) => setTimeout(resolve, config.POLL.INTERVAL * 1e3)
+            );
+            continue;
+          }
+          if (!data.result) {
+            await new Promise(
+              (resolve) => setTimeout(resolve, config.POLL.INTERVAL * 1e3)
+            );
+            continue;
+          }
+          const {
+            access_token,
+            refresh_token,
+            expires_in,
+            token_type,
+            scope
+          } = data.result;
+          return {
+            accessToken: access_token,
+            refreshToken: refresh_token,
+            expiresIn: expires_in,
+            tokenType: token_type,
+            scope: Array.isArray(scope) ? scope : [scope || ""]
+          };
+        }
+        throw new Error("Authorization timed out. Please try again.");
+      }
+    };
+  }
+});
+
+// src/adapters/ora-ui-callbacks.ts
+var ora_ui_callbacks_exports = {};
+__export(ora_ui_callbacks_exports, {
+  OraUICallbacks: () => OraUICallbacks
+});
+import ora from "ora";
+var OraUICallbacks;
+var init_ora_ui_callbacks = __esm({
+  "src/adapters/ora-ui-callbacks.ts"() {
+    "use strict";
+    init_esm_shims();
+    OraUICallbacks = class {
+      spinner = null;
+      onStart(message) {
+        this.spinner = ora(message).start();
+      }
+      onSuccess(message) {
+        if (this.spinner) {
+          this.spinner.succeed(message);
+          this.spinner = null;
+        }
+      }
+      onError(message) {
+        if (this.spinner) {
+          this.spinner.fail(message);
+          this.spinner = null;
+        }
+      }
+      onUpdate(message) {
+        if (this.spinner) {
+          this.spinner.text = message;
+        }
+      }
+    };
+  }
+});
+
+// src/core/auth/keytar-adapter.ts
+import { createRequire } from "module";
+async function setPassword(service, account, password) {
+  await keytar.setPassword(service, account, password);
+}
+async function getPassword(service, account) {
+  return await keytar.getPassword(service, account);
+}
+async function deletePassword(service, account) {
+  return await keytar.deletePassword(service, account);
+}
+var require2, keytar;
+var init_keytar_adapter = __esm({
+  "src/core/auth/keytar-adapter.ts"() {
+    "use strict";
+    init_esm_shims();
+    require2 = createRequire(import.meta.url);
+    keytar = require2("keytar");
+  }
+});
+
+// src/providers/credential-store.ts
+var credential_store_exports = {};
+__export(credential_store_exports, {
+  InMemoryCredentialStore: () => InMemoryCredentialStore,
+  KeytarCredentialStore: () => KeytarCredentialStore,
+  getCredentialStore: () => getCredentialStore,
+  getTestCredentialStore: () => getTestCredentialStore
+});
+function getCredentialStore() {
+  return new KeytarCredentialStore();
+}
+function getTestCredentialStore() {
+  return new InMemoryCredentialStore();
+}
+var KeytarCredentialStore, InMemoryCredentialStore;
+var init_credential_store = __esm({
+  "src/providers/credential-store.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_keytar_adapter();
+    KeytarCredentialStore = class {
+      async setPassword(service, account, password) {
+        await setPassword(service, account, password);
+      }
+      async getPassword(service, account) {
+        return await getPassword(service, account);
+      }
+      async deletePassword(service, account) {
+        return await deletePassword(service, account);
+      }
+    };
+    InMemoryCredentialStore = class {
+      store = /* @__PURE__ */ new Map();
+      getKey(service, account) {
+        return `${service}:${account}`;
+      }
+      async setPassword(service, account, password) {
+        this.store.set(this.getKey(service, account), password);
+      }
+      async getPassword(service, account) {
+        return this.store.get(this.getKey(service, account)) || null;
+      }
+      async deletePassword(service, account) {
+        return this.store.delete(this.getKey(service, account));
+      }
+      clear() {
+        this.store.clear();
+      }
+    };
+  }
+});
+
+// src/core/auth/token-cache.ts
+var token_cache_exports = {};
+__export(token_cache_exports, {
+  MemoryTokenCache: () => MemoryTokenCache,
+  getGlobalTokenCache: () => getGlobalTokenCache,
+  initializeTokenCache: () => initializeTokenCache,
+  resetGlobalTokenCache: () => resetGlobalTokenCache
+});
+function getGlobalTokenCache() {
+  if (!globalCacheInstance) {
+    globalCacheInstance = new MemoryTokenCache();
+  }
+  return globalCacheInstance;
+}
+function resetGlobalTokenCache() {
+  globalCacheInstance = null;
+}
+async function initializeTokenCache(loadTokens) {
+  const cache = getGlobalTokenCache();
+  const { accessToken, refreshToken } = await loadTokens();
+  if (accessToken && refreshToken) {
+    cache.setTokens(accessToken, refreshToken);
+  }
+}
+var MemoryTokenCache, globalCacheInstance;
+var init_token_cache = __esm({
+  "src/core/auth/token-cache.ts"() {
+    "use strict";
+    init_esm_shims();
+    MemoryTokenCache = class {
+      accessToken = null;
+      refreshToken = null;
+      getAccessToken() {
+        return this.accessToken;
+      }
+      getRefreshToken() {
+        return this.refreshToken;
+      }
+      setTokens(accessToken, refreshToken) {
+        this.accessToken = accessToken;
+        this.refreshToken = refreshToken;
+      }
+      clear() {
+        this.accessToken = null;
+        this.refreshToken = null;
+      }
+      hasAccessToken() {
+        return this.accessToken !== null && this.accessToken.length > 0;
+      }
+      hasRefreshToken() {
+        return this.refreshToken !== null && this.refreshToken.length > 0;
+      }
+    };
+    globalCacheInstance = null;
+  }
+});
+
+// src/cli.ts
+init_esm_shims();
+import { Command as Command4 } from "commander";
+
+// src/utils/debug.ts
+init_esm_shims();
+import chalk from "chalk";
+var debugMode = null;
+var explicitSet = false;
+function setDebugMode(enabled, explicit = true) {
+  if (explicit) {
+    debugMode = enabled;
+    explicitSet = true;
+  }
+  global.__debugMode = enabled;
+}
+function isDebugMode() {
+  if (explicitSet) {
+    return debugMode === true;
+  }
+  if (global.__debugMode === true) {
+    return true;
+  }
+  return process.env.WUKONG_CLI_DEBUG === "true";
+}
+function debugRequest(method, url, headers, body) {
+  if (!isDebugMode()) return;
+  console.log("");
+  console.log(chalk.dim("=== HTTP Request ==="));
+  console.log(chalk.cyan(`${method} ${url}`));
+  if (headers) {
+    console.log(chalk.dim("Headers:"));
+    for (const [key, value] of Object.entries(headers)) {
+      if (key.toLowerCase() === "authorization") {
+        const truncated = value.length > 50 ? value.substring(0, 50) + "..." : value;
+        console.log(chalk.dim(`  ${key}: ${truncated}`));
+      } else {
+        console.log(chalk.dim(`  ${key}: ${value}`));
+      }
+    }
+  }
+  if (body) {
+    console.log(chalk.dim("Body:"));
+    console.log(chalk.dim(JSON.stringify(body, null, 2)));
+  }
+  console.log("");
+}
+function debugResponse(status, statusText, body, duration) {
+  if (!isDebugMode()) return;
+  const statusColor = status >= 200 && status < 300 ? chalk.green : chalk.red;
+  console.log(chalk.dim("=== HTTP Response") + chalk.dim(` (${duration}ms) ===`));
+  console.log(statusColor(`Status: ${status} ${statusText}`));
+  console.log(chalk.dim("Body:"));
+  console.log(chalk.dim(JSON.stringify(body, null, 2)));
+  console.log("");
+}
+
+// src/commands/auth.ts
+init_esm_shims();
+import { Command } from "commander";
+import chalk4 from "chalk";
+import ora3 from "ora";
+
+// src/core/auth/device-flow.ts
+init_esm_shims();
+init_oceanet();
+import chalk2 from "chalk";
+
+// src/adapters/cli-device-flow.ts
+init_esm_shims();
+var CliDeviceFlowAdapter = class {
+  /**
+   * 构造函数
+   * @param deviceFlow 设备流程服务实例
+   * @param ui UI 回调实例
+   */
+  constructor(deviceFlow, ui) {
+    this.deviceFlow = deviceFlow;
+    this.ui = ui;
+  }
+  /**
+   * 获取设备授权码（带 UI）
+   */
+  async getDeviceCode() {
+    this.ui.onStart("Getting device authorization...");
+    try {
+      const result = await this.deviceFlow.getDeviceCode();
+      this.ui.onSuccess("Device code obtained");
+      return result;
+    } catch (error) {
+      this.ui.onError("Failed to get device code");
+      throw error;
+    }
+  }
+  /**
+   * 轮询获取 token（带 UI）
+   */
+  async pollToken(deviceCode) {
+    this.ui.onStart("Waiting for authorization...");
+    try {
+      const result = await this.deviceFlow.pollToken(deviceCode);
+      this.ui.onSuccess("Authorization successful!");
+      return result;
+    } catch (error) {
+      this.ui.onError("Authorization error");
+      throw error;
+    }
+  }
+};
+function createCliDeviceFlowAdapter() {
+  const { getDeviceFlowService: getDeviceFlowService2 } = (init_device_flow_service(), __toCommonJS(device_flow_service_exports));
+  const { OraUICallbacks: OraUICallbacks2 } = (init_ora_ui_callbacks(), __toCommonJS(ora_ui_callbacks_exports));
+  const deviceFlow = getDeviceFlowService2();
+  const ui = new OraUICallbacks2();
+  return new CliDeviceFlowAdapter(deviceFlow, ui);
+}
+
+// src/core/auth/device-flow.ts
+init_device_flow_service();
+
+// src/adapters/ui-callbacks.ts
+init_esm_shims();
+
+// src/core/auth/device-flow.ts
+init_ora_ui_callbacks();
+async function getDeviceCode() {
+  const config = getOceanetConfig();
+  const adapter = createCliDeviceFlowAdapter();
+  if (config.DEBUG) {
+    console.log("");
+    console.log(chalk2.dim("=== Debug Info ==="));
+    console.log(chalk2.dim("Getting device authorization..."));
+    console.log(chalk2.dim("Client ID:"), chalk2.yellow(config.CLIENT_ID));
+    console.log("");
+  }
+  const result = await adapter.getDeviceCode();
+  if (config.DEBUG) {
+    console.log(chalk2.dim("=== Response ==="));
+    console.log(chalk2.dim("Device Code:"), chalk2.yellow(result.deviceCode));
+    console.log(chalk2.dim("Verification URI:"), chalk2.cyan(result.verificationUri));
+    console.log(chalk2.dim("Expires In:"), chalk2.yellow(result.expiresIn));
+    console.log("");
+  }
+  return result;
+}
+async function pollToken(deviceCode) {
+  const adapter = createCliDeviceFlowAdapter();
+  return adapter.pollToken(deviceCode);
+}
+
+// src/core/auth/token-manager.ts
+init_esm_shims();
+init_oceanet();
+import ora2 from "ora";
+var TokenManager = class {
+  /**
+   * 构造函数
+   * @param credentialStore 凭据存储实例
+   * @param tokenCache token 缓存实例
+   */
+  constructor(credentialStore, tokenCache) {
+    this.credentialStore = credentialStore;
+    this.tokenCache = tokenCache;
+  }
+  /**
+   * 保存 Token
+   */
+  async saveToken(accessToken, refreshToken) {
+    const config = getOceanetConfig();
+    await this.credentialStore.setPassword(config.SERVICE_NAME, "access_token", accessToken);
+    await this.credentialStore.setPassword(config.SERVICE_NAME, "refresh_token", refreshToken);
+    this.tokenCache.setTokens(accessToken, refreshToken);
+  }
+  /**
+   * 获取 Access Token
+   */
+  async getAccessToken() {
+    const cached = this.tokenCache.getAccessToken();
+    if (cached) {
+      return cached;
+    }
+    const config = getOceanetConfig();
+    const token = await this.credentialStore.getPassword(config.SERVICE_NAME, "access_token");
+    if (token) {
+      this.tokenCache.setTokens(token, null);
+    }
+    return token;
+  }
+  /**
+   * 获取 Refresh Token
+   */
+  async getRefreshToken() {
+    const cached = this.tokenCache.getRefreshToken();
+    if (cached) {
+      return cached;
+    }
+    const config = getOceanetConfig();
+    const token = await this.credentialStore.getPassword(config.SERVICE_NAME, "refresh_token");
+    if (token) {
+      this.tokenCache.setTokens(null, token);
+    }
+    return token;
+  }
+  /**
+   * 刷新 Token
+   */
+  async refreshAccessToken(refreshToken) {
+    const spinner = ora2("Refreshing access token...").start();
+    try {
+      const config = getOceanetConfig();
+      const url = `${config.AUTH_BASE_URL}${config.AUTH_ENDPOINTS.REFRESH_TOKEN}`;
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ param: refreshToken })
+      });
+      const data = await response.json();
+      if (data.code !== 200) {
+        spinner.fail("Token refresh failed");
+        throw new Error(data.message || "Refresh token failed");
+      }
+      const {
+        access_token,
+        refresh_token: new_refresh_token,
+        expires_in,
+        token_type,
+        scope
+      } = data.result;
+      spinner.succeed("Token refreshed");
+      return {
+        accessToken: access_token,
+        refreshToken: new_refresh_token,
+        expiresIn: expires_in,
+        tokenType: token_type,
+        scope: Array.isArray(scope) ? scope : [scope || ""]
+      };
+    } catch (error) {
+      spinner.fail("Token refresh error");
+      throw error;
+    }
+  }
+  /**
+   * 清除本地 Token
+   */
+  async clearTokens() {
+    const config = getOceanetConfig();
+    await this.credentialStore.deletePassword(config.SERVICE_NAME, "access_token");
+    await this.credentialStore.deletePassword(config.SERVICE_NAME, "refresh_token");
+    this.tokenCache.clear();
+  }
+  /**
+   * 退出登录
+   */
+  async logout(accessToken) {
+    try {
+      const config = getOceanetConfig();
+      await fetch(`${config.AUTH_BASE_URL}${config.AUTH_ENDPOINTS.LOGOUT}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${accessToken}`
+        }
+      });
+    } catch (error) {
+    }
+    await this.clearTokens();
+  }
+  /**
+   * 初始化 Token 缓存
+   * 从持久化存储加载 token 到内存缓存
+   */
+  async initTokenCache() {
+    const config = getOceanetConfig();
+    const [accessToken, refreshToken] = await Promise.all([
+      this.credentialStore.getPassword(config.SERVICE_NAME, "access_token"),
+      this.credentialStore.getPassword(config.SERVICE_NAME, "refresh_token")
+    ]);
+    if (accessToken || refreshToken) {
+      this.tokenCache.setTokens(accessToken || null, refreshToken || null);
+    }
+  }
+};
+var tokenManagerInstance = null;
+function getTokenManager() {
+  if (!tokenManagerInstance) {
+    const { getCredentialStore: getCredentialStore2 } = (init_credential_store(), __toCommonJS(credential_store_exports));
+    const { getGlobalTokenCache: getGlobalTokenCache2 } = (init_token_cache(), __toCommonJS(token_cache_exports));
+    const credentialStore = getCredentialStore2();
+    const tokenCache = getGlobalTokenCache2();
+    tokenManagerInstance = new TokenManager(credentialStore, tokenCache);
+  }
+  return tokenManagerInstance;
+}
+async function saveToken(accessToken, refreshToken) {
+  const manager = getTokenManager();
+  await manager.saveToken(accessToken, refreshToken);
+}
+async function getAccessToken() {
+  const manager = getTokenManager();
+  return await manager.getAccessToken();
+}
+async function logout(accessToken) {
+  const manager = getTokenManager();
+  await manager.logout(accessToken);
+}
+
+// src/core/http/client.ts
+init_esm_shims();
+
+// src/core/http/base-http-client.ts
+init_esm_shims();
+init_oceanet();
+function buildUrl(endpoint, params) {
+  if (endpoint.startsWith("http://") || endpoint.startsWith("https://")) {
+    let url2 = endpoint;
+    if (params) {
+      const searchParams = new URLSearchParams(params);
+      const separator = url2.includes("?") ? "&" : "?";
+      url2 += `${separator}${searchParams.toString()}`;
+    }
+    return url2;
+  }
+  const config = getOceanetConfig();
+  let url = `${config.API_BASE_URL}${endpoint}`;
+  if (params) {
+    const searchParams = new URLSearchParams(params);
+    url += `?${searchParams.toString()}`;
+  }
+  return url;
+}
+var BaseHttpClient = class {
+  /**
+   * 发起 HTTP 请求
+   */
+  async request(endpoint, options = {}) {
+    const {
+      method = "GET",
+      headers = {},
+      body,
+      params
+    } = options;
+    const url = buildUrl(endpoint, params);
+    const requestHeaders = {
+      ...headers,
+      "Content-Type": "application/json"
+    };
+    debugRequest(method, url, requestHeaders, body);
+    const startTime = Date.now();
+    const response = await fetch(url, {
+      method,
+      headers: requestHeaders,
+      body: body ? JSON.stringify(body) : void 0
+    });
+    const duration = Date.now() - startTime;
+    const data = await response.json();
+    debugResponse(response.status, response.statusText, data, duration);
+    return data;
+  }
+  /**
+   * GET 请求
+   */
+  async get(endpoint, params) {
+    return this.request(endpoint, { method: "GET", params });
+  }
+  /**
+   * POST 请求
+   */
+  async post(endpoint, data, headers) {
+    return this.request(endpoint, {
+      method: "POST",
+      body: data,
+      headers
+    });
+  }
+  /**
+   * PUT 请求
+   */
+  async put(endpoint, data, headers) {
+    return this.request(endpoint, {
+      method: "PUT",
+      body: data,
+      headers
+    });
+  }
+  /**
+   * DELETE 请求
+   */
+  async delete(endpoint) {
+    return this.request(endpoint, { method: "DELETE" });
+  }
+  /**
+   * PATCH 请求
+   */
+  async patch(endpoint, data, headers) {
+    return this.request(endpoint, {
+      method: "PATCH",
+      body: data,
+      headers
+    });
+  }
+};
+
+// src/core/http/authenticating-http-client.ts
+init_esm_shims();
+
+// src/core/http/api-error-handler.ts
+init_esm_shims();
+import chalk3 from "chalk";
+var ApiError = class extends Error {
+  constructor(code, message, retryable = false) {
+    super(message);
+    this.code = code;
+    this.retryable = retryable;
+    this.name = "ApiError";
+  }
+};
+var ApiErrorHandler = class {
+  errorHandlers = /* @__PURE__ */ new Map();
+  constructor() {
+    this.registerDefaultHandlers();
+  }
+  /**
+   * 注册默认的 Oceanet 错误处理器
+   */
+  registerDefaultHandlers() {
+    this.register(9913, (response) => {
+      const error = new ApiError(
+        response.code,
+        response.message || "Token expired or invalid",
+        true
+        // 可重试
+      );
+      throw error;
+    });
+    [401, 403].forEach((code) => {
+      this.register(code, (response) => {
+        throw new ApiError(
+          response.code,
+          response.message || "Authentication failed",
+          code === 401
+          // 401 可以尝试刷新 token
+        );
+      });
+    });
+  }
+  /**
+   * 注册错误处理器
+   * @param code 错误码
+   * @param handler 处理函数
+   */
+  register(code, handler) {
+    this.errorHandlers.set(code, handler);
+  }
+  /**
+   * 处理 API 响应
+   * @param response API 响应
+   * @throws {ApiError} 当响应包含错误时
+   */
+  handle(response) {
+    if (response.code !== 200) {
+      const handler = this.errorHandlers.get(response.code);
+      if (handler) {
+        handler(response);
+      }
+      throw new ApiError(
+        response.code,
+        response.message || "Unknown API error"
+      );
+    }
+  }
+  /**
+   * 检查响应是否为错误
+   * @param response API 响应
+   * @returns 是否为错误
+   */
+  isError(response) {
+    return response.code !== 200;
+  }
+  /**
+   * 尝试从错误中恢复
+   * @param error 错误对象
+   * @param recoverFunction 恢复函数
+   * @returns 恢复结果或抛出错误
+   */
+  async tryRecover(error, recoverFunction) {
+    if (error instanceof ApiError && error.retryable) {
+      console.log("");
+      console.log(chalk3.yellow("\u26A0 Token expired, attempting refresh..."));
+      try {
+        return await recoverFunction();
+      } catch (refreshError) {
+        console.log("");
+        console.log(chalk3.yellow("\u26A0 Auto-refresh failed:"), chalk3.dim(refreshError.message));
+        throw new ApiError(
+          error.code,
+          `${error.message} (Auto-refresh failed)`
+        );
+      }
+    }
+    throw error;
+  }
+};
+var errorHandlerInstance = null;
+function getApiErrorHandler() {
+  if (!errorHandlerInstance) {
+    errorHandlerInstance = new ApiErrorHandler();
+  }
+  return errorHandlerInstance;
+}
+
+// src/core/http/interceptors.ts
+init_esm_shims();
+init_oceanet();
+import { createRetoken } from "ts-retoken";
+function createRetokenInstance(credentialStore, tokenCache) {
+  const config = getOceanetConfig();
+  const store = credentialStore || (init_credential_store(), __toCommonJS(credential_store_exports)).getCredentialStore();
+  const cache = tokenCache || (init_token_cache(), __toCommonJS(token_cache_exports)).getGlobalTokenCache();
+  return createRetoken({
+    refreshEndpoint: {
+      url: `${config.AUTH_BASE_URL}${config.AUTH_ENDPOINTS.REFRESH_TOKEN}`,
+      method: "POST",
+      // Oceanet API 要求: { "param": "refresh_token_string" }
+      buildBody: (token) => JSON.stringify({ param: token }),
+      headers: {
+        "Content-Type": "application/json"
+      },
+      parseResponse: (data) => {
+        if (config.DEBUG || global.__debugMode) {
+          console.log("");
+          console.log("=== HTTP Request ===");
+          console.log(`POST ${config.AUTH_BASE_URL}${config.AUTH_ENDPOINTS.REFRESH_TOKEN}`);
+          console.log("Headers:");
+          console.log("  Content-Type: application/json");
+          console.log("Body:");
+          const refreshToken = cache.getRefreshToken();
+          const truncated = refreshToken && refreshToken.length > 50 ? refreshToken.substring(0, 50) + "..." : refreshToken || "(none)";
+          console.log(`  {"param":"${truncated}"}`);
+          console.log("");
+          console.log("=== HTTP Response ===");
+          console.log(JSON.stringify(data, null, 2));
+          console.log("");
+        }
+        if (data.code === 401 || data.code === 403) {
+          const error = new Error(data.message || "Refresh token expired or invalid");
+          error.code = data.code;
+          error.isAuthFailure = true;
+          throw error;
+        }
+        const result = data.result || data;
+        if (!result.access_token && !result.accessToken) {
+          throw new Error("Invalid token response: missing access_token field");
+        }
+        if (!result.refresh_token && !result.refreshToken) {
+          throw new Error("Invalid token response: missing refresh_token field");
+        }
+        return {
+          accessToken: result.access_token || result.accessToken,
+          refreshToken: result.refresh_token || result.refreshToken
+        };
+      }
+    },
+    // 从缓存获取 token（同步函数）
+    getAccessToken: () => {
+      return cache.getAccessToken();
+    },
+    getRefreshToken: () => {
+      return cache.getRefreshToken();
+    },
+    // 保存 token 到持久化存储和缓存（异步）
+    setTokens: async (tokens) => {
+      const accessToken = tokens?.accessToken || tokens?.access_token;
+      const refreshToken = tokens?.refreshToken || tokens?.refresh_token;
+      if (!accessToken || !refreshToken) {
+        throw new Error("Invalid tokens: missing access_token or refresh_token");
+      }
+      const cfg = getOceanetConfig();
+      await store.setPassword(cfg.SERVICE_NAME, "access_token", accessToken);
+      await store.setPassword(cfg.SERVICE_NAME, "refresh_token", refreshToken);
+      cache.setTokens(accessToken, refreshToken);
+    },
+    // 清除 token
+    clearTokens: async () => {
+      const cfg = getOceanetConfig();
+      await store.deletePassword(cfg.SERVICE_NAME, "access_token");
+      await store.deletePassword(cfg.SERVICE_NAME, "refresh_token");
+      cache.clear();
+    },
+    // 提前 1 分钟（60 秒）主动刷新
+    expirationLeeway: 60,
+    // 401 时触发重试
+    retryStatuses: [401],
+    // 认证完全失败时的回调
+    onAuthFailure: async () => {
+      const cfg = getOceanetConfig();
+      try {
+        await store.deletePassword(cfg.SERVICE_NAME, "access_token");
+        await store.deletePassword(cfg.SERVICE_NAME, "refresh_token");
+        cache.clear();
+      } catch {
+      }
+    }
+  });
+}
+var retokenInstances = {};
+function getRetoken() {
+  const config = getOceanetConfig();
+  const env = config.ENVIRONMENT;
+  if (!retokenInstances[env]) {
+    retokenInstances[env] = createRetokenInstance();
+  }
+  return retokenInstances[env];
+}
+
+// src/core/http/authenticating-http-client.ts
+var AuthenticatingHttpClient = class {
+  constructor(baseClient, tokenCache) {
+    this.baseClient = baseClient;
+    this.tokenCache = tokenCache;
+  }
+  initialized = false;
+  /**
+   * 确保 token 缓存已初始化
+   */
+  async ensureInitialized() {
+    if (!this.initialized) {
+      const tokenManager = getTokenManager();
+      await tokenManager.initTokenCache();
+      this.initialized = true;
+    }
+  }
+  /**
+   * 发起认证的 HTTP 请求
+   */
+  async request(endpoint, options = {}) {
+    await this.ensureInitialized();
+    const accessToken = this.tokenCache.getAccessToken();
+    if (!accessToken) {
+      throw new Error(
+        "Not authenticated. Please run: wukong-cli auth login"
+      );
+    }
+    const headers = {
+      ...options.headers,
+      "Authorization": `Bearer ${accessToken}`
+    };
+    const url = `${global.__apiBaseUrl || ""}${endpoint}`;
+    debugRequest(options.method || "GET", url, headers, options.body);
+    const retoken = getRetoken();
+    const startTime = Date.now();
+    const response = await retoken.fetch(
+      url,
+      {
+        method: options.method || "GET",
+        headers,
+        body: options.body ? JSON.stringify(options.body) : void 0
+      }
+    );
+    const data = await response.json();
+    const duration = Date.now() - startTime;
+    debugResponse(response.status, response.statusText, data, duration);
+    const errorHandler = getApiErrorHandler();
+    if (data.code === 9913) {
+      return errorHandler.tryRecover(
+        new ApiError(data.code, data.message || "Token expired", true),
+        async () => {
+          await retoken.refreshToken();
+          const newAccessToken = this.tokenCache.getAccessToken();
+          if (newAccessToken) {
+            const retryResponse = await fetch(
+              `${global.__apiBaseUrl || ""}${endpoint}`,
+              {
+                method: options.method || "GET",
+                headers: {
+                  ...headers,
+                  "Authorization": `Bearer ${newAccessToken}`
+                },
+                body: options.body ? JSON.stringify(options.body) : void 0
+              }
+            );
+            const retryData = await retryResponse.json();
+            if (retryData.code === 200) {
+              return retryData.result;
+            }
+            throw new Error(
+              `API Error (${retryData.code}): ${retryData.message || "Unknown error"}`
+            );
+          }
+          throw new Error("Failed to refresh token");
+        }
+      );
+    }
+    errorHandler.handle(data);
+    return data.result;
+  }
+  /**
+   * GET 请求
+   */
+  async get(endpoint, params) {
+    return this.request(endpoint, { method: "GET", params });
+  }
+  /**
+   * POST 请求
+   */
+  async post(endpoint, data, headers) {
+    return this.request(endpoint, {
+      method: "POST",
+      body: data,
+      headers
+    });
+  }
+  /**
+   * PUT 请求
+   */
+  async put(endpoint, data, headers) {
+    return this.request(endpoint, {
+      method: "PUT",
+      body: data,
+      headers
+    });
+  }
+  /**
+   * DELETE 请求
+   */
+  async delete(endpoint) {
+    return this.request(endpoint, { method: "DELETE" });
+  }
+  /**
+   * PATCH 请求
+   */
+  async patch(endpoint, data, headers) {
+    return this.request(endpoint, {
+      method: "PATCH",
+      body: data,
+      headers
+    });
+  }
+  /**
+   * 检查 token 是否即将过期
+   */
+  async isTokenExpiringSoon() {
+    await this.ensureInitialized();
+    const retoken = getRetoken();
+    return retoken.isTokenExpiringSoon();
+  }
+  /**
+   * 手动刷新 token
+   */
+  async refreshToken() {
+    await this.ensureInitialized();
+    const retoken = getRetoken();
+    await retoken.refreshToken();
+  }
+};
+
+// src/core/http/client.ts
+init_oceanet();
+var OceanetClient = class {
+  authenticatingClient;
+  /**
+   * 构造函数
+   * @param tokenCache token 缓存实例（可选）
+   */
+  constructor(tokenCache) {
+    let cache;
+    if (tokenCache) {
+      cache = tokenCache;
+    } else {
+      const { getGlobalTokenCache: getGlobalTokenCache2 } = (init_token_cache(), __toCommonJS(token_cache_exports));
+      cache = getGlobalTokenCache2();
+    }
+    const baseClient = new BaseHttpClient();
+    this.authenticatingClient = new AuthenticatingHttpClient(baseClient, cache);
+  }
+  /**
+   * 发起 HTTP 请求
+   */
+  async request(endpoint, options) {
+    return this.authenticatingClient.request(endpoint, options);
+  }
+  /**
+   * GET 请求
+   */
+  async get(endpoint, params) {
+    return this.authenticatingClient.get(endpoint, params);
+  }
+  /**
+   * POST 请求
+   */
+  async post(endpoint, data, headers) {
+    return this.authenticatingClient.post(endpoint, data, headers);
+  }
+  /**
+   * PUT 请求
+   */
+  async put(endpoint, data, headers) {
+    return this.authenticatingClient.put(endpoint, data, headers);
+  }
+  /**
+   * DELETE 请求
+   */
+  async delete(endpoint) {
+    return this.authenticatingClient.delete(endpoint);
+  }
+  /**
+   * PATCH 请求
+   */
+  async patch(endpoint, data, headers) {
+    return this.authenticatingClient.patch(endpoint, data, headers);
+  }
+  /**
+   * 检查 token 是否即将过期
+   */
+  async isTokenExpiringSoon() {
+    return this.authenticatingClient.isTokenExpiringSoon();
+  }
+  /**
+   * 手动刷新 token
+   */
+  async refreshToken() {
+    return this.authenticatingClient.refreshToken();
+  }
+};
+var clientInstance = null;
+var lastEnvironment = null;
+function clearTokenCache() {
+  const { getGlobalTokenCache: getGlobalTokenCache2 } = (init_token_cache(), __toCommonJS(token_cache_exports));
+  const cache = getGlobalTokenCache2();
+  cache.clear();
+}
+function getClient() {
+  const currentEnv2 = getOceanetConfig().ENVIRONMENT;
+  if (!clientInstance || lastEnvironment !== currentEnv2) {
+    clearTokenCache();
+    clientInstance = new OceanetClient();
+    lastEnvironment = currentEnv2;
+  }
+  return clientInstance;
+}
+
+// src/commands/auth.ts
+init_oceanet();
+init_config_loader();
+var authCommands = new Command("auth").description("Authentication commands");
+authCommands.command("login").description("Login using Device Authorization Flow").action(async () => {
+  try {
+    const env = getCurrentEnvironment();
+    const allEnvs = getAllEnvironments();
+    setCurrentEnvironment(env);
+    const config = getOceanetConfig();
+    const envConfig = allEnvs[env];
+    console.log("");
+    console.log(chalk4.bgBlue.white.bold(" Wukong CLI Login "));
+    console.log("");
+    console.log(chalk4.dim(`Environment: ${chalk4.cyan(env)} - ${envConfig.displayName}`));
+    console.log(chalk4.dim(`Auth URL: ${config.AUTH_BASE_URL}`));
+    console.log(chalk4.dim(`API URL: ${config.API_BASE_URL}`));
+    console.log(chalk4.dim(`Client ID: ${config.CLIENT_ID}`));
+    console.log("");
+    const { verificationUri, deviceCode, expiresIn, interval } = await getDeviceCode();
+    console.log("");
+    console.log(chalk4.bold("\u2550".repeat(50)));
+    console.log(chalk4.bold("  \u8BF7\u5B8C\u6210\u6388\u6743 / Please complete authorization"));
+    console.log(chalk4.bold("\u2550".repeat(50)));
+    console.log("");
+    console.log(chalk4.green("  \u6388\u6743\u94FE\u63A5 / Authorization URL:"));
+    console.log("");
+    console.log(chalk4.cyan(`  ${verificationUri}`));
+    console.log("");
+    console.error(chalk4.yellow.bold(">>> \u8BF7\u5728\u6D4F\u89C8\u5668\u4E2D\u6253\u5F00\u6B64\u94FE\u63A5\u5B8C\u6210\u6388\u6743 <<<"));
+    console.error(chalk4.cyan(verificationUri));
+    console.error("");
+    const open = await import("open").catch(() => null);
+    if (open) {
+      try {
+        await open.default(verificationUri);
+        console.log(chalk4.dim("  \u6D4F\u89C8\u5668\u5DF2\u81EA\u52A8\u6253\u5F00 / Browser opened automatically"));
+      } catch {
+        console.log(chalk4.dim("  \u8BF7\u624B\u52A8\u590D\u5236\u94FE\u63A5\u5230\u6D4F\u89C8\u5668 / Please copy link to browser"));
+      }
+    } else {
+      console.log(chalk4.dim("  \u8BF7\u624B\u52A8\u590D\u5236\u94FE\u63A5\u5230\u6D4F\u89C8\u5668 / Please copy link to browser"));
+    }
+    console.log("");
+    console.log(chalk4.dim("\u2550".repeat(50)));
+    console.log(chalk4.dim(`  Device Code: ${deviceCode}`));
+    console.log(chalk4.dim(`  Expires in: ${expiresIn} seconds`));
+    console.log(chalk4.dim("\u2550".repeat(50)));
+    console.log("");
+    const tokens = await pollToken(deviceCode);
+    await saveToken(tokens.accessToken, tokens.refreshToken);
+    console.log("");
+    console.log(chalk4.bgGreen.black.bold(" \u2713 \u767B\u5F55\u6210\u529F / Login Successful "));
+    console.log("");
+    console.log(chalk4.green("\u2713 Tokens saved securely"));
+    console.log(chalk4.dim(`Environment: ${env} - ${envConfig.displayName}`));
+    console.log(chalk4.dim(`Access Token expires in: ${Math.floor(tokens.expiresIn / 60)} minutes`));
+    console.log("");
+    console.log(chalk4.dim("Next:"), chalk4.cyan("wukong-cli auth status"));
+    console.log("");
+  } catch (error) {
+    console.log("");
+    console.log(chalk4.red(`\u2717 Error: ${error instanceof Error ? error.message : "Unknown error"}`));
+    console.log("");
+  }
+});
+authCommands.command("logout").description("Logout and clear saved tokens").action(async () => {
+  const env = getCurrentEnvironment();
+  const allEnvs = getAllEnvironments();
+  setCurrentEnvironment(env);
+  const envConfig = allEnvs[env];
+  try {
+    const accessToken = await getAccessToken();
+    if (accessToken) {
+      await logout(accessToken);
+    }
+    console.log("");
+    console.log(chalk4.green(`\u2713 Logged out from ${env}`), chalk4.dim(`(${envConfig.displayName})`));
+    console.log("");
+  } catch {
+    console.log("");
+    console.log(chalk4.yellow(`\u25CB Already logged out from ${env}`), chalk4.dim(`(${envConfig.displayName})`));
+    console.log("");
+  }
+});
+authCommands.command("refresh").description("Manually refresh access token").action(async () => {
+  const env = getCurrentEnvironment();
+  const config = getOceanetConfig();
+  try {
+    const accessToken = await getAccessToken();
+    if (!accessToken) {
+      console.log("");
+      console.log(chalk4.yellow("\u2717 Not authenticated"));
+      console.log(chalk4.dim(`Environment: ${env}`));
+      console.log("");
+      console.log(chalk4.dim(`Run: wukong-cli auth login`));
+      console.log("");
+      return;
+    }
+    const spinner = ora3("Refreshing access token...").start();
+    try {
+      const client = getClient();
+      await client.refreshToken();
+      spinner.succeed("Token refreshed successfully!");
+      console.log("");
+      console.log(chalk4.dim("Environment:"), chalk4.cyan(env));
+      console.log(chalk4.dim("New tokens saved securely"));
+      console.log("");
+    } catch (error) {
+      spinner.fail("Token refresh failed");
+      throw error;
+    }
+  } catch (error) {
+    console.log("");
+    console.log(chalk4.red(`\u2717 Error: ${error instanceof Error ? error.message : "Unknown error"}`));
+    console.log("");
+    console.log(chalk4.dim(`Environment: ${env}`));
+    console.log(chalk4.dim(`Your session may have expired. Please run:`));
+    console.log(chalk4.dim(`  wukong-cli auth login`));
+    console.log("");
+  }
+});
+authCommands.command("status").description("Show authentication status").action(async () => {
+  console.log("");
+  const env = getCurrentEnvironment();
+  const allEnvs = getAllEnvironments();
+  setCurrentEnvironment(env);
+  const envConfig = allEnvs[env];
+  const config = getOceanetConfig();
+  try {
+    const accessToken = await getAccessToken();
+    if (!accessToken) {
+      console.log(chalk4.yellow(`\u2717 Not authenticated`));
+      console.log("");
+      console.log(chalk4.dim(`Environment: ${env} - ${envConfig.displayName}`));
+      console.log(chalk4.dim(`Run: wukong-cli auth login`));
+      console.log("");
+      return;
+    }
+    try {
+      const client = getClient();
+      const userInfoUrl = `${config.AUTH_BASE_URL}/oceanet-auth/web/userInfo`;
+      const userInfo = await client.get(userInfoUrl);
+      console.log(chalk4.green(`\u2713 Authenticated`));
+      console.log("");
+      const displayUser = userInfo.firstName ? `${userInfo.firstName} (${userInfo.username})` : userInfo.username || "N/A";
+      console.log(chalk4.dim("Environment:"), chalk4.cyan(`${env} - ${envConfig.displayName}`));
+      console.log(chalk4.dim("User:"), chalk4.cyan(displayUser));
+      console.log(chalk4.dim("Email:"), chalk4.cyan(userInfo.email || "N/A"));
+      console.log(chalk4.dim("OrgCode:"), chalk4.cyan(userInfo.ouCode || "N/A"));
+      console.log(chalk4.dim("OrgName:"), chalk4.cyan(userInfo.ouName || "N/A"));
+      console.log("");
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      console.log(chalk4.yellow(`\u2717 Not authenticated`));
+      console.log("");
+      console.log(chalk4.red("Error:"), chalk4.dim(errorMsg));
+      console.log("");
+      console.log(chalk4.dim(`Environment: ${env} - ${envConfig.displayName}`));
+      console.log(chalk4.dim(`Run: wukong-cli auth login`));
+      console.log("");
+    }
+  } catch (error) {
+    console.log(chalk4.yellow(`\u2717 Not authenticated`));
+    console.log("");
+    console.log(chalk4.dim(`Environment: ${env} - ${envConfig.displayName}`));
+    console.log(chalk4.dim(`Run: wukong-cli auth login`));
+    console.log("");
+  }
+});
+
+// src/commands/test.ts
+init_esm_shims();
+import { Command as Command2 } from "commander";
+import ora4 from "ora";
+import chalk5 from "chalk";
+var testCommand = new Command2("test").description("Test API request with saved token").action(async () => {
+  try {
+    const accessToken = await getAccessToken();
+    if (!accessToken) {
+      console.log("");
+      console.log(chalk5.red("\u2717 Not authenticated"));
+      console.log("");
+      console.log(chalk5.dim("Please run: wukong-cli auth login"));
+      console.log("");
+      process.exit(1);
+    }
+    const spinner = ora4("Testing API connection...").start();
+    try {
+      const client = getClient();
+      const userInfo = await client.get("/oceanet-auth/web/userInfo");
+      spinner.succeed("API request successful");
+      console.log("");
+      console.log(chalk5.green("User Info:"));
+      console.log(chalk5.dim(JSON.stringify(userInfo, null, 2)));
+      console.log("");
+    } catch (error) {
+      spinner.fail("API request failed");
+      if (error.message.includes("401") || error.message.includes("expired")) {
+        console.log("");
+        console.log(chalk5.yellow("Token expired or invalid"));
+        console.log(chalk5.dim("Try: wukong-cli auth refresh"));
+        console.log("");
+      } else {
+        throw error;
+      }
+    }
+  } catch (error) {
+    console.log("");
+    console.log(chalk5.red(`\u2717 Error: ${error instanceof Error ? error.message : "Unknown error"}`));
+    console.log("");
+    process.exit(1);
+  }
+});
+
+// src/commands/http.ts
+init_esm_shims();
+import { Command as Command3 } from "commander";
+import ora5 from "ora";
+import chalk6 from "chalk";
+init_oceanet();
+function fixGitBashPath(url) {
+  if (url.includes(":") && !url.startsWith("http")) {
+    const oceanetIndex = url.indexOf("/oceanet-");
+    if (oceanetIndex >= 0) {
+      return url.substring(oceanetIndex);
+    }
+  }
+  return url;
+}
+function parseHeaders(headers) {
+  const result = {};
+  if (Array.isArray(headers)) {
+    for (const h of headers) {
+      const [key, ...valueParts] = h.split(":");
+      if (key && valueParts.length > 0) {
+        result[key.trim()] = valueParts.join(":").trim();
+      }
+    }
+  }
+  return result;
+}
+function buildUrl2(url, baseUrl) {
+  const cleanUrl = fixGitBashPath(url);
+  if (cleanUrl.startsWith("http")) {
+    return cleanUrl;
+  }
+  const base = baseUrl || OCEANET_CONFIG.API_BASE_URL;
+  return `${base}${cleanUrl}`;
+}
+async function executeRequest(method, url, options) {
+  const spinner = ora5("Sending request...").start();
+  try {
+    const accessToken = await getAccessToken();
+    if (!accessToken) {
+      spinner.fail("Not authenticated");
+      console.error(chalk6.red("Please run: wukong-cli auth login"));
+      process.exit(1);
+    }
+    const fullUrl = buildUrl2(url, options.baseUrl);
+    const customHeaders = parseHeaders(options.headers);
+    const headers = {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${accessToken}`,
+      ...customHeaders
+    };
+    let body;
+    if (options.data) {
+      body = options.data;
+      if (!customHeaders["Content-Type"]) {
+        headers["Content-Type"] = "application/json";
+      }
+    }
+    spinner.text = `${method} ${chalk6.cyan(fullUrl)}`;
+    const response = await fetch(fullUrl, {
+      method,
+      headers,
+      body: method !== "GET" && method !== "DELETE" ? body : void 0
+    });
+    const data = await response.json();
+    spinner.succeed("Response received");
+    console.log("");
+    console.log(chalk6.dim("Status:"), response.status, response.statusText);
+    console.log("");
+    console.log(chalk6.dim("Response:"));
+    console.log(JSON.stringify(data, null, 2));
+  } catch (error) {
+    spinner.fail("Request failed");
+    if (error instanceof Error) {
+      console.error(chalk6.red(error.message));
+    }
+    process.exit(1);
+  }
+}
+var httpCommand = new Command3("http");
+httpCommand.command("get <url>").description("Send GET request (uses OCEANET_API_BASE_URL or override with -b)").option("-b, --base-url <url>", "Override base URL").option("-H, --header <key:value>", "Custom header (can be used multiple times)", []).action(async (url, options) => {
+  await executeRequest("GET", url, options);
+});
+httpCommand.command("post <url>").description("Send POST request with JSON data").option("-b, --base-url <url>", "Override base URL").option("-H, --header <key:value>", "Custom header (can be used multiple times)", []).option("-d, --data <json>", "Request body as JSON string").action(async (url, options) => {
+  await executeRequest("POST", url, options);
+});
+httpCommand.command("put <url>").description("Send PUT request with JSON data").option("-b, --base-url <url>", "Override base URL").option("-H, --header <key:value>", "Custom header (can be used multiple times)", []).option("-d, --data <json>", "Request body as JSON string").action(async (url, options) => {
+  await executeRequest("PUT", url, options);
+});
+httpCommand.command("delete <url>").description("Send DELETE request").option("-b, --base-url <url>", "Override base URL").option("-H, --header <key:value>", "Custom header (can be used multiple times)", []).action(async (url, options) => {
+  await executeRequest("DELETE", url, options);
+});
+
+// src/cli.ts
+var program = new Command4();
+program.name("wukong-cli").description("Wukong CLI - TypeScript implementation").version("0.1.0").option("--debug", "Enable debug mode (show HTTP requests)").hook("preAction", (thisCommand) => {
+  const options = thisCommand.opts();
+  if (options.debug === true) {
+    setDebugMode(true, true);
+  } else {
+    setDebugMode(false, false);
+  }
+});
+program.addCommand(authCommands);
+program.addCommand(testCommand);
+program.addCommand(httpCommand);
+if (process.argv.length === 2) {
+  program.help();
+}
+program.parse();
+//# sourceMappingURL=cli.js.map