hippo-memory 1.70.0 → 1.72.0

package/dist/cli/serve.js

@@ -1,18 +1,20 @@
 // Long-running verbs: `hippo dashboard`, `hippo mcp` and `hippo serve`.
 import { installCrashHandlers } from '../util/crash-handlers.js';
-import { envPort, envRequireAuth, envTlsCert, envTlsKey } from '../util/env.js';
+import { envAllowKeylessLocal, envPort, envRequireAuth, envTlsCert, envTlsKey } from '../util/env.js';
 import * as fs from 'fs';
 import * as path from 'path';
 import { printError } from './output.js';
-import { stringFlagOrExit, stringFlag } from './flag-values.js';
+import { stringFlagOrExit, stringFlag, numberFlag } from './flag-values.js';
 import { requireInit } from './shared.js';
 import { errorMessage } from '../util/log.js';
+import { CliExit } from './exit.js';
+import { DEFAULT_DASHBOARD_PORT, DEFAULT_SERVER_HOST, DEFAULT_SERVER_PORT } from '../server/defaults.js';
 export async function handleDashboard({ hippoRoot, flags }) {
     requireInit(hippoRoot);
-    const port = parseInt(String(flags['port'] ?? '3333'), 10);
+    const port = numberFlag(flags, 'port') ?? DEFAULT_DASHBOARD_PORT;
     const { serveDashboard } = await import('../dashboard/dashboard.js');
-    serveDashboard(hippoRoot, port);
-    // A busy port or a later throw ends in one log line and exit 1, as it does for serve and mcp.
+    serveDashboard(hippoRoot, port, undefined, { handleSignals: true });
+    // A later throw ends in one log line and exit 1, as it does for serve and mcp; a busy port is reported by the dashboard itself.
     installCrashHandlers('dashboard');
     await new Promise(() => { }); // run until Ctrl+C
 }
@@ -35,33 +37,40 @@ function readTlsFiles(flags) {
         return undefined;
     if (certPath === undefined || keyPath === undefined) {
         printError('hippo serve: TLS needs both a certificate and a key: --tls-cert and --tls-key, or HIPPO_TLS_CERT and HIPPO_TLS_KEY.');
-        process.exit(1);
+        throw new CliExit(1);
     }
     try {
         return { cert: fs.readFileSync(certPath), key: fs.readFileSync(keyPath) };
     }
     catch (err) {
         printError(`hippo serve: cannot read the TLS files: ${errorMessage(err)}`);
-        process.exit(1);
+        throw new CliExit(1);
     }
 }
+/** Said at every start, so the key rule is a choice an operator sees, and an upgrade that changed it explains itself. */
+function keyRuleLine() {
+    if (envRequireAuth())
+        return 'every request needs an API key (HIPPO_REQUIRE_AUTH=1)';
+    if (envAllowKeylessLocal()) {
+        return 'requests from this machine need no API key and act as host admin (HIPPO_ALLOW_KEYLESS_LOCAL=1); unset it to require a key on every request';
+    }
+    return 'every request needs an API key: mint one with `hippo auth create` and send it as "Authorization: Bearer <key>" ' +
+        '(the hippo CLI reads HIPPO_API_KEY). To let requests from this machine in without a key, start with HIPPO_ALLOW_KEYLESS_LOCAL=1';
+}
 export async function handleServe({ hippoRoot, flags }) {
     requireInit(hippoRoot);
-    const portRaw = flags['port'] ?? envPort() ?? '6789';
+    const portRaw = flags['port'] ?? envPort() ?? DEFAULT_SERVER_PORT;
     const port = Number(portRaw);
     if (!Number.isFinite(port) || port < 0) {
         printError(`Invalid --port: ${String(portRaw)}`);
-        process.exit(1);
+        throw new CliExit(1);
     }
-    const host = stringFlag(flags, 'host') ?? '127.0.0.1';
+    const host = stringFlag(flags, 'host') ?? DEFAULT_SERVER_HOST;
     const tls = readTlsFiles(flags);
     const { serve } = await import('../server.js');
     const handle = await serve({ hippoRoot, port, host, handleSignals: true, tls });
     console.log(`hippo serve listening on ${handle.url} (pid ${process.pid})`);
-    // Said at every start: the no-key local fallback is a default an operator should choose, not discover.
-    if (!envRequireAuth()) {
-        console.log('local requests need no API key and act as host admin; set HIPPO_REQUIRE_AUTH=1 to require a key on every request');
-    }
+    console.log(keyRuleLine());
     console.log(`pidfile: ${path.join(hippoRoot, 'server.pid')}`);
     console.log('press Ctrl+C to stop');
     // The SIGINT/SIGTERM handlers stop the server and exit. Hang until then.

package/dist/cli/session-hooks.d.ts

@@ -1,26 +1,18 @@
 import { type CliFlags, type CommandContext } from './flag-values.js';
-/**
- * SessionEnd entry point. Claude Code / OpenCode fire this on /exit while
- * tearing down the TUI, which kills any child that is still running when
- * the parent returns. Running sleep + capture synchronously here means both
- * get SIGTERM'd mid-consolidation.
- *
- * So we do the minimum inline (read stdin for transcript_path), then spawn
- * a fully detached Node child that runs sleep → capture and exit the parent
- * immediately. The child writes to the log file and survives TUI teardown;
- * the next SessionStart reads the log via `hippo last-sleep`.
- */
-export declare function cmdSessionEnd(hippoRoot: string, flags: CliFlags): Promise<void>;
-export declare function cmdSessionEndWorker(hippoRoot: string, flags: CliFlags): Promise<void>;
+/** SessionEnd entry: TUI teardown kills children still running, so read stdin inline, spawn a detached child that runs sleep then capture, and exit.
+ * The child logs to a file that the next SessionStart reads via `hippo last-sleep`. */
+export declare function handleSessionEnd({ hippoRoot, tenantId, flags }: CommandContext): Promise<void>;
+export declare function handleSessionEndWorker({ hippoRoot, tenantId, flags }: CommandContext): Promise<void>;
 /** Quotes one cmd.exe argument; each `%` leaves the quotes as `^%`, so no %NAME% pair can expand. */
 export declare function quoteCmdArg(arg: string): string;
 /** cmd.exe arguments that run a .cmd or .bat shim with every forwarded argument delivered verbatim. */
 export declare function cmdShimArgs(shimPath: string, forwardArgs: readonly string[]): string[];
-export declare function cmdCodexRun(hippoRoot: string, args: string[]): void;
-export declare function cmdCodexSessionEndWorker(hippoRoot: string, flags: CliFlags): Promise<void>;
-export declare function handlePreCompact({ hippoRoot, flags }: CommandContext): Promise<void>;
+export declare function handleCodexRun({ hippoRoot, tenantId, args }: CommandContext): void;
+export declare function cmdCodexSessionEndWorker(hippoRoot: string, tenantId: string, flags: CliFlags): Promise<void>;
+export declare function handleCodexSessionEndWorker({ hippoRoot, tenantId, flags }: CommandContext): Promise<void>;
+export declare function handlePreCompact({ hippoRoot, tenantId, flags }: CommandContext): Promise<void>;
 export declare function handlePostCompact({ hippoRoot, flags }: CommandContext): Promise<void>;
-export declare function handleCaptureError({ hippoRoot, flags }: CommandContext): Promise<void>;
-export declare function handleCompactResume({ hippoRoot }: CommandContext): Promise<void>;
-export declare function handleCapture({ hippoRoot, flags }: CommandContext): Promise<void>;
+export declare function handleCaptureError({ hippoRoot, tenantId, flags }: CommandContext): Promise<void>;
+export declare function handleCompactResume({ hippoRoot, tenantId }: CommandContext): Promise<void>;
+export declare function handleCapture({ hippoRoot, tenantId, flags }: CommandContext): Promise<void>;
 //# sourceMappingURL=session-hooks.d.ts.map