@aliyunrds/ctxdb 1.0.2 → 1.0.3

package/dist/{chunk-6FZL67GH.js → chunk-JFTKYEVN.js}

@@ -68,37 +68,72 @@ var CtxdbError = class extends Error {
   }
 };
 var AuthError = class extends CtxdbError {
-  constructor(message = "Unauthorized (HTTP 401) \u2014 check api_key") {
+  status = 401;
+  errorCode;
+  errorMessage;
+  data;
+  responseBody;
+  constructor(message = "Unauthorized (HTTP 401) \u2014 check api_key", fields = {}) {
     super(message);
     this.name = "AuthError";
+    this.errorCode = fields.errorCode;
+    this.errorMessage = fields.errorMessage;
+    this.data = fields.data;
+    this.responseBody = fields.responseBody;
   }
 };
 var NotFoundError = class extends CtxdbError {
+  status = 404;
   path;
-  constructor(path) {
+  errorCode;
+  errorMessage;
+  data;
+  responseBody;
+  constructor(path, fields = {}) {
     super(`Not found: ${path}`);
     this.name = "NotFoundError";
     this.path = path;
+    this.errorCode = fields.errorCode;
+    this.errorMessage = fields.errorMessage;
+    this.data = fields.data;
+    this.responseBody = fields.responseBody;
   }
 };
 var APIError = class extends CtxdbError {
+  status = 400;
   path;
   detail;
-  constructor(path, detail) {
+  errorCode;
+  errorMessage;
+  data;
+  responseBody;
+  constructor(path, detail, fields = {}) {
     super(`API error at ${path}: ${detail}`);
     this.name = "APIError";
     this.path = path;
     this.detail = detail;
+    this.errorCode = fields.errorCode;
+    this.errorMessage = fields.errorMessage;
+    this.data = fields.data;
+    this.responseBody = fields.responseBody;
   }
 };
 var CtxdbHttpError = class extends CtxdbError {
   status;
   detail;
-  constructor(status, detail) {
+  errorCode;
+  errorMessage;
+  data;
+  responseBody;
+  constructor(status, detail, fields = {}) {
     super(`HTTP ${status}: ${detail}`);
     this.name = "CtxdbHttpError";
     this.status = status;
     this.detail = detail;
+    this.errorCode = fields.errorCode;
+    this.errorMessage = fields.errorMessage;
+    this.data = fields.data;
+    this.responseBody = fields.responseBody;
   }
 };
 var HttpClient = class {
@@ -117,12 +152,13 @@ var HttpClient = class {
     const f = opts.fetchImpl ?? globalThis.fetch.bind(globalThis);
     this.fetchImpl = f;
   }
-  buildHeaders(contentType) {
+  buildHeaders(contentType, requestHeaders = {}) {
     const h = {
       Authorization: `Token ${this.apiKey}`,
       "User-Agent": this.userAgent,
       Connection: "close",
-      ...this.extraHeaders
+      ...this.extraHeaders,
+      ...requestHeaders
     };
     if (contentType) h["Content-Type"] = contentType;
     return h;
@@ -151,7 +187,7 @@ var HttpClient = class {
       try {
         resp = await this.fetchImpl(url, {
           method,
-          headers: this.buildHeaders(init.contentType),
+          headers: this.buildHeaders(init.contentType, init.headers),
           body: init.body,
           signal: controller.signal
         });
@@ -179,12 +215,18 @@ var HttpClient = class {
         throw new CtxdbError(`network error reading body from ${url}: ${err?.message ?? err}`);
       }
       if (!resp.ok) {
-        const detail = extractErrorDetail(text, `HTTP ${resp.status}`);
-        if (dbg) debug("http", `\u2190 ${method} ${path} ${resp.status} (${Date.now() - t0}ms) ${detail}`);
-        if (resp.status === 401) throw new AuthError();
-        if (resp.status === 404) throw new NotFoundError(path);
-        if (resp.status === 400) throw new APIError(path, detail);
-        throw new CtxdbHttpError(resp.status, detail);
+        const parsedError = parseErrorResponse(text, `HTTP ${resp.status}`);
+        if (dbg) debug("http", `\u2190 ${method} ${path} ${resp.status} (${Date.now() - t0}ms) ${parsedError.detail}`);
+        if (resp.status === 401) {
+          throw new AuthError(void 0, parsedError);
+        }
+        if (resp.status === 404) {
+          throw new NotFoundError(path, parsedError);
+        }
+        if (resp.status === 400) {
+          throw new APIError(path, parsedError.detail, parsedError);
+        }
+        throw new CtxdbHttpError(resp.status, parsedError.detail, parsedError);
       }
       if (dbg) debug("http", `\u2190 ${method} ${path} ${resp.status} (${Date.now() - t0}ms) body=${text.length}B`);
       if (!text) return {};
@@ -197,11 +239,13 @@ var HttpClient = class {
   get(path, params) {
     return this.doRequest("GET", path, { params });
   }
-  postJson(path, body, params) {
+  postJson(path, body, params, options = {}) {
     return this.doRequest("POST", path, {
       body: JSON.stringify(body ?? {}),
       contentType: "application/json",
-      params
+      params,
+      timeoutMs: options.timeoutMs,
+      headers: options.headers
     });
   }
   putJson(path, body) {
@@ -230,7 +274,12 @@ var HttpClient = class {
       const blob = part.content instanceof Blob ? part.content : new Blob([part.content], { type: part.mimeType });
       fd.append(name, blob, part.filename);
     }
-    return this.doRequest("POST", path, { body: fd, timeoutMs: options.timeoutMs });
+    return this.doRequest("POST", path, {
+      body: fd,
+      params: options.params,
+      timeoutMs: options.timeoutMs,
+      headers: options.headers
+    });
   }
 };
 function maybeJson(text) {
@@ -240,28 +289,43 @@ function maybeJson(text) {
     return text;
   }
 }
-function extractErrorDetail(text, fallback) {
-  if (!text) return fallback;
+function parseErrorResponse(text, fallback) {
+  if (!text) return { detail: fallback };
   let parsed;
   try {
     parsed = JSON.parse(text);
   } catch {
-    return text || fallback;
+    return { detail: text || fallback, responseBody: text || void 0 };
   }
   if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
     const obj = parsed;
-    for (const k of ["detail", "message", "error"]) {
+    let detail = "";
+    for (const k of ["errorMessage", "detail", "message", "error"]) {
       const v = obj[k];
-      if (typeof v === "string" && v) return v;
+      if (typeof v === "string" && v) {
+        detail = v;
+        break;
+      }
     }
-    return JSON.stringify(parsed);
+    const rawCode = obj.errorCode;
+    const numericCode = typeof rawCode === "number" ? rawCode : typeof rawCode === "string" && rawCode.trim() !== "" ? Number(rawCode) : void 0;
+    const errorCode = typeof numericCode === "number" && Number.isFinite(numericCode) ? numericCode : void 0;
+    const errorMessage = typeof obj.errorMessage === "string" && obj.errorMessage ? obj.errorMessage : void 0;
+    return {
+      detail: detail || JSON.stringify(parsed),
+      errorCode,
+      errorMessage,
+      data: Object.hasOwn(obj, "data") ? obj.data : void 0,
+      responseBody: parsed
+    };
   }
-  return String(parsed);
+  return { detail: String(parsed), responseBody: parsed };
 }
 
 // src/lib/agents.ts
 import { homedir as homedir2 } from "os";
-import { join as join3 } from "path";
+import { delimiter, join as join3, sep } from "path";
+import { accessSync, constants, existsSync, statSync } from "fs";
 var SUPPORTED_AGENTS = ["qoder", "qoderwork", "codex", "claude", "opencode", "hermes"];
 function isBuiltinAgent(v) {
   return typeof v === "string" && SUPPORTED_AGENTS.includes(v);
@@ -270,33 +334,152 @@ function isAgentSlug(v) {
   return v === "default" || isBuiltinAgent(v);
 }
 var isAgent = isAgentSlug;
-function agentHomeDir(agent) {
+function agentHomeDir(agent, home = homedir2()) {
   switch (agent) {
     case "qoder":
-      return join3(homedir2(), ".qoder");
+      return join3(home, ".qoder");
     case "qoderwork":
-      return join3(homedir2(), ".qoderwork");
+      return join3(home, ".qoderwork");
     case "codex":
-      return join3(homedir2(), ".codex");
+      return join3(home, ".codex");
     case "claude":
-      return join3(homedir2(), ".claude");
+      return join3(home, ".claude");
     case "opencode":
-      return join3(homedir2(), ".config", "opencode");
+      return join3(home, ".config", "opencode");
     case "hermes":
-      return join3(homedir2(), ".hermes");
+      return join3(home, ".hermes");
   }
 }
 var AGENT_VARIANT_HOMES = {
   qoder: [".qoder-cn"],
   qoderwork: [".qoderworkcn"]
 };
-function agentHomeDirs(agent) {
-  const primary = agentHomeDir(agent);
+function agentHomeDirs(agent, home = homedir2()) {
+  const primary = agentHomeDir(agent, home);
   const variants = (AGENT_VARIANT_HOMES[agent] ?? []).map(
-    (name) => join3(homedir2(), name)
+    (name) => join3(home, name)
   );
   return [primary, ...variants];
 }
+function agentPlatformSupport(agent, platform = process.platform) {
+  if (agent === "hermes" && platform === "win32") {
+    return {
+      supported: false,
+      detail: "Hermes integration currently supports macOS/Linux only; Windows Hermes is not yet supported."
+    };
+  }
+  return { supported: true, detail: `${agent} is supported on ${platform}.` };
+}
+function inspectAgentHomes(agent, options = {}) {
+  const exists = options.exists ?? existsSyncAdapter;
+  const candidates = agentHomeDirs(agent, options.home);
+  const existing = candidates.filter(exists);
+  return { exists: existing.length > 0, existing, candidates };
+}
+function existsSyncAdapter(path) {
+  try {
+    return existsSync(path);
+  } catch {
+    return false;
+  }
+}
+var EXECUTABLE_AGENT_NAMES = {
+  opencode: "opencode",
+  hermes: "hermes"
+};
+function isDirectoryAdapter(path) {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function isExecutableAdapter(path, platform) {
+  try {
+    if (!statSync(path).isFile()) return false;
+    if (platform !== "win32") accessSync(path, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function envValue(env, name, platform) {
+  if (env[name] !== void 0) return env[name];
+  if (platform !== "win32") return void 0;
+  const entry = Object.entries(env).find(([key]) => key.toLowerCase() === name.toLowerCase());
+  return entry?.[1];
+}
+function resolveAgentExecutable(command, options = {}) {
+  const platform = options.platform ?? process.platform;
+  const env = options.env ?? process.env;
+  const isExecutable = options.isExecutable ?? isExecutableAdapter;
+  const pathValue = envValue(env, "PATH", platform) ?? "";
+  const pathSeparator = platform === "win32" ? ";" : delimiter;
+  const pathEntries = pathValue.split(pathSeparator).map((entry) => entry.trim().replace(/^"(.*)"$/, "$1")).filter(Boolean);
+  const suffixes = platform === "win32" ? (envValue(env, "PATHEXT", platform) ?? ".COM;.EXE;.BAT;.CMD").split(";").map((suffix) => suffix.trim()).filter(Boolean) : [""];
+  for (const directory of pathEntries) {
+    for (const suffix of suffixes) {
+      const candidate = join3(directory, `${command}${suffix}`);
+      if (isExecutable(candidate, platform)) return candidate;
+    }
+  }
+  return void 0;
+}
+function displayHomePath(home, path) {
+  if (path === home) return "~";
+  return path.startsWith(`${home}${sep}`) ? `~${path.slice(home.length)}` : path;
+}
+function detectInstalledAgents(options = {}) {
+  const home = options.home ?? homedir2();
+  const platform = options.platform ?? process.platform;
+  const env = options.env ?? process.env;
+  const isDirectory = options.isDirectory ?? isDirectoryAdapter;
+  const observations = [];
+  for (const agent of SUPPORTED_AGENTS) {
+    const evidence = [];
+    for (const candidate of agentHomeDirs(agent, home)) {
+      if (isDirectory(candidate)) {
+        evidence.push({ kind: "home", value: displayHomePath(home, candidate) });
+      }
+    }
+    const executableName = EXECUTABLE_AGENT_NAMES[agent];
+    if (executableName) {
+      const executable = resolveAgentExecutable(executableName, {
+        platform,
+        env,
+        isExecutable: options.isExecutable
+      });
+      if (executable) {
+        evidence.push({ kind: "executable", value: executableName });
+      }
+    }
+    if (evidence.length === 0) {
+      observations.push({
+        agent,
+        selected: false,
+        reason: "not-detected",
+        evidence
+      });
+      continue;
+    }
+    const support = agentPlatformSupport(agent, platform);
+    if (!support.supported) {
+      observations.push({
+        agent,
+        selected: false,
+        reason: "unsupported-platform",
+        evidence,
+        detail: support.detail
+      });
+      continue;
+    }
+    observations.push({ agent, selected: true, reason: "detected", evidence });
+  }
+  return {
+    selected: observations.filter((item) => item.selected).map((item) => item.agent),
+    observations
+  };
+}
 function agentFromEnv(env = process.env) {
   return isAgentSlug(env.CTXDB_AGENT) ? env.CTXDB_AGENT : "default";
 }
@@ -315,9 +498,110 @@ function agentFromArgvWithFallback(argv = process.argv.slice(2), env = process.e
 }
 
 // src/lib/config.ts
-import { readFileSync as readFileSync2, writeFileSync, mkdirSync as mkdirSync2, existsSync, unlinkSync } from "fs";
+import { readFileSync as readFileSync2, existsSync as existsSync3, unlinkSync as unlinkSync2 } from "fs";
 import { homedir as homedir3 } from "os";
-import { dirname as dirname3, join as join4 } from "path";
+import { join as join4 } from "path";
+
+// src/lib/secure-file.ts
+import {
+  chmodSync,
+  closeSync,
+  copyFileSync,
+  existsSync as existsSync2,
+  fsyncSync,
+  mkdirSync as mkdirSync2,
+  openSync,
+  renameSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { randomBytes } from "crypto";
+import { dirname as dirname3 } from "path";
+var nodeSecureFileSystem = {
+  exists: existsSync2,
+  mkdir: (path, options) => {
+    mkdirSync2(path, options);
+  },
+  chmod: chmodSync,
+  open: openSync,
+  write: (fd, data) => {
+    writeFileSync(fd, data);
+  },
+  fsync: fsyncSync,
+  close: closeSync,
+  copy: copyFileSync,
+  rename: renameSync,
+  unlink: unlinkSync
+};
+function configBackupPath(target) {
+  return `${target}.bak`;
+}
+function secureAtomicWrite(target, content, options = {}) {
+  const fs = options.fs ?? nodeSecureFileSystem;
+  const platform = options.platform ?? process.platform;
+  const posix = platform !== "win32";
+  const dir = dirname3(target);
+  const backup = configBackupPath(target);
+  const suffix = options.tempSuffix ?? `${process.pid}.${randomBytes(6).toString("hex")}`;
+  const temp = `${target}.${suffix}.tmp`;
+  const hadTarget = fs.exists(target);
+  fs.mkdir(dir, { recursive: true, mode: 448 });
+  if (posix) {
+    fs.chmod(dir, 448);
+    if (hadTarget) fs.chmod(target, 384);
+  }
+  let fd = null;
+  let tempExists = false;
+  try {
+    fd = fs.open(temp, "wx", 384);
+    tempExists = true;
+    fs.write(fd, Buffer.from(content, "utf-8"));
+    fs.fsync(fd);
+    fs.close(fd);
+    fd = null;
+    if (posix) fs.chmod(temp, 384);
+    if (hadTarget && options.backup !== false) {
+      if (platform === "win32") {
+        if (fs.exists(backup)) fs.unlink(backup);
+        fs.rename(target, backup);
+        try {
+          fs.rename(temp, target);
+          tempExists = false;
+        } catch (error) {
+          fs.rename(backup, target);
+          throw error;
+        }
+      } else {
+        fs.copy(target, backup);
+        fs.chmod(backup, 384);
+        fs.rename(temp, target);
+        tempExists = false;
+      }
+    } else {
+      fs.rename(temp, target);
+      tempExists = false;
+    }
+  } finally {
+    if (fd !== null) {
+      try {
+        fs.close(fd);
+      } catch {
+      }
+    }
+    if (tempExists && fs.exists(temp)) {
+      try {
+        fs.unlink(temp);
+      } catch {
+      }
+    }
+  }
+}
+
+// src/lib/secrets.ts
+import { createHmac, randomBytes as randomBytes2 } from "crypto";
+var PROCESS_FINGERPRINT_KEY = randomBytes2(32);
+
+// src/lib/config.ts
 function defaultConfigPath() {
   return join4(homedir3(), ".ctxdb", "ctxdb.json");
 }
@@ -360,7 +644,7 @@ function coerceKbCatalogInjection(v) {
   return DEFAULT_KB_CATALOG_INJECTION;
 }
 function readRaw(path) {
-  if (!existsSync(path)) return {};
+  if (!existsSync3(path)) return {};
   try {
     const parsed = JSON.parse(readFileSync2(path, "utf-8"));
     if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
@@ -458,7 +742,7 @@ function configToDisk(cfg) {
 }
 function removeAgent(agent, path, options = {}) {
   const target = path ?? defaultConfigPath();
-  if (!existsSync(target)) {
+  if (!existsSync3(target)) {
     return { removed: false, remainingAgents: [], fileDeleted: false };
   }
   const raw = readRaw(target);
@@ -477,13 +761,14 @@ function removeAgent(agent, path, options = {}) {
   const remaining = Object.keys(agents);
   if (remaining.length === 0 && !options.keepEmptyShell) {
     try {
-      unlinkSync(target);
+      unlinkSync2(target);
       return { removed: true, remainingAgents: [], fileDeleted: true };
     } catch {
     }
   }
-  const onDisk = { version: 2, agents };
-  writeFileSync(target, JSON.stringify(onDisk, null, 2) + "\n", "utf-8");
+  const onDisk = { ...raw, version: 2, agents };
+  delete onDisk.default_agent;
+  secureAtomicWrite(target, JSON.stringify(onDisk, null, 2) + "\n");
   return { removed: true, remainingAgents: remaining, fileDeleted: false };
 }
 function save(cfg, path, options = {}) {
@@ -493,14 +778,15 @@ function save(cfg, path, options = {}) {
   const validRaw = isV2Schema(raw) ? raw : {};
   const existingAgents = validRaw.agents && typeof validRaw.agents === "object" && !Array.isArray(validRaw.agents) ? { ...validRaw.agents } : {};
   const onDisk = {
+    ...validRaw,
     version: 2,
     agents: {
       ...existingAgents,
       [agent]: configToDisk(cfg)
     }
   };
-  mkdirSync2(dirname3(target), { recursive: true });
-  writeFileSync(target, JSON.stringify(onDisk, null, 2) + "\n", "utf-8");
+  delete onDisk.default_agent;
+  secureAtomicWrite(target, JSON.stringify(onDisk, null, 2) + "\n");
 }
 function configuredAgents(path) {
   const target = path ?? defaultConfigPath();
@@ -512,8 +798,7 @@ function writeInstalledPkgVersion(version, path) {
   const target = path ?? defaultConfigPath();
   const raw = readRaw(target);
   const updated = { ...raw, installed_pkg_version: version };
-  mkdirSync2(dirname3(target), { recursive: true });
-  writeFileSync(target, JSON.stringify(updated, null, 2) + "\n", "utf-8");
+  secureAtomicWrite(target, JSON.stringify(updated, null, 2) + "\n");
 }
 
 export {
@@ -528,6 +813,9 @@ export {
   isAgentSlug,
   agentHomeDir,
   agentHomeDirs,
+  agentPlatformSupport,
+  inspectAgentHomes,
+  detectInstalledAgents,
   agentFromEnv,
   agentFromArgvWithFallback,
   configDir,

package/dist/{chunk-EUQ3OFCQ.js → chunk-Q4JYST7K.js}

@@ -1,15 +1,15 @@
 #!/usr/bin/env node
 import {
   listKnowledgeBases
-} from "./chunk-UH7AJF6F.js";
+} from "./chunk-3PFMHU3C.js";
 import {
   isConnectionError,
   resetCircuit,
   tripCircuit
-} from "./chunk-TGVURF54.js";
+} from "./chunk-USMJLDBD.js";
 import {
   CtxdbError
-} from "./chunk-6FZL67GH.js";
+} from "./chunk-JFTKYEVN.js";
 
 // src/lib/kb-catalog.ts
 function sanitizeKeyEntities(raw) {

package/dist/{chunk-IMYLU5C2.js → chunk-SAQT6VL6.js}

@@ -4,12 +4,12 @@ import {
   isConnectionError,
   resetCircuit,
   tripCircuit
-} from "./chunk-TGVURF54.js";
+} from "./chunk-USMJLDBD.js";
 import {
   CtxdbError,
   debug,
   isDebug
-} from "./chunk-6FZL67GH.js";
+} from "./chunk-JFTKYEVN.js";
 
 // src/lib/capture-orchestrator.ts
 import {

package/dist/{chunk-TGVURF54.js → chunk-USMJLDBD.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   configDir
-} from "./chunk-6FZL67GH.js";
+} from "./chunk-JFTKYEVN.js";
 
 // src/lib/circuit.ts
 import { statSync, writeFileSync, unlinkSync, mkdirSync, readdirSync, readFileSync } from "fs";