@thinkingai/ae-cli 6.1.24 → 6.1.26

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

@@ -4,14 +4,259 @@ import {
 } from "./chunk-Y74WTIKJ.js";
 import {
   SecureStoreAuthError,
+  clearCliTokenCache,
   getCliToken
-} from "./chunk-7XGFSUOM.js";
+} from "./chunk-GIK6EDUG.js";
 import {
   safeJsonParse
-} from "./chunk-7FTTULED.js";
+} from "./chunk-UQ77JXYH.js";
 import {
   PermissionError
-} from "./chunk-MAPZ7VB6.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";
+var CONTEXT_ENCODING_HEADER = "X-TA-CLI-Context-Encoding";
+var CONTEXT_HEADER_ENCODING = "base64url";
+var WELL_KNOWN_CONTEXT_FILES = [
+  ".ta/cli-agent-context.json",
+  ".ae/cli-agent-context.json"
+];
+var FIELDS = [
+  { key: "agent_client", env: "TA_CLI_AGENT_CLIENT", header: "X-TA-CLI-Agent-Client", maxLength: 64 },
+  { key: "agent_model", env: "TA_CLI_AGENT_MODEL", header: "X-TA-CLI-Agent-Model", maxLength: 128 },
+  { key: "agent_session_id", env: "TA_CLI_AGENT_SESSION_ID", header: "X-TA-CLI-Agent-Session-Id", maxLength: 191 },
+  { key: "agent_turn_id", env: "TA_CLI_AGENT_TURN_ID", header: "X-TA-CLI-Agent-Turn-Id", maxLength: 191 },
+  { key: "parent_turn_id", env: "TA_CLI_PARENT_TURN_ID", header: "X-TA-CLI-Parent-Turn-Id", maxLength: 191 },
+  { key: "intent_relation", env: "TA_CLI_INTENT_RELATION", header: "X-TA-CLI-Intent-Relation", maxLength: 64 },
+  { key: "intent_revision", env: "TA_CLI_INTENT_REVISION", header: "X-TA-CLI-Intent-Revision", maxLength: 64 },
+  { key: "runtime", env: "TA_CLI_RUNTIME", header: "X-TA-CLI-Runtime", maxLength: 64 },
+  { key: "intent_source", env: "TA_CLI_INTENT_SOURCE", header: "X-TA-CLI-Intent-Source", maxLength: 64 },
+  { key: "session_initial_intent", env: "TA_CLI_SESSION_INITIAL_INTENT", header: "X-TA-CLI-Session-Initial-Intent", maxLength: 2048 },
+  { key: "user_intent", env: "TA_CLI_USER_INTENT", header: "X-TA-CLI-User-Intent", maxLength: 2048 },
+  { key: "user_intent_hash", env: "TA_CLI_USER_INTENT_HASH", header: "X-TA-CLI-User-Intent-Hash", maxLength: 128 },
+  { 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(),
+    ...scopedContext.getStore()
+  };
+  return withCaptureStatus(context);
+}
+function cliAgentContextHeaders(context = readCliAgentContext()) {
+  const headers = {};
+  for (const field of FIELDS) {
+    if (!field.header) continue;
+    const value = context[field.key];
+    if (value) headers[field.header] = Buffer.from(value, "utf8").toString("base64url");
+  }
+  if (Object.keys(headers).length > 0) {
+    headers[CONTEXT_ENCODING_HEADER] = CONTEXT_HEADER_ENCODING;
+  }
+  return headers;
+}
+function withCliAgentContextBody(body, context = readCliAgentContext()) {
+  if (!hasContext(context) || !isPlainRecord(body)) {
+    return body;
+  }
+  return {
+    ...body,
+    client_context: context
+  };
+}
+function readEnvContext() {
+  const context = {};
+  for (const field of FIELDS) {
+    const value = cleanValue(process.env[field.env], field.maxLength);
+    if (value) context[field.key] = value;
+  }
+  return context;
+}
+function inferRuntimeContext() {
+  return inferCodexContext() ?? inferClaudeCodeContext() ?? inferWorkBuddyContext() ?? {};
+}
+function inferCodexContext() {
+  if (!process.env.CODEX_SESSION_ID && !process.env.CODEX_THREAD_ID && !process.env.CODEX_VERSION && !process.env.CODEX_SHELL) {
+    return void 0;
+  }
+  return compactContext({
+    agent_client: "codex",
+    agent_model: firstEnv("CODEX_MODEL", "OPENAI_MODEL"),
+    agent_session_id: firstEnv("CODEX_THREAD_ID", "CODEX_SESSION_ID"),
+    runtime: process.env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE ? "codex_desktop" : "codex_cli",
+    intent_source: "runtime_env"
+  });
+}
+function inferClaudeCodeContext() {
+  if (!firstEnv("CLAUDE_CODE_SESSION_ID", "CLAUDE_SESSION_ID", "CLAUDECODE", "CLAUDE_CODE")) {
+    return void 0;
+  }
+  return compactContext({
+    agent_client: "claude_code",
+    agent_model: firstEnv("CLAUDE_CODE_MODEL", "CLAUDE_MODEL", "ANTHROPIC_MODEL"),
+    agent_session_id: firstEnv("CLAUDE_CODE_SESSION_ID", "CLAUDE_SESSION_ID"),
+    runtime: "claude_code",
+    intent_source: "runtime_env"
+  });
+}
+function inferWorkBuddyContext() {
+  if (!firstEnv("WORKBUDDY_SESSION_ID", "WORKBUDDY_AGENT_ID", "WORKBUDDY_RUNTIME")) {
+    return void 0;
+  }
+  return compactContext({
+    agent_client: "workbuddy",
+    agent_model: firstEnv("WORKBUDDY_MODEL", "WORKBUDDY_AGENT_MODEL"),
+    agent_session_id: firstEnv("WORKBUDDY_SESSION_ID", "WORKBUDDY_CONVERSATION_ID"),
+    runtime: firstEnv("WORKBUDDY_RUNTIME") ?? "workbuddy",
+    intent_source: "runtime_env"
+  });
+}
+function compactContext(values) {
+  const context = {};
+  for (const field of FIELDS) {
+    const value = cleanValue(values[field.key], field.maxLength);
+    if (value) context[field.key] = value;
+  }
+  return context;
+}
+function firstEnv(...keys) {
+  for (const key of keys) {
+    const value = process.env[key]?.trim();
+    if (value) return value;
+  }
+  return void 0;
+}
+function readFileContext() {
+  const filePath = resolveContextFilePath();
+  if (!filePath) return {};
+  try {
+    const stat = statSync(filePath);
+    if (!stat.isFile() || stat.size > MAX_CONTEXT_FILE_BYTES) return {};
+    const parsed = JSON.parse(readFileSync(filePath, "utf8"));
+    const record = normalizeContextFileRecord(parsed);
+    if (!record) return {};
+    const context = {};
+    for (const field of FIELDS) {
+      const value = cleanValue(record[field.key], field.maxLength);
+      if (value) context[field.key] = value;
+    }
+    return context;
+  } catch {
+    return {};
+  }
+}
+function readArgumentContext() {
+  const raw = readContextArgument(process.argv.slice(2));
+  if (!raw) return {};
+  const parsed = parseContextArgument(raw);
+  if (!parsed) return {};
+  const context = contextFromRecord(parsed);
+  if (!hasContext(context)) return {};
+  return {
+    intent_source: "agent_argument",
+    ...context
+  };
+}
+function readContextArgument(args) {
+  for (let i = 0; i < args.length; i += 1) {
+    const token = args[i];
+    if (token === "--") return void 0;
+    if (token === CONTEXT_ARG) return args[i + 1];
+    if (token.startsWith(`${CONTEXT_ARG}=`)) return token.slice(CONTEXT_ARG.length + 1);
+  }
+  return void 0;
+}
+function parseContextArgument(raw) {
+  const text = raw.trim();
+  if (!text) return void 0;
+  const decoded = text.startsWith("{") ? text : decodeBase64Url(text);
+  if (!decoded) return void 0;
+  try {
+    const parsed = JSON.parse(decoded);
+    return normalizeContextFileRecord(parsed);
+  } catch {
+    return void 0;
+  }
+}
+function decodeBase64Url(value) {
+  try {
+    return Buffer.from(value, "base64url").toString("utf8");
+  } catch {
+    return void 0;
+  }
+}
+function resolveContextFilePath() {
+  const configured = process.env[CONTEXT_FILE_ENV]?.trim();
+  if (configured) return configured;
+  return findWellKnownContextFile(process.cwd());
+}
+function findWellKnownContextFile(startDir) {
+  let current = resolve(startDir);
+  const root = parse(current).root;
+  while (true) {
+    for (const fileName of WELL_KNOWN_CONTEXT_FILES) {
+      const candidate = join(current, fileName);
+      try {
+        const stat = statSync(candidate);
+        if (stat.isFile() && stat.size <= MAX_CONTEXT_FILE_BYTES) return candidate;
+      } catch {
+      }
+    }
+    if (current === root) return void 0;
+    current = dirname(current);
+  }
+}
+function normalizeContextFileRecord(value) {
+  if (!isPlainRecord(value)) return void 0;
+  if (isPlainRecord(value.client_context)) return value.client_context;
+  return value;
+}
+function contextFromRecord(record) {
+  const context = {};
+  for (const field of FIELDS) {
+    const value = cleanValue(record[field.key], field.maxLength);
+    if (value) context[field.key] = value;
+  }
+  return context;
+}
+function withCaptureStatus(context) {
+  if (!hasContext(context)) return {};
+  if (context.context_capture_status) return context;
+  const required = ["agent_client", "agent_session_id", "agent_turn_id", "user_intent"];
+  const complete = required.every((key) => Boolean(context[key]));
+  return {
+    ...context,
+    context_capture_status: complete ? "full" : "partial"
+  };
+}
+function hasContext(context) {
+  return Object.keys(context).some((key) => key !== "context_capture_status" && Boolean(context[key]));
+}
+function cleanValue(value, maxLength) {
+  if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
+    return void 0;
+  }
+  const text = String(value).replace(/[\r\n\t]+/g, " ").trim();
+  if (!text) return void 0;
+  return text.length > maxLength ? text.slice(0, maxLength) : text;
+}
+function isPlainRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
 
 // src/core/capability-api.ts
 import { readFile } from "fs/promises";
@@ -32,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) {
@@ -144,16 +389,18 @@ 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,
     "Accept": accept,
-    ...internalCallSourceHeaders()
+    ...internalCallSourceHeaders(),
+    ...cliAgentContextHeaders(agentContext)
   };
   const init = { method, headers };
   if (body !== void 0 && method !== "GET") {
     headers["Content-Type"] = "application/json";
-    init.body = JSON.stringify(body);
+    init.body = JSON.stringify(includeClientContextInBody ? withCliAgentContextBody(body, agentContext) : body);
   }
   return fetch(url, init);
 }
@@ -172,9 +419,14 @@ 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);
-  const 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, "application/json", options.includeClientContextInBody);
+  }
   if (resp.status === 403) {
     const error = await permissionError(resp);
     if (options.retryOnInvalidTokenForbidden !== false && isInvalidCliTokenMessage(error.message)) {
@@ -303,6 +555,8 @@ async function callCapabilityApi(host, domain, action, method = "POST", params =
 }
 
 export {
+  runWithCliAgentContext,
+  readCliAgentContext,
   CapabilityGatewayError,
   buildCapabilityGatewayUrl,
   fetchCapabilityGateway,

package/dist/{chunk-57RRFUEZ.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-HFGZGYCG.js";
+} from "./chunk-EOYSKMXN.js";
 import {
   SecureStoreAuthError,
   getCliToken
-} from "./chunk-7XGFSUOM.js";
+} from "./chunk-GIK6EDUG.js";
 import {
   safeJsonParse
-} from "./chunk-7FTTULED.js";
+} from "./chunk-UQ77JXYH.js";
 import {
   PermissionError
-} from "./chunk-MAPZ7VB6.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;