@aliyunrds/ctxdb 1.0.2 → 1.0.3

package/dist/chunk-BQA7YSXT.js

@@ -0,0 +1,462 @@
+#!/usr/bin/env node
+
+// src/lib/self-update.ts
+import { spawnSync } from "child_process";
+import { fileURLToPath } from "url";
+import { dirname } from "path";
+import semver from "semver";
+var PACKAGE_NAME = "@aliyunrds/ctxdb";
+var NPM_VIEW_TIMEOUT_MS = 1e4;
+function npmCommand(platform = process.platform) {
+  return platform === "win32" ? "npm.cmd" : "npm";
+}
+function ctxdbCommand(platform = process.platform) {
+  return platform === "win32" ? "ctxdb.cmd" : "ctxdb";
+}
+function detectInstallMethod() {
+  const dir = dirname(fileURLToPath(import.meta.url));
+  return dir.includes("/node_modules/") || dir.includes("\\node_modules\\") ? "npm" : "unknown";
+}
+function checkLatestVersion(currentVersion, options = {}) {
+  const current = semver.valid(currentVersion);
+  if (!current) {
+    return {
+      latest: null,
+      current: currentVersion,
+      isNewer: false,
+      error: `invalid current package version: ${currentVersion}`
+    };
+  }
+  const platform = options.platform ?? process.platform;
+  const run = options.spawnSyncFn ?? spawnSync;
+  const result = run(npmCommand(platform), ["view", PACKAGE_NAME, "version"], {
+    encoding: "utf-8",
+    timeout: options.timeoutMs ?? NPM_VIEW_TIMEOUT_MS,
+    stdio: ["ignore", "pipe", "pipe"],
+    shell: platform === "win32"
+  });
+  if (result.status !== 0 || !result.stdout?.trim()) {
+    return {
+      latest: null,
+      current: currentVersion,
+      isNewer: false,
+      error: spawnFailureMessage(result, "npm view")
+    };
+  }
+  const latest = semver.valid(result.stdout.trim());
+  if (!latest) {
+    return {
+      latest: null,
+      current,
+      isNewer: false,
+      error: `npm view returned an invalid version: ${result.stdout.trim()}`
+    };
+  }
+  return {
+    latest,
+    current,
+    isNewer: isNewerVersion(latest, current)
+  };
+}
+function spawnFailureMessage(result, commandLabel) {
+  const stderr = result.stderr?.toString().trim();
+  if (stderr) return stderr;
+  if (result.error) return `${commandLabel} failed: ${result.error.message}`;
+  if (result.signal) return `${commandLabel} terminated by signal ${result.signal}`;
+  return `${commandLabel} exited with code ${result.status}`;
+}
+function isNewerVersion(candidate, current) {
+  const candidateVersion = semver.valid(candidate);
+  const currentVersion = semver.valid(current);
+  return Boolean(
+    candidateVersion && currentVersion && semver.gt(candidateVersion, currentVersion)
+  );
+}
+function runSelfUpdate(currentVersion, passthroughArgs = [], options = {}) {
+  const method = options.installMethod ?? detectInstallMethod();
+  if (method !== "npm") {
+    return {
+      ok: false,
+      updated: false,
+      fromVersion: currentVersion,
+      error: "ctxdb was not installed via npm. Update manually with your package manager."
+    };
+  }
+  const check = checkLatestVersion(currentVersion);
+  if (check.error) {
+    return {
+      ok: false,
+      updated: false,
+      fromVersion: currentVersion,
+      error: `npm view failed: ${check.error}`
+    };
+  }
+  if (!check.isNewer) {
+    process.stderr.write(
+      `ctxdb: package already up to date (current v${currentVersion}, latest v${check.latest})
+`
+    );
+    return { ok: true, updated: false, fromVersion: currentVersion };
+  }
+  process.stderr.write(`ctxdb: updating ${PACKAGE_NAME} v${currentVersion} \u2192 v${check.latest}...
+`);
+  const install = spawnSync(npmCommand(), ["install", "-g", `${PACKAGE_NAME}@${check.latest}`], {
+    stdio: "inherit",
+    encoding: "utf-8",
+    shell: process.platform === "win32"
+  });
+  if (install.status !== 0) {
+    return {
+      ok: false,
+      updated: false,
+      fromVersion: currentVersion,
+      error: spawnFailureMessage(install, "npm install -g")
+    };
+  }
+  process.stderr.write(`ctxdb: package updated to v${check.latest}, running setup...
+`);
+  const setupArgs = ["update", "--no-self-update", ...passthroughArgs];
+  const refresh = spawnSync(ctxdbCommand(), setupArgs, {
+    stdio: "inherit",
+    encoding: "utf-8",
+    shell: process.platform === "win32"
+  });
+  return {
+    ok: refresh.status === 0,
+    updated: true,
+    fromVersion: currentVersion,
+    toVersion: check.latest,
+    error: refresh.status !== 0 ? spawnFailureMessage(refresh, "ctxdb setup") : void 0,
+    failureHandled: refresh.status !== null && refresh.status !== 0
+  };
+}
+
+// src/lib/update-notifier.ts
+import { randomUUID } from "crypto";
+import { spawn } from "child_process";
+import {
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { homedir } from "os";
+import { dirname as dirname2, join } from "path";
+import semver2 from "semver";
+var VERSION_CHECK_SCHEMA = 1;
+var SUCCESS_TTL_MS = 24 * 60 * 60 * 1e3;
+var FAILURE_BACKOFF_BASE_MS = 60 * 60 * 1e3;
+var FAILURE_BACKOFF_MAX_MS = 6 * 60 * 60 * 1e3;
+var NOTIFICATION_THROTTLE_MS = 24 * 60 * 60 * 1e3;
+var LOCK_STALE_AFTER_MS = 10 * 60 * 1e3;
+function versionCheckPaths(home = homedir()) {
+  const cacheDir = join(home, ".ctxdb", "cache");
+  return {
+    cacheDir,
+    statePath: join(cacheDir, "version-check.json"),
+    lockPath: join(cacheDir, "version-check.lock")
+  };
+}
+function createInitialVersionCheckState(currentVersion) {
+  return {
+    schemaVersion: VERSION_CHECK_SCHEMA,
+    currentVersion,
+    latestVersion: null,
+    lastSuccessAt: null,
+    lastFailureAt: null,
+    nextCheckAt: 0,
+    consecutiveFailures: 0,
+    lastNotifiedAt: null,
+    lastNotifiedVersion: null
+  };
+}
+function isNullableTimestamp(value) {
+  return value === null || typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function isVersionCheckState(value) {
+  if (!value || typeof value !== "object") return false;
+  const state = value;
+  return state.schemaVersion === VERSION_CHECK_SCHEMA && typeof state.currentVersion === "string" && (state.latestVersion === null || typeof state.latestVersion === "string") && isNullableTimestamp(state.lastSuccessAt) && isNullableTimestamp(state.lastFailureAt) && typeof state.nextCheckAt === "number" && Number.isFinite(state.nextCheckAt) && state.nextCheckAt >= 0 && Number.isInteger(state.consecutiveFailures) && state.consecutiveFailures >= 0 && isNullableTimestamp(state.lastNotifiedAt) && (state.lastNotifiedVersion === null || typeof state.lastNotifiedVersion === "string");
+}
+function readVersionCheckState(statePath) {
+  try {
+    const parsed = JSON.parse(readFileSync(statePath, "utf8"));
+    return isVersionCheckState(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function writeVersionCheckState(statePath, state) {
+  const cacheDir = dirname2(statePath);
+  const temporaryPath = `${statePath}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    mkdirSync(cacheDir, { recursive: true, mode: 448 });
+    writeFileSync(temporaryPath, `${JSON.stringify(state, null, 2)}
+`, {
+      encoding: "utf8",
+      mode: 384,
+      flag: "wx"
+    });
+    renameSync(temporaryPath, statePath);
+    return true;
+  } catch {
+    try {
+      rmSync(temporaryPath, { force: true });
+    } catch {
+    }
+    return false;
+  }
+}
+function stateForCurrentVersion(state, currentVersion) {
+  return state?.currentVersion === currentVersion ? state : createInitialVersionCheckState(currentVersion);
+}
+function isVersionCheckDue(state, now) {
+  return now >= state.nextCheckAt;
+}
+function failureBackoffMs(consecutiveFailures) {
+  const exponent = Math.max(0, consecutiveFailures - 1);
+  return Math.min(
+    FAILURE_BACKOFF_BASE_MS * 2 ** exponent,
+    FAILURE_BACKOFF_MAX_MS
+  );
+}
+function recordVersionCheckSuccess(paths, currentVersion, latestVersion, now = Date.now()) {
+  if (!semver2.valid(currentVersion) || !semver2.valid(latestVersion)) return false;
+  const state = stateForCurrentVersion(
+    readVersionCheckState(paths.statePath),
+    currentVersion
+  );
+  return writeVersionCheckState(paths.statePath, {
+    ...state,
+    latestVersion,
+    lastSuccessAt: now,
+    lastFailureAt: null,
+    nextCheckAt: now + SUCCESS_TTL_MS,
+    consecutiveFailures: 0
+  });
+}
+function recordVersionCheckFailure(paths, currentVersion, now = Date.now()) {
+  const state = stateForCurrentVersion(
+    readVersionCheckState(paths.statePath),
+    currentVersion
+  );
+  const consecutiveFailures = state.consecutiveFailures + 1;
+  return writeVersionCheckState(paths.statePath, {
+    ...state,
+    lastFailureAt: now,
+    nextCheckAt: now + failureBackoffMs(consecutiveFailures),
+    consecutiveFailures
+  });
+}
+function readLock(lockPath) {
+  try {
+    const parsed = JSON.parse(readFileSync(lockPath, "utf8"));
+    if (!parsed || typeof parsed !== "object") return null;
+    const lock = parsed;
+    if (typeof lock.token !== "string" || typeof lock.createdAt !== "number" || !Number.isFinite(lock.createdAt)) {
+      return null;
+    }
+    return { token: lock.token, createdAt: lock.createdAt };
+  } catch {
+    return null;
+  }
+}
+function lockCreatedAt(lockPath) {
+  const lock = readLock(lockPath);
+  if (lock) return lock.createdAt;
+  try {
+    return statSync(lockPath).mtimeMs;
+  } catch {
+    return null;
+  }
+}
+function acquireVersionCheckLock(paths, now = Date.now(), token = randomUUID()) {
+  try {
+    mkdirSync(paths.cacheDir, { recursive: true, mode: 448 });
+  } catch {
+    return null;
+  }
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const lock = { token, createdAt: now };
+      writeFileSync(paths.lockPath, `${JSON.stringify(lock)}
+`, {
+        encoding: "utf8",
+        mode: 384,
+        flag: "wx"
+      });
+      return lock;
+    } catch (error) {
+      if (error.code !== "EEXIST") return null;
+      const createdAt = lockCreatedAt(paths.lockPath);
+      if (createdAt === null || now - createdAt < LOCK_STALE_AFTER_MS) return null;
+      try {
+        unlinkSync(paths.lockPath);
+      } catch {
+        return null;
+      }
+    }
+  }
+  return null;
+}
+function releaseVersionCheckLock(paths, token) {
+  const lock = readLock(paths.lockPath);
+  if (!lock || lock.token !== token) return false;
+  try {
+    unlinkSync(paths.lockPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getUpdateHintCandidate(state, now = Date.now()) {
+  const current = semver2.valid(state.currentVersion);
+  const latest = state.latestVersion ? semver2.valid(state.latestVersion) : null;
+  if (!current || !latest || !semver2.gt(latest, current)) return null;
+  if (state.lastNotifiedVersion === latest && state.lastNotifiedAt !== null && now - state.lastNotifiedAt < NOTIFICATION_THROTTLE_MS) {
+    return null;
+  }
+  return {
+    currentVersion: current,
+    latestVersion: latest,
+    message: `ctxdb: update available v${current} \u2192 v${latest}; run \`ctxdb update\`.
+`
+  };
+}
+function markVersionNotified(paths, candidate, now = Date.now()) {
+  const state = stateForCurrentVersion(
+    readVersionCheckState(paths.statePath),
+    candidate.currentVersion
+  );
+  if (state.latestVersion === null) return false;
+  return writeVersionCheckState(paths.statePath, {
+    ...state,
+    lastNotifiedAt: now,
+    lastNotifiedVersion: candidate.latestVersion
+  });
+}
+function scheduleVersionCheck(options) {
+  const now = options.now ?? Date.now();
+  if (!semver2.valid(options.currentVersion)) return false;
+  const state = stateForCurrentVersion(
+    readVersionCheckState(options.paths.statePath),
+    options.currentVersion
+  );
+  if (!isVersionCheckDue(state, now)) return false;
+  const lock = acquireVersionCheckLock(options.paths, now);
+  if (!lock) return false;
+  const handleLaunchFailure = () => {
+    recordVersionCheckFailure(options.paths, options.currentVersion, now);
+    releaseVersionCheckLock(options.paths, lock.token);
+  };
+  try {
+    const spawnFn = options.spawnFn ?? spawn;
+    const child = spawnFn(
+      options.execPath ?? process.execPath,
+      [
+        options.workerPath,
+        `--current-version=${options.currentVersion}`,
+        `--state-path=${options.paths.statePath}`,
+        `--lock-path=${options.paths.lockPath}`,
+        `--lock-token=${lock.token}`
+      ],
+      {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true
+      }
+    );
+    child.once("error", handleLaunchFailure);
+    child.unref();
+    return true;
+  } catch {
+    handleLaunchFailure();
+    return false;
+  }
+}
+function isCiEnvironment(env = process.env) {
+  const ci = env.CI?.trim().toLowerCase();
+  if (ci && ci !== "0" && ci !== "false") return true;
+  return [
+    "CONTINUOUS_INTEGRATION",
+    "GITHUB_ACTIONS",
+    "GITLAB_CI",
+    "TF_BUILD",
+    "JENKINS_URL",
+    "BUILDKITE",
+    "CIRCLECI",
+    "TEAMCITY_VERSION"
+  ].some((name) => Boolean(env[name]));
+}
+function shouldUseUpdateNotifier(argv, options = {}) {
+  const env = options.env ?? process.env;
+  if (options.stderrIsTTY !== true) return false;
+  if (options.installMethod !== "npm") return false;
+  if (env.CTXDB_DISABLE_UPDATE_CHECK === "1") return false;
+  if (isCiEnvironment(env)) return false;
+  if (argv.some((argument) => argument === "--json" || argument.startsWith("--json="))) {
+    return false;
+  }
+  const command = argv[0];
+  return command !== "update" && command !== "upgrade";
+}
+function beginUpdateNotification(argv, options) {
+  try {
+    const installMethod = options.installMethod ?? detectInstallMethod();
+    if (!shouldUseUpdateNotifier(argv, {
+      env: options.env ?? process.env,
+      stderrIsTTY: options.stderrIsTTY ?? process.stderr.isTTY,
+      installMethod
+    })) {
+      return null;
+    }
+    const now = options.now ?? Date.now();
+    const paths = options.paths ?? versionCheckPaths(options.home);
+    const state = stateForCurrentVersion(
+      readVersionCheckState(paths.statePath),
+      options.currentVersion
+    );
+    const candidate = getUpdateHintCandidate(state, now);
+    scheduleVersionCheck({
+      paths,
+      currentVersion: options.currentVersion,
+      workerPath: options.workerPath,
+      now,
+      execPath: options.execPath,
+      spawnFn: options.spawnFn
+    });
+    return { paths, candidate };
+  } catch {
+    return null;
+  }
+}
+function completeUpdateNotification(session, exitCode, options = {}) {
+  if (!session?.candidate || exitCode !== 0) return false;
+  try {
+    if (!markVersionNotified(
+      session.paths,
+      session.candidate,
+      options.now ?? Date.now()
+    )) {
+      return false;
+    }
+    const writeStderr = options.writeStderr ?? ((message) => process.stderr.write(message));
+    writeStderr(session.candidate.message);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export {
+  checkLatestVersion,
+  runSelfUpdate,
+  recordVersionCheckSuccess,
+  recordVersionCheckFailure,
+  releaseVersionCheckLock,
+  beginUpdateNotification,
+  completeUpdateNotification
+};

package/dist/{chunk-2CSEFSLC.js → chunk-BVCDRUU4.js}

@@ -2,7 +2,7 @@
 import {
   fetchKbCatalogBlock,
   recallTurn
-} from "./chunk-EUQ3OFCQ.js";
+} from "./chunk-Q4JYST7K.js";
 
 // src/lib/user-prompt-submit-compose.ts
 async function composeUserPromptSubmit(cfg, agent, client, prompt) {

package/dist/{chunk-WTP4ZX22.js → chunk-CWGF5D52.js}

@@ -2,10 +2,10 @@
 import {
   fetchKbCatalogBlock,
   recallTurn
-} from "./chunk-EUQ3OFCQ.js";
+} from "./chunk-Q4JYST7K.js";
 import {
   debug
-} from "./chunk-6FZL67GH.js";
+} from "./chunk-JFTKYEVN.js";
 
 // src/lib/warmup-recall.ts
 import { execSync } from "child_process";