@thinkingai/ae-cli 6.0.41 → 6.0.44

package/dist/{chunk-AXDXJTPC.js → chunk-UW5UN47B.js}

@@ -1,11 +1,13 @@
 // src/core/errors.ts
 var PermissionError = class extends Error {
-  constructor(message, code) {
+  constructor(message, code, hint) {
     super(message);
     this.code = code;
+    this.hint = hint;
     this.name = "PermissionError";
   }
   code;
+  hint;
 };
 var CliValidationError = class extends Error {
   code;
@@ -45,9 +47,24 @@ var CommunityReportError = class extends Error {
     this.meta = options.meta;
   }
 };
+var LocalDataUploadError = class extends Error {
+  code;
+  httpStatus;
+  hint;
+  meta;
+  constructor(message, options = {}) {
+    super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+    this.name = "LocalDataUploadError";
+    this.code = options.code;
+    this.httpStatus = options.httpStatus;
+    this.hint = options.hint;
+    this.meta = options.meta;
+  }
+};
 
 export {
   PermissionError,
   CliValidationError,
-  CommunityReportError
+  CommunityReportError,
+  LocalDataUploadError
 };

package/dist/chunk-VPKZ7I72.js

@@ -0,0 +1,509 @@
+import {
+  internalCallSourceHeaders
+} from "./chunk-6EIJSNBD.js";
+import {
+  clearCliToken,
+  getCliToken
+} from "./chunk-4SGZG4XY.js";
+import {
+  getActiveHost,
+  getSandboxRuntimeRoot
+} from "./chunk-ZZUOD757.js";
+import {
+  PermissionError
+} from "./chunk-UW5UN47B.js";
+
+// 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() {
+  return join(getSandboxRuntimeRoot(), ".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(
+      `Failed to read ${envPath}: ${err?.message ?? err}`,
+      "Check file permissions, or inject runtime credentials via TE_CLAUDE_BASE_URL / SANDBOX_ID / SECRET_KEY"
+    );
+  }
+}
+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(
+        `Failed to parse ${credPath}: ${err.message}`,
+        "The credentials file may be corrupted; alternatively inject runtime credentials via TE_CLAUDE_BASE_URL / SANDBOX_ID / SECRET_KEY"
+      );
+    }
+    throw new TeAgentCredentialsError(
+      `Failed to read ${credPath}: ${err?.message ?? err}`,
+      "Check file permissions, or inject runtime credentials via TE_CLAUDE_BASE_URL / SANDBOX_ID / SECRET_KEY"
+    );
+  }
+}
+function tryLoadTeAgentSandboxCredentials() {
+  const legacy = readLegacyCredentials();
+  const persistent = readPersistentEnv();
+  const url = process.env.TE_CLAUDE_BASE_URL || persistent?.TE_CLAUDE_BASE_URL || legacy?.url;
+  if (typeof url !== "string" || !url) {
+    return null;
+  }
+  const sandboxId = process.env.SANDBOX_ID || persistent?.SANDBOX_ID || legacy?.sandboxId || null;
+  const sandboxSecretKey = process.env.SECRET_KEY || process.env.SANDBOX_SECRET_KEY || persistent?.SECRET_KEY || persistent?.SANDBOX_SECRET_KEY || legacy?.sandboxSecretKey || legacy?.secretKey || null;
+  return {
+    url,
+    sandboxId: typeof sandboxId === "string" ? sandboxId : null,
+    sandboxSecretKey: typeof sandboxSecretKey === "string" ? sandboxSecretKey : null
+  };
+}
+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
+import { open, unlink } from "fs/promises";
+import path from "path";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+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;
+var DOWNLOAD_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(
+        `Request timed out (${timeoutMs}ms) for ${safeRequestOrigin(url)}`,
+        0,
+        "TIMEOUT"
+      );
+    }
+    throw networkRequestError(url, err);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function safeRequestOrigin(url) {
+  try {
+    return new URL(url).origin;
+  } catch {
+    return "the configured service";
+  }
+}
+function networkRequestError(url, error) {
+  const nestedCause = error && typeof error === "object" && "cause" in error ? error.cause : void 0;
+  const root = nestedCause ?? error;
+  const detail = root && typeof root === "object" ? root : {};
+  const code = typeof detail.code === "string" ? detail.code : void 0;
+  const address = typeof detail.address === "string" ? detail.address : typeof detail.hostname === "string" ? detail.hostname : void 0;
+  const port = typeof detail.port === "number" || typeof detail.port === "string" ? String(detail.port) : void 0;
+  const endpoint = address ? `${address}${port ? `:${port}` : ""}` : void 0;
+  const cause = [code, endpoint].filter(Boolean).join(" ");
+  const suffix = cause ? ` (${cause})` : "";
+  return new TeAgentApiError(
+    `Network request failed for ${safeRequestOrigin(url)}${suffix}`,
+    0,
+    "NETWORK_ERROR"
+  );
+}
+function teClaudeBaseFromActiveHost(hostOverride) {
+  const override = hostOverride ? void 0 : process.env.TE_CLAUDE_BASE_URL;
+  if (override) return override.replace(/\/+$/, "");
+  const h = hostOverride || getActiveHost();
+  if (!h) return void 0;
+  const base = h.replace(/\/+$/, "");
+  const bp = process.env.TE_CLAUDE_BASE_PATH || "/agent";
+  return base.endsWith(bp) ? base : base + bp;
+}
+async function signRequest(method, path2, hostOverride, includeJsonContentType = true) {
+  const sandboxCred = tryLoadTeAgentSandboxCredentials();
+  if (!hostOverride && sandboxCred && sandboxCred.sandboxId && sandboxCred.sandboxSecretKey) {
+    const headers = {
+      "X-Sandbox-Id": sandboxCred.sandboxId,
+      "X-Sandbox-Secret-Key": sandboxCred.sandboxSecretKey
+    };
+    if (includeJsonContentType && (method === "POST" || method === "PATCH" || method === "PUT")) {
+      headers["Content-Type"] = "application/json";
+    }
+    return {
+      url: `${sandboxCred.url.replace(/\/$/, "")}${path2}`,
+      headers,
+      authKind: "sandbox"
+    };
+  }
+  const baseUrl = hostOverride ? teClaudeBaseFromActiveHost(hostOverride) : sandboxCred?.url || teClaudeBaseFromActiveHost();
+  if (!baseUrl) {
+    throw new TeAgentCredentialsError(
+      "Cannot determine the te-claude service URL",
+      "Run ae-cli config set-host <url> to configure the service URL, or execute inside a te-agent sandbox"
+    );
+  }
+  const hostForToken = hostOverride || getActiveHost() || baseUrl;
+  const contentTypeHeader = includeJsonContentType && (method === "POST" || method === "PATCH" || method === "PUT") ? { "Content-Type": "application/json" } : {};
+  const cliToken = await getCliToken(hostForToken);
+  return {
+    url: `${baseUrl.replace(/\/$/, "")}${path2}`,
+    headers: {
+      "cli-token": cliToken,
+      ...internalCallSourceHeaders(),
+      ...contentTypeHeader
+    },
+    authKind: "cli-token",
+    tokenHost: hostForToken
+  };
+}
+async function fetchSignedWithRetry(options) {
+  let signed = await signRequest(
+    options.method,
+    options.path,
+    options.hostOverride,
+    options.includeJsonContentType
+  );
+  const request = (requestToSend) => fetchWithTimeout(
+    requestToSend.url,
+    {
+      method: options.method,
+      headers: requestToSend.headers,
+      body: options.body
+    },
+    options.timeoutMs
+  );
+  let response = await request(signed);
+  if (response.status === 401 && signed.authKind === "cli-token" && signed.tokenHost) {
+    clearCliToken(signed.tokenHost);
+    signed = await signRequest(
+      options.method,
+      options.path,
+      options.hostOverride,
+      options.includeJsonContentType
+    );
+    response = await request(signed);
+  }
+  return response;
+}
+function errorDetails(parsed, defaultErrorPrefix, status) {
+  const nested = parsed && typeof parsed === "object" && parsed.error && typeof parsed.error === "object" ? parsed.error : parsed;
+  const message = typeof parsed?.error === "string" ? parsed.error : typeof nested?.message === "string" ? nested.message : typeof parsed?.message === "string" ? parsed.message : typeof parsed?.return_message === "string" ? parsed.return_message : `${defaultErrorPrefix} ${status}`;
+  const code = typeof nested?.code === "string" ? nested.code : typeof parsed?.code === "string" ? parsed.code : void 0;
+  const hint = typeof nested?.hint === "string" ? nested.hint : typeof parsed?.hint === "string" ? parsed.hint : void 0;
+  return { message, code, hint };
+}
+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 details = errorDetails(parsed, defaultErrorPrefix, response.status);
+    if (response.status === 403) {
+      throw new PermissionError(details.message, details.code, details.hint);
+    }
+    if (response.status === 401) {
+      throw new TeAgentApiError(
+        "Session expired or unauthorized. Please run: ae-cli auth login",
+        response.status,
+        "auth_expired",
+        parsed
+      );
+    }
+    throw new TeAgentApiError(details.message, response.status, details.code, parsed);
+  }
+  return parsed;
+}
+async function postToMainApp(path2, body, hostOverride) {
+  const rawBody = JSON.stringify(body);
+  const response = await fetchSignedWithRetry({
+    method: "POST",
+    path: path2,
+    body: rawBody,
+    hostOverride
+  });
+  return parseResponse(response, "Main app returned");
+}
+async function getFromMainApp(path2, hostOverride) {
+  const response = await fetchSignedWithRetry({
+    method: "GET",
+    path: path2,
+    hostOverride
+  });
+  return parseResponse(response, "Main app returned");
+}
+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"
+  });
+}
+async function deleteFromMainApp(path2, hostOverride) {
+  const response = await fetchSignedWithRetry({
+    method: "DELETE",
+    path: path2,
+    hostOverride
+  });
+  return parseResponse(response, "Main app returned");
+}
+async function patchToMainApp(path2, body, hostOverride) {
+  const rawBody = JSON.stringify(body);
+  const response = await fetchSignedWithRetry({
+    method: "PATCH",
+    path: path2,
+    body: rawBody,
+    hostOverride
+  });
+  return parseResponse(response, "Main app returned");
+}
+async function putToMainApp(path2, body, hostOverride) {
+  const rawBody = JSON.stringify(body);
+  const response = await fetchSignedWithRetry({
+    method: "PUT",
+    path: path2,
+    body: rawBody,
+    hostOverride
+  });
+  return parseResponse(response, "Main app returned");
+}
+async function getBufferFromMainApp(path2, hostOverride) {
+  const response = await fetchSignedWithRetry({
+    method: "GET",
+    path: path2,
+    hostOverride
+  });
+  if (!response.ok) {
+    await parseResponse(response, "Main app returned");
+  }
+  const arrayBuffer = await response.arrayBuffer();
+  const buffer = Buffer.from(arrayBuffer);
+  const cd = response.headers.get("Content-Disposition") || "";
+  const match = cd.match(/filename\*=UTF-8''([^;]+)/);
+  const fileName = match ? decodeURIComponent(match[1]) : null;
+  const contentType = response.headers.get("Content-Type");
+  return { buffer, fileName, contentType };
+}
+function responseFileName(response) {
+  const disposition = response.headers.get("Content-Disposition") ?? "";
+  const encoded = disposition.match(/filename\*=UTF-8''([^;]+)/i)?.[1];
+  if (encoded) {
+    try {
+      return decodeURIComponent(encoded.trim());
+    } catch {
+      return encoded.trim();
+    }
+  }
+  return disposition.match(/filename="([^"]+)"/i)?.[1] ?? disposition.match(/filename=([^;]+)/i)?.[1]?.trim() ?? null;
+}
+async function* responseBodyChunks(body) {
+  const reader = body.getReader();
+  try {
+    while (true) {
+      const chunk = await reader.read();
+      if (chunk.done) return;
+      yield chunk.value;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function downloadFromMainApp(requestPath, outputPath, hostOverride) {
+  const absolutePath = path.resolve(outputPath);
+  let fileHandle;
+  let created = false;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), DOWNLOAD_TIMEOUT_MS);
+  try {
+    try {
+      fileHandle = await open(absolutePath, "wx");
+      created = true;
+    } catch (error) {
+      if (error.code === "EEXIST") {
+        throw new TeAgentApiError(
+          `Output file already exists: ${absolutePath}`,
+          0,
+          "OUTPUT_EXISTS"
+        );
+      }
+      throw new TeAgentApiError(
+        `Unable to create output file: ${absolutePath}`,
+        0,
+        "OUTPUT_ERROR"
+      );
+    }
+    let signed = await signRequest("GET", requestPath, hostOverride);
+    let response;
+    const request = async (requestToSend) => {
+      try {
+        return await fetch(requestToSend.url, {
+          method: "GET",
+          headers: requestToSend.headers,
+          signal: controller.signal
+        });
+      } catch (error) {
+        if (error?.name === "AbortError") {
+          throw new TeAgentApiError(
+            `Request timed out (${DOWNLOAD_TIMEOUT_MS}ms) for ${safeRequestOrigin(requestToSend.url)}`,
+            0,
+            "TIMEOUT"
+          );
+        }
+        throw networkRequestError(requestToSend.url, error);
+      }
+    };
+    response = await request(signed);
+    if (response.status === 401 && signed.authKind === "cli-token" && signed.tokenHost) {
+      clearCliToken(signed.tokenHost);
+      signed = await signRequest("GET", requestPath, hostOverride);
+      response = await request(signed);
+    }
+    if (!response.ok) {
+      await parseResponse(response, "Main app returned");
+    }
+    if (!response.body) {
+      throw new TeAgentApiError("Main app returned an empty download stream", 0, "EMPTY_BODY");
+    }
+    const output = fileHandle.createWriteStream();
+    try {
+      await pipeline(
+        Readable.from(responseBodyChunks(response.body)),
+        output
+      );
+    } catch (error) {
+      if (error?.name === "AbortError") {
+        throw new TeAgentApiError(
+          `Request timed out (${DOWNLOAD_TIMEOUT_MS}ms): ${signed.url}`,
+          0,
+          "TIMEOUT"
+        );
+      }
+      throw new TeAgentApiError(
+        `Download failed: ${error instanceof Error ? error.message : String(error)}`,
+        0,
+        "DOWNLOAD_ERROR"
+      );
+    }
+    return {
+      path: absolutePath,
+      bytes: output.bytesWritten,
+      fileName: responseFileName(response),
+      contentType: response.headers.get("Content-Type")
+    };
+  } catch (error) {
+    if (fileHandle) await fileHandle.close().catch(() => void 0);
+    if (created) await unlink(absolutePath).catch(() => void 0);
+    throw error;
+  } finally {
+    clearTimeout(timer);
+    controller.abort();
+  }
+}
+async function uploadToMainApp(path2, formData, hostOverride) {
+  const response = await fetchSignedWithRetry({
+    method: "POST",
+    path: path2,
+    body: formData,
+    hostOverride,
+    includeJsonContentType: false,
+    timeoutMs: UPLOAD_TIMEOUT_MS
+  });
+  return parseResponse(response, "Upload failed");
+}
+
+export {
+  TeAgentCredentialsError,
+  tryLoadTeAgentSandboxCredentials,
+  getClaudeConfigDir,
+  TeAgentApiError,
+  postToMainApp,
+  getFromMainApp,
+  getSandboxModels,
+  postSandboxModelSelection,
+  getSandboxSyncPullCandidates,
+  postSandboxSyncPull,
+  deleteFromMainApp,
+  patchToMainApp,
+  putToMainApp,
+  getBufferFromMainApp,
+  downloadFromMainApp,
+  uploadToMainApp
+};