@thinkingai/ae-cli 6.1.25 → 6.1.26

package/dist/{chunk-QYXDJOLA.js → chunk-EOYSKMXN.js}

@@ -6,17 +6,18 @@ import {
   SecureStoreAuthError,
   clearCliTokenCache,
   getCliToken
-} from "./chunk-DU72X2IO.js";
+} from "./chunk-GIK6EDUG.js";
 import {
   safeJsonParse
-} from "./chunk-IG3DYEIR.js";
+} from "./chunk-UQ77JXYH.js";
 import {
   PermissionError
-} from "./chunk-YVGXGTD6.js";
+} from "./chunk-WNGFSIOB.js";
 
 // src/core/cli-agent-context.ts
 import { readFileSync, statSync } from "fs";
 import { dirname, join, parse, resolve } from "path";
+import { AsyncLocalStorage } from "async_hooks";
 var MAX_CONTEXT_FILE_BYTES = 64 * 1024;
 var CONTEXT_FILE_ENV = "TA_CLI_CONTEXT_FILE";
 var CONTEXT_ARG = "--agent-context";
@@ -42,12 +43,17 @@ var FIELDS = [
   { key: "session_goal", env: "TA_CLI_SESSION_GOAL", header: "X-TA-CLI-Session-Goal", maxLength: 2048 },
   { key: "context_capture_status", env: "TA_CLI_CONTEXT_CAPTURE_STATUS", header: "X-TA-CLI-Context-Capture-Status", maxLength: 32 }
 ];
+var scopedContext = new AsyncLocalStorage();
+function runWithCliAgentContext(context, run) {
+  return scopedContext.run(context, run);
+}
 function readCliAgentContext() {
   const context = {
     ...inferRuntimeContext(),
     ...readEnvContext(),
     ...readArgumentContext(),
-    ...readFileContext()
+    ...readFileContext(),
+    ...scopedContext.getStore()
   };
   return withCaptureStatus(context);
 }
@@ -271,11 +277,11 @@ var CapabilityGatewayError = class extends Error {
   meta;
   type;
 };
-function buildCapabilityGatewayUrl(host, domain, pathAfterV1, queryParams = {}) {
+function buildCapabilityGatewayUrl(host, domain, pathAfterV1, queryParams = {}, apiVersion = "v1") {
   const base = host.replace(/\/+$/, "");
   const cleanDomain = domain.replace(/^\/+|\/+$/g, "");
   const cleanPath = pathAfterV1.replace(/^\/+|\/+$/g, "");
-  const gatewayPrefix = cleanDomain === "" ? "/api/cli/v1" : `/api/cli/${cleanDomain}/v1`;
+  const gatewayPrefix = cleanDomain === "" ? `/api/cli/${apiVersion}` : `/api/cli/${cleanDomain}/${apiVersion}`;
   const url = new URL(`${base}${gatewayPrefix}/${cleanPath}`);
   for (const [key, value] of Object.entries(queryParams)) {
     if (value !== void 0 && value !== null) {
@@ -383,7 +389,7 @@ async function throwCapabilityHttpError(resp) {
   }
   throw error;
 }
-async function requestOnce(url, method, token, body, accept = "application/json") {
+async function requestOnce(url, method, token, body, accept = "application/json", includeClientContextInBody = true) {
   const agentContext = readCliAgentContext();
   const headers = {
     "cli-token": token,
@@ -394,7 +400,7 @@ async function requestOnce(url, method, token, body, accept = "application/json"
   const init = { method, headers };
   if (body !== void 0 && method !== "GET") {
     headers["Content-Type"] = "application/json";
-    init.body = JSON.stringify(withCliAgentContextBody(body, agentContext));
+    init.body = JSON.stringify(includeClientContextInBody ? withCliAgentContextBody(body, agentContext) : body);
   }
   return fetch(url, init);
 }
@@ -413,13 +419,13 @@ async function callGateway(host, domain, pathAfterV1, method, body, queryParams
   return (await callGatewayWithEnvelope(host, domain, pathAfterV1, method, body, queryParams, options)).data;
 }
 async function callGatewayWithEnvelope(host, domain, pathAfterV1, method, body, queryParams = {}, options = {}) {
-  const url = buildCapabilityGatewayUrl(options.apiBaseUrl ?? host, domain, pathAfterV1, queryParams);
+  const url = buildCapabilityGatewayUrl(options.apiBaseUrl ?? host, domain, pathAfterV1, queryParams, options.apiVersion);
   const token = await getCliToken(host);
-  let resp = await requestOnce(url, method, token, body);
+  let resp = await requestOnce(url, method, token, body, "application/json", options.includeClientContextInBody);
   if (resp.status === 401 && options.retryOnUnauthorized === true) {
     await resp.body?.cancel();
     clearCliTokenCache(host);
-    resp = await requestOnce(url, method, await getCliToken(host), body);
+    resp = await requestOnce(url, method, await getCliToken(host), body, "application/json", options.includeClientContextInBody);
   }
   if (resp.status === 403) {
     const error = await permissionError(resp);
@@ -549,6 +555,8 @@ async function callCapabilityApi(host, domain, action, method = "POST", params =
 }
 
 export {
+  runWithCliAgentContext,
+  readCliAgentContext,
   CapabilityGatewayError,
   buildCapabilityGatewayUrl,
   fetchCapabilityGateway,

package/dist/{chunk-5XRQ3CZR.js → chunk-FMNNGNYO.js}

@@ -1,17 +1,17 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   CapabilityGatewayError
-} from "./chunk-QYXDJOLA.js";
+} from "./chunk-EOYSKMXN.js";
 import {
   SecureStoreAuthError,
   getCliToken
-} from "./chunk-DU72X2IO.js";
+} from "./chunk-GIK6EDUG.js";
 import {
   safeJsonParse
-} from "./chunk-IG3DYEIR.js";
+} from "./chunk-UQ77JXYH.js";
 import {
   PermissionError
-} from "./chunk-YVGXGTD6.js";
+} from "./chunk-WNGFSIOB.js";
 
 // src/core/mcp-access.ts
 function buildUrl(host, path, params = {}) {
@@ -26,6 +26,11 @@ function buildUrl(host, path, params = {}) {
   return url.toString();
 }
 var KbUnauthorizedError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+  }
+  code;
 };
 function optionalString(value) {
   return typeof value === "string" && value.trim() ? value.trim() : void 0;
@@ -49,6 +54,16 @@ function responseErrorMessage(data) {
   const nestedError = data?.error && typeof data.error === "object" ? data.error : void 0;
   return optionalString(typeof data?.error === "string" ? data.error : void 0) ?? optionalString(nestedError?.message) ?? optionalString(data?.message) ?? optionalString(data?.return_message);
 }
+function safeTextErrorCode(data) {
+  const rawCode = responseErrorMetadata(data).code;
+  return rawCode && /^[a-z0-9][a-z0-9_.:-]{0,127}$/i.test(rawCode) ? rawCode : void 0;
+}
+function safeTextError(resp, data) {
+  const code = safeTextErrorCode(data);
+  const message = resp.status === 404 && !code ? "This host does not support the KB text API (HTTP 404)." : `KB text request failed (HTTP ${resp.status}${code ? `, ${code}` : ""}).`;
+  const hint = code === "SOURCE_CONTENT_REVISION_CONFLICT" ? "The source changed. Keep your local input, read the current revision and explicitly resolve the conflict." : resp.status === 404 ? "Verify the exact source and host support for text APIs; no upload fallback was attempted." : "Inspect the source list and current state before retrying. Source content is omitted from diagnostics.";
+  return resp.status === 403 ? new PermissionError(message, code, hint) : new KbHttpError(message, code, resp.status, hint);
+}
 function responseStatus(resp) {
   const statusText = optionalString(resp.statusText);
   return statusText ? `${resp.status} ${statusText}` : String(resp.status);
@@ -68,6 +83,7 @@ var KbHttpError = class extends CapabilityGatewayError {
   }
 };
 function nonOkResponseError(resp, data, options) {
+  if (options.redactErrorDetails) return safeTextError(resp, data);
   const metadata = responseErrorMetadata(data);
   const serverMessage = responseErrorMessage(data);
   const fallbackMessage = `KB API HTTP error: ${responseStatus(resp)}`;
@@ -84,41 +100,59 @@ function parseKbResponse(resp, text, options = {}) {
     let metadata = {};
     try {
       const d = safeJsonParse(text);
+      if (options.redactErrorDetails) throw safeTextError(resp, d);
       const m = d && (typeof d.error === "string" ? d.error : d.error?.message || d.message);
       if (m && typeof m === "string") msg = m;
       if (options.preserveErrorMetadata) metadata = responseErrorMetadata(d);
-    } catch {
+    } catch (error) {
+      if (error instanceof PermissionError) throw error;
     }
     throw new PermissionError(msg, metadata.code, metadata.hint);
   }
   if (resp.status === 401) {
+    let code;
+    if (options.redactErrorDetails) {
+      try {
+        code = safeTextErrorCode(safeJsonParse(text));
+      } catch {
+      }
+    }
     throw new KbUnauthorizedError(
-      `KB API token auth failed: HTTP ${resp.status} ${resp.statusText}`
+      options.redactErrorDetails ? "KB API token auth failed: HTTP 401." : `KB API token auth failed: HTTP ${resp.status} ${resp.statusText}`,
+      code
     );
   }
   if (!text.trim()) {
+    if (options.redactErrorDetails && !resp.ok) throw safeTextError(resp, void 0);
     throw malformedResponseError(resp, "empty response body");
   }
   let data;
   try {
     data = safeJsonParse(text);
   } catch {
+    if (options.redactErrorDetails && !resp.ok) throw safeTextError(resp, void 0);
     throw malformedResponseError(resp, "non-JSON response");
   }
   if (data?.return_code === -1001) {
     throw new KbUnauthorizedError(
-      `KB API token auth failed: ${data.return_message || "unauthorized"} (code: ${data.return_code})`
+      options.redactErrorDetails ? "KB API token auth failed (code: -1001)." : `KB API token auth failed: ${data.return_message || "unauthorized"} (code: ${data.return_code})`,
+      options.redactErrorDetails ? safeTextErrorCode(data) : void 0
     );
   }
   if (!resp.ok) {
     throw nonOkResponseError(resp, data, options);
   }
   if (data?.return_code !== 0 && data?.return_code !== void 0) {
+    if (options.redactErrorDetails) throw safeTextError(resp, data);
     throw new Error(
       `AE API error: ${data.return_message || "unknown"} (code: ${data.return_code})`
     );
   }
+  if (options.redactErrorDetails && data?.error && typeof data.error === "object") {
+    throw safeTextError(resp, data);
+  }
   if (data && typeof data === "object" && typeof data.error === "string" && data.error.trim() && data.return_code === void 0 && data.success === void 0) {
+    if (options.redactErrorDetails) throw safeTextError(resp, data);
     if (options.preserveErrorMetadata) {
       const metadata = responseErrorMetadata(data);
       throw new CapabilityGatewayError(
@@ -171,7 +205,8 @@ async function requestWithCliToken(host, input, init, options) {
         }
       }
       throw new SecureStoreAuthError(
-        `The stored CLI token for ${host} is invalid or expired. Run: ae-cli auth login --host ${host}`
+        `The stored CLI token for ${host} is invalid or expired. Run: ae-cli auth login --host ${host}`,
+        options.redactErrorDetails ? error.code : void 0
       );
     }
     throw error;

package/dist/{chunk-DU72X2IO.js → chunk-GIK6EDUG.js}

@@ -6,11 +6,11 @@ import {
   normalizeUrl,
   safeJsonParse,
   safeReadJsonFile
-} from "./chunk-IG3DYEIR.js";
+} from "./chunk-UQ77JXYH.js";
 import {
   PermissionError,
   logger
-} from "./chunk-YVGXGTD6.js";
+} from "./chunk-WNGFSIOB.js";
 
 // src/core/secure-store.ts
 import crypto from "crypto";
@@ -521,10 +521,12 @@ function loadCliToken(host) {
   return getActiveCredential(host)?.cliToken ?? null;
 }
 var SecureStoreAuthError = class extends Error {
-  constructor(message) {
+  constructor(message, code) {
     super(message);
+    this.code = code;
     this.name = "SecureStoreAuthError";
   }
+  code;
 };
 var CredentialStoreUnreadableError = class extends Error {
   code = "CREDENTIAL_STORE_UNREADABLE";
@@ -542,6 +544,9 @@ import path2 from "path";
 var CLI_TOKEN_GENERATE_PATH = "/v1/ta/cli/token/generate";
 var CLI_TOKEN_RENEW_PATH = "/v1/ta/cli/token/renew";
 var CLI_TOKEN_VALIDATE_PATH = "/v1/ta/cli/token/validate";
+function safeReturnCode(value) {
+  return typeof value === "number" && Number.isFinite(value) ? String(value) : void 0;
+}
 var CliTokenValidationUnavailableError = class extends Error {
   constructor(message) {
     super(message);
@@ -660,19 +665,26 @@ async function generateCliToken(hostUrl, accessToken) {
         body = text ? safeJsonParse(text) : {};
       } catch {
       }
-      const message = body.message ?? body.return_message ?? "CLI access is disabled for this account.";
-      const code = body.code ?? (String(message).includes("CLI_ACCESS_DISABLED") ? "CLI_ACCESS_DISABLED" : void 0);
-      throw new PermissionError(message, code, body.hint);
+      const serviceMessage = body.message ?? body.return_message;
+      const code = body.code === "CLI_ACCESS_DISABLED" || String(serviceMessage).includes("CLI_ACCESS_DISABLED") ? "CLI_ACCESS_DISABLED" : void 0;
+      throw new PermissionError(
+        code === "CLI_ACCESS_DISABLED" ? "CLI access is disabled for this account." : "You do not have permission to generate a CLI token.",
+        code
+      );
     }
     throw new Error(`CLI token generate HTTP error: ${resp.status} ${resp.statusText}`);
   }
   const data = safeJsonParse(await resp.text());
   if (data.return_code !== 0) {
-    const message = data.return_message || data.message || "unknown";
-    if (data.code === "CLI_ACCESS_DISABLED" || String(message).includes("CLI_ACCESS_DISABLED")) {
-      throw new PermissionError(message, "CLI_ACCESS_DISABLED", data.hint);
+    const serviceMessage = data.return_message || data.message;
+    if (data.code === "CLI_ACCESS_DISABLED" || String(serviceMessage).includes("CLI_ACCESS_DISABLED")) {
+      throw new PermissionError(
+        "CLI access is disabled for this account.",
+        "CLI_ACCESS_DISABLED"
+      );
     }
-    throw new Error(`CLI token generate error: ${message} (code: ${data.return_code})`);
+    const code = safeReturnCode(data.return_code);
+    throw new Error(`CLI token generation failed${code ? ` (code: ${code})` : ""}`);
   }
   const cliToken = data.data?.userSecret ?? data.data?.user_secret;
   if (!cliToken) throw new Error("CLI token generate error: empty userSecret in response");

package/dist/chunk-HVHR4SCP.js

@@ -0,0 +1,133 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  currentAgentSpaceId
+} from "./chunk-RK6GLDGI.js";
+import {
+  deleteAgentApi,
+  getAgentApi,
+  patchAgentApi,
+  postAgentApi,
+  putAgentApi,
+  uploadAgentApi
+} from "./chunk-4655PUNX.js";
+import {
+  TeAgentApiError,
+  createTeAgentApiError
+} from "./chunk-PLE722AJ.js";
+import {
+  CliValidationError,
+  isApiErrorType
+} from "./chunk-WNGFSIOB.js";
+
+// src/commands/workspace/client.ts
+var DEFAULT_TE_CLAUDE_BASE_PATH = "/agent";
+var WORKSPACE_CLI_BASE_PATH = "/api/cli/workspace/v1";
+function normalizeBasePath(value) {
+  const trimmed = value.trim();
+  if (!trimmed || trimmed === "/") return "";
+  return `/${trimmed.replace(/^\/+|\/+$/g, "")}`;
+}
+function resolveWorkspaceApiBaseUrl(host) {
+  const base = host.replace(/\/+$/, "");
+  const basePath = normalizeBasePath(
+    process.env.TE_CLAUDE_BASE_PATH ?? process.env.AE_API_PREFIX ?? DEFAULT_TE_CLAUDE_BASE_PATH
+  );
+  return basePath && !base.endsWith(basePath) ? `${base}${basePath}` : base;
+}
+function buildWorkspaceCliUrl(ctx, path) {
+  return `${resolveWorkspaceApiBaseUrl(ctx.host())}${path}`;
+}
+function unwrapWorkspaceResponse(response) {
+  if (response && typeof response === "object" && !Array.isArray(response)) {
+    const envelope = response;
+    if (envelope.ok === true) return envelope.data;
+    if (envelope.ok === false) {
+      const error = envelope.error;
+      if (error && isApiErrorType(error.type) && typeof error.code === "string" && error.code.trim() && typeof error.message === "string" && error.message.trim()) {
+        throw createTeAgentApiError(response, 200, "Workspace API request failed");
+      }
+      throw new TeAgentApiError("The Workspace API returned an invalid error response.", 200, "WORKSPACE_INVALID_RESPONSE");
+    }
+  }
+  return response;
+}
+async function getWorkspaceApi(ctx, path) {
+  return unwrapWorkspaceResponse(await getAgentApi(ctx, path));
+}
+async function postWorkspaceApi(ctx, path, body) {
+  return unwrapWorkspaceResponse(await postAgentApi(ctx, path, body));
+}
+async function patchWorkspaceApi(ctx, path, body) {
+  return unwrapWorkspaceResponse(await patchAgentApi(ctx, path, body));
+}
+async function putWorkspaceApi(ctx, path, body) {
+  return unwrapWorkspaceResponse(await putAgentApi(ctx, path, body));
+}
+async function deleteWorkspaceApi(ctx, path) {
+  return unwrapWorkspaceResponse(await deleteAgentApi(ctx, path));
+}
+async function uploadWorkspaceApi(ctx, path, formData) {
+  return unwrapWorkspaceResponse(await uploadAgentApi(ctx, path, formData));
+}
+
+// src/commands/workspace/target.ts
+function optional(value) {
+  const trimmed = value?.trim();
+  return trimmed || void 0;
+}
+var workspaceTargetFlags = [
+  {
+    name: "workspace-id",
+    type: "string",
+    required: false,
+    desc: "AgentSpace ID; defaults to the current AgentSpace or resolves from the current conversation"
+  },
+  {
+    name: "conversation-id",
+    type: "string",
+    required: false,
+    desc: "Conversation ID used to verify or resolve the AgentSpace target"
+  }
+];
+function workspaceTargetParams(ctx) {
+  const params = new URLSearchParams();
+  const workspaceId = optional(ctx.str("workspaceId")) ?? currentAgentSpaceId();
+  const conversationId = optional(ctx.str("conversationId")) ?? optional(process.env.TE_AGENT_CONVERSATION_ID);
+  if (!workspaceId && !conversationId) {
+    throw new CliValidationError(
+      "Workspace target is required. Provide --workspace-id or --conversation-id, or run inside an AgentSpace conversation."
+    );
+  }
+  if (workspaceId) params.set("agentSpaceId", workspaceId);
+  if (conversationId) params.set("conversationId", conversationId);
+  return params;
+}
+function workspaceTargetPath(ctx) {
+  return `${WORKSPACE_CLI_BASE_PATH}/target?${workspaceTargetParams(ctx).toString()}`;
+}
+async function resolveWorkspaceTarget(ctx) {
+  return getWorkspaceApi(ctx, workspaceTargetPath(ctx));
+}
+function workspaceResourcePath(agentSpaceId, suffix = "") {
+  return `${WORKSPACE_CLI_BASE_PATH}/agent-spaces/${encodeURIComponent(agentSpaceId)}${suffix}`;
+}
+function previewWorkspaceResourcePath(ctx, suffix = "") {
+  const id = optional(ctx.str("workspaceId")) ?? currentAgentSpaceId() ?? ":resolved-workspace-id";
+  return workspaceResourcePath(id, suffix);
+}
+
+export {
+  WORKSPACE_CLI_BASE_PATH,
+  buildWorkspaceCliUrl,
+  getWorkspaceApi,
+  postWorkspaceApi,
+  patchWorkspaceApi,
+  putWorkspaceApi,
+  deleteWorkspaceApi,
+  uploadWorkspaceApi,
+  workspaceTargetFlags,
+  workspaceTargetPath,
+  resolveWorkspaceTarget,
+  workspaceResourcePath,
+  previewWorkspaceResourcePath
+};

package/dist/{chunk-2FJM4HRV.js → chunk-KAEHZZH4.js}

@@ -3,16 +3,16 @@ import {
   dryRunCapability,
   executeCapabilityWithEnvelope,
   validateCapability
-} from "./chunk-QYXDJOLA.js";
+} from "./chunk-EOYSKMXN.js";
 import {
   resolveGatewayDomain
 } from "./chunk-KPQY44JQ.js";
 import {
   withOutputMetadata
-} from "./chunk-BW7JUDEI.js";
+} from "./chunk-KFNMQTZI.js";
 import {
   CliValidationError
-} from "./chunk-YVGXGTD6.js";
+} from "./chunk-WNGFSIOB.js";
 
 // src/core/definition-intent.ts
 import { createHash } from "crypto";