@thinkingai/ae-cli 1.0.24 → 1.0.27

package/dist/{chunk-DC66L5AM.js → chunk-BI5ZVD6T.js}

@@ -1,81 +1,9 @@
-// src/core/logger.ts
-import fs from "fs";
-import path from "path";
-var LOG_DIR = path.join(process.env.HOME || "", ".ae-cli", "log");
-var Logger = class {
-  logDir;
-  date;
-  constructor() {
-    this.logDir = LOG_DIR;
-    this.date = this.today();
-    this.ensureDir();
-  }
-  today() {
-    const d = /* @__PURE__ */ new Date();
-    return `${d.getFullYear()}${String(d.getMonth() + 1).padStart(2, "0")}${String(d.getDate()).padStart(2, "0")}`;
-  }
-  timestamp() {
-    return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").split(".")[0];
-  }
-  ensureDir() {
-    if (!fs.existsSync(this.logDir)) {
-      fs.mkdirSync(this.logDir, { recursive: true });
-    }
-  }
-  filePath(level) {
-    const today = this.today();
-    if (today !== this.date) {
-      this.date = today;
-    }
-    return path.join(this.logDir, `${this.date}_${level}.log`);
-  }
-  /**
-   * 写入日志到文件（不输出到控制台，控制台由现有 process.stderr.write 负责）
-   */
-  write(level, message) {
-    const ts = this.timestamp();
-    const line = `[${ts}] ${message}
-`;
-    try {
-      fs.appendFileSync(this.filePath(level), line);
-    } catch {
-    }
-  }
-  /** 常规操作日志 */
-  info(message) {
-    this.write("info", message);
-  }
-  /** 警告日志 */
-  warn(message) {
-    this.write("warning", message);
-  }
-  /** 错误日志 */
-  error(message) {
-    this.write("error", message);
-  }
-  /** 记录 HTTP API 请求详情 */
-  api(method, url, status, reqBody, respBody) {
-    const parts = [`API ${method} ${url} \u2192 HTTP ${status}`];
-    if (reqBody !== void 0 && reqBody !== null) {
-      const s = typeof reqBody === "string" ? reqBody : JSON.stringify(reqBody);
-      parts.push(`REQ: ${s.slice(0, 500)}`);
-    }
-    if (respBody !== void 0 && respBody !== null) {
-      const s = typeof respBody === "string" ? respBody : JSON.stringify(respBody);
-      parts.push(`RESP: ${s.slice(0, 500)}`);
-    }
-    this.info(parts.join(" | "));
-  }
-  /** 记录命令执行 */
-  command(name, args) {
-    const filtered = Object.entries(args).filter(([, v]) => v !== void 0 && v !== null && v !== "").map(([k, v]) => `--${k}=${JSON.stringify(v)}`).join(" ");
-    this.info(`CMD ${name}${filtered ? " " + filtered : ""}`);
-  }
-};
-var logger = new Logger();
+import {
+  logger
+} from "./chunk-MNHE6SSI.js";
 
 // src/core/json-utils.ts
-import fs2 from "fs";
+import fs from "fs";
 import { createRequire } from "module";
 var require2 = createRequire(import.meta.url);
 var JSONbig = require2("json-bigint");
@@ -84,28 +12,28 @@ function safeJsonParse(text) {
   return jsonParser.parse(text);
 }
 function safeReadJsonFile(filePath) {
-  const content = fs2.readFileSync(filePath, "utf-8");
+  const content = fs.readFileSync(filePath, "utf-8");
   return safeJsonParse(content);
 }
 
 // src/core/config.ts
-import fs3 from "fs";
-import path2 from "path";
-var CONFIG_DIR = path2.join(process.env.HOME || "", ".ae-cli");
-var CONFIG_FILE = path2.join(CONFIG_DIR, "config.json");
-var MCP_TOKENS_FILE = path2.join(CONFIG_DIR, "mcp-tokens.json");
-var FALLBACK_MCP_TOKEN_FILE = "/data/app/te_agent_ta/.ae-config/mcp-token.json";
+import fs2 from "fs";
+import path from "path";
+var CONFIG_DIR = path.join(process.env.HOME || "", ".ae-cli");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+var MCP_TOKENS_FILE = path.join(CONFIG_DIR, "mcp-tokens.json");
+var FALLBACK_MCP_TOKEN_FILE = "/home/ta/te_agent_ta/.ae-config/mcp-token.json";
 function ensureDir() {
-  if (!fs3.existsSync(CONFIG_DIR)) fs3.mkdirSync(CONFIG_DIR, { recursive: true });
+  if (!fs2.existsSync(CONFIG_DIR)) fs2.mkdirSync(CONFIG_DIR, { recursive: true });
 }
 function migrateFromFallback() {
-  if (!fs3.existsSync(FALLBACK_MCP_TOKEN_FILE) || fs3.existsSync(MCP_TOKENS_FILE)) {
+  if (!fs2.existsSync(FALLBACK_MCP_TOKEN_FILE) || fs2.existsSync(MCP_TOKENS_FILE)) {
     return null;
   }
   return doMigrateFromFallback();
 }
 function forceMigrateFromFallback() {
-  if (!fs3.existsSync(FALLBACK_MCP_TOKEN_FILE)) {
+  if (!fs2.existsSync(FALLBACK_MCP_TOKEN_FILE)) {
     return null;
   }
   return doMigrateFromFallback();
@@ -123,7 +51,7 @@ function doMigrateFromFallback() {
     }
     if (Object.keys(tokenStore).length > 0) {
       ensureDir();
-      fs3.writeFileSync(MCP_TOKENS_FILE, JSON.stringify(tokenStore, null, 2));
+      fs2.writeFileSync(MCP_TOKENS_FILE, JSON.stringify(tokenStore, null, 2));
       return tokenStore;
     }
   } catch {
@@ -133,7 +61,7 @@ function doMigrateFromFallback() {
 function loadConfig() {
   try {
     const migratedTokens = migrateFromFallback();
-    if (fs3.existsSync(CONFIG_FILE)) {
+    if (fs2.existsSync(CONFIG_FILE)) {
       const raw = safeReadJsonFile(CONFIG_FILE);
       if (raw.defaultHost && !raw.activeHost) {
         const migrated = migrateConfig(raw);
@@ -182,7 +110,7 @@ function migrateConfig(old) {
 }
 function saveConfig(config) {
   ensureDir();
-  fs3.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+  fs2.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
   logger.info(`Config saved: activeHost=${config.activeHost}, hosts=${Object.keys(config.hosts).length}`);
 }
 function getActiveHost() {
@@ -242,7 +170,6 @@ function extractHostname(fullUrl) {
 }
 
 export {
-  logger,
   safeJsonParse,
   safeReadJsonFile,
   forceMigrateFromFallback,

package/dist/chunk-MNHE6SSI.js

@@ -0,0 +1,79 @@
+// src/core/logger.ts
+import fs from "fs";
+import path from "path";
+var LOG_DIR = path.join(process.env.HOME || "", ".ae-cli", "log");
+var Logger = class {
+  logDir;
+  date;
+  constructor() {
+    this.logDir = LOG_DIR;
+    this.date = this.today();
+    this.ensureDir();
+  }
+  today() {
+    const d = /* @__PURE__ */ new Date();
+    return `${d.getFullYear()}${String(d.getMonth() + 1).padStart(2, "0")}${String(d.getDate()).padStart(2, "0")}`;
+  }
+  timestamp() {
+    return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").split(".")[0];
+  }
+  ensureDir() {
+    if (!fs.existsSync(this.logDir)) {
+      fs.mkdirSync(this.logDir, { recursive: true });
+    }
+  }
+  filePath(level) {
+    const today = this.today();
+    if (today !== this.date) {
+      this.date = today;
+    }
+    return path.join(this.logDir, `${this.date}_${level}.log`);
+  }
+  /**
+   * 写入日志到文件（不输出到控制台，控制台由现有 process.stderr.write 负责）
+   */
+  write(level, message) {
+    const ts = this.timestamp();
+    const line = `[${ts}] ${message}
+`;
+    try {
+      fs.appendFileSync(this.filePath(level), line);
+    } catch {
+    }
+  }
+  /** 常规操作日志 */
+  info(message) {
+    this.write("info", message);
+  }
+  /** 警告日志 */
+  warn(message) {
+    this.write("warning", message);
+  }
+  /** 错误日志 */
+  error(message) {
+    this.write("error", message);
+  }
+  /** 记录 HTTP API 请求详情 */
+  api(method, url, status, reqBody, respBody) {
+    const parts = [`API ${method} ${url} \u2192 HTTP ${status}`];
+    if (reqBody !== void 0 && reqBody !== null) {
+      const s = typeof reqBody === "string" ? reqBody : JSON.stringify(reqBody);
+      parts.push(`REQ: ${s.slice(0, 500)}`);
+    }
+    if (respBody !== void 0 && respBody !== null) {
+      const s = typeof respBody === "string" ? respBody : JSON.stringify(respBody);
+      parts.push(`RESP: ${s.slice(0, 500)}`);
+    }
+    this.info(parts.join(" | "));
+  }
+  /** 记录命令执行 */
+  command(name, args) {
+    const filtered = Object.entries(args).filter(([, v]) => v !== void 0 && v !== null && v !== "").map(([k, v]) => `--${k}=${JSON.stringify(v)}`).join(" ");
+    this.info(`CMD ${name}${filtered ? " " + filtered : ""}`);
+  }
+};
+var logger = new Logger();
+
+export {
+  logger
+};

package/dist/chunk-MWWYGZ76.js

@@ -0,0 +1,130 @@
+import {
+  loadMcpTokenStore
+} from "./chunk-2NGWYMLB.js";
+import {
+  forceMigrateFromFallback,
+  safeJsonParse
+} from "./chunk-BI5ZVD6T.js";
+import {
+  logger
+} from "./chunk-MNHE6SSI.js";
+
+// src/core/mcp-access.ts
+function buildUrl(host, path, params = {}) {
+  const base = host.replace(/\/$/, "");
+  const p = path.startsWith("/") ? path : `/${path}`;
+  const url = new URL(`${base}${p}`);
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0 && value !== null) {
+      url.searchParams.set(key, String(value));
+    }
+  }
+  return url.toString();
+}
+function getMcpTokenForHost(host) {
+  const store = loadMcpTokenStore();
+  const normalizedHost = host.replace(/\/+$/, "");
+  if (store[host]) return store[host];
+  if (store[normalizedHost]) return store[normalizedHost];
+  for (const [key, token] of Object.entries(store)) {
+    if (key.replace(/\/+$/, "") === normalizedHost) {
+      return token;
+    }
+  }
+  return void 0;
+}
+function getTokenFromStore(store, host) {
+  const normalizedHost = host.replace(/\/+$/, "");
+  if (store[host]) return store[host];
+  if (store[normalizedHost]) return store[normalizedHost];
+  for (const [key, token] of Object.entries(store)) {
+    if (key.replace(/\/+$/, "") === normalizedHost) {
+      return token;
+    }
+  }
+  return void 0;
+}
+function refreshMcpTokenFromFallback(host) {
+  logger.warn(`KB MCP request failed for ${host}, trying fallback`);
+  const migrated = forceMigrateFromFallback();
+  const token = migrated ? getTokenFromStore(migrated, host) : void 0;
+  if (token) {
+    logger.info(`KB MCP token refreshed from fallback for ${host}`);
+    process.stderr.write(`[ae-cli] MCP token refreshed from fallback for ${host}
+`);
+  }
+  return token;
+}
+function isMcpAuthFailure(resp, data) {
+  return !resp.ok || data.return_code === -1001;
+}
+function parseKbResponse(resp, text) {
+  if (resp.status === 401 || resp.status === 403) {
+    throw new Error(`KB MCP token auth failed: HTTP ${resp.status} ${resp.statusText}`);
+  }
+  const data = safeJsonParse(text);
+  if (data.return_code === -1001) {
+    throw new Error(`KB MCP token auth failed: ${data.return_message || "unauthorized"} (code: ${data.return_code})`);
+  }
+  if (data.return_code !== 0 && data.return_code !== void 0) {
+    throw new Error(`AE API error: ${data.return_message || "unknown"} (code: ${data.return_code})`);
+  }
+  return data.data !== void 0 ? data.data : data;
+}
+async function fetchWithMcpToken(host, input, init, mcpToken) {
+  const headers = new Headers(init.headers);
+  headers.set("mcp-token", mcpToken);
+  const resp = await fetch(input, { ...init, headers });
+  const text = await resp.text();
+  if (!resp.ok) {
+    const refreshedToken = refreshMcpTokenFromFallback(host);
+    if (refreshedToken) {
+      headers.set("mcp-token", refreshedToken);
+      const retryResp = await fetch(input, { ...init, headers });
+      return parseKbResponse(retryResp, await retryResp.text());
+    }
+    return parseKbResponse(resp, text);
+  }
+  const data = safeJsonParse(text);
+  if (isMcpAuthFailure(resp, data)) {
+    const refreshedToken = refreshMcpTokenFromFallback(host);
+    if (refreshedToken) {
+      headers.set("mcp-token", refreshedToken);
+      const retryResp = await fetch(input, { ...init, headers });
+      return parseKbResponse(retryResp, await retryResp.text());
+    }
+  }
+  return parseKbResponse(resp, text);
+}
+async function kbApi(ctx, method, path, params = {}, body) {
+  const host = ctx.host();
+  const mcpToken = getMcpTokenForHost(host);
+  if (!mcpToken) {
+    return ctx.api(method, path, params, body);
+  }
+  const upperMethod = method.toUpperCase();
+  return fetchWithMcpToken(host, buildUrl(host, path, params), {
+    method: upperMethod,
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: upperMethod === "GET" ? void 0 : JSON.stringify(body ?? {})
+  }, mcpToken);
+}
+async function kbUpload(ctx, path, form, params = {}) {
+  const host = ctx.host();
+  const mcpToken = getMcpTokenForHost(host);
+  if (!mcpToken) {
+    const { httpUpload } = await import("./client-IU2E5IOL.js");
+    return httpUpload(path, form, params, host);
+  }
+  return fetchWithMcpToken(host, buildUrl(host, path, params), {
+    method: "POST",
+    body: form
+  }, mcpToken);
+}
+
+export {
+  kbApi,
+  kbUpload
+};

package/dist/{chunk-47MTN54I.js → chunk-SRRUNQIM.js}

@@ -2,16 +2,19 @@ import {
   extractHostname,
   getActiveHost,
   getConfigDir,
-  logger,
   safeJsonParse,
   safeReadJsonFile
-} from "./chunk-DC66L5AM.js";
+} from "./chunk-BI5ZVD6T.js";
+import {
+  logger
+} from "./chunk-MNHE6SSI.js";
 
 // src/core/auth.ts
 import fs from "fs";
 import path from "path";
 import { execFileSync } from "child_process";
 var TOKENS_FILE = path.join(getConfigDir(), "tokens.json");
+var MCP_TOKENS_FILE = path.join(getConfigDir(), "mcp-tokens.json");
 var LEGACY_DIR = path.join(process.env.HOME || "", ".te-mcp");
 var TOKEN_TTL_MS = 20 * 60 * 60 * 1e3;
 var OSASCRIPT_POLL_INTERVAL_MS = 2e3;
@@ -113,6 +116,23 @@ function getAuthStatus(hostUrl) {
   }
   return { authenticated: false, host: hostUrl };
 }
+function getCachedMcpToken(hostUrl) {
+  try {
+    if (!fs.existsSync(MCP_TOKENS_FILE)) return void 0;
+    const store = safeReadJsonFile(MCP_TOKENS_FILE);
+    const normalizedHost = hostUrl.replace(/\/+$/, "");
+    if (store[hostUrl]) return store[hostUrl];
+    if (store[normalizedHost]) return store[normalizedHost];
+    for (const [key, token] of Object.entries(store)) {
+      if (key.replace(/\/+$/, "") === normalizedHost) {
+        return token;
+      }
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
 function extractTokenViaOsascript(hostUrl) {
   if (process.platform !== "darwin") return { token: null, error: "not_mac" };
   const hostname = extractHostname(hostUrl);
@@ -242,6 +262,13 @@ Run: ae-cli config set-host`
     logger.info(`Using cached token for ${hostUrl}`);
     return cached.token;
   }
+  if (getCachedMcpToken(hostUrl)) {
+    logger.info(`MCP token exists for ${hostUrl}; skipping browser token extraction`);
+    throw new Error(
+      `MCP token already exists for ${hostUrl}; skipped browser login.
+Use an MCP-token aware command, or run: ae-cli auth set-token <token>`
+    );
+  }
   const { token: osascriptToken, error } = extractTokenViaOsascript(hostUrl);
   if (error === "no_js_permission") {
     logger.warn("Chrome JS Apple Events not enabled");

package/dist/chunk-TG64AQV4.js

@@ -0,0 +1,262 @@
+// src/core/te-agent-credentials.ts
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function getCredentialsPath() {
+  return join(process.env.HOME || homedir(), ".te-agent", "credentials.json");
+}
+function getPersistentEnvPath() {
+  const runtimeRoot = process.env.SANDBOX_RUNTIME_ROOT ?? "/home/ta/te_agent_ta";
+  return join(runtimeRoot, ".env");
+}
+function parseDotEnv(raw) {
+  const result = {};
+  for (const line of raw.split("\n")) {
+    if (/^\s*#/.test(line) || line.trim() === "") continue;
+    const match = /^\s*([^=]+)=(.*)$/.exec(line);
+    if (!match) continue;
+    const key = match[1].trim();
+    let value = match[2].trim();
+    if (value.startsWith('"') && value.endsWith('"')) {
+      value = value.slice(1, -1).replace(/\\"/g, '"');
+    }
+    if (value !== "") result[key] = value;
+  }
+  return result;
+}
+function readPersistentEnv() {
+  const envPath = getPersistentEnvPath();
+  try {
+    const raw = readFileSync(envPath, "utf8");
+    return parseDotEnv(raw);
+  } catch (err) {
+    if (err?.code === "ENOENT") return null;
+    throw new TeAgentCredentialsError(
+      `${envPath} \u8BFB\u53D6\u5931\u8D25\uFF1A${err?.message ?? err}`,
+      "\u8BF7\u68C0\u67E5\u6587\u4EF6\u6743\u9650\uFF0C\u6216\u901A\u8FC7 TE_CLAUDE_BASE_URL / SANDBOX_ID / SECRET_KEY \u6CE8\u5165\u8FD0\u884C\u65F6\u51ED\u8BC1"
+    );
+  }
+}
+var TeAgentCredentialsError = class extends Error {
+  constructor(message, hint) {
+    super(message);
+    this.hint = hint;
+    this.name = "TeAgentCredentialsError";
+  }
+  hint;
+};
+function readLegacyCredentials() {
+  const credPath = getCredentialsPath();
+  try {
+    const raw = readFileSync(credPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const main = parsed?.mainApp;
+    return main && typeof main === "object" ? main : null;
+  } catch (err) {
+    if (err?.code === "ENOENT") return null;
+    if (err instanceof SyntaxError) {
+      throw new TeAgentCredentialsError(
+        `${credPath} \u89E3\u6790\u5931\u8D25\uFF1A${err.message}`,
+        "\u51ED\u8BC1\u6587\u4EF6\u53EF\u80FD\u5DF2\u635F\u574F\uFF1B\u4E5F\u53EF\u4EE5\u901A\u8FC7 TE_CLAUDE_BASE_URL / SANDBOX_ID / SECRET_KEY \u6CE8\u5165\u8FD0\u884C\u65F6\u51ED\u8BC1"
+      );
+    }
+    throw new TeAgentCredentialsError(
+      `${credPath} \u8BFB\u53D6\u5931\u8D25\uFF1A${err?.message ?? err}`,
+      "\u8BF7\u68C0\u67E5\u6587\u4EF6\u6743\u9650\uFF0C\u6216\u901A\u8FC7 TE_CLAUDE_BASE_URL / SANDBOX_ID / SECRET_KEY \u6CE8\u5165\u8FD0\u884C\u65F6\u51ED\u8BC1"
+    );
+  }
+}
+function loadTeAgentCredentials() {
+  const legacy = readLegacyCredentials();
+  const credPath = getCredentialsPath();
+  const envPath = getPersistentEnvPath();
+  const persistent = readPersistentEnv();
+  const url = process.env.TE_CLAUDE_BASE_URL || persistent?.TE_CLAUDE_BASE_URL || legacy?.url;
+  const sandboxId = process.env.SANDBOX_ID || persistent?.SANDBOX_ID || legacy?.sandboxId;
+  const sandboxSecretKey = process.env.SECRET_KEY || process.env.SANDBOX_SECRET_KEY || persistent?.SECRET_KEY || persistent?.SANDBOX_SECRET_KEY || legacy?.sandboxSecretKey || legacy?.secretKey;
+  if (typeof url !== "string" || !url) {
+    throw new TeAgentCredentialsError(
+      "TE_CLAUDE_BASE_URL \u7F3A\u5931",
+      `\u8BF7\u5728 te-agent \u6C99\u7BB1\u5185\u6267\u884C\uFF0C\u6216\u914D\u7F6E ${envPath} / ${credPath}`
+    );
+  }
+  if (typeof sandboxId !== "string" || !sandboxId) {
+    throw new TeAgentCredentialsError(
+      "SANDBOX_ID \u7F3A\u5931",
+      `\u8BF7\u5728 te-agent \u6C99\u7BB1\u5185\u6267\u884C\uFF0C\u6216\u914D\u7F6E ${envPath} / ${credPath}`
+    );
+  }
+  if (typeof sandboxSecretKey !== "string" || !sandboxSecretKey) {
+    throw new TeAgentCredentialsError(
+      "SECRET_KEY \u7F3A\u5931",
+      `\u8BF7\u5728 te-agent \u6C99\u7BB1\u5185\u6267\u884C\uFF0C\u6216\u914D\u7F6E ${envPath} / ${credPath}`
+    );
+  }
+  return { mainApp: { url, sandboxId, sandboxSecretKey } };
+}
+function getClaudeConfigDir() {
+  const fromEnv = process.env.CLAUDE_CONFIG_DIR;
+  if (typeof fromEnv === "string" && fromEnv.length > 0) {
+    return fromEnv;
+  }
+  return join(homedir(), ".claude");
+}
+
+// src/core/te-agent-client.ts
+var TeAgentApiError = class extends Error {
+  constructor(message, status, code, body) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.body = body;
+    this.name = "TeAgentApiError";
+  }
+  status;
+  code;
+  body;
+};
+var DEFAULT_TIMEOUT_MS = 3e4;
+var UPLOAD_TIMEOUT_MS = 12e4;
+async function fetchWithTimeout(url, init, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } catch (err) {
+    if (err?.name === "AbortError") {
+      throw new TeAgentApiError(`\u8BF7\u6C42\u8D85\u65F6\uFF08${timeoutMs}ms\uFF09\uFF1A${url}`, 0, "TIMEOUT");
+    }
+    throw new TeAgentApiError(`\u7F51\u7EDC\u8BF7\u6C42\u5931\u8D25\uFF1A${err?.message ?? err}`, 0, "NETWORK_ERROR");
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function signRequest(method, path, rawBody) {
+  const cred = loadTeAgentCredentials();
+  const { url: baseUrl, sandboxId, sandboxSecretKey } = cred.mainApp;
+  const headers = {
+    "X-Sandbox-Id": sandboxId,
+    "X-Sandbox-Secret-Key": sandboxSecretKey
+  };
+  if (method === "POST" || method === "PATCH") {
+    headers["Content-Type"] = "application/json";
+  }
+  return {
+    url: `${baseUrl.replace(/\/$/, "")}${path}`,
+    headers,
+    rawBody
+  };
+}
+async function parseResponse(response, defaultErrorPrefix) {
+  const text = await response.text();
+  let parsed = void 0;
+  if (text) {
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      parsed = text;
+    }
+  }
+  if (!response.ok) {
+    const message = typeof parsed === "object" && parsed && typeof parsed.error === "string" ? parsed.error : `${defaultErrorPrefix} ${response.status}`;
+    const code = typeof parsed === "object" && parsed && typeof parsed.code === "string" ? parsed.code : void 0;
+    throw new TeAgentApiError(message, response.status, code, parsed);
+  }
+  return parsed;
+}
+async function postToMainApp(path, body) {
+  const rawBody = JSON.stringify(body);
+  const signed = signRequest("POST", path, rawBody);
+  const response = await fetchWithTimeout(signed.url, {
+    method: "POST",
+    headers: signed.headers,
+    body: signed.rawBody
+  });
+  return parseResponse(response, "\u4E3B\u5E94\u7528\u8FD4\u56DE");
+}
+async function getFromMainApp(path) {
+  const signed = signRequest("GET", path, "");
+  const response = await fetchWithTimeout(signed.url, {
+    method: "GET",
+    headers: signed.headers
+  });
+  return parseResponse(response, "\u4E3B\u5E94\u7528\u8FD4\u56DE");
+}
+async function getSandboxModels(currentModelId) {
+  const qs = currentModelId ? `?current=${encodeURIComponent(currentModelId)}` : "";
+  const data = await getFromMainApp(`/api/sandbox/models${qs}`);
+  return Array.isArray(data?.models) ? data.models : [];
+}
+async function postSandboxModelSelection(args) {
+  return postToMainApp("/api/sandbox/models/select", args);
+}
+async function getSandboxSyncPullCandidates(args) {
+  const qs = new URLSearchParams({
+    workspacePath: args.workspacePath,
+    kind: args.kind
+  });
+  return getFromMainApp(
+    `/api/sandbox/sync/pull/candidates?${qs.toString()}`
+  );
+}
+async function postSandboxSyncPull(args) {
+  return postToMainApp("/api/sandbox/sync/pull", {
+    workspacePath: args.workspacePath,
+    kind: args.kind,
+    skills: args.skills,
+    mcp: args.mcp,
+    mode: "merge",
+    ifUnmodifiedSince: args.ifUnmodifiedSince
+  });
+}
+async function deleteFromMainApp(path) {
+  const signed = signRequest("DELETE", path, "");
+  const response = await fetchWithTimeout(signed.url, {
+    method: "DELETE",
+    headers: signed.headers
+  });
+  return parseResponse(response, "\u4E3B\u5E94\u7528\u8FD4\u56DE");
+}
+async function patchToMainApp(path, body) {
+  const rawBody = JSON.stringify(body);
+  const signed = signRequest("PATCH", path, rawBody);
+  const response = await fetchWithTimeout(signed.url, {
+    method: "PATCH",
+    headers: signed.headers,
+    body: signed.rawBody
+  });
+  return parseResponse(response, "\u4E3B\u5E94\u7528\u8FD4\u56DE");
+}
+async function uploadToMainApp(path, formData) {
+  const cred = loadTeAgentCredentials();
+  const baseUrl = cred.mainApp.url.replace(/\/$/, "");
+  const url = `${baseUrl}${path}`;
+  const response = await fetchWithTimeout(
+    url,
+    {
+      method: "POST",
+      headers: {
+        "X-Sandbox-Id": cred.mainApp.sandboxId,
+        "X-Sandbox-Secret-Key": cred.mainApp.sandboxSecretKey
+      },
+      body: formData
+    },
+    UPLOAD_TIMEOUT_MS
+  );
+  return parseResponse(response, "\u4E0A\u4F20\u5931\u8D25");
+}
+
+export {
+  TeAgentCredentialsError,
+  getClaudeConfigDir,
+  TeAgentApiError,
+  postToMainApp,
+  getFromMainApp,
+  getSandboxModels,
+  postSandboxModelSelection,
+  getSandboxSyncPullCandidates,
+  postSandboxSyncPull,
+  deleteFromMainApp,
+  patchToMainApp,
+  uploadToMainApp
+};