@thinkingai/ae-cli 6.1.23 → 6.1.25

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

@@ -4,14 +4,253 @@ import {
 } from "./chunk-Y74WTIKJ.js";
 import {
   SecureStoreAuthError,
+  clearCliTokenCache,
   getCliToken
-} from "./chunk-7XGFSUOM.js";
+} from "./chunk-DU72X2IO.js";
 import {
   safeJsonParse
-} from "./chunk-7FTTULED.js";
+} from "./chunk-IG3DYEIR.js";
 import {
   PermissionError
-} from "./chunk-MAPZ7VB6.js";
+} from "./chunk-YVGXGTD6.js";
+
+// src/core/cli-agent-context.ts
+import { readFileSync, statSync } from "fs";
+import { dirname, join, parse, resolve } from "path";
+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 }
+];
+function readCliAgentContext() {
+  const context = {
+    ...inferRuntimeContext(),
+    ...readEnvContext(),
+    ...readArgumentContext(),
+    ...readFileContext()
+  };
+  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";
@@ -145,15 +384,17 @@ async function throwCapabilityHttpError(resp) {
   throw error;
 }
 async function requestOnce(url, method, token, body, accept = "application/json") {
+  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(withCliAgentContextBody(body, agentContext));
   }
   return fetch(url, init);
 }
@@ -174,7 +415,12 @@ async function callGateway(host, domain, pathAfterV1, method, body, queryParams
 async function callGatewayWithEnvelope(host, domain, pathAfterV1, method, body, queryParams = {}, options = {}) {
   const url = buildCapabilityGatewayUrl(options.apiBaseUrl ?? host, domain, pathAfterV1, queryParams);
   const token = await getCliToken(host);
-  const resp = await requestOnce(url, method, token, body);
+  let resp = await requestOnce(url, method, token, body);
+  if (resp.status === 401 && options.retryOnUnauthorized === true) {
+    await resp.body?.cancel();
+    clearCliTokenCache(host);
+    resp = await requestOnce(url, method, await getCliToken(host), body);
+  }
   if (resp.status === 403) {
     const error = await permissionError(resp);
     if (options.retryOnInvalidTokenForbidden !== false && isInvalidCliTokenMessage(error.message)) {

package/dist/{chunk-DVMLWQD4.js → chunk-SO5LKIWP.js}

@@ -5,11 +5,11 @@ import {
   require_node,
   require_process_nextick_args,
   require_util
-} from "./chunk-V2NUHPXF.js";
+} from "./chunk-GK7WDY7E.js";
 import {
   __commonJS,
   __require
-} from "./chunk-MAPZ7VB6.js";
+} from "./chunk-YVGXGTD6.js";
 
 // node_modules/jszip/node_modules/readable-stream/lib/internal/streams/stream.js
 var require_stream = __commonJS({

package/dist/{chunk-VYXXOKYS.js → chunk-XKIW3QMF.js}

@@ -3,7 +3,7 @@ import {
   CapabilityGatewayError,
   fetchCapabilityGateway,
   requestCapabilityGateway
-} from "./chunk-HFGZGYCG.js";
+} from "./chunk-QYXDJOLA.js";
 import {
   resolveGatewayDomain
 } from "./chunk-KPQY44JQ.js";
@@ -11,13 +11,14 @@ import {
   readOutputMetadata,
   unwrapOutputData,
   withOutputMetadata
-} from "./chunk-DX5CDO34.js";
+} from "./chunk-BW7JUDEI.js";
 import {
   PermissionError
-} from "./chunk-MAPZ7VB6.js";
+} from "./chunk-YVGXGTD6.js";
 
 // src/core/analysis-async-artifact.ts
 import { randomBytes } from "crypto";
+import { once } from "events";
 import { createWriteStream } from "fs";
 import { access, link, mkdir, rename, stat, unlink } from "fs/promises";
 import { Readable } from "stream";
@@ -261,9 +262,11 @@ async function downloadAnalysisArtifact(host, runId, artifactId, output, options
     if (!response.body) {
       throw protocolError("Artifact download response has no body.", runId);
     }
+    const destination = createWriteStream(tempPath, { flags: "wx", mode: options.mode });
+    await once(destination, "open");
     tempPresent = true;
     const source = Readable.fromWeb(response.body);
-    await pipeline(source, createWriteStream(tempPath, { flags: "wx", mode: options.mode }), {
+    await pipeline(source, destination, {
       signal: options.signal
     });
     const file = await stat(tempPath);

package/dist/{chunk-MAPZ7VB6.js → chunk-YVGXGTD6.js}

@@ -166,6 +166,18 @@ var CliValidationError = class extends Error {
     }
   }
 };
+var CliApiError = class extends Error {
+  code;
+  hint;
+  meta;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "CliApiError";
+    this.code = options.code;
+    this.hint = options.hint;
+    this.meta = options.meta;
+  }
+};
 var CommunityReportError = class extends Error {
   code;
   httpStatus;
@@ -205,6 +217,7 @@ export {
   logger,
   PermissionError,
   CliValidationError,
+  CliApiError,
   CommunityReportError,
   LocalDataUploadError
 };

package/dist/{community-report-client-CU22W53K.js → community-report-client-6VJDDMJJ.js}

@@ -2,7 +2,7 @@ import { createRequire as __createRequire } from 'node:module'; const require =
 import {
   CommunityReportError,
   logger
-} from "./chunk-MAPZ7VB6.js";
+} from "./chunk-YVGXGTD6.js";
 
 // src/core/community-report-client.ts
 var DEFAULT_TIMEOUT_MS = 3e4;

package/dist/{config-XO3LI3SA.js → config-XQWOPDHN.js}

@@ -8,12 +8,17 @@ import {
   missingAeHostHint
 } from "./chunk-6ZIQV5GW.js";
 import {
+  fetchCliConfig,
   printError,
-  printOutput
-} from "./chunk-DX5CDO34.js";
-import "./chunk-7XGFSUOM.js";
+  printOutput,
+  resolveKbAutoDiscoveryFeature
+} from "./chunk-BW7JUDEI.js";
+import {
+  peekCliToken
+} from "./chunk-DU72X2IO.js";
 import {
   addHost,
+  getActiveHost,
   listHosts,
   loadConfig,
   normalizeUrl,
@@ -21,8 +26,8 @@ import {
   resolveHostSelector,
   setActiveHost,
   updateHostLabel
-} from "./chunk-7FTTULED.js";
-import "./chunk-MAPZ7VB6.js";
+} from "./chunk-IG3DYEIR.js";
+import "./chunk-YVGXGTD6.js";
 
 // src/commands/config.ts
 import * as readline2 from "readline";
@@ -252,7 +257,7 @@ async function confirm(question) {
 
 // src/commands/config.ts
 function registerConfig(program) {
-  const configCmd = program.command("config").description("Manage AE host environments interactively or with subcommands").action(async () => {
+  const configCmd = program.command("config").description("Manage AE host environments and read configuration values").action(async () => {
     if (!process.stdin.isTTY || !process.stderr.isTTY) {
       failConfig(
         "Interactive config requires a TTY.",
@@ -268,6 +273,20 @@ function registerConfig(program) {
   configCmd.command("current").description("Show the active AE environment").action(async () => {
     await printCurrentConfig(program);
   });
+  configCmd.command("show").description("Show effective configuration for the selected AE host and account").action(async () => {
+    const host = program.opts().host || getActiveHost();
+    const token = host ? peekCliToken(host) : null;
+    const feature = host && token ? await resolveKbAutoDiscoveryFeature(host, token, () => fetchCliConfig(host, token)) : { enabled: false, source: "unavailable" };
+    await printOutput(
+      {
+        host: host || null,
+        routing: { knowledge_base: feature.enabled ? "auto" : "explicit" },
+        source: feature.source
+      },
+      program.opts().format || "json",
+      program.opts().jq
+    );
+  });
   configCmd.command("use <env>").description("Switch active AE environment by exact URL or unique label").action(async (env) => {
     await useConfigEnv(program, env);
   });

package/dist/{context-IFJI3LIT.js → context-M3HDGEIR.js}

@@ -1,13 +1,13 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   getFromMainApp
-} from "./chunk-HBGADCKA.js";
+} from "./chunk-KJDOTPYU.js";
 import "./chunk-Y74WTIKJ.js";
-import "./chunk-7XGFSUOM.js";
-import "./chunk-7FTTULED.js";
+import "./chunk-DU72X2IO.js";
+import "./chunk-IG3DYEIR.js";
 import {
   CliValidationError
-} from "./chunk-MAPZ7VB6.js";
+} from "./chunk-YVGXGTD6.js";
 
 // src/commands/context/current.ts
 var CURRENT_PAGE_CONTEXT_PATH = "/api/sandbox/agent/context/current";

package/dist/{data-integration-HNGUKFIC.js → data-integration-XBTCGXQT.js}

@@ -8,20 +8,20 @@ import {
   utils,
   validateAndFix,
   validateDraft
-} from "./chunk-4NRCTUZJ.js";
-import "./chunk-DVMLWQD4.js";
+} from "./chunk-KS4DE3MX.js";
+import "./chunk-SO5LKIWP.js";
 import {
   require_archiver
-} from "./chunk-EQ255HKO.js";
-import "./chunk-V2NUHPXF.js";
+} from "./chunk-7WZACOAI.js";
+import "./chunk-GK7WDY7E.js";
 import {
   getConfigDir
-} from "./chunk-7FTTULED.js";
+} from "./chunk-IG3DYEIR.js";
 import {
   CliValidationError,
   LocalDataUploadError,
   __toESM
-} from "./chunk-MAPZ7VB6.js";
+} from "./chunk-YVGXGTD6.js";
 
 // src/commands/data-integration/inspect.ts
 import { basename as basename3 } from "path";