@agentage/cli 0.35.0 → 0.38.0

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;

package/dist/daemon/server.js

@@ -1,135 +0,0 @@
-import { createServer } from 'node:http';
-import { dispatchMemory, isMemoryVerb } from './actions.js';
-import { isAllowedHost, isAllowedOrigin, loopbackHosts } from './guards.js';
-import { handleMcp } from './mcp-http.js';
-const LOOPBACK = '127.0.0.1';
-const AUTH_HEADER = 'x-agentage-token';
-const readBody = (req) => new Promise((resolve, reject) => {
-    const chunks = [];
-    req.on('data', (c) => chunks.push(c));
-    req.on('end', () => {
-        const raw = Buffer.concat(chunks).toString('utf-8');
-        if (raw.length === 0)
-            return resolve({});
-        try {
-            resolve(JSON.parse(raw));
-        }
-        catch {
-            reject(new Error('invalid JSON body'));
-        }
-    });
-    req.on('error', reject);
-});
-const send = (res, status, body) => {
-    res.writeHead(status, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify(body));
-};
-const isJsonContentType = (req) => (req.headers['content-type'] ?? '').split(';')[0]?.trim() === 'application/json';
-const header = (req, name) => {
-    const v = req.headers[name];
-    return Array.isArray(v) ? v[0] : v;
-};
-// Loopback-only JSON HTTP: GET /api/health + POST /api/memory/<verb> (the CLI verbs) + POST /mcp
-// (the frozen 6 tools for on-machine AI clients, stateless Streamable HTTP). Web-origin defense on
-// EVERY request (Host + Origin allow-lists + DNS-rebinding protection on /mcp); /api/* additionally
-// needs the per-daemon token, while /health and /mcp stay tokenless for probes and editor clients.
-export const createDaemonServer = (opts) => {
-    const startedAt = opts.startedAt ?? Date.now();
-    let served = 0;
-    let boundPort = 0;
-    // 403 unless the request looks like it came from a genuine same-machine loopback client.
-    const originGuard = (req) => isAllowedHost(header(req, 'host'), boundPort) && isAllowedOrigin(header(req, 'origin'));
-    const handle = async (req, res) => {
-        const url = req.url ?? '/';
-        if (!originGuard(req))
-            return send(res, 403, { error: 'forbidden' });
-        const path = url.split('?')[0] ?? url;
-        const isApi = path.startsWith('/api/') && path !== '/api/health';
-        if (isApi && header(req, AUTH_HEADER) !== opts.authToken) {
-            return send(res, 401, { error: 'unauthorized' });
-        }
-        if (isApi && req.method === 'POST' && !isJsonContentType(req)) {
-            return send(res, 415, { error: 'unsupported media type' });
-        }
-        if (req.method === 'GET' && url === '/api/health') {
-            return send(res, 200, {
-                ok: true,
-                version: opts.version,
-                pid: process.pid,
-                uptime: Math.floor((Date.now() - startedAt) / 1000),
-                served,
-                mcp: !!opts.buildMcpServer,
-            });
-        }
-        if (path === '/mcp') {
-            if (!opts.buildMcpServer)
-                return send(res, 404, { error: 'not found' });
-            return handleMcp(req, res, opts.buildMcpServer, loopbackHosts(boundPort));
-        }
-        if (req.method === 'GET' && url === '/api/sync/status') {
-            if (!opts.sync)
-                return send(res, 404, { error: 'not found' });
-            return send(res, 200, opts.sync.status());
-        }
-        if (req.method === 'POST' && url === '/api/sync/run') {
-            if (!opts.sync)
-                return send(res, 404, { error: 'not found' });
-            const body = (await readBody(req));
-            if (!body.vault)
-                return send(res, 400, { error: 'vault is required' });
-            try {
-                return send(res, 200, await opts.sync.runNow(body.vault));
-            }
-            catch (err) {
-                return send(res, 400, { error: err instanceof Error ? err.message : String(err) });
-            }
-        }
-        const match = url.match(/^\/api\/memory\/([a-z]+)$/);
-        if (req.method === 'POST' && match) {
-            const verb = match[1];
-            if (!isMemoryVerb(verb))
-                return send(res, 404, { error: `unknown verb: ${verb}` });
-            try {
-                const body = await readBody(req);
-                const result = await dispatchMemory(await opts.getClient(), verb, body);
-                served += 1;
-                return send(res, 200, result);
-            }
-            catch (err) {
-                return send(res, 400, { error: err instanceof Error ? err.message : String(err) });
-            }
-        }
-        send(res, 404, { error: 'not found' });
-    };
-    const server = createServer((req, res) => {
-        handle(req, res).catch((err) => send(res, 500, { error: err instanceof Error ? err.message : String(err) }));
-    });
-    const start = (port, host = LOOPBACK) => new Promise((resolve, reject) => {
-        const onError = (err) => {
-            if (err.code !== 'EADDRINUSE')
-                return reject(err);
-            // Preserve the code so the entry point can exit distinctly on a busy port.
-            const busy = new Error(`port ${port} already in use`);
-            busy.code = 'EADDRINUSE';
-            reject(busy);
-        };
-        server.once('error', onError);
-        server.listen(port, host, () => {
-            const addr = server.address();
-            boundPort = typeof addr === 'object' && addr ? addr.port : port;
-            server.removeListener('error', onError);
-            resolve();
-        });
-    });
-    // close() alone hangs on idle keep-alive sockets; drop idle ones now, force the rest after a grace.
-    const stop = () => new Promise((resolve) => {
-        server.closeIdleConnections();
-        const grace = setTimeout(() => server.closeAllConnections(), 500);
-        grace.unref();
-        server.close(() => {
-            clearTimeout(grace);
-            resolve();
-        });
-    });
-    return { server, start, stop };
-};

package/dist/daemon-entry.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/daemon-entry.js

@@ -1,9 +0,0 @@
-// The daemon's bin, a loader and nothing else: @agentage/observability instruments node:http and
-// MCP tool registration through module hooks that only see modules imported after they register, so
-// the bootstrap runs before the daemon itself is loaded. The path stays src/daemon-entry.ts because
-// spawnDaemon resolves dist/daemon-entry.js.
-const { DAEMON_SERVICE, startObservability } = await import('./observability.js');
-await startObservability(DAEMON_SERVICE);
-const { boot } = await import('./daemon/entry.js');
-boot();
-export {};

package/dist/lib/auth/provision.d.ts

@@ -1,14 +0,0 @@
-import { type AuthState } from '../fs/config.js';
-import { type Links } from '../net/origins.js';
-export type ProvisionStatus = 'provisioned' | 'exists' | 'unauthenticated' | 'offline';
-export interface ProvisionResult {
-    status: ProvisionStatus;
-    message: string;
-}
-export interface ProvisionDeps {
-    readAuth: () => AuthState | null;
-    links: () => Links;
-    post: (auth: AuthState, links: Links, url: string, body: unknown) => Promise<Response>;
-}
-export declare const defaultProvisionDeps: () => ProvisionDeps;
-export declare const provisionAccountVault: (name: string, deps?: ProvisionDeps) => Promise<ProvisionResult>;

package/dist/lib/auth/provision.js

@@ -1,49 +0,0 @@
-import { authedPost } from './api.js';
-import { readAuth } from '../fs/config.js';
-import { links as buildLinks, siteFqdn } from '../net/origins.js';
-export const defaultProvisionDeps = () => ({
-    readAuth,
-    links: () => buildLinks(siteFqdn()),
-    post: authedPost,
-});
-const registeredLocally = (name, tail) => `Vault '${name}' registered locally${tail}`;
-export const provisionAccountVault = async (name, deps = defaultProvisionDeps()) => {
-    const auth = deps.readAuth();
-    if (!auth) {
-        return {
-            status: 'unauthenticated',
-            message: registeredLocally(name, ' - run `agentage setup` to create it in your account.'),
-        };
-    }
-    // A PAT is an MCP-surface credential; the backend REST provisioning endpoint rejects plain
-    // bearers (only session cookies), so it cannot create the account memory. Fail clearly.
-    if (auth.kind === 'pat') {
-        return {
-            status: 'unauthenticated',
-            message: registeredLocally(name, ' - account provisioning needs an interactive session (run `agentage setup`); ' +
-                'a personal access token only authorizes memory (MCP) calls.'),
-        };
-    }
-    const links = deps.links();
-    let res;
-    try {
-        res = await deps.post(auth, links, `${links.api}/memories`, { name });
-    }
-    catch {
-        return {
-            status: 'offline',
-            message: registeredLocally(name, ' - will provision when online.'),
-        };
-    }
-    if (res.status === 201)
-        return { status: 'provisioned', message: `Provisioned account vault '${name}'.` };
-    if (res.status === 200)
-        return { status: 'exists', message: `Account vault '${name}' already provisioned.` };
-    if (res.status === 401)
-        return {
-            status: 'unauthenticated',
-            message: registeredLocally(name, ' - run `agentage setup` to create it in your account.'),
-        };
-    // Any other status stays non-fatal: keep the local entry, let the daemon retry later.
-    return { status: 'offline', message: registeredLocally(name, ' - will provision when online.') };
-};

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

@@ -1,37 +0,0 @@
-import { type SyncResult } from '../../sync/git/cycle.js';
-import { type SyncStatus } from '../../sync/git/manager.js';
-import { type MemoryClient } from '../memory/memory-client.js';
-export interface Health {
-    ok: boolean;
-    version: string;
-    pid: number;
-    uptime: number;
-    served: number;
-    mcp?: boolean;
-}
-export declare const health: (port: number, timeoutMs?: number) => Promise<Health | null>;
-export declare const syncStatus: (port: number, timeoutMs?: number) => Promise<SyncStatus | null>;
-export declare const syncRun: (port: number, vault: string) => Promise<SyncResult>;
-export declare const waitForHealth: (port: number, opts?: {
-    timeoutMs?: number;
-    intervalMs?: number;
-}) => Promise<boolean>;
-export declare const createDaemonClient: (port: number) => MemoryClient;
-export declare const mismatchNotice: (daemonVersion: string) => string | null;
-export type SpawnOutcome = {
-    ok: true;
-} | {
-    ok: false;
-    reason: 'port-in-use' | 'unreachable' | 'blocked';
-};
-export declare const spawnDaemon: (port: number, opts?: {
-    timeoutMs?: number;
-    noMcp?: boolean;
-}) => Promise<SpawnOutcome>;
-export interface EnsureDeps {
-    port?: number;
-    probe?: (port: number) => Promise<Health | null>;
-    spawn?: (port: number) => Promise<SpawnOutcome>;
-    readToken?: () => string | null;
-}
-export declare const ensureDaemon: (deps?: EnsureDeps) => Promise<MemoryClient | null>;