@remnic/core 1.0.0

package/dist/chunk-LOBRX7VD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/objective-state.ts"],"sourcesContent":["import path from \"node:path\";\nimport { mkdir, writeFile } from \"node:fs/promises\";\nimport { listJsonFiles, readJsonFile } from \"./json-store.js\";\nimport {\n  assertIsoRecordedAt,\n  assertSafePathSegment,\n  assertString,\n  isRecord,\n  optionalString,\n  optionalStringArray,\n  recordStoreDay,\n  validateStringRecord,\n} from \"./store-contract.js\";\n\nexport type ObjectiveStateSnapshotSource = \"tool_result\" | \"cli\" | \"system\" | \"manual\";\nexport type ObjectiveStateSnapshotKind = \"tool\" | \"file\" | \"process\" | \"record\" | \"workspace\";\nexport type ObjectiveStateChangeKind = \"created\" | \"updated\" | \"deleted\" | \"observed\" | \"executed\" | \"failed\";\nexport type ObjectiveStateOutcome = \"success\" | \"failure\" | \"partial\" | \"unknown\";\n\nexport interface ObjectiveStateValueRef {\n  exists?: boolean;\n  ref?: string;\n  valueHash?: string;\n}\n\nexport interface ObjectiveStateSnapshot {\n  schemaVersion: 1;\n  snapshotId: string;\n  recordedAt: string;\n  sessionKey: string;\n  source: ObjectiveStateSnapshotSource;\n  kind: ObjectiveStateSnapshotKind;\n  changeKind: ObjectiveStateChangeKind;\n  scope: string;\n  summary: string;\n  toolName?: string;\n  command?: string;\n  outcome?: ObjectiveStateOutcome;\n  before?: ObjectiveStateValueRef;\n  after?: ObjectiveStateValueRef;\n  entityRefs?: string[];\n  tags?: string[];\n  metadata?: Record<string, string>;\n}\n\nexport interface ObjectiveStateStoreStatus {\n  enabled: boolean;\n  writesEnabled: boolean;\n  rootDir: string;\n  snapshotsDir: string;\n  snapshots: {\n    total: number;\n    valid: number;\n    invalid: number;\n    byKind: Partial<Record<ObjectiveStateSnapshotKind, number>>;\n    byOutcome: Partial<Record<ObjectiveStateOutcome, number>>;\n    latestSnapshotId?: string;\n    latestRecordedAt?: string;\n    latestSessionKey?: string;\n  };\n  latestSnapshot?: ObjectiveStateSnapshot;\n  invalidSnapshots: Array<{\n    path: string;\n    error: string;\n  }>;\n}\n\nexport interface ObjectiveStateSearchResult {\n  snapshot: ObjectiveStateSnapshot;\n  score: number;\n}\n\nfunction validateValueRef(raw: unknown, field: string): ObjectiveStateValueRef | undefined {\n  if (raw === undefined) return undefined;\n  if (!isRecord(raw)) throw new Error(`${field} must be an object`);\n  const exists = typeof raw.exists === \"boolean\" ? raw.exists : undefined;\n  const ref = optionalString(raw.ref);\n  const valueHash = optionalString(raw.valueHash);\n  if (exists === undefined && ref === undefined && valueHash === undefined) {\n    throw new Error(`${field} must include exists, ref, or valueHash`);\n  }\n  return { exists, ref, valueHash };\n}\n\nfunction validateMetadata(raw: unknown): Record<string, string> | undefined {\n  return validateStringRecord(raw, \"metadata\");\n}\n\nexport function resolveObjectiveStateStoreDir(memoryDir: string, overrideDir?: string): string {\n  if (typeof overrideDir === \"string\" && overrideDir.trim().length > 0) {\n    return overrideDir.trim();\n  }\n  return path.join(memoryDir, \"state\", \"objective-state\");\n}\n\nexport function validateObjectiveStateSnapshot(raw: unknown): ObjectiveStateSnapshot {\n  if (!isRecord(raw)) throw new Error(\"objective-state snapshot must be an object\");\n  if (raw.schemaVersion !== 1) throw new Error(\"schemaVersion must be 1\");\n\n  const source = assertString(raw.source, \"source\");\n  if (![\"tool_result\", \"cli\", \"system\", \"manual\"].includes(source)) {\n    throw new Error(\"source must be one of tool_result|cli|system|manual\");\n  }\n\n  const kind = assertString(raw.kind, \"kind\");\n  if (![\"tool\", \"file\", \"process\", \"record\", \"workspace\"].includes(kind)) {\n    throw new Error(\"kind must be one of tool|file|process|record|workspace\");\n  }\n\n  const changeKind = assertString(raw.changeKind, \"changeKind\");\n  if (![\"created\", \"updated\", \"deleted\", \"observed\", \"executed\", \"failed\"].includes(changeKind)) {\n    throw new Error(\"changeKind must be one of created|updated|deleted|observed|executed|failed\");\n  }\n\n  const outcomeRaw = optionalString(raw.outcome);\n  if (outcomeRaw !== undefined && ![\"success\", \"failure\", \"partial\", \"unknown\"].includes(outcomeRaw)) {\n    throw new Error(\"outcome must be one of success|failure|partial|unknown\");\n  }\n\n  return {\n    schemaVersion: 1,\n    snapshotId: assertSafePathSegment(assertString(raw.snapshotId, \"snapshotId\"), \"snapshotId\"),\n    recordedAt: assertIsoRecordedAt(assertString(raw.recordedAt, \"recordedAt\")),\n    sessionKey: assertString(raw.sessionKey, \"sessionKey\"),\n    source: source as ObjectiveStateSnapshotSource,\n    kind: kind as ObjectiveStateSnapshotKind,\n    changeKind: changeKind as ObjectiveStateChangeKind,\n    scope: assertString(raw.scope, \"scope\"),\n    summary: assertString(raw.summary, \"summary\"),\n    toolName: optionalString(raw.toolName),\n    command: optionalString(raw.command),\n    outcome: outcomeRaw as ObjectiveStateOutcome | undefined,\n    before: validateValueRef(raw.before, \"before\"),\n    after: validateValueRef(raw.after, \"after\"),\n    entityRefs: optionalStringArray(raw.entityRefs, \"entityRefs\"),\n    tags: optionalStringArray(raw.tags, \"tags\"),\n    metadata: validateMetadata(raw.metadata),\n  };\n}\n\nexport async function recordObjectiveStateSnapshot(options: {\n  memoryDir: string;\n  objectiveStateStoreDir?: string;\n  snapshot: ObjectiveStateSnapshot;\n}): Promise<string> {\n  const rootDir = resolveObjectiveStateStoreDir(options.memoryDir, options.objectiveStateStoreDir);\n  const validated = validateObjectiveStateSnapshot(options.snapshot);\n  const day = recordStoreDay(validated.recordedAt);\n  const snapshotsDir = path.join(rootDir, \"snapshots\", day);\n  const filePath = path.join(snapshotsDir, `${validated.snapshotId}.json`);\n  await mkdir(snapshotsDir, { recursive: true });\n  await writeFile(filePath, JSON.stringify(validated, null, 2), \"utf8\");\n  return filePath;\n}\n\nexport async function getObjectiveStateStoreStatus(options: {\n  memoryDir: string;\n  objectiveStateStoreDir?: string;\n  enabled: boolean;\n  writesEnabled: boolean;\n}): Promise<ObjectiveStateStoreStatus> {\n  const rootDir = resolveObjectiveStateStoreDir(options.memoryDir, options.objectiveStateStoreDir);\n  const snapshotsDir = path.join(rootDir, \"snapshots\");\n  const { files, snapshots, invalidSnapshots } = await readObjectiveStateSnapshots(options);\n\n  snapshots.sort((a, b) => b.recordedAt.localeCompare(a.recordedAt));\n  const byKind: Partial<Record<ObjectiveStateSnapshotKind, number>> = {};\n  const byOutcome: Partial<Record<ObjectiveStateOutcome, number>> = {};\n  for (const snapshot of snapshots) {\n    byKind[snapshot.kind] = (byKind[snapshot.kind] ?? 0) + 1;\n    const outcome = snapshot.outcome ?? \"unknown\";\n    byOutcome[outcome] = (byOutcome[outcome] ?? 0) + 1;\n  }\n\n  return {\n    enabled: options.enabled,\n    writesEnabled: options.writesEnabled,\n    rootDir,\n    snapshotsDir,\n    snapshots: {\n      total: files.length,\n      valid: snapshots.length,\n      invalid: invalidSnapshots.length,\n      byKind,\n      byOutcome,\n      latestSnapshotId: snapshots[0]?.snapshotId,\n      latestRecordedAt: snapshots[0]?.recordedAt,\n      latestSessionKey: snapshots[0]?.sessionKey,\n    },\n    latestSnapshot: snapshots[0],\n    invalidSnapshots,\n  };\n}\n\nasync function readObjectiveStateSnapshots(options: {\n  memoryDir: string;\n  objectiveStateStoreDir?: string;\n}): Promise<{\n  files: string[];\n  snapshots: ObjectiveStateSnapshot[];\n  invalidSnapshots: Array<{ path: string; error: string }>;\n}> {\n  const rootDir = resolveObjectiveStateStoreDir(options.memoryDir, options.objectiveStateStoreDir);\n  const files = await listJsonFiles(path.join(rootDir, \"snapshots\"));\n  const snapshots: ObjectiveStateSnapshot[] = [];\n  const invalidSnapshots: Array<{ path: string; error: string }> = [];\n  for (const filePath of files) {\n    try {\n      snapshots.push(validateObjectiveStateSnapshot(await readJsonFile(filePath)));\n    } catch (error) {\n      invalidSnapshots.push({\n        path: filePath,\n        error: error instanceof Error ? error.message : String(error),\n      });\n    }\n  }\n  return { files, snapshots, invalidSnapshots };\n}\n\nfunction normalizeTokens(value: string): string[] {\n  return value\n    .toLowerCase()\n    .split(/[^a-z0-9]+/)\n    .map((token) => token.trim())\n    .filter((token) => token.length >= 2);\n}\n\nfunction overlapScore(queryTokens: Set<string>, value: string | undefined, weight: number): number {\n  if (!value) return 0;\n  const tokens = new Set(normalizeTokens(value));\n  let matches = 0;\n  for (const token of queryTokens) {\n    if (tokens.has(token)) matches += 1;\n  }\n  return matches * weight;\n}\n\nfunction lexicalScoreObjectiveStateSnapshot(\n  snapshot: ObjectiveStateSnapshot,\n  queryTokens: Set<string>,\n): number {\n  let score = 0;\n  score += overlapScore(queryTokens, snapshot.scope, 4);\n  score += overlapScore(queryTokens, snapshot.summary, 3);\n  score += overlapScore(queryTokens, snapshot.command, 3);\n  score += overlapScore(queryTokens, snapshot.toolName, 2);\n  score += overlapScore(queryTokens, snapshot.tags?.join(\" \"), 2);\n  score += overlapScore(queryTokens, snapshot.entityRefs?.join(\" \"), 2);\n  score += overlapScore(queryTokens, snapshot.kind, 1);\n  score += overlapScore(queryTokens, snapshot.changeKind, 1);\n  score += overlapScore(queryTokens, snapshot.outcome, 1);\n  return score;\n}\n\nfunction scoreObjectiveStateSnapshot(\n  snapshot: ObjectiveStateSnapshot,\n  lexicalScore: number,\n  sessionKey?: string,\n): number {\n  let score = lexicalScore;\n  if (sessionKey && snapshot.sessionKey === sessionKey) score += 1.5;\n\n  const recordedAtMs = Date.parse(snapshot.recordedAt);\n  if (Number.isFinite(recordedAtMs)) {\n    const ageHours = Math.max(0, (Date.now() - recordedAtMs) / 3_600_000);\n    score += 1 / (1 + ageHours);\n  }\n  return score;\n}\n\nexport async function searchObjectiveStateSnapshots(options: {\n  memoryDir: string;\n  objectiveStateStoreDir?: string;\n  query: string;\n  maxResults: number;\n  sessionKey?: string;\n}): Promise<ObjectiveStateSearchResult[]> {\n  const maxResults = Math.max(0, Math.floor(options.maxResults));\n  if (maxResults === 0) return [];\n\n  const { snapshots } = await readObjectiveStateSnapshots(options);\n  if (snapshots.length === 0) return [];\n\n  const queryTokens = new Set(normalizeTokens(options.query));\n  const scored = snapshots.map((snapshot) => {\n    const lexicalScore = lexicalScoreObjectiveStateSnapshot(snapshot, queryTokens);\n    return {\n      snapshot,\n      lexicalScore,\n      score: scoreObjectiveStateSnapshot(snapshot, lexicalScore, options.sessionKey),\n    };\n  });\n\n  const filtered = queryTokens.size === 0\n    ? scored\n    : scored.filter((result) => result.lexicalScore > 0);\n\n  filtered.sort((left, right) => {\n    if (right.score !== left.score) return right.score - left.score;\n    return right.snapshot.recordedAt.localeCompare(left.snapshot.recordedAt);\n  });\n  return filtered.slice(0, maxResults);\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-LPSF4OQH.js

@@ -0,0 +1,47 @@
+// src/json-store.ts
+import path from "path";
+import { readFile, readdir } from "fs/promises";
+async function listJsonFiles(dir) {
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    const out = [];
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        out.push(...await listJsonFiles(fullPath));
+      } else if (entry.isFile() && entry.name.endsWith(".json")) {
+        out.push(fullPath);
+      }
+    }
+    return out.sort();
+  } catch {
+    return [];
+  }
+}
+async function listNamedFiles(dir, fileName) {
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    const out = [];
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        out.push(...await listNamedFiles(fullPath, fileName));
+      } else if (entry.isFile() && entry.name === fileName) {
+        out.push(fullPath);
+      }
+    }
+    return out.sort();
+  } catch {
+    return [];
+  }
+}
+async function readJsonFile(filePath) {
+  return JSON.parse(await readFile(filePath, "utf8"));
+}
+
+export {
+  listJsonFiles,
+  listNamedFiles,
+  readJsonFile
+};
+//# sourceMappingURL=chunk-LPSF4OQH.js.map

package/dist/chunk-LPSF4OQH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/json-store.ts"],"sourcesContent":["import path from \"node:path\";\nimport { readFile, readdir } from \"node:fs/promises\";\n\nexport async function listJsonFiles(dir: string): Promise<string[]> {\n  try {\n    const entries = await readdir(dir, { withFileTypes: true });\n    const out: string[] = [];\n    for (const entry of entries) {\n      const fullPath = path.join(dir, entry.name);\n      if (entry.isDirectory()) {\n        out.push(...(await listJsonFiles(fullPath)));\n      } else if (entry.isFile() && entry.name.endsWith(\".json\")) {\n        out.push(fullPath);\n      }\n    }\n    return out.sort();\n  } catch {\n    return [];\n  }\n}\n\nexport async function listNamedFiles(dir: string, fileName: string): Promise<string[]> {\n  try {\n    const entries = await readdir(dir, { withFileTypes: true });\n    const out: string[] = [];\n    for (const entry of entries) {\n      const fullPath = path.join(dir, entry.name);\n      if (entry.isDirectory()) {\n        out.push(...(await listNamedFiles(fullPath, fileName)));\n      } else if (entry.isFile() && entry.name === fileName) {\n        out.push(fullPath);\n      }\n    }\n    return out.sort();\n  } catch {\n    return [];\n  }\n}\n\nexport async function readJsonFile(filePath: string): Promise<unknown> {\n  return JSON.parse(await readFile(filePath, \"utf8\")) as unknown;\n}\n"],"mappings":";AAAA,OAAO,UAAU;AACjB,SAAS,UAAU,eAAe;AAElC,eAAsB,cAAc,KAAgC;AAClE,MAAI;AACF,UAAM,UAAU,MAAM,QAAQ,KAAK,EAAE,eAAe,KAAK,CAAC;AAC1D,UAAM,MAAgB,CAAC;AACvB,eAAW,SAAS,SAAS;AAC3B,YAAM,WAAW,KAAK,KAAK,KAAK,MAAM,IAAI;AAC1C,UAAI,MAAM,YAAY,GAAG;AACvB,YAAI,KAAK,GAAI,MAAM,cAAc,QAAQ,CAAE;AAAA,MAC7C,WAAW,MAAM,OAAO,KAAK,MAAM,KAAK,SAAS,OAAO,GAAG;AACzD,YAAI,KAAK,QAAQ;AAAA,MACnB;AAAA,IACF;AACA,WAAO,IAAI,KAAK;AAAA,EAClB,QAAQ;AACN,WAAO,CAAC;AAAA,EACV;AACF;AAEA,eAAsB,eAAe,KAAa,UAAqC;AACrF,MAAI;AACF,UAAM,UAAU,MAAM,QAAQ,KAAK,EAAE,eAAe,KAAK,CAAC;AAC1D,UAAM,MAAgB,CAAC;AACvB,eAAW,SAAS,SAAS;AAC3B,YAAM,WAAW,KAAK,KAAK,KAAK,MAAM,IAAI;AAC1C,UAAI,MAAM,YAAY,GAAG;AACvB,YAAI,KAAK,GAAI,MAAM,eAAe,UAAU,QAAQ,CAAE;AAAA,MACxD,WAAW,MAAM,OAAO,KAAK,MAAM,SAAS,UAAU;AACpD,YAAI,KAAK,QAAQ;AAAA,MACnB;AAAA,IACF;AACA,WAAO,IAAI,KAAK;AAAA,EAClB,QAAQ;AACN,WAAO,CAAC;AAAA,EACV;AACF;AAEA,eAAsB,aAAa,UAAoC;AACrE,SAAO,KAAK,MAAM,MAAM,SAAS,UAAU,MAAM,CAAC;AACpD;","names":[]}

package/dist/chunk-LU3GQNDQ.js

@@ -0,0 +1,152 @@
+import {
+  readEnvVar
+} from "./chunk-MARWOCVP.js";
+import {
+  log
+} from "./chunk-KWBU5S5U.js";
+
+// src/resolve-provider-secret.ts
+import path from "path";
+import os from "os";
+var _resolveApiKeyForProvider = null;
+var _resolverLoaded = false;
+var _resolverNextRetryAt = 0;
+var RESOLVER_RETRY_BACKOFF_MS = 6e4;
+var resolvedCache = /* @__PURE__ */ new Map();
+async function getGatewayResolver() {
+  if (_resolverLoaded) {
+    return _resolveApiKeyForProvider;
+  }
+  if (_resolverNextRetryAt > 0 && Date.now() < _resolverNextRetryAt) {
+    return null;
+  }
+  try {
+    const candidates = [
+      // Try glob-matching the runtime module name (hash varies per build)
+      ...await findRuntimeModules()
+    ];
+    const { pathToFileURL } = await import("url");
+    for (const candidate of candidates) {
+      try {
+        const importUrl = pathToFileURL(candidate).href;
+        const mod = await import(importUrl);
+        if (typeof mod.resolveApiKeyForProvider === "function") {
+          _resolveApiKeyForProvider = mod.resolveApiKeyForProvider;
+          _resolverLoaded = true;
+          log.debug("loaded gateway resolveApiKeyForProvider from runtime module");
+          return _resolveApiKeyForProvider;
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  _resolverNextRetryAt = Date.now() + RESOLVER_RETRY_BACKOFF_MS;
+  log.debug(`gateway resolveApiKeyForProvider not available \u2014 will retry after ${RESOLVER_RETRY_BACKOFF_MS / 1e3}s`);
+  return null;
+}
+async function findRuntimeModules() {
+  const { readdirSync } = await import("fs");
+  const { createRequire } = await import("module");
+  const candidates = [];
+  const distDirs = [];
+  try {
+    const req = createRequire(import.meta.url);
+    const openclawMain = req.resolve("openclaw");
+    const openclawDist = path.join(path.dirname(openclawMain), "..", "dist");
+    if (openclawDist) distDirs.push(path.resolve(openclawDist));
+  } catch {
+  }
+  try {
+    const { realpathSync } = await import("fs");
+    const mainScript = process.argv[1];
+    if (mainScript) {
+      const realScript = realpathSync(mainScript);
+      if (realScript.includes("openclaw")) {
+        const distDir = path.dirname(realScript);
+        if (!distDirs.includes(distDir)) distDirs.push(distDir);
+      }
+    }
+  } catch {
+  }
+  for (const dir of distDirs) {
+    try {
+      const files = readdirSync(dir);
+      for (const f of files) {
+        if (f.startsWith("runtime-model-auth.runtime-") && f.endsWith(".js")) {
+          candidates.push(path.join(dir, f));
+        }
+      }
+    } catch {
+    }
+  }
+  return candidates;
+}
+async function resolveProviderApiKey(providerId, apiKeyValue, gatewayConfig, agentDir) {
+  const cacheKey = `provider:${providerId}`;
+  if (resolvedCache.has(cacheKey)) {
+    return resolvedCache.get(cacheKey);
+  }
+  let resolved;
+  if (typeof apiKeyValue === "string" && apiKeyValue.trim().length > 0) {
+    if (apiKeyValue === "secretref-managed" || apiKeyValue.endsWith("-oauth") || apiKeyValue.endsWith("-local") || apiKeyValue === "lm-studio" || apiKeyValue.startsWith("gcp-")) {
+    } else {
+      resolved = apiKeyValue;
+      resolvedCache.set(cacheKey, resolved);
+      return resolved;
+    }
+  }
+  const resolver = await getGatewayResolver();
+  if (resolver) {
+    try {
+      const resolvedAgentDir = agentDir ?? path.join(os.homedir(), ".openclaw", "agents", "main", "agent");
+      const auth = await resolver({ provider: providerId, cfg: gatewayConfig, agentDir: resolvedAgentDir });
+      if (auth?.apiKey) {
+        resolved = auth.apiKey;
+        log.debug(`resolved API key for provider "${providerId}" via gateway auth (source: ${auth.source ?? "unknown"}, mode: ${auth.mode ?? "unknown"})`);
+        resolvedCache.set(cacheKey, resolved);
+        return resolved;
+      }
+    } catch (err) {
+      log.debug(
+        `gateway auth resolution failed for provider "${providerId}": ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  resolved = resolveFromEnv(providerId);
+  if (resolved) {
+    log.debug(`resolved API key for provider "${providerId}" from environment variable`);
+  } else {
+    log.debug(`could not resolve API key for provider "${providerId}" \u2014 skipping`);
+  }
+  if (resolved) {
+    resolvedCache.set(cacheKey, resolved);
+  }
+  return resolved;
+}
+function resolveFromEnv(providerId) {
+  const normalized = providerId.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+  const candidates = [
+    `${normalized}_API_KEY`,
+    `${normalized}_TOKEN`
+  ];
+  for (const envVar of candidates) {
+    const value = readEnvVar(envVar);
+    if (value && value.trim().length > 0) {
+      return value.trim();
+    }
+  }
+  return void 0;
+}
+function clearSecretCache() {
+  resolvedCache.clear();
+  _resolveApiKeyForProvider = null;
+  _resolverLoaded = false;
+  _resolverNextRetryAt = 0;
+}
+
+export {
+  resolveProviderApiKey,
+  clearSecretCache
+};
+//# sourceMappingURL=chunk-LU3GQNDQ.js.map

package/dist/chunk-LU3GQNDQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/resolve-provider-secret.ts"],"sourcesContent":["import { log } from \"./logger.js\";\nimport { readEnvVar } from \"./runtime/env.js\";\nimport path from \"node:path\";\nimport os from \"node:os\";\n\n/**\n * Resolve a provider API key using OpenClaw's own auth resolution system.\n *\n * This module delegates to the gateway's `resolveApiKeyForProvider()` function,\n * which handles all secret reference formats (SecretRef objects, auth profiles,\n * \"secretref-managed\" markers, environment variables, etc.) using the same\n * codepath the gateway uses for its own agent sessions.\n *\n * For plain-text API keys, a fast path returns them directly without\n * involving the gateway auth system.\n *\n * Results are cached per provider for the gateway process lifetime.\n */\n\ntype ResolveApiKeyFn = (params: {\n  provider: string;\n  cfg?: unknown;\n  agentDir?: string;\n}) => Promise<{ apiKey?: string; source?: string; mode?: string } | null>;\n\nlet _resolveApiKeyForProvider: ResolveApiKeyFn | null = null;\nlet _resolverLoaded = false;\nlet _resolverNextRetryAt = 0;\nconst RESOLVER_RETRY_BACKOFF_MS = 60_000; // 1 minute between retries after first failure\nconst resolvedCache = new Map<string, string | undefined>();\n\n/**\n * Lazily load the gateway's resolveApiKeyForProvider function.\n * Returns null if not available (e.g., running outside the gateway process).\n */\nasync function getGatewayResolver(): Promise<ResolveApiKeyFn | null> {\n  if (_resolverLoaded) {\n    return _resolveApiKeyForProvider;\n  }\n  // Backoff: don't re-scan filesystem on every call when module wasn't found.\n  // After a failure, wait RESOLVER_RETRY_BACKOFF_MS before trying again.\n  if (_resolverNextRetryAt > 0 && Date.now() < _resolverNextRetryAt) {\n    return null;\n  }\n\n  try {\n    // The gateway bundles this in a runtime chunk — import it dynamically.\n    // This import path is stable across gateway versions since it's a named runtime export.\n    const candidates = [\n      // Try glob-matching the runtime module name (hash varies per build)\n      ...await findRuntimeModules(),\n    ];\n\n    const { pathToFileURL } = await import(\"node:url\");\n    for (const candidate of candidates) {\n      try {\n        // Convert native path to file:// URL for cross-platform ESM import compatibility\n        const importUrl = pathToFileURL(candidate).href;\n        const mod = await import(importUrl);\n        if (typeof mod.resolveApiKeyForProvider === \"function\") {\n          _resolveApiKeyForProvider = mod.resolveApiKeyForProvider;\n          _resolverLoaded = true;\n          log.debug(\"loaded gateway resolveApiKeyForProvider from runtime module\");\n          return _resolveApiKeyForProvider;\n        }\n      } catch {\n        // Try next candidate\n      }\n    }\n  } catch {\n    // Silent\n  }\n\n  // Backoff before retrying — avoid repeated fs scanning.\n  // Retries after RESOLVER_RETRY_BACKOFF_MS so the resolver can\n  // recover if the gateway restarts or the module becomes available.\n  _resolverNextRetryAt = Date.now() + RESOLVER_RETRY_BACKOFF_MS;\n  log.debug(`gateway resolveApiKeyForProvider not available — will retry after ${RESOLVER_RETRY_BACKOFF_MS / 1000}s`);\n  return null;\n}\n\n/**\n * Find the gateway's model-auth runtime module by scanning the dist directory.\n * Uses require.resolve to find the openclaw package regardless of install method.\n */\nasync function findRuntimeModules(): Promise<string[]> {\n  const { readdirSync } = await import(\"node:fs\");\n  const { createRequire } = await import(\"node:module\");\n  const candidates: string[] = [];\n\n  // Discover the openclaw dist directory from the installed package,\n  // regardless of how it was installed (Homebrew, npm global, local, etc.)\n  const distDirs: string[] = [];\n\n  try {\n    // require.resolve finds the package from the current process context\n    const req = createRequire(import.meta.url);\n    const openclawMain = req.resolve(\"openclaw\");\n    const openclawDist = path.join(path.dirname(openclawMain), \"..\", \"dist\");\n    if (openclawDist) distDirs.push(path.resolve(openclawDist));\n  } catch {\n    // openclaw not resolvable from plugin context — try alternate paths\n  }\n\n  // Fallback: infer from the running process (gateway runs from its own dist/)\n  // Use fs.realpathSync to resolve symlinks (e.g., /usr/local/bin/openclaw → actual path)\n  try {\n    const { realpathSync } = await import(\"node:fs\");\n    const mainScript = process.argv[1];\n    if (mainScript) {\n      const realScript = realpathSync(mainScript);\n      if (realScript.includes(\"openclaw\")) {\n        const distDir = path.dirname(realScript);\n        if (!distDirs.includes(distDir)) distDirs.push(distDir);\n      }\n    }\n  } catch {\n    // Silent\n  }\n\n  for (const dir of distDirs) {\n    try {\n      const files = readdirSync(dir);\n      for (const f of files) {\n        if (f.startsWith(\"runtime-model-auth.runtime-\") && f.endsWith(\".js\")) {\n          candidates.push(path.join(dir, f));\n        }\n      }\n    } catch {\n      // Directory doesn't exist — skip\n    }\n  }\n\n  return candidates;\n}\n\n/**\n * Resolve a provider API key from various OpenClaw formats.\n *\n * Resolution order:\n * 1. Plain-text string → returned immediately\n * 2. Gateway's resolveApiKeyForProvider → handles all secret ref formats\n * 3. Environment variable fallback (PROVIDER_NAME_API_KEY)\n * 4. undefined → provider is skipped in the fallback chain\n */\nexport async function resolveProviderApiKey(\n  providerId: string,\n  apiKeyValue: unknown,\n  gatewayConfig?: unknown,\n  agentDir?: string,\n): Promise<string | undefined> {\n  // Check cache first\n  const cacheKey = `provider:${providerId}`;\n  if (resolvedCache.has(cacheKey)) {\n    return resolvedCache.get(cacheKey);\n  }\n\n  let resolved: string | undefined;\n\n  // Fast path: plain-text string that looks like an actual API key\n  if (typeof apiKeyValue === \"string\" && apiKeyValue.trim().length > 0) {\n    // Skip known non-API-key markers used by the gateway for auth modes\n    // that don't use bearer tokens (OAuth, local endpoints, GCP credentials)\n    if (\n      apiKeyValue === \"secretref-managed\" ||\n      apiKeyValue.endsWith(\"-oauth\") ||\n      apiKeyValue.endsWith(\"-local\") ||\n      apiKeyValue === \"lm-studio\" ||\n      apiKeyValue.startsWith(\"gcp-\")\n    ) {\n      // Fall through to gateway resolver / env var fallback\n    } else {\n      resolved = apiKeyValue;\n      resolvedCache.set(cacheKey, resolved);\n      return resolved;\n    }\n  }\n\n  // The API key is either a SecretRef object, \"secretref-managed\", or empty.\n  // Try the gateway's own auth resolution system first.\n  const resolver = await getGatewayResolver();\n  if (resolver) {\n    try {\n      const resolvedAgentDir = agentDir ?? path.join(os.homedir(), \".openclaw\", \"agents\", \"main\", \"agent\");\n      const auth = await resolver({ provider: providerId, cfg: gatewayConfig, agentDir: resolvedAgentDir });\n      if (auth?.apiKey) {\n        resolved = auth.apiKey;\n        log.debug(`resolved API key for provider \"${providerId}\" via gateway auth (source: ${auth.source ?? \"unknown\"}, mode: ${auth.mode ?? \"unknown\"})`);\n        resolvedCache.set(cacheKey, resolved);\n        return resolved;\n      }\n    } catch (err) {\n      log.debug(\n        `gateway auth resolution failed for provider \"${providerId}\": ${err instanceof Error ? err.message : String(err)}`,\n      );\n    }\n  }\n\n  // Environment variable fallback\n  resolved = resolveFromEnv(providerId);\n  if (resolved) {\n    log.debug(`resolved API key for provider \"${providerId}\" from environment variable`);\n  } else {\n    log.debug(`could not resolve API key for provider \"${providerId}\" — skipping`);\n  }\n\n  // Only cache successful resolutions — failures are retried on next call\n  // so providers can recover after transient issues (e.g., 1Password agent restart)\n  if (resolved) {\n    resolvedCache.set(cacheKey, resolved);\n  }\n  return resolved;\n}\n\n/**\n * Try to resolve an API key from environment variables.\n */\nfunction resolveFromEnv(providerId: string): string | undefined {\n  const normalized = providerId.toUpperCase().replace(/[^A-Z0-9]/g, \"_\");\n  const candidates = [\n    `${normalized}_API_KEY`,\n    `${normalized}_TOKEN`,\n  ];\n  for (const envVar of candidates) {\n    const value = readEnvVar(envVar);\n    if (value && value.trim().length > 0) {\n      return value.trim();\n    }\n  }\n  return undefined;\n}\n\n/**\n * Clear the resolution cache (useful for testing or key rotation).\n */\nexport function clearSecretCache(): void {\n  resolvedCache.clear();\n  _resolveApiKeyForProvider = null;\n  _resolverLoaded = false;\n  _resolverNextRetryAt = 0;\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-M5KEYE5E.js

@@ -0,0 +1,350 @@
+import {
+  log
+} from "./chunk-KWBU5S5U.js";
+
+// src/boxes.ts
+import { mkdir, writeFile, readFile, readdir } from "fs/promises";
+import path from "path";
+import { createHash } from "crypto";
+var BOX_DIR = "boxes";
+var STATE_DIR = "state";
+var TRACES_FILE = "traces.json";
+var OPEN_BOX_STATE_FILE = "open-box.json";
+function topicOverlapScore(a, b) {
+  if (a.length === 0 || b.length === 0) return 0;
+  const setA = new Set(a.map((t) => t.toLowerCase()));
+  const setB = new Set(b.map((t) => t.toLowerCase()));
+  const intersection = [...setA].filter((t) => setB.has(t)).length;
+  const union = (/* @__PURE__ */ new Set([...setA, ...setB])).size;
+  return union === 0 ? 0 : intersection / union;
+}
+function makeBoxId() {
+  return `box-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+}
+function makeTraceId(topics) {
+  const key = topics.slice().sort().join(",");
+  return `trace-${createHash("sha256").update(key).digest("hex").slice(0, 8)}`;
+}
+function serializeBoxFrontmatter(fm) {
+  const lines = [
+    "---",
+    `id: ${fm.id}`,
+    `memoryKind: ${fm.memoryKind}`,
+    `createdAt: ${fm.createdAt}`,
+    `sealedAt: ${fm.sealedAt}`,
+    `sealReason: ${fm.sealReason}`,
+    `topics: [${fm.topics.map((t) => `"${t}"`).join(", ")}]`,
+    `memoryIds: [${fm.memoryIds.map((m) => `"${m}"`).join(", ")}]`
+  ];
+  if (fm.sessionKey) lines.push(`sessionKey: ${fm.sessionKey}`);
+  if (fm.traceId) lines.push(`traceId: ${fm.traceId}`);
+  if (fm.goal) lines.push(`goal: ${fm.goal.replace(/[\r\n]+/g, " ")}`);
+  if (fm.toolsUsed?.length) lines.push(`toolsUsed: [${fm.toolsUsed.map((t) => `"${t}"`).join(", ")}]`);
+  if (fm.outcome) lines.push(`outcome: ${fm.outcome}`);
+  lines.push("---");
+  return lines.join("\n");
+}
+function parseBoxFrontmatter(raw) {
+  const match = raw.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return null;
+  const fmBlock = match[1];
+  const fm = {};
+  for (const line of fmBlock.split("\n")) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    fm[line.slice(0, colonIdx).trim()] = line.slice(colonIdx + 1).trim();
+  }
+  const parseArray = (val) => {
+    if (!val) return [];
+    const m = val.match(/\[(.*)]/);
+    if (!m) return [];
+    return m[1].split(",").map((s) => s.trim().replace(/^"|"$/g, "")).filter(Boolean);
+  };
+  const outcome = fm.outcome;
+  return {
+    id: fm.id ?? "",
+    memoryKind: "box",
+    createdAt: fm.createdAt ?? "",
+    sealedAt: fm.sealedAt ?? "",
+    sealReason: fm.sealReason ?? "forced",
+    sessionKey: fm.sessionKey,
+    topics: parseArray(fm.topics),
+    memoryIds: parseArray(fm.memoryIds),
+    traceId: fm.traceId,
+    goal: fm.goal || void 0,
+    toolsUsed: fm.toolsUsed ? parseArray(fm.toolsUsed) : void 0,
+    outcome: outcome && ["success", "failure", "partial", "unknown"].includes(outcome) ? outcome : void 0
+  };
+}
+var BoxBuilder = class {
+  baseDir;
+  cfg;
+  openBox = null;
+  stateLoaded = false;
+  constructor(baseDir, cfg) {
+    this.baseDir = baseDir;
+    this.cfg = cfg;
+  }
+  get boxBaseDir() {
+    return path.join(this.baseDir, BOX_DIR);
+  }
+  get stateDir() {
+    return path.join(this.baseDir, STATE_DIR);
+  }
+  get openBoxStatePath() {
+    return path.join(this.stateDir, OPEN_BOX_STATE_FILE);
+  }
+  get tracesPath() {
+    return path.join(this.stateDir, TRACES_FILE);
+  }
+  // ── State persistence ────────────────────────────────────────────────────
+  async loadOpenBox() {
+    if (this.stateLoaded) return;
+    this.stateLoaded = true;
+    try {
+      const raw = await readFile(this.openBoxStatePath, "utf-8");
+      this.openBox = JSON.parse(raw);
+    } catch {
+      this.openBox = null;
+    }
+  }
+  async saveOpenBox() {
+    await mkdir(this.stateDir, { recursive: true });
+    if (this.openBox) {
+      await writeFile(this.openBoxStatePath, JSON.stringify(this.openBox, null, 2), "utf-8");
+    } else {
+      try {
+        await writeFile(this.openBoxStatePath, "null", "utf-8");
+      } catch {
+      }
+    }
+  }
+  async loadTraceIndex() {
+    try {
+      const raw = await readFile(this.tracesPath, "utf-8");
+      const parsed = JSON.parse(raw);
+      parsed.traceLastSeen ??= {};
+      return parsed;
+    } catch {
+      return { traces: {}, boxToTrace: {}, traceTopics: {}, traceLastSeen: {} };
+    }
+  }
+  async saveTraceIndex(idx) {
+    try {
+      await mkdir(this.stateDir, { recursive: true });
+      await writeFile(this.tracesPath, JSON.stringify(idx, null, 2), "utf-8");
+    } catch (err) {
+      log.warn(`[engram/boxes] Failed to save trace index: ${err.message}`);
+    }
+  }
+  // ── Core logic ────────────────────────────────────────────────────────────
+  /**
+   * Called after each extraction run.
+   * Decides whether to seal the current open box and/or start a new one.
+   */
+  async onExtraction(event) {
+    if (!this.cfg.memoryBoxesEnabled) return;
+    await this.loadOpenBox();
+    const newTopics = event.topics.filter(Boolean);
+    const now = new Date(event.timestamp);
+    const nowMs = now.getTime();
+    if (this.openBox) {
+      const lastActivity = new Date(this.openBox.lastActivityAt).getTime();
+      const timeGapMs = nowMs - lastActivity;
+      const overlap = topicOverlapScore(this.openBox.topics, newTopics);
+      const topicShifted = newTopics.length > 0 && overlap < this.cfg.boxTopicShiftThreshold;
+      const timeExpired = timeGapMs >= this.cfg.boxTimeGapMs;
+      const tooManyMemories = this.openBox.memoryIds.length + event.memoryIds.length > this.cfg.boxMaxMemories;
+      if (tooManyMemories) {
+        const topicSet = /* @__PURE__ */ new Set([...this.openBox.topics, ...newTopics]);
+        this.openBox.topics = [...topicSet];
+        this.openBox.memoryIds.push(...event.memoryIds);
+        if (event.toolsUsed?.length) {
+          const toolSet = /* @__PURE__ */ new Set([...this.openBox.toolsUsed ?? [], ...event.toolsUsed]);
+          this.openBox.toolsUsed = [...toolSet];
+        }
+        await this.sealCurrent("max_memories");
+      } else if (topicShifted) {
+        await this.sealCurrent("topic_shift");
+        this.openBox = this.newBox(event, now.toISOString());
+        await this.saveOpenBox();
+      } else if (timeExpired) {
+        await this.sealCurrent("time_gap");
+        this.openBox = this.newBox(event, now.toISOString());
+        await this.saveOpenBox();
+      } else {
+        this.openBox.memoryIds.push(...event.memoryIds);
+        const topicSet = /* @__PURE__ */ new Set([...this.openBox.topics, ...newTopics]);
+        this.openBox.topics = [...topicSet];
+        this.openBox.lastActivityAt = now.toISOString();
+        if (event.toolsUsed?.length) {
+          const toolSet = /* @__PURE__ */ new Set([...this.openBox.toolsUsed ?? [], ...event.toolsUsed]);
+          this.openBox.toolsUsed = [...toolSet];
+        }
+        await this.saveOpenBox();
+      }
+    } else {
+      this.openBox = this.newBox(event, now.toISOString());
+      if (this.openBox.memoryIds.length > this.cfg.boxMaxMemories) {
+        await this.sealCurrent("max_memories");
+      } else {
+        await this.saveOpenBox();
+      }
+    }
+  }
+  newBox(event, ts) {
+    return {
+      id: makeBoxId(),
+      createdAt: ts,
+      lastActivityAt: ts,
+      topics: event.topics.filter(Boolean),
+      memoryIds: [...event.memoryIds],
+      goal: event.goal,
+      toolsUsed: event.toolsUsed?.length ? [...event.toolsUsed] : void 0
+    };
+  }
+  /**
+   * Seal the current open box and write it to disk.
+   * Also runs trace weaving if enabled.
+   */
+  async sealCurrent(reason) {
+    await this.loadOpenBox();
+    if (!this.openBox) return null;
+    const box = this.openBox;
+    this.openBox = null;
+    if (box.memoryIds.length === 0 && box.topics.length === 0) {
+      await this.saveOpenBox();
+      return null;
+    }
+    const sealedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const day = sealedAt.slice(0, 10);
+    const dir = path.join(this.boxBaseDir, day);
+    await mkdir(dir, { recursive: true });
+    let traceId;
+    if (this.cfg.traceWeaverEnabled && box.topics.length > 0) {
+      traceId = await this.resolveTrace(box.id, box.topics);
+    }
+    const fm = {
+      id: box.id,
+      memoryKind: "box",
+      createdAt: box.createdAt,
+      sealedAt,
+      sealReason: reason,
+      topics: box.topics,
+      memoryIds: box.memoryIds,
+      traceId,
+      goal: box.goal,
+      toolsUsed: box.toolsUsed?.length ? box.toolsUsed : void 0,
+      outcome: "unknown"
+    };
+    const content = `${serializeBoxFrontmatter(fm)}
+
+<!-- Topics: ${box.topics.join(", ")} | Memories: ${box.memoryIds.length} -->
+`;
+    const filePath = path.join(dir, `${box.id}.md`);
+    await writeFile(filePath, content, "utf-8");
+    log.debug(`[boxes] sealed box ${box.id} (${reason}): ${box.memoryIds.length} memories, topics=[${box.topics.join(",")}]`);
+    await this.saveOpenBox();
+    return box.id;
+  }
+  // ── Trace Weaving ─────────────────────────────────────────────────────────
+  /**
+   * Find an existing trace that matches box topics, or create a new trace.
+   * Returns the traceId to assign to this box.
+   */
+  async resolveTrace(boxId, topics) {
+    const idx = await this.loadTraceIndex();
+    const lookbackMs = this.cfg.traceWeaverLookbackDays * 24 * 60 * 60 * 1e3;
+    const cutoff = new Date(Date.now() - lookbackMs);
+    let bestTraceId;
+    let bestScore = 0;
+    for (const [tid, traceTopics] of Object.entries(idx.traceTopics)) {
+      const lastSeen = idx.traceLastSeen[tid];
+      if (lastSeen && new Date(lastSeen) < cutoff) continue;
+      const score = topicOverlapScore(topics, traceTopics);
+      if (score >= this.cfg.traceWeaverOverlapThreshold && score > bestScore) {
+        bestScore = score;
+        bestTraceId = tid;
+      }
+    }
+    const traceId = bestTraceId ?? makeTraceId(topics);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    if (!idx.traces[traceId]) idx.traces[traceId] = [];
+    idx.traces[traceId].push(boxId);
+    idx.boxToTrace[boxId] = traceId;
+    idx.traceLastSeen[traceId] = now;
+    if (idx.traceTopics[traceId]) {
+      const merged = /* @__PURE__ */ new Set([...idx.traceTopics[traceId], ...topics]);
+      idx.traceTopics[traceId] = [...merged];
+    } else {
+      idx.traceTopics[traceId] = [...topics];
+    }
+    await this.saveTraceIndex(idx);
+    return traceId;
+  }
+  // ── Recall ────────────────────────────────────────────────────────────────
+  /**
+   * Read all sealed boxes from the last N days for recall injection.
+   */
+  async readRecentBoxes(days) {
+    const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1e3);
+    const cutoffDateStr = cutoff.toISOString().slice(0, 10);
+    let topEntries;
+    try {
+      topEntries = await readdir(this.boxBaseDir, { withFileTypes: true, encoding: "utf-8" });
+    } catch {
+      return [];
+    }
+    const recentDirs = topEntries.filter((e) => e.isDirectory() && /^\d{4}-\d{2}-\d{2}$/.test(e.name) && e.name >= cutoffDateStr).map((e) => path.join(this.boxBaseDir, e.name));
+    const legacyEntries = topEntries.filter(
+      (e) => !e.isDirectory() || !/^\d{4}-\d{2}-\d{2}$/.test(e.name)
+    );
+    const boxes = [];
+    const readDir = async (dir) => {
+      let files;
+      try {
+        files = (await readdir(dir)).filter((f) => f.endsWith(".md"));
+      } catch {
+        return;
+      }
+      const results = await Promise.all(
+        files.map(async (f) => {
+          try {
+            const raw = await readFile(path.join(dir, f), "utf-8");
+            const parsed = parseBoxFrontmatter(raw);
+            return parsed && new Date(parsed.sealedAt) >= cutoff ? parsed : null;
+          } catch {
+            return null;
+          }
+        })
+      );
+      for (const r of results) {
+        if (r !== null) boxes.push(r);
+      }
+    };
+    await Promise.all(recentDirs.map(readDir));
+    for (const e of legacyEntries) {
+      const full = path.join(this.boxBaseDir, e.name);
+      if (e.isDirectory()) {
+        await readDir(full);
+      } else if (e.name.endsWith(".md")) {
+        try {
+          const raw = await readFile(full, "utf-8");
+          const parsed = parseBoxFrontmatter(raw);
+          if (parsed && new Date(parsed.sealedAt) >= cutoff) boxes.push(parsed);
+        } catch {
+        }
+      }
+    }
+    boxes.sort((a, b) => new Date(b.sealedAt).getTime() - new Date(a.sealedAt).getTime());
+    return boxes;
+  }
+};
+
+export {
+  BOX_DIR,
+  topicOverlapScore,
+  parseBoxFrontmatter,
+  BoxBuilder
+};
+//# sourceMappingURL=chunk-M5KEYE5E.js.map