@agentage/cli 0.37.2 → 0.38.1

package/dist/commands/vault/vault.d.ts

@@ -1,22 +0,0 @@
-import { type Command } from 'commander';
-import { type VaultsConfig } from '@agentage/memory-core';
-import { type ProvisionResult } from '../../lib/auth/provision.js';
-import { type LoadedVaults } from '../../lib/vault/vaults.js';
-export interface VaultDeps {
-    load: () => LoadedVaults;
-    mutate: (fn: (config: VaultsConfig) => VaultsConfig | null | void) => Promise<VaultsConfig>;
-    ensureDir: (path: string) => void;
-    provision: (name: string) => Promise<ProvisionResult>;
-    log: (msg: string) => void;
-}
-export interface VaultAddOptions {
-    local?: string | boolean;
-    git?: string;
-    path?: string;
-}
-export declare const runVaultAdd: (name: string, opts: VaultAddOptions, deps?: VaultDeps) => Promise<void>;
-export declare const runVaultRemove: (name: string, deps?: VaultDeps) => Promise<void>;
-export declare const runVaultList: (opts: {
-    json?: boolean;
-}, deps?: VaultDeps) => void;
-export declare const registerVault: (program: Command) => void;

package/dist/commands/vault/vault.js

@@ -1,129 +0,0 @@
-import chalk from 'chalk';
-import { isAccountVault } from '@agentage/memory-core';
-import { addVault, appendDiscoverIgnore, ensureVaultDir, formatVaultLine, redactEntry, removeVault, vaultType, } from '../../lib/vault/vault-registry.js';
-import { defaultProvisionDeps, provisionAccountVault, } from '../../lib/auth/provision.js';
-import { loadVaultsConfig, mutateVaultsConfig } from '../../lib/vault/vaults.js';
-import { assertSafeRemoteUrl, redactRemoteUrl } from '../../sync/git/remote-url.js';
-import { defaultVaultSyncDeps, runVaultSync } from './vault-sync.js';
-const defaultDeps = {
-    load: loadVaultsConfig,
-    mutate: mutateVaultsConfig,
-    ensureDir: ensureVaultDir,
-    provision: (name) => provisionAccountVault(name, defaultProvisionDeps()),
-    log: (msg) => console.log(msg),
-};
-const buildEntry = (name, opts) => {
-    const hasLocal = opts.local !== undefined;
-    if (hasLocal && opts.git)
-        throw new Error('choose one of --local or --git, not both');
-    if (opts.path !== undefined && (hasLocal || opts.git))
-        throw new Error('--path applies only to an account vault (drop --local and --git)');
-    // A --git vault is a local working copy that syncs to an external git remote (path + origin);
-    // the daemon commits/pushes and pulls it per its interval.
-    if (opts.git) {
-        assertSafeRemoteUrl(opts.git);
-        return { path: `~/vaults/${name}`, origin: [{ remote: opts.git }], mcp: ['local'] };
-    }
-    if (hasLocal) {
-        const path = typeof opts.local === 'string' ? opts.local : `~/vaults/${name}`;
-        return { path, mcp: ['local'] };
-    }
-    // No --local/--git: an account vault - a local folder plus a memory in your account; this CLI
-    // has no channel that syncs the two.
-    return { path: opts.path ?? `~/vaults/${name}`, origin: [{ remote: 'agentage' }] };
-};
-export const runVaultAdd = async (name, opts, deps = defaultDeps) => {
-    const entry = buildEntry(name, opts);
-    // The dup check + save run together under the lock, against the FRESH on-disk config.
-    await deps.mutate((config) => addVault(config, name, entry));
-    if (entry.path)
-        deps.ensureDir(entry.path);
-    const kind = vaultType(entry);
-    const where = entry.path ?? entry.origin?.[0]?.remote ?? '';
-    const via = kind === 'git' && entry.origin?.length ? ` <- ${redactRemoteUrl(entry.origin[0].remote)}` : '';
-    deps.log(chalk.green(`Added vault '${name}' (${kind}) -> ${where}${via}`));
-    // Offline-first: the local entry is saved first; provisioning the account channel is never fatal.
-    if (isAccountVault(entry))
-        deps.log((await deps.provision(name)).message);
-};
-export const runVaultRemove = async (name, deps = defaultDeps) => {
-    let wasDefault = false;
-    let ignoredRoot = null;
-    // The removal and the discover-ignore append run as one locked read-modify-write, against the
-    // FRESH on-disk config, else a concurrent writer's update is lost or the next scan re-adds the folder.
-    const next = await deps.mutate((config) => {
-        wasDefault = config.default === name;
-        const path = config.vaults?.[name]?.path;
-        let updated = removeVault(config, name);
-        const ignored = path ? appendDiscoverIgnore(updated, name, path) : null;
-        if (ignored) {
-            updated = ignored.config;
-            ignoredRoot = ignored.root;
-        }
-        return updated;
-    });
-    deps.log(`Removed vault '${name}' (files left on disk).`);
-    if (ignoredRoot)
-        deps.log(`Added '${name}' to ${ignoredRoot} ignore so it is not re-discovered.`);
-    if (wasDefault && next.default)
-        deps.log(`Default vault is now '${next.default}'.`);
-};
-export const runVaultList = (opts, deps = defaultDeps) => {
-    const { config } = deps.load();
-    const vaults = config.vaults ?? {};
-    const names = Object.keys(vaults);
-    if (opts.json) {
-        // Backward-compatible: still the name-keyed map, each entry annotated with its honest type.
-        // Origin remotes are redacted so a credentialed URL never leaks into machine output.
-        const out = Object.fromEntries(names.map((n) => [n, { ...redactEntry(vaults[n]), type: vaultType(vaults[n]) }]));
-        deps.log(JSON.stringify(out, null, 2));
-        return;
-    }
-    if (names.length === 0) {
-        deps.log('No vaults registered. Add one with `agentage vault add <name> --local`.');
-        return;
-    }
-    for (const name of names) {
-        const suffix = name === config.default ? '  (default)' : '';
-        deps.log(formatVaultLine(name, vaults[name]) + suffix);
-    }
-};
-const guard = (fn) => {
-    try {
-        fn();
-    }
-    catch (err) {
-        console.error(chalk.red(err instanceof Error ? err.message : String(err)));
-        process.exitCode = 1;
-    }
-};
-const guardAsync = (fn) => fn().catch((err) => {
-    console.error(chalk.red(err instanceof Error ? err.message : String(err)));
-    process.exitCode = 1;
-});
-export const registerVault = (program) => {
-    const vault = program.command('vault').description('Manage local memory vaults');
-    vault
-        .command('list')
-        .description('List registered vaults')
-        .option('--json', 'machine-readable output')
-        .action((opts) => guard(() => runVaultList(opts)));
-    vault
-        .command('add <name>')
-        .description('Register a vault (account by default; --local or --git for a self-hosted one)')
-        .option('--local [path]', 'a local folder (default ~/vaults/<name>)')
-        .option('--git <remote>', 'a vault synced to an external git remote')
-        .option('--path <dir>', 'account vault local mirror dir (default ~/vaults/<name>)')
-        .action((name, opts) => guardAsync(() => runVaultAdd(name, opts)));
-    vault
-        .command('remove <name>')
-        .description('Unregister a vault (files stay on disk)')
-        .action((name) => guardAsync(() => runVaultRemove(name)));
-    vault
-        .command('sync [name]')
-        .description('Sync vaults now (git commit/push/pull)')
-        .action((name) => runVaultSync(name, defaultVaultSyncDeps()).catch((err) => {
-        console.error(chalk.red(err instanceof Error ? err.message : String(err)));
-        process.exitCode = 1;
-    }));
-};

package/dist/daemon/actions.d.ts

@@ -1,5 +0,0 @@
-import { type MemoryClient } from '../lib/memory/memory-client.js';
-export declare const MEMORY_VERBS: readonly ["search", "read", "write", "edit", "list", "delete"];
-export type MemoryVerb = (typeof MEMORY_VERBS)[number];
-export declare const isMemoryVerb: (v: string) => v is MemoryVerb;
-export declare const dispatchMemory: (client: MemoryClient, verb: MemoryVerb, body: unknown) => Promise<unknown>;

package/dist/daemon/actions.js

@@ -1,22 +0,0 @@
-export const MEMORY_VERBS = ['search', 'read', 'write', 'edit', 'list', 'delete'];
-export const isMemoryVerb = (v) => MEMORY_VERBS.includes(v);
-// Map one wire payload to the matching MemoryClient call. The daemon and the CLI share this verb
-// set so a daemon request runs the exact method a DirectClient would run in-process (DO2).
-export const dispatchMemory = (client, verb, body) => {
-    const p = (body ?? {});
-    switch (verb) {
-        case 'search':
-            return client.search(p['query'], p['opts']);
-        case 'read':
-            return client.read(p['ref'], p['opts']);
-        case 'write':
-            return client.write(p['ref'], p['body'], p['opts']);
-        case 'edit':
-            return client.edit(p['ref'], p['op'], p['opts']);
-        case 'list':
-            return client.list(p['folder'], p['opts']);
-        case 'delete':
-            return client.delete(p['ref'], p['opts']);
-    }
-    throw new Error(`unknown verb: ${verb}`);
-};

package/dist/daemon/client-provider.d.ts

@@ -1,2 +0,0 @@
-import { type MemoryClient } from '../lib/memory/memory-client.js';
-export declare const createClientProvider: () => (() => MemoryClient);

package/dist/daemon/client-provider.js

@@ -1,16 +0,0 @@
-import { existsSync, statSync } from 'node:fs';
-import { createDirectClient } from '../lib/memory/memory-client.js';
-import { loadVaultsConfig, vaultsJsonPath } from '../lib/vault/vaults.js';
-// One in-process engine per daemon, rebuilt only when vaults.json changes on disk, so a
-// `vault add` between requests is picked up without a daemon restart.
-export const createClientProvider = () => {
-    let cached;
-    return () => {
-        const path = vaultsJsonPath();
-        const mtime = existsSync(path) ? statSync(path).mtimeMs : 0;
-        if (!cached || cached.mtime !== mtime) {
-            cached = { client: createDirectClient(loadVaultsConfig().config), mtime };
-        }
-        return cached.client;
-    };
-};

package/dist/daemon/entry.d.ts

@@ -1,8 +0,0 @@
-export declare const isEaddrinuse: (err: unknown) => boolean;
-export declare const createStateCleanup: (remove: () => void) => {
-    markOwned: () => void;
-    cleanup: () => void;
-};
-export declare const safeReschedule: (steps: Array<() => void>, onError: (msg: string) => void) => void;
-export declare const mcpEnabled: (env?: NodeJS.ProcessEnv) => boolean;
-export declare const boot: () => void;

package/dist/daemon/entry.js

@@ -1,113 +0,0 @@
-import { unwatchFile, watchFile } from 'node:fs';
-import { createClientProvider } from './client-provider.js';
-import { EADDRINUSE_EXIT_CODE, generateDaemonToken, removePidFile, removePortFile, removeTokenFile, resolvePort, writePidFile, writePortFile, writeTokenFile, } from './lifecycle.js';
-import { createDaemonServer } from './server.js';
-import { loadLocalMemoryServer } from '../mcp/local-server.js';
-import { vaultsJsonPath } from '../lib/vault/vaults.js';
-import { createDiscoverWatcher } from '../sync/discover/watcher.js';
-import { createSyncManager } from '../sync/git/manager.js';
-import { VERSION } from '../utils/version.js';
-export const isEaddrinuse = (err) => typeof err === 'object' && err !== null && err.code === 'EADDRINUSE';
-// Gate state-file cleanup on ownership: a loser of an autostart race must never wipe the winner's
-// pid/port/token files. Only the process that actually wrote them may remove them.
-export const createStateCleanup = (remove) => {
-    let owned = false;
-    return {
-        markOwned: () => {
-            owned = true;
-        },
-        cleanup: () => {
-            if (owned)
-                remove();
-        },
-    };
-};
-// Run each reschedule independently: a transiently-invalid config edit must not crash the daemon or
-// stop the others rescheduling; the throwing one keeps its last-good schedule.
-export const safeReschedule = (steps, onError) => {
-    for (const step of steps) {
-        try {
-            step();
-        }
-        catch (err) {
-            onError(err instanceof Error ? err.message : String(err));
-        }
-    }
-};
-// MCP is served at /mcp by default; AGENTAGE_DAEMON_NO_MCP=1 leaves buildMcpServer unset so the
-// endpoint 404s (the `daemon start --no-mcp` flag sets this on the spawned process).
-export const mcpEnabled = (env = process.env) => env['AGENTAGE_DAEMON_NO_MCP'] !== '1';
-// Unset/empty/invalid -> undefined (the watcher's defaults apply); the watcher floors low values.
-const envInt = (name) => {
-    const raw = process.env[name];
-    if (!raw)
-        return undefined;
-    const v = Number(raw);
-    return Number.isFinite(v) && v >= 0 ? v : undefined;
-};
-const state = createStateCleanup(() => {
-    removePidFile();
-    removePortFile();
-    removeTokenFile();
-});
-// The detached, long-lived engine host: one loopback HTTP server that owns a single in-process
-// engine and serialises every vault mutation, avoiding concurrent git index.lock collisions. It
-// runs the git sync loop and reschedules on config change.
-const main = async () => {
-    const port = resolvePort();
-    const authToken = generateDaemonToken();
-    const git = createSyncManager();
-    const discover = createDiscoverWatcher({
-        log: (msg) => console.log(`[discover] ${msg}`),
-        debounceMs: envInt('AGENTAGE_DISCOVER_DEBOUNCE_MS'),
-        pollMs: envInt('AGENTAGE_DISCOVER_POLL_MS'),
-    });
-    const server = createDaemonServer({
-        getClient: createClientProvider(),
-        buildMcpServer: mcpEnabled() ? loadLocalMemoryServer : undefined,
-        sync: {
-            status: () => ({ ...git.status(), discover: discover.status() }),
-            runNow: (vault) => git.runNow(vault),
-        },
-        authToken,
-        version: VERSION,
-    });
-    await server.start(port);
-    writePidFile(process.pid);
-    writePortFile(port);
-    writeTokenFile(authToken);
-    state.markOwned();
-    const reschedule = () => safeReschedule([() => git.reschedule(), () => discover.reschedule()], (msg) => console.error(`[daemon] reschedule failed: ${msg}`));
-    reschedule();
-    const configPath = vaultsJsonPath();
-    watchFile(configPath, { interval: 2000 }, reschedule);
-    const shutdown = () => {
-        unwatchFile(configPath);
-        git.stop();
-        discover.stop();
-        server.stop().finally(() => {
-            state.cleanup();
-            process.exit(0);
-        });
-    };
-    process.on('SIGTERM', shutdown);
-    process.on('SIGINT', shutdown);
-};
-// Boot the real daemon. Invoked by the bin (src/daemon-entry.ts) once the observability bootstrap
-// has run; importing this module for tests must never start a server.
-export const boot = () => {
-    process.on('uncaughtException', (err) => {
-        console.error(`[daemon] uncaught: ${err instanceof Error ? err.message : String(err)}`);
-        state.cleanup();
-        process.exit(1);
-    });
-    main().catch((err) => {
-        if (isEaddrinuse(err)) {
-            // Another daemon owns the port + our state files: exit distinctly, touch nothing.
-            process.exit(EADDRINUSE_EXIT_CODE);
-        }
-        console.error(err instanceof Error ? err.message : String(err));
-        state.cleanup();
-        process.exit(1);
-    });
-};

package/dist/daemon/guards.d.ts

@@ -1,3 +0,0 @@
-export declare const loopbackHosts: (port: number) => string[];
-export declare const isAllowedHost: (host: string | undefined, port: number) => boolean;
-export declare const isAllowedOrigin: (origin: string | undefined) => boolean;

package/dist/daemon/guards.js

@@ -1,13 +0,0 @@
-// Web-origin defense for the loopback daemon: a Host allow-list blocks DNS-rebinding (an attacker
-// domain that later resolves to 127.0.0.1 still sends its own Host), and an Origin allow-list blocks
-// a browser page from POSTing to the daemon. Both are pure so they unit-test without a socket.
-// The only Host values a genuine loopback client sends, pinned to the actually-bound port.
-export const loopbackHosts = (port) => [
-    `127.0.0.1:${port}`,
-    `localhost:${port}`,
-    `[::1]:${port}`,
-];
-export const isAllowedHost = (host, port) => host !== undefined && loopbackHosts(port).includes(host);
-// A missing Origin is fine (non-browser clients omit it); a present one must be loopback (any port).
-const LOOPBACK_ORIGIN = /^https?:\/\/(127\.0\.0\.1|localhost|\[::1\])(:\d+)?$/;
-export const isAllowedOrigin = (origin) => origin === undefined || LOOPBACK_ORIGIN.test(origin);

package/dist/daemon/lifecycle.d.ts

@@ -1,17 +0,0 @@
-export declare const DEFAULT_DAEMON_PORT = 4243;
-export declare const EADDRINUSE_EXIT_CODE = 3;
-export declare const writePidFile: (pid: number) => void;
-export declare const writePortFile: (port: number) => void;
-export declare const generateDaemonToken: () => string;
-export declare const writeTokenFile: (token: string) => void;
-export declare const readDaemonToken: () => string | null;
-export declare const removePidFile: () => void;
-export declare const removePortFile: () => void;
-export declare const removeTokenFile: () => void;
-export declare const resolvePort: () => number;
-export declare const isProcessAlive: (pid: number) => boolean;
-export declare const signalPid: (pid: number) => boolean;
-export declare const isDaemonRunning: () => boolean;
-export declare const stopDaemon: () => boolean;
-export declare const stopDaemonSafely: (probe?: (port: number) => Promise<number | null>) => Promise<boolean>;
-export declare const stopDaemonAndWait: (timeoutMs?: number) => Promise<boolean>;

package/dist/daemon/lifecycle.js

@@ -1,151 +0,0 @@
-import { randomBytes } from 'node:crypto';
-import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import chalk from 'chalk';
-import { getConfigDir } from '../lib/fs/config.js';
-// The daemon's on-disk state lives beside the config so an isolated AGENTAGE_CONFIG_DIR fully
-// isolates a daemon (pid, port, token) from any other - tests never collide with a real one.
-export const DEFAULT_DAEMON_PORT = 4243;
-// The daemon entry exits with this code on EADDRINUSE so a spawning CLI can short-circuit fast.
-export const EADDRINUSE_EXIT_CODE = 3;
-const pidPath = () => join(getConfigDir(), 'daemon.pid');
-const portPath = () => join(getConfigDir(), 'daemon.port');
-const tokenPath = () => join(getConfigDir(), 'daemon.token');
-export const writePidFile = (pid) => writeFileSync(pidPath(), String(pid), 'utf-8');
-export const writePortFile = (port) => writeFileSync(portPath(), String(port), 'utf-8');
-// A 256-bit per-daemon secret gating /api/*; only a same-machine client that can read the 0600
-// file (so, the same user) can call it, closing the loopback socket to any other local process.
-export const generateDaemonToken = () => randomBytes(32).toString('hex');
-export const writeTokenFile = (token) => writeFileSync(tokenPath(), token, { encoding: 'utf-8', mode: 0o600 });
-export const readDaemonToken = () => {
-    if (!existsSync(tokenPath()))
-        return null;
-    const token = readFileSync(tokenPath(), 'utf-8').trim();
-    return token.length > 0 ? token : null;
-};
-export const removePidFile = () => {
-    if (existsSync(pidPath()))
-        unlinkSync(pidPath());
-};
-export const removePortFile = () => {
-    if (existsSync(portPath()))
-        unlinkSync(portPath());
-};
-export const removeTokenFile = () => {
-    if (existsSync(tokenPath()))
-        unlinkSync(tokenPath());
-};
-const readNumberFile = (path) => {
-    if (!existsSync(path))
-        return null;
-    const n = Number.parseInt(readFileSync(path, 'utf-8').trim(), 10);
-    return Number.isNaN(n) ? null : n;
-};
-// Env override wins (test isolation); else the running daemon's recorded port; else the default.
-export const resolvePort = () => {
-    const env = process.env['AGENTAGE_DAEMON_PORT'];
-    if (env) {
-        const n = Number.parseInt(env, 10);
-        if (!Number.isNaN(n))
-            return n;
-    }
-    return readNumberFile(portPath()) ?? DEFAULT_DAEMON_PORT;
-};
-const readPid = () => readNumberFile(pidPath());
-export const isProcessAlive = (pid) => {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-};
-// SIGTERM a known-live pid (a legacy daemon we learned about via /health, not our pidfile).
-// Returns whether the signal was delivered; false when the pid is already gone or unsignalable.
-export const signalPid = (pid) => {
-    if (!isProcessAlive(pid))
-        return false;
-    try {
-        process.kill(pid, 'SIGTERM');
-        return true;
-    }
-    catch {
-        return false;
-    }
-};
-export const isDaemonRunning = () => {
-    const pid = readPid();
-    if (pid === null)
-        return false;
-    if (!isProcessAlive(pid)) {
-        removePidFile();
-        removePortFile();
-        removeTokenFile();
-        return false;
-    }
-    return true;
-};
-// SIGTERM the running daemon and clear its on-disk state; the daemon also self-cleans on exit.
-// Returns whether a live process was actually signalled.
-export const stopDaemon = () => {
-    const pid = readPid();
-    if (pid === null)
-        return false;
-    const alive = isProcessAlive(pid);
-    if (alive)
-        process.kill(pid, 'SIGTERM');
-    removePidFile();
-    removePortFile();
-    removeTokenFile();
-    return alive;
-};
-// Lightweight, cycle-free /health probe (daemon-client imports this module) returning the reported
-// pid; null when the port holds no reachable agentage daemon.
-const probeDaemonPid = async (port) => {
-    try {
-        const res = await fetch(`http://127.0.0.1:${port}/api/health`, {
-            signal: AbortSignal.timeout(500),
-        });
-        if (!res.ok)
-            return null;
-        const h = (await res.json());
-        return typeof h.pid === 'number' ? h.pid : null;
-    }
-    catch {
-        return null;
-    }
-};
-// stopDaemon signals a bare recorded pid, which the OS may have recycled onto an unrelated process.
-// Guard it: signal only when /health confirms the pid is our daemon, or - if no port was recorded -
-// fall back to the blind signal with a printed caveat. Refuse otherwise rather than kill a stranger.
-export const stopDaemonSafely = async (probe = probeDaemonPid) => {
-    const pid = readPid();
-    if (pid === null || !isProcessAlive(pid))
-        return stopDaemon();
-    const port = readNumberFile(portPath());
-    const confirmed = port !== null && (await probe(port)) === pid;
-    if (confirmed)
-        return stopDaemon();
-    if (port === null) {
-        console.error(chalk.yellow(`No recorded port; signalling pid ${pid} without confirmation.`));
-        return stopDaemon();
-    }
-    console.error(chalk.yellow(`Daemon on port ${port} did not confirm pid ${pid}; not signalling. Delete the pid file to force.`));
-    return false;
-};
-// Stop, then wait (bounded) for the old process to actually exit so a restart can rebind the
-// port without an EADDRINUSE window. Returns whether the process is confirmed gone.
-export const stopDaemonAndWait = async (timeoutMs = 2000) => {
-    const pid = readPid();
-    const signalled = stopDaemon();
-    if (!signalled || pid === null)
-        return true;
-    const deadline = Date.now() + timeoutMs;
-    while (isProcessAlive(pid)) {
-        if (Date.now() >= deadline)
-            return false;
-        await new Promise((r) => setTimeout(r, 50));
-    }
-    return true;
-};

package/dist/daemon/mcp-http.d.ts

@@ -1,3 +0,0 @@
-import { type IncomingMessage, type ServerResponse } from 'node:http';
-import { type McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-export declare const handleMcp: (req: IncomingMessage, res: ServerResponse, buildServer: () => Promise<McpServer>, allowedHosts: string[]) => Promise<void>;

package/dist/daemon/mcp-http.js

@@ -1,34 +0,0 @@
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-const jsonRpcError = (res, status, message) => {
-    res.writeHead(status, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({ jsonrpc: '2.0', error: { code: -32000, message }, id: null }));
-};
-// Stateless Streamable HTTP (JSON, no session), mirroring the cloud memory endpoint: a fresh MCP
-// server + transport per POST, torn down when the response closes. GET/DELETE are 405 - stateless
-// exposes no server-initiated SSE stream or session teardown. Tokenless (editor clients stay
-// simple) but DNS-rebinding-protected: allowedHosts pins the Host to the bound loopback port.
-export const handleMcp = async (req, res, buildServer, allowedHosts) => {
-    if (req.method !== 'POST') {
-        jsonRpcError(res, 405, 'Method not allowed: this endpoint is stateless (POST only).');
-        return;
-    }
-    const server = await buildServer();
-    const transport = new StreamableHTTPServerTransport({
-        sessionIdGenerator: undefined,
-        enableJsonResponse: true,
-        enableDnsRebindingProtection: true,
-        allowedHosts,
-    });
-    res.on('close', () => {
-        void transport.close();
-        void server.close();
-    });
-    try {
-        await server.connect(transport);
-        await transport.handleRequest(req, res);
-    }
-    catch {
-        if (!res.headersSent)
-            jsonRpcError(res, 500, 'Internal server error');
-    }
-};

package/dist/daemon/server.d.ts

@@ -1,23 +0,0 @@
-import { type Server } from 'node:http';
-import { type McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { type MemoryClient } from '../lib/memory/memory-client.js';
-import { type SyncResult } from '../sync/git/cycle.js';
-import { type SyncStatus } from '../sync/git/manager.js';
-export interface DaemonSyncApi {
-    status: () => SyncStatus;
-    runNow: (vault: string) => Promise<SyncResult>;
-}
-export interface DaemonServerOptions {
-    getClient: () => MemoryClient | Promise<MemoryClient>;
-    buildMcpServer?: () => Promise<McpServer>;
-    sync?: DaemonSyncApi;
-    authToken: string;
-    version: string;
-    startedAt?: number;
-}
-export interface DaemonServer {
-    server: Server;
-    start: (port: number, host?: string) => Promise<void>;
-    stop: () => Promise<void>;
-}
-export declare const createDaemonServer: (opts: DaemonServerOptions) => DaemonServer;