@agentage/cli 0.37.2 → 0.38.1

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>;

package/dist/lib/daemon/daemon-client.js

@@ -1,136 +0,0 @@
-import { spawn as spawnChild } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import chalk from 'chalk';
-import { EADDRINUSE_EXIT_CODE, readDaemonToken, resolvePort } from '../../daemon/lifecycle.js';
-import { daemonServiceName } from '../../observability.js';
-import { VERSION } from '../../utils/version.js';
-const base = (port) => `http://127.0.0.1:${port}`;
-// The 0600 token file is the daemon's auth: read it fresh per call so a restart's new token is
-// picked up; absent means we cannot authenticate, so /api/* will 401 and callers fall back.
-const apiHeaders = () => {
-    const token = readDaemonToken();
-    return { 'Content-Type': 'application/json', ...(token ? { 'X-Agentage-Token': token } : {}) };
-};
-const post = async (port, verb, body) => {
-    const res = await fetch(`${base(port)}/api/memory/${verb}`, {
-        method: 'POST',
-        headers: apiHeaders(),
-        body: JSON.stringify(body),
-    });
-    if (!res.ok) {
-        const data = (await res.json().catch(() => ({})));
-        throw new Error(data.error || `daemon request failed: ${res.status}`);
-    }
-    return res.json();
-};
-export const health = async (port, timeoutMs = 1000) => {
-    try {
-        const res = await fetch(`${base(port)}/api/health`, {
-            signal: AbortSignal.timeout(timeoutMs),
-        });
-        return res.ok ? (await res.json()) : null;
-    }
-    catch {
-        return null;
-    }
-};
-// Read the daemon's per-vault sync state (last run, last error); null when the endpoint is absent
-// (an older daemon) or unreachable.
-export const syncStatus = async (port, timeoutMs = 1000) => {
-    try {
-        const res = await fetch(`${base(port)}/api/sync/status`, {
-            headers: apiHeaders(),
-            signal: AbortSignal.timeout(timeoutMs),
-        });
-        return res.ok ? (await res.json()) : null;
-    }
-    catch {
-        return null;
-    }
-};
-// Ask the daemon to sync one vault now; the daemon runs the git cycle in its own process.
-export const syncRun = async (port, vault) => {
-    const res = await fetch(`${base(port)}/api/sync/run`, {
-        method: 'POST',
-        headers: apiHeaders(),
-        body: JSON.stringify({ vault }),
-    });
-    if (!res.ok) {
-        const data = (await res.json().catch(() => ({})));
-        throw new Error(data.error || `sync request failed: ${res.status}`);
-    }
-    return res.json();
-};
-export const waitForHealth = async (port, opts = {}) => {
-    const intervalMs = opts.intervalMs ?? 100;
-    const deadline = Date.now() + (opts.timeoutMs ?? 4000);
-    while (Date.now() < deadline) {
-        if (await health(port, intervalMs + 200))
-            return true;
-        await new Promise((r) => setTimeout(r, intervalMs));
-    }
-    return false;
-};
-// A thin MemoryClient over HTTP: every method is a pass-through POST; the daemon's in-process
-// DirectClient does the vault scoping, so the wire carries the raw ref + opts unchanged.
-export const createDaemonClient = (port) => ({
-    search: (query, opts) => post(port, 'search', { query, opts }),
-    read: (ref, opts) => post(port, 'read', { ref, opts }),
-    write: (ref, body, opts) => post(port, 'write', { ref, body, opts }),
-    edit: (ref, op, opts) => post(port, 'edit', { ref, op, opts }),
-    list: (folder, opts) => post(port, 'list', { folder, opts }),
-    delete: (ref, opts) => post(port, 'delete', { ref, opts }),
-});
-// A restart hint when the running daemon predates the current binary.
-export const mismatchNotice = (daemonVersion) => daemonVersion === VERSION
-    ? null
-    : `daemon version ${daemonVersion} != cli ${VERSION}; restart with: agentage daemon stop && agentage daemon start`;
-const entryPath = () => fileURLToPath(new URL('../../daemon-entry.js', import.meta.url));
-// Detached spawn (not fork: fork's IPC channel keeps the parent event loop alive past unref) so
-// the daemon outlives this CLI; ignore stdio + unref so the CLI can exit. Watches the child's exit
-// so a fast EADDRINUSE death short-circuits the health wait instead of burning the full timeout.
-export const spawnDaemon = async (port, opts = {}) => {
-    let child;
-    try {
-        child = spawnChild(process.execPath, [entryPath()], {
-            detached: true,
-            stdio: 'ignore',
-            env: {
-                ...process.env,
-                AGENTAGE_DAEMON_PORT: String(port),
-                // Its own service in telemetry: never inherit the name we defaulted into the CLI's env.
-                OTEL_SERVICE_NAME: daemonServiceName(),
-                ...(opts.noMcp ? { AGENTAGE_DAEMON_NO_MCP: '1' } : {}),
-            },
-        });
-    }
-    catch {
-        return { ok: false, reason: 'blocked' };
-    }
-    const exited = new Promise((resolve) => {
-        child.once('exit', (code) => resolve({ ok: false, reason: code === EADDRINUSE_EXIT_CODE ? 'port-in-use' : 'unreachable' }));
-    });
-    child.unref();
-    const healthy = waitForHealth(port, { timeoutMs: opts.timeoutMs ?? 4000 }).then((ok) => (ok ? { ok: true } : { ok: false, reason: 'unreachable' }));
-    return Promise.race([healthy, exited]);
-};
-// DO3/DO4/DO9: prefer a live daemon, autostart one if absent, and return null when it is
-// unreachable, cannot be spawned, or has no readable token (nothing to authenticate with) so the
-// caller falls back to the in-process DirectClient.
-export const ensureDaemon = async (deps = {}) => {
-    const port = deps.port ?? resolvePort();
-    const probe = deps.probe ?? health;
-    const spawn = deps.spawn ?? spawnDaemon;
-    const readToken = deps.readToken ?? readDaemonToken;
-    const existing = await probe(port);
-    if (existing) {
-        if (!readToken())
-            return null;
-        const notice = mismatchNotice(existing.version);
-        if (notice)
-            console.error(chalk.yellow(notice));
-        return createDaemonClient(port);
-    }
-    const outcome = await spawn(port).catch(() => ({ ok: false, reason: 'blocked' }));
-    return outcome.ok && readToken() ? createDaemonClient(port) : null;
-};

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

@@ -1,2 +0,0 @@
-export declare const disableDaemon: () => void;
-export declare const daemonDisabled: () => boolean;

package/dist/lib/daemon/daemon-pref.js

@@ -1,10 +0,0 @@
-// Whether the memory verbs must run in-process (DirectClient) instead of via the daemon.
-// Set by the `--no-daemon` global flag or AGENTAGE_NO_DAEMON=1 (tests/sandbox/CI).
-let forced = false;
-export const disableDaemon = () => {
-    forced = true;
-};
-export const daemonDisabled = () => {
-    const env = process.env['AGENTAGE_NO_DAEMON'];
-    return forced || env === '1' || env === 'true';
-};

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

@@ -1,30 +0,0 @@
-import { type EditInput, type ListResult, type MemoryView, type SearchResult, type VaultsConfig, type WriteResult } from '@agentage/memory-core';
-export interface DeleteResult {
-    path: string;
-    deleted: boolean;
-}
-export declare const translateEngineMessage: (message: string) => string;
-export interface VerbOptions {
-    vault?: string;
-}
-export interface SearchOptions extends VerbOptions {
-    folder?: string;
-    limit?: number;
-    tags?: string[];
-    cursor?: string;
-}
-export interface ListOptions extends VerbOptions {
-    depth?: 1 | 2;
-    tags?: string[];
-}
-export interface MemoryClient {
-    search(query: string, opts?: SearchOptions): Promise<SearchResult>;
-    read(ref: string, opts?: VerbOptions): Promise<MemoryView>;
-    write(ref: string, body: string, opts?: VerbOptions & {
-        frontmatter?: Record<string, unknown>;
-    }): Promise<WriteResult>;
-    edit(ref: string, op: Omit<EditInput, 'path'>, opts?: VerbOptions): Promise<WriteResult>;
-    list(folder: string | undefined, opts?: ListOptions): Promise<ListResult>;
-    delete(ref: string, opts?: VerbOptions): Promise<DeleteResult>;
-}
-export declare const createDirectClient: (config: VaultsConfig) => MemoryClient;

package/dist/lib/memory/memory-client.js

@@ -1,98 +0,0 @@
-import { createRegistry, createRouter, } from '@agentage/memory-core';
-// Engine (memory-core) messages leak MCP tool vocabulary (`memory__list`, ...) unfit for a terminal.
-// Rewrite the known patterns to CLI vocabulary at this seam; do not fork the engine.
-const ENGINE_MESSAGE_MAP = [
-    [
-        /Use memory__list with no folder to see available vaults\.?/g,
-        'Run `agentage vault list` to see available vaults.',
-    ],
-];
-export const translateEngineMessage = (message) => ENGINE_MESSAGE_MAP.reduce((m, [pattern, replacement]) => m.replace(pattern, replacement), message);
-// --vault becomes an @-prefix so the router resolves it; an explicit @<vault>/... passes through.
-const scopeRef = (ref, vault) => ref.startsWith('@') ? ref : vault ? `@${vault}/${ref}` : ref;
-const scopeFolder = (folder, vault) => {
-    if (vault)
-        return folder ? `@${vault}/${folder}` : `@${vault}`;
-    return folder || undefined;
-};
-export const createDirectClient = (config) => {
-    let ctxP;
-    const ctx = () => {
-        if (!ctxP) {
-            ctxP = (async () => {
-                const registry = await createRegistry(config);
-                // Offline engine: only local (git working-copy) backends are usable here.
-                const local = registry.list().filter((h) => h.backend.capabilities().kind === 'local');
-                if (local.length === 0)
-                    throw new Error('no local vaults registered - run `agentage vault add <name> --local`');
-                const def = registry.default();
-                const defaultHandle = def && local.some((h) => h.id === def.id) ? def : undefined;
-                return {
-                    router: createRouter(local, defaultHandle),
-                    multi: local.length > 1,
-                    hasDefault: !!defaultHandle,
-                };
-            })();
-            ctxP.catch(() => (ctxP = undefined));
-        }
-        return ctxP;
-    };
-    // A single-target verb on a bare ref needs a vault when >1 is registered and none is default.
-    const requireTarget = (ref, c) => {
-        if (c.multi && !c.hasDefault && !ref.startsWith('@'))
-            throw new Error('multiple vaults - use --vault <name>, @<vault>/<path>, or set "default" in vaults.json');
-    };
-    return {
-        async search(query, opts = {}) {
-            const { router } = await ctx();
-            return router.search({
-                query,
-                folder: scopeFolder(opts.folder, opts.vault),
-                tags: opts.tags,
-                limit: opts.limit,
-                cursor: opts.cursor,
-            });
-        },
-        async read(ref, opts = {}) {
-            const c = await ctx();
-            const target = scopeRef(ref, opts.vault);
-            requireTarget(target, c);
-            const view = await c.router.read(target);
-            if (!view)
-                throw new Error(`not found: ${ref}`);
-            return view;
-        },
-        async write(ref, body, opts = {}) {
-            const c = await ctx();
-            const target = scopeRef(ref, opts.vault);
-            requireTarget(target, c);
-            return c.router.write({ path: target, body, frontmatter: opts.frontmatter });
-        },
-        async edit(ref, op, opts = {}) {
-            const c = await ctx();
-            const target = scopeRef(ref, opts.vault);
-            requireTarget(target, c);
-            const receipt = await c.router.edit({ ...op, path: target });
-            if (!receipt)
-                throw new Error(`not found: ${ref}`);
-            return receipt;
-        },
-        async list(folder, opts = {}) {
-            const { router } = await ctx();
-            return router.list({
-                folder: scopeFolder(folder, opts.vault),
-                depth: opts.depth,
-                tags: opts.tags,
-            });
-        },
-        async delete(ref, opts = {}) {
-            const c = await ctx();
-            const target = scopeRef(ref, opts.vault);
-            requireTarget(target, c);
-            const deleted = await c.router.delete(target);
-            if (!deleted)
-                throw new Error(`not found: ${ref}`);
-            return { path: target, deleted };
-        },
-    };
-};

package/dist/lib/status/format.d.ts

@@ -1 +0,0 @@
-export declare const formatUptime: (seconds: number) => string;

package/dist/lib/status/format.js

@@ -1,12 +0,0 @@
-// Compact "Hh Mm" / "Mm Ss" uptime, matching the daemon and status rows. Seconds only under a
-// minute; hours dropped once zero so short-lived daemons read cleanly.
-export const formatUptime = (seconds) => {
-    const s = Math.max(0, Math.floor(seconds));
-    if (s < 60)
-        return `${s}s`;
-    const h = Math.floor(s / 3600);
-    const m = Math.floor((s % 3600) / 60);
-    if (h > 0)
-        return `${h}h ${m}m`;
-    return `${m}m ${s % 60}s`;
-};

package/dist/lib/status/vaults-format.d.ts

@@ -1,2 +0,0 @@
-import { type VaultStatus } from './vaults-status.js';
-export declare const vaultLines: (vaults: VaultStatus[]) => string[];

package/dist/lib/status/vaults-format.js

@@ -1,49 +0,0 @@
-import chalk from 'chalk';
-const mark = (good) => (good ? chalk.green('✓') : chalk.red('✗'));
-// HH:MM in local time; a malformed timestamp falls back to the raw string so we never crash.
-const shortTime = (iso) => {
-    if (!iso)
-        return '';
-    const d = new Date(iso);
-    return Number.isNaN(d.getTime())
-        ? iso
-        : `${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`;
-};
-const shortError = (err) => (err ?? 'sync failed').split('\n')[0]?.slice(0, 40) ?? 'sync failed';
-// One right-hand status cell per vault, sharing the check/cross marks with the other status rows.
-const statusCell = (v) => {
-    switch (v.status) {
-        case 'ok':
-            return `${mark(true)} last ok ${shortTime(v.lastRun)}`.trimEnd();
-        case 'syncing':
-            return `${chalk.yellow('⋯')} syncing`;
-        case 'error':
-            return `${mark(false)} error (${shortError(v.lastError)})`;
-        case 'unknown':
-            return chalk.dim('- unknown (daemon stopped)');
-        case 'unsynced':
-            return `${mark(false)} not synced - account vaults have no sync channel`;
-        case 'idle':
-            return v.channel === 'local' ? chalk.dim('- local only') : chalk.dim('- idle');
-    }
-};
-// Only git vaults are "connected": an account vault has no sync channel, so counting it would
-// re-tell the lie the per-vault row exists to correct.
-const countLabel = (vaults) => {
-    const connected = vaults.filter((v) => v.channel === 'git').length;
-    if (connected > 0)
-        return `${connected} connected`;
-    const n = vaults.length;
-    return `${n} ${n === 1 ? 'vault' : 'vaults'}`;
-};
-// The `vaults` block: a header count line then one aligned `<name> <channel> <status>` row per vault.
-// Zero vaults prints a single actionable hint instead of an empty block.
-export const vaultLines = (vaults) => {
-    if (vaults.length === 0)
-        return [`${'vaults'.padEnd(10)} none - run: agentage vault add <name> --local`];
-    const nameW = Math.max(...vaults.map((v) => v.name.length));
-    const chanW = Math.max(...vaults.map((v) => v.channel.length));
-    const header = `${'vaults'.padEnd(10)} ${countLabel(vaults)}`;
-    const rows = vaults.map((v) => `  ${v.name.padEnd(nameW)}  ${v.channel.padEnd(chanW)} ${statusCell(v)}`);
-    return [header, ...rows];
-};

package/dist/lib/status/vaults-status.d.ts

@@ -1,12 +0,0 @@
-import { type VaultsConfig } from '@agentage/memory-core';
-import { type SyncStatus } from '../../sync/git/manager.js';
-export type VaultChannel = 'local' | 'git' | 'account';
-export type VaultSyncState = 'ok' | 'syncing' | 'error' | 'idle' | 'unknown' | 'unsynced';
-export interface VaultStatus {
-    name: string;
-    channel: VaultChannel;
-    status: VaultSyncState;
-    lastRun?: string;
-    lastError?: string;
-}
-export declare const buildVaultStatuses: (sync: SyncStatus | null, daemonUp: boolean, config?: VaultsConfig) => VaultStatus[];