hippo-memory 1.46.0 → 1.48.0

package/dist/support-bundle.js

@@ -0,0 +1,292 @@
+/** `hippo support-bundle`: one redacted JSON snapshot for a support ticket. Read-only; never touches memory content. */
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { findHippoStoreDir, isGlobalStoreRoot, realpathOrResolve } from './project-identity.js';
+import { getGlobalRoot } from './shared.js';
+import { isInitialized } from './store.js';
+import { openHippoDbReadOnly, closeHippoDb, getSchemaVersion, getMeta, countTableRows } from './db.js';
+import { runDoctor } from './doctor.js';
+import { loadConfig } from './config.js';
+import { redactSecretsStrict } from './secret-detect.js';
+const TAIL_MAX_BYTES = 256 * 1024;
+export const TAIL_MAX_LINES = 200;
+const TAIL_MAX_LINE_CHARS = 2000;
+// Greedy on purpose: complete key blocks are redacted first, so any END left is an orphan and what precedes it may be key body.
+const ORPHAN_KEY_END_RE = /^[\s\S]*-----END [A-Z ]*PRIVATE KEY-----/;
+// The other env vars hippo reads outside the HIPPO_ prefix (src/embedding-provider.ts, connectors/*).
+const OTHER_ENV_NAMES = [
+    'ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'VOYAGE_API_KEY', 'COHERE_API_KEY', 'TYPESAFE_API_KEY',
+    'GITHUB_TOKEN', 'GITHUB_WEBHOOK_SECRET', 'GITHUB_WEBHOOK_SECRET_PREVIOUS',
+    'GITHUB_ALLOW_UNKNOWN_INSTALLATION_FALLBACK', 'SLACK_BOT_TOKEN', 'SLACK_TEAM_ID',
+    'SLACK_SIGNING_SECRET', 'SLACK_SIGNING_SECRET_PREVIOUS', 'SLACK_ALLOW_UNKNOWN_TEAM_FALLBACK',
+    'XDG_DATA_HOME', 'MCP_SSE_HEARTBEAT_MS', 'MCP_SSE_MAX_AGE_SEC',
+];
+const CONFIG_SECRET_KEY_RE = /key|token|secret|passw|credential|auth|cookie|bearer|signature|private/i;
+function isJsonObject(v) {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+function isJsonString(v) {
+    return typeof v === 'string';
+}
+function buildRuntime() {
+    return {
+        node: process.versions.node,
+        sqlite: process.versions.sqlite ?? null,
+        platform: process.platform,
+        arch: process.arch,
+        osRelease: os.release(),
+    };
+}
+function listTableNames(db) {
+    // SAFETY: each row's shape matches the single `name` column named in the SELECT above.
+    const rows = db.prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' AND sql NOT LIKE 'CREATE VIRTUAL TABLE%' ORDER BY name`).all();
+    return rows.map((r) => r.name);
+}
+function countTables(db) {
+    const tables = {};
+    for (const name of listTableNames(db))
+        tables[name] = countTableRows(db, name);
+    return tables;
+}
+function redactConfigValue(value) {
+    if (Array.isArray(value))
+        return value.map(redactConfigValue);
+    if (isJsonObject(value)) {
+        const out = {};
+        for (const [key, v] of Object.entries(value)) {
+            out[key] = CONFIG_SECRET_KEY_RE.test(key) ? '[REDACTED]' : redactConfigValue(v);
+        }
+        return out;
+    }
+    return value;
+}
+function readStoreConfig(storeDir) {
+    const configPath = path.join(storeDir, 'config.json');
+    let configFile = 'absent';
+    if (fs.existsSync(configPath)) {
+        try {
+            JSON.parse(fs.readFileSync(configPath, 'utf8'));
+            configFile = 'present';
+        }
+        catch {
+            configFile = 'invalid';
+        }
+    }
+    // loadConfig always returns the effective config: its own defaults on a missing or broken file.
+    const effective = JSON.parse(JSON.stringify(loadConfig(storeDir)));
+    return { configFile, config: redactConfigValue(effective) };
+}
+function buildStoreEntry(kind, storeDir) {
+    const dbPath = path.join(storeDir, 'hippo.db');
+    if (!fs.existsSync(dbPath)) {
+        return { kind, path: storeDir, error: 'no hippo.db here (hippo init has not run)' };
+    }
+    // Stat before opening: a read-only open leaves an empty -wal behind it.
+    const files = { 'hippo.db': fs.statSync(dbPath).size };
+    const walPath = `${dbPath}-wal`;
+    if (fs.existsSync(walPath))
+        files['hippo.db-wal'] = fs.statSync(walPath).size;
+    let db = null;
+    try {
+        db = openHippoDbReadOnly(storeDir);
+        const schemaVersion = getSchemaVersion(db);
+        const minCompatibleBinary = getMeta(db, 'min_compatible_binary', '') || null;
+        const tables = countTables(db);
+        const { configFile, config } = readStoreConfig(storeDir);
+        return { kind, path: storeDir, schemaVersion, minCompatibleBinary, files, tables, configFile, config };
+    }
+    catch (err) {
+        return { kind, path: storeDir, error: err instanceof Error ? err.message : String(err) };
+    }
+    finally {
+        if (db !== null)
+            closeHippoDb(db);
+    }
+}
+function buildStores(opts) {
+    const stores = [];
+    const projectDir = findHippoStoreDir(opts.cwd, { homeDir: opts.home });
+    if (projectDir !== null)
+        stores.push(buildStoreEntry('project', projectDir));
+    const globalDir = getGlobalRoot();
+    const alreadyListed = projectDir !== null && isGlobalStoreRoot(projectDir);
+    if (isInitialized(globalDir) && !alreadyListed)
+        stores.push(buildStoreEntry('global', globalDir));
+    return stores;
+}
+function listSetEnvNames() {
+    const names = new Set();
+    for (const key of Object.keys(process.env)) {
+        if (key.startsWith('HIPPO_'))
+            names.add(key);
+    }
+    for (const key of OTHER_ENV_NAMES) {
+        if (process.env[key] !== undefined)
+            names.add(key);
+    }
+    return [...names].sort();
+}
+function listLogFileNames(dir) {
+    if (!fs.existsSync(dir))
+        return [];
+    return fs.readdirSync(dir, { withFileTypes: true })
+        .filter((d) => d.isFile())
+        .map((d) => d.name)
+        .sort();
+}
+function tailLogFile(file) {
+    const size = fs.statSync(file).size;
+    const readSize = Math.min(size, TAIL_MAX_BYTES);
+    const startedMidFile = size > TAIL_MAX_BYTES;
+    const fd = fs.openSync(file, 'r');
+    let text;
+    try {
+        const buf = Buffer.alloc(readSize);
+        fs.readSync(fd, buf, 0, readSize, size - readSize);
+        text = buf.toString('utf8');
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+    let lines = text.split(/\r?\n/);
+    // A tail read starting mid-file cuts its first piece off mid-line.
+    if (startedMidFile)
+        lines = lines.slice(1);
+    if (lines.length > 0 && lines[lines.length - 1] === '')
+        lines = lines.slice(0, -1);
+    // Redact before splitting: a private key spans lines. An END still left has lost its BEGIN to the window cut.
+    const redacted = redactSecretsStrict(lines.join('\n')).replace(ORPHAN_KEY_END_RE, '[REDACTED]');
+    return redacted.split('\n').slice(-TAIL_MAX_LINES).map((line) => line.length > TAIL_MAX_LINE_CHARS ? `${line.slice(0, TAIL_MAX_LINE_CHARS)} [truncated]` : line);
+}
+function buildLogsSection(opts) {
+    const dir = path.join(opts.home, '.hippo', 'logs');
+    const names = listLogFileNames(dir);
+    const files = names.map((name) => {
+        const stat = fs.statSync(path.join(dir, name));
+        return { name, bytes: stat.size, modified: stat.mtime.toISOString() };
+    });
+    const logs = { dir: '~/.hippo/logs', files };
+    if (opts.includeLogs) {
+        const tails = {};
+        for (const name of names)
+            tails[name] = tailLogFile(path.join(dir, name));
+        logs['tails'] = tails;
+    }
+    return logs;
+}
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+// The native realpath is the only form that exposes a short-name (8.3) or symlinked alias for what it is.
+function nativeRealPathKey(p) {
+    try {
+        const real = fs.realpathSync.native(p);
+        return process.platform === 'win32' ? real.toLowerCase() : real;
+    }
+    catch {
+        // A path that does not exist has no alias to find.
+        return null;
+    }
+}
+// Longest first: where one home form nests in another (a test home under the real one), swap the longer.
+function collectHomeForms(home, probes) {
+    const forms = new Set();
+    const add = (s) => { if (s.length >= 3)
+        forms.add(s); };
+    for (const base of [home, realpathOrResolve(home), os.homedir(), realpathOrResolve(os.homedir())]) {
+        add(base);
+        add(path.resolve(base));
+        if (process.platform === 'win32') {
+            add(base.replace(/\\/g, '/'));
+            add(path.resolve(base).replace(/\\/g, '/'));
+        }
+    }
+    // The alias (e.g. a short-name temp root) can sit above the probe itself, so walk ancestors and
+    // compare native realpaths rather than checking each probe alone.
+    const homeKeys = new Set([nativeRealPathKey(home), nativeRealPathKey(os.homedir())].filter((k) => k !== null));
+    for (const probe of probes) {
+        let dir = path.resolve(probe);
+        for (;;) {
+            const key = nativeRealPathKey(dir);
+            if (key !== null && homeKeys.has(key)) {
+                add(dir);
+                if (process.platform === 'win32')
+                    add(dir.replace(/\\/g, '/'));
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    const seen = new Set();
+    const deduped = [];
+    for (const f of [...forms].sort((a, b) => b.length - a.length)) {
+        const key = process.platform === 'win32' ? f.toLowerCase() : f;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        deduped.push(f);
+    }
+    return deduped;
+}
+function replaceHomeForms(text, forms) {
+    if (forms.length === 0)
+        return text;
+    // Stop only before another name character: "<home> now" and "<home>." swap, a longer user name ("<home>ty") does not.
+    const re = new RegExp(`(?:${forms.map(escapeRegExp).join('|')})(?![\\p{L}\\p{N}_])`, process.platform === 'win32' ? 'giu' : 'gu');
+    return text.replace(re, '~');
+}
+const URL_RE = /\b[a-z][a-z0-9+.-]*:\/\/[^\s"'<>]+/gi;
+function redactUrlsInString(text) {
+    return text.replace(URL_RE, (match) => {
+        const scheme = match.slice(0, match.indexOf('://'));
+        try {
+            const url = new URL(match);
+            url.username = '';
+            url.password = '';
+            url.search = '';
+            url.hash = '';
+            return url.toString();
+        }
+        catch {
+            return `${scheme}://[REDACTED]`;
+        }
+    });
+}
+function redactString(text, homeForms) {
+    return replaceHomeForms(redactSecretsStrict(redactUrlsInString(text)), homeForms);
+}
+function redactStrings(value, homeForms) {
+    if (isJsonString(value))
+        return redactString(value, homeForms);
+    if (Array.isArray(value))
+        return value.map((v) => redactStrings(v, homeForms));
+    if (isJsonObject(value)) {
+        const out = {};
+        for (const [k, v] of Object.entries(value))
+            out[k] = redactStrings(v, homeForms);
+        return out;
+    }
+    return value;
+}
+/** Read-only: builds one redacted support-ticket snapshot. Never reads a memory content column. */
+export function buildSupportBundle(opts) {
+    const bundle = {
+        format: 'hippo-support-bundle/1',
+        createdAt: opts.now.toISOString(),
+        hippo: opts.version,
+        runtime: buildRuntime(),
+        doctor: JSON.parse(JSON.stringify(runDoctor(opts))),
+        stores: buildStores(opts),
+        env: listSetEnvNames(),
+        logs: buildLogsSection(opts),
+    };
+    // Store paths found from the working folder arrive resolved; the global root arrives as HIPPO_HOME was typed, and log lines
+    // often quote the temp folder, which usually sits under the home.
+    const redacted = redactStrings(bundle, collectHomeForms(opts.home, [getGlobalRoot(), os.tmpdir()]));
+    // SAFETY: the value built above is always a JsonObject; redactStrings preserves object shape.
+    return redacted;
+}
+//# sourceMappingURL=support-bundle.js.map

package/dist/version.d.ts

@@ -16,7 +16,7 @@
  * an ESM `import` can resolve cleanly, and a hardcoded constant survives
  * any packager that drops .json files.
  */
-export declare const PACKAGE_VERSION = "1.46.0";
+export declare const PACKAGE_VERSION = "1.48.0";
 /** Compares plain x.y.z versions, positive if a > b; tags throw so the rollback guard never misfires silently. */
 export declare function compareSemver(a: string, b: string): number;
 //# sourceMappingURL=version.d.ts.map

package/dist/version.js

@@ -16,7 +16,7 @@
  * an ESM `import` can resolve cleanly, and a hardcoded constant survives
  * any packager that drops .json files.
  */
-export const PACKAGE_VERSION = '1.46.0';
+export const PACKAGE_VERSION = '1.48.0';
 /** Compares plain x.y.z versions, positive if a > b; tags throw so the rollback guard never misfires silently. */
 export function compareSemver(a, b) {
     const parse = (v) => {

package/extensions/openclaw-plugin/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "hippo-memory",
   "name": "Hippo Memory",
   "description": "Biologically-inspired memory for AI agents. Decay by default, retrieval strengthening, sleep consolidation.",
-  "version": "1.46.0",
+  "version": "1.48.0",
 
   "configSchema": {
     "type": "object",

package/extensions/openclaw-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hippo-memory",
-  "version": "1.46.0",
+  "version": "1.48.0",
   "type": "module",
   "description": "Hippo Memory plugin for OpenClaw - biologically-inspired agent memory",
   "main": "index.ts",

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "hippo-memory",
   "name": "Hippo Memory",
   "description": "Biologically-inspired memory for AI agents. Decay by default, retrieval strengthening, sleep consolidation.",
-  "version": "1.46.0",
+  "version": "1.48.0",
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hippo-memory",
-  "version": "1.46.0",
+  "version": "1.48.0",
   "description": "Biologically-inspired memory for AI agents. Zero runtime deps, SQLite, MCP server, and an opt-in hosted TypeSafe Jev reranker. Decay, retrieval strengthening, consolidation.",
   "mcpName": "io.github.kitfunso/hippo-memory",
   "type": "module",
@@ -34,6 +34,7 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "lint": "oxlint",
+    "sbom": "node scripts/sbom.mjs",
     "audit:security": "npm audit --audit-level=high && npm --prefix ui audit --audit-level=high",
     "postinstall": "node scripts/postinstall.cjs",
     "smoke:pack": "node scripts/smoke-pack.mjs",