@agentage/cli 0.26.0 → 0.27.0

package/dist/sync/couch/cycle.js

@@ -1,58 +0,0 @@
-import { ensureWire, pendingCount } from './wire.js';
-// One couch cycle: commit dirty local truth first, drain queued pushes/deletions, then push+pull.
-// Every failure is caught and recorded (lastError / paused); it never throws to the caller.
-export const runCouchCycle = async (rt, st) => {
-    const vault = st.target.vault;
-    const build = (extra) => ({
-        vault,
-        channel: 'couch',
-        ok: true,
-        committed: false,
-        pulled: false,
-        pendingCount: pendingCount(st),
-        ...extra,
-    });
-    if (st.running)
-        return build({});
-    st.running = true;
-    try {
-        const bearer = await rt.getBearer();
-        if (!bearer) {
-            st.paused = 'signed out';
-            st.lastError = undefined;
-            return build({ paused: 'signed out' });
-        }
-        const decision = await rt.discovery.channelFor(vault, bearer);
-        if (decision.kind === 'paused') {
-            st.paused = decision.reason;
-            st.lastError = undefined;
-            return build({ paused: decision.reason });
-        }
-        st.paused = undefined;
-        const couch = await ensureWire(rt, st, decision);
-        const pre = await rt.commitDirty(st.target.path, `sync: ${rt.nowIso()}`);
-        await couch.flushPending(); // drain queued pushes AND queued deletions first
-        const res = await couch.syncNow(); // pushAll + reconcile deletions, then pullOnce
-        const post = await rt.commitDirty(st.target.path, `sync: couch ${rt.nowIso()}`);
-        if (res.error) {
-            st.lastError = res.error;
-            return build({
-                ok: false,
-                committed: pre.committed,
-                pulled: post.committed,
-                error: res.error,
-            });
-        }
-        st.lastSync = rt.nowIso();
-        st.lastError = undefined;
-        return build({ committed: pre.committed, pulled: post.committed });
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        st.lastError = msg;
-        return build({ ok: false, error: msg });
-    }
-    finally {
-        st.running = false;
-    }
-};

package/dist/sync/couch/discovery.d.ts

@@ -1,22 +0,0 @@
-import { type FetchJson } from '@agentage/memory-core';
-import { type ProvisionResult } from '../../lib/auth/provision.js';
-export type ChannelDecision = {
-    kind: 'couch';
-    endpoint: string;
-    db: string;
-    tokenUrl: string;
-} | {
-    kind: 'paused';
-    reason: string;
-};
-export interface DiscoveryDeps {
-    bootstrapHost: string;
-    fetchJson: FetchJson;
-    provision: (vault: string) => Promise<ProvisionResult>;
-    now?: () => number;
-}
-export interface Discovery {
-    channelFor(vault: string, token: string): Promise<ChannelDecision>;
-    reset(): void;
-}
-export declare const createDiscovery: (deps: DiscoveryDeps) => Discovery;

package/dist/sync/couch/discovery.js

@@ -1,34 +0,0 @@
-import { channelForVault, HostResolver } from '@agentage/memory-core';
-const pausedReason = (prov) => {
-    switch (prov.status) {
-        case 'disabled':
-            return 'account sync is not enabled on this server';
-        case 'conflict':
-            return 'name conflicts with a memory on another channel';
-        case 'unauthenticated':
-            return 'signed out';
-        default:
-            return 'provisioning - will retry';
-    }
-};
-export const createDiscovery = (deps) => {
-    const resolver = new HostResolver(deps.bootstrapHost, deps.fetchJson, deps.now ?? Date.now);
-    const toCouch = (ch) => ch.channel === 'couch'
-        ? { kind: 'couch', endpoint: ch.endpoint, db: ch.db, tokenUrl: ch.tokenUrl }
-        : null;
-    return {
-        async channelFor(vault, token) {
-            const first = toCouch(channelForVault(await resolver.resolve(token), vault));
-            if (first)
-                return first;
-            // Missing from couch_vaults: provision once, refresh discovery once, re-check.
-            const prov = await deps.provision(vault);
-            resolver.invalidate();
-            const second = toCouch(channelForVault(await resolver.resolve(token), vault));
-            return second ?? { kind: 'paused', reason: pausedReason(prov) };
-        },
-        reset() {
-            resolver.invalidate();
-        },
-    };
-};

package/dist/sync/couch/file-store.d.ts

@@ -1,2 +0,0 @@
-import { type FileStore } from '@agentage/memory-core';
-export declare const createFileStore: (root: string) => FileStore;

package/dist/sync/couch/file-store.js

@@ -1,47 +0,0 @@
-import { existsSync } from 'node:fs';
-import { mkdir, readdir, readFile, rm, writeFile } from 'node:fs/promises';
-import { dirname, join, relative, sep } from 'node:path';
-// The couch channel speaks vault-relative POSIX paths; on Windows the fs layer still uses `\`.
-const toPosix = (p) => (sep === '/' ? p : p.split(sep).join('/'));
-const fromPosix = (p) => (sep === '/' ? p : p.split('/').join(sep));
-// Recursively collect *.md under root as vault-relative POSIX paths. Dot-directories are skipped -
-// `.git` (the engine's own repo) must never enter the content-addressed model, and editor state
-// like `.obsidian/` holds no synced notes; this mirrors memory-core's own local listing.
-const walk = async (root, dir, acc) => {
-    const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
-    for (const e of entries) {
-        if (e.name.startsWith('.'))
-            continue;
-        const abs = join(dir, e.name);
-        if (e.isDirectory())
-            await walk(root, abs, acc);
-        else if (e.isFile() && e.name.endsWith('.md'))
-            acc.push(toPosix(relative(root, abs)));
-    }
-};
-// A FileStore rooted at one account vault's mirror dir: the seam CouchSync reads/writes through.
-export const createFileStore = (root) => ({
-    async listMarkdown() {
-        if (!existsSync(root))
-            return [];
-        const acc = [];
-        await walk(root, root, acc);
-        return acc.sort();
-    },
-    async read(path) {
-        try {
-            return await readFile(join(root, fromPosix(path)), 'utf8');
-        }
-        catch {
-            return null; // gone from the file set
-        }
-    },
-    async write(path, body) {
-        const abs = join(root, fromPosix(path));
-        await mkdir(dirname(abs), { recursive: true });
-        await writeFile(abs, body, 'utf8');
-    },
-    async remove(path) {
-        await rm(join(root, fromPosix(path)), { force: true });
-    },
-});

package/dist/sync/couch/local-commit.d.ts

@@ -1,2 +0,0 @@
-import { type CommitOutcome } from './manager.types.js';
-export declare const gitCommitDirty: (path: string, message: string) => Promise<CommitOutcome>;

package/dist/sync/couch/local-commit.js

@@ -1,24 +0,0 @@
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { createSyncGit, GitError } from '../git/git-exec.js';
-// The default local-git commit: stage everything and make one commit when the tree is dirty. An
-// index.lock collision (the engine mid-mutation) is a clean skip - the change stays for next cycle.
-export const gitCommitDirty = async (path, message) => {
-    if (!existsSync(path))
-        return { committed: false, skipped: false };
-    const git = createSyncGit(path);
-    try {
-        if (!existsSync(join(path, '.git')))
-            await git.run(['init', '-b', 'main']);
-        await git.run(['add', '-A']);
-        if ((await git.exec(['diff', '--cached', '--quiet'])).code === 0)
-            return { committed: false, skipped: false };
-        await git.run(['commit', '-m', message]);
-        return { committed: true, skipped: false };
-    }
-    catch (err) {
-        if (err instanceof GitError && err.kind === 'lock')
-            return { committed: false, skipped: true };
-        throw err;
-    }
-};

package/dist/sync/couch/manager.d.ts

@@ -1,4 +0,0 @@
-import { type CouchSyncManager, type CouchSyncManagerDeps } from './manager.types.js';
-export { type CouchSyncManager, type CouchSyncManagerDeps, type CouchSyncResult, type CouchTargetStatus, } from './manager.types.js';
-export { resolveMutationTarget } from './mutation-target.js';
-export declare const createCouchSyncManager: (deps?: CouchSyncManagerDeps) => CouchSyncManager;

package/dist/sync/couch/manager.fixtures.d.ts

@@ -1,20 +0,0 @@
-import { type FileStore, type VaultsConfig } from '@agentage/memory-core';
-import { type ChannelDecision, type Discovery } from './discovery.js';
-import { type CouchSyncManagerDeps } from './manager.js';
-export declare const config: VaultsConfig;
-export declare const autoConfig: VaultsConfig;
-export declare const noopStore: () => FileStore;
-export declare const couchDecision: ChannelDecision;
-export declare const makeManager: (over?: Partial<CouchSyncManagerDeps>) => {
-    mgr: import("./manager.types.js").CouchSyncManager;
-    couch: {
-        pushFileLive: import("vitest").Mock<() => Promise<void>>;
-        removeFile: import("vitest").Mock<() => Promise<void>>;
-        flushPending: import("vitest").Mock<() => Promise<void>>;
-        syncNow: import("vitest").Mock<() => Promise<{
-            pushed: boolean;
-            pulled: boolean;
-        }>>;
-    };
-    discovery: Discovery;
-};

package/dist/sync/couch/manager.fixtures.js

@@ -1,56 +0,0 @@
-import { vi } from 'vitest';
-import { createCouchSyncManager } from './manager.js';
-export const config = {
-    version: 1,
-    default: 'acct',
-    vaults: {
-        acct: { path: '/tmp/acct', origin: [{ remote: 'agentage', interval: 0 }] },
-        git: { path: '/tmp/git', origin: [{ remote: 'git@h:g.git' }] },
-        local: { path: '/tmp/local' },
-    },
-};
-export const autoConfig = {
-    version: 1,
-    default: 'acct',
-    vaults: {
-        acct: { path: '/tmp/acct', origin: [{ remote: 'agentage', interval: 300 }] },
-        two: { path: '/tmp/two', origin: [{ remote: 'agentage', interval: 300 }] },
-    },
-};
-export const noopStore = () => ({
-    listMarkdown: async () => [],
-    read: async () => null,
-    write: async () => { },
-    remove: async () => { },
-});
-export const couchDecision = {
-    kind: 'couch',
-    endpoint: 'https://couch.test',
-    db: 'mem_acct',
-    tokenUrl: 'https://auth.test/couch-token',
-};
-export const makeManager = (over = {}) => {
-    const couch = {
-        pushFileLive: vi.fn(async () => { }),
-        removeFile: vi.fn(async () => { }),
-        flushPending: vi.fn(async () => { }),
-        syncNow: vi.fn(async () => ({ pushed: true, pulled: true })),
-    };
-    const discovery = {
-        channelFor: vi.fn(async () => couchDecision),
-        reset: vi.fn(),
-    };
-    const mgr = createCouchSyncManager({
-        getConfig: () => config,
-        configDir: () => '/tmp/cfg',
-        getBearer: async () => 'tok',
-        discovery,
-        makeCouchSync: () => couch,
-        makeFileStore: noopStore,
-        makeStatePersistence: () => ({ load: async () => null, save: async () => { } }),
-        commitDirty: async () => ({ committed: false, skipped: false }),
-        now: () => '2026-01-01T00:00:00Z',
-        ...over,
-    });
-    return { mgr, couch, discovery };
-};

package/dist/sync/couch/manager.js

@@ -1,126 +0,0 @@
-import { CouchSync } from '@agentage/memory-core';
-import { currentBearer } from '../../lib/auth/api.js';
-import { getConfigDir, readAuth } from '../../lib/fs/config.js';
-import { links, siteFqdn } from '../../lib/net/origins.js';
-import { requestHeaders } from '../../lib/net/user-agent.js';
-import { defaultProvisionDeps, provisionAccountVault } from '../../lib/auth/provision.js';
-import { loadVaultsConfig } from '../../lib/vault/vaults.js';
-import { intervalMs } from '../git/planner.js';
-import { runCouchCycle } from './cycle.js';
-import { createDiscovery } from './discovery.js';
-import { createFileStore } from './file-store.js';
-import { gitCommitDirty } from './local-commit.js';
-import { resolveMutationTarget } from './mutation-target.js';
-import { pushOnWrite } from './push-on-write.js';
-import { createStatePersistence } from './state-store.js';
-import { autoCouchTargets, couchTargets } from './targets.js';
-import { getState, pendingCount } from './wire.js';
-export { resolveMutationTarget } from './mutation-target.js';
-// Couch sync runs inside the daemon; identify the caller as the daemon on every outbound request.
-const daemonHeaders = () => requestHeaders({ component: 'daemon' });
-const defaultFetch = (url, init) => {
-    const base = init;
-    const merged = { ...base, headers: { ...daemonHeaders(), ...base?.headers } };
-    return globalThis.fetch(url, merged);
-};
-const defaultFetchJson = async (url, token) => {
-    const res = await globalThis.fetch(url, {
-        headers: { authorization: `Bearer ${token}`, ...daemonHeaders() },
-    });
-    const json = await res.json().catch(() => null);
-    return { status: res.status, json };
-};
-// The daemon-side couch scheduler: per-account-vault timers + a persistent CouchSync per target for
-// sync-on-save. Every couch failure is caught and recorded (lastError / paused); it never crashes
-// the daemon and never blocks a memory API response.
-export const createCouchSyncManager = (deps = {}) => {
-    const getConfig = deps.getConfig ?? (() => loadVaultsConfig().config);
-    const getBearer = deps.getBearer ?? (() => currentBearer(readAuth, links(siteFqdn())));
-    const makeFileStore = deps.makeFileStore ?? createFileStore;
-    const makeCouchSync = deps.makeCouchSync ??
-        ((files, cfg, f, authorize, onUnauthorized, state, log) => new CouchSync(files, cfg, f, authorize, onUnauthorized, state, log));
-    const rt = {
-        configDir: deps.configDir ?? getConfigDir,
-        getBearer,
-        fetch: deps.fetch ?? defaultFetch,
-        makeCouchSync,
-        makeStatePersistence: deps.makeStatePersistence ?? createStatePersistence,
-        commitDirty: deps.commitDirty ?? gitCommitDirty,
-        discovery: deps.discovery ??
-            createDiscovery({
-                bootstrapHost: links(siteFqdn()).sync,
-                fetchJson: defaultFetchJson,
-                provision: (vault) => provisionAccountVault(vault, defaultProvisionDeps()),
-            }),
-        nowIso: deps.now ?? (() => new Date().toISOString()),
-        log: deps.log ?? (() => { }),
-    };
-    const states = new Map();
-    const timers = new Map();
-    const ensureTargetState = (target) => {
-        const existing = states.get(target.vault);
-        if (existing) {
-            existing.target = target;
-            return existing;
-        }
-        const fresh = { target, files: makeFileStore(target.path), running: false };
-        states.set(target.vault, fresh);
-        return fresh;
-    };
-    return {
-        reschedule() {
-            for (const timer of timers.values())
-                clearInterval(timer);
-            timers.clear();
-            const targets = couchTargets(getConfig());
-            const live = new Set(targets.map((t) => t.vault));
-            for (const vault of [...states.keys()])
-                if (!live.has(vault))
-                    states.delete(vault);
-            for (const t of targets)
-                void getState(rt, ensureTargetState(t)).catch(() => { });
-            for (const t of autoCouchTargets(getConfig())) {
-                const timer = setInterval(() => void runCouchCycle(rt, ensureTargetState(t)), intervalMs(t.intervalSeconds));
-                timer.unref?.();
-                timers.set(t.vault, timer);
-            }
-        },
-        async runNow(vault) {
-            const t = couchTargets(getConfig()).find((x) => x.vault === vault);
-            if (!t)
-                throw new Error(`'${vault}' is not an account vault`);
-            return runCouchCycle(rt, ensureTargetState(t));
-        },
-        onWrite(verb, body) {
-            if (verb !== 'write' && verb !== 'edit' && verb !== 'delete')
-                return;
-            const target = resolveMutationTarget(getConfig(), body);
-            if (!target)
-                return;
-            const t = couchTargets(getConfig()).find((x) => x.vault === target.vault);
-            if (!t)
-                return;
-            void pushOnWrite(rt, ensureTargetState(t), verb, target.path);
-        },
-        status() {
-            return couchTargets(getConfig()).map((t) => {
-                const st = states.get(t.vault);
-                return {
-                    vault: t.vault,
-                    channel: 'couch',
-                    intervalSeconds: t.intervalSeconds,
-                    lastSync: st?.lastSync,
-                    lastError: st?.lastError,
-                    pendingCount: pendingCount(st),
-                    paused: st?.paused,
-                    running: st?.running ?? false,
-                };
-            });
-        },
-        stop() {
-            for (const timer of timers.values())
-                clearInterval(timer);
-            timers.clear();
-        },
-    };
-};

package/dist/sync/couch/manager.types.d.ts

@@ -1,81 +0,0 @@
-import { type CouchState, type CouchStatePersistence, type FetchLike, type FileStore, type SyncResult as CouchChannelResult, type VaultsConfig } from '@agentage/memory-core';
-import { type MemoryVerb } from '../../daemon/actions.js';
-import { type Discovery } from './discovery.js';
-import { type CouchTarget } from './targets.js';
-export interface CouchSyncResult {
-    vault: string;
-    channel: 'couch';
-    ok: boolean;
-    committed: boolean;
-    pulled: boolean;
-    pendingCount: number;
-    paused?: string;
-    error?: string;
-}
-export interface CouchTargetStatus {
-    vault: string;
-    channel: 'couch';
-    intervalSeconds: number;
-    lastSync?: string;
-    lastError?: string;
-    pendingCount: number;
-    paused?: string;
-    running: boolean;
-}
-export interface CouchLike {
-    pushFileLive(path: string): Promise<void>;
-    removeFile(path: string): Promise<void>;
-    flushPending(): Promise<void>;
-    syncNow(): Promise<CouchChannelResult>;
-}
-export type MakeCouchSync = (files: FileStore, cfg: {
-    endpoint: string;
-    db: string;
-}, fetch: FetchLike, authorize: () => Promise<string>, onUnauthorized: () => void, state: CouchState, log?: (msg: string) => void) => CouchLike;
-export interface CommitOutcome {
-    committed: boolean;
-    skipped: boolean;
-}
-export interface CouchSyncManagerDeps {
-    getConfig?: () => VaultsConfig;
-    configDir?: () => string;
-    getBearer?: () => Promise<string | null>;
-    discovery?: Discovery;
-    fetch?: FetchLike;
-    makeFileStore?: (path: string) => FileStore;
-    makeStatePersistence?: (configDir: string, vault: string) => CouchStatePersistence;
-    makeCouchSync?: MakeCouchSync;
-    commitDirty?: (path: string, message: string) => Promise<CommitOutcome>;
-    now?: () => string;
-    log?: (msg: string) => void;
-}
-export interface CouchSyncManager {
-    reschedule(): void;
-    runNow(vault: string): Promise<CouchSyncResult>;
-    onWrite(verb: MemoryVerb, body: unknown): void;
-    status(): CouchTargetStatus[];
-    stop(): void;
-}
-export interface TargetState {
-    target: CouchTarget;
-    files: FileStore;
-    state?: CouchState;
-    statePromise?: Promise<CouchState>;
-    couch?: CouchLike;
-    wireKey?: string;
-    running: boolean;
-    lastSync?: string;
-    lastError?: string;
-    paused?: string;
-}
-export interface CouchRuntime {
-    configDir: () => string;
-    getBearer: () => Promise<string | null>;
-    fetch: FetchLike;
-    makeCouchSync: MakeCouchSync;
-    makeStatePersistence: (configDir: string, vault: string) => CouchStatePersistence;
-    commitDirty: (path: string, message: string) => Promise<CommitOutcome>;
-    discovery: Discovery;
-    nowIso: () => string;
-    log: (msg: string) => void;
-}

package/dist/sync/couch/manager.types.js

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

package/dist/sync/couch/mutation-target.d.ts

@@ -1,5 +0,0 @@
-import { type VaultsConfig } from '@agentage/memory-core';
-export declare const resolveMutationTarget: (config: VaultsConfig, body: unknown) => {
-    vault: string;
-    path: string;
-} | null;

package/dist/sync/couch/mutation-target.js

@@ -1,33 +0,0 @@
-import { isAccountVault } from '@agentage/memory-core';
-// Map one memory-verb wire payload to the account vault + vault-relative POSIX path it mutated, or
-// null when the target is not an account vault (git/local mutations never touch the couch channel).
-export const resolveMutationTarget = (config, body) => {
-    const p = (body ?? {});
-    const ref = typeof p.ref === 'string' ? p.ref : '';
-    if (!ref)
-        return null;
-    let vault;
-    let path;
-    if (ref.startsWith('@')) {
-        const m = ref.match(/^@([^/]+)\/(.+)$/);
-        if (!m)
-            return null; // a bare '@vault' is not a file mutation
-        vault = m[1];
-        path = m[2];
-    }
-    else {
-        vault = (typeof p.opts?.vault === 'string' ? p.opts.vault : undefined) ?? config.default;
-        if (!vault) {
-            const names = Object.keys(config.vaults ?? {});
-            if (names.length === 1)
-                vault = names[0];
-        }
-        path = ref;
-    }
-    if (!vault)
-        return null;
-    const entry = config.vaults?.[vault];
-    if (!entry || !isAccountVault(entry))
-        return null;
-    return { vault, path: path.replace(/^\.?\//, '') };
-};

package/dist/sync/couch/push-on-write.d.ts

@@ -1,3 +0,0 @@
-import { type MemoryVerb } from '../../daemon/actions.js';
-import { type CouchRuntime, type TargetState } from './manager.types.js';
-export declare const pushOnWrite: (rt: CouchRuntime, st: TargetState, verb: MemoryVerb, path: string) => Promise<void>;

package/dist/sync/couch/push-on-write.js

@@ -1,33 +0,0 @@
-import { ensureWire, getState } from './wire.js';
-// Sync-on-save: push (or tombstone) one path right after the engine committed it. Failures queue
-// the path in the module's persisted pending/deletion sets (retried by the next cycle) and never
-// surface to the API. A delete is durable regardless of auth/network state at delete time: with
-// no wire it enqueues the deletion, and removeFile itself self-enqueues on transport failure.
-export const pushOnWrite = async (rt, st, verb, path) => {
-    const defer = async () => {
-        const state = await getState(rt, st);
-        if (verb === 'delete')
-            await state.enqueueDeletion(path);
-        else
-            await state.enqueue(path);
-    };
-    try {
-        const bearer = await rt.getBearer();
-        if (bearer) {
-            const decision = await rt.discovery.channelFor(st.target.vault, bearer);
-            if (decision.kind === 'couch') {
-                const couch = await ensureWire(rt, st, decision);
-                if (verb === 'delete')
-                    await couch.removeFile(path);
-                else
-                    await couch.pushFileLive(path);
-                return;
-            }
-        }
-        await defer(); // no wire yet (signed out / paused) - queued until one exists
-    }
-    catch (err) {
-        rt.log(`couch push-on-write ${path}: ${err instanceof Error ? err.message : String(err)}`);
-        await defer().catch(() => { });
-    }
-};

package/dist/sync/couch/state-store.d.ts

@@ -1,3 +0,0 @@
-import { type CouchStatePersistence } from '@agentage/memory-core';
-export declare const couchStateDir: (configDir: string) => string;
-export declare const createStatePersistence: (configDir: string, vault: string) => CouchStatePersistence;

package/dist/sync/couch/state-store.js

@@ -1,28 +0,0 @@
-import { mkdirSync } from 'node:fs';
-import { readFile, rename, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-// The couch sync cursor + rev-cache + pending queue for one vault, at
-// <configDir>/couch-state/<vault>.json. Load returns null on a missing OR unparseable file so a
-// corrupt state degrades to a fresh from-scratch sync rather than crashing the daemon; save is
-// atomic (temp + rename) so a crash mid-write never truncates it.
-export const couchStateDir = (configDir) => join(configDir, 'couch-state');
-export const createStatePersistence = (configDir, vault) => {
-    const dir = couchStateDir(configDir);
-    const path = join(dir, `${encodeURIComponent(vault)}.json`);
-    return {
-        async load() {
-            try {
-                return JSON.parse(await readFile(path, 'utf8'));
-            }
-            catch {
-                return null;
-            }
-        },
-        async save(state) {
-            mkdirSync(dir, { recursive: true });
-            const tmp = `${path}.tmp`;
-            await writeFile(tmp, JSON.stringify(state), 'utf8');
-            await rename(tmp, path);
-        },
-    };
-};

package/dist/sync/couch/targets.d.ts

@@ -1,9 +0,0 @@
-import { type VaultsConfig } from '@agentage/memory-core';
-export declare const ACCOUNT_REMOTE = "agentage";
-export interface CouchTarget {
-    vault: string;
-    path: string;
-    intervalSeconds: number;
-}
-export declare const couchTargets: (config: VaultsConfig) => CouchTarget[];
-export declare const autoCouchTargets: (config: VaultsConfig) => CouchTarget[];

package/dist/sync/couch/targets.js

@@ -1,23 +0,0 @@
-import { expandPath, isAccountVault } from '@agentage/memory-core';
-import { DEFAULT_INTERVAL_SECONDS } from '../git/planner.js';
-// The account (agentage) channel a couch target syncs to. Unlike a git target it has no external
-// remote URL: the daemon resolves the per-memory CouchDB + JWT endpoints from discovery at runtime.
-export const ACCOUNT_REMOTE = 'agentage';
-// Every account vault (agentage origin) with a local mirror path is a couch target. Interval rides
-// on the agentage origin and matches git semantics: absent = 300s, 0 = manual-only.
-export const couchTargets = (config) => {
-    const out = [];
-    for (const [vault, entry] of Object.entries(config.vaults ?? {})) {
-        if (!isAccountVault(entry) || !entry.path)
-            continue;
-        const origin = entry.origin?.find((o) => o.remote === ACCOUNT_REMOTE);
-        out.push({
-            vault,
-            path: expandPath(entry.path),
-            intervalSeconds: origin?.interval ?? DEFAULT_INTERVAL_SECONDS,
-        });
-    }
-    return out;
-};
-// The couch targets the daemon auto-loop schedules: interval 0 is manual-only and excluded.
-export const autoCouchTargets = (config) => couchTargets(config).filter((t) => t.intervalSeconds > 0);

package/dist/sync/couch/wire.d.ts

@@ -1,6 +0,0 @@
-import { type CouchState } from '@agentage/memory-core';
-import { type ChannelDecision } from './discovery.js';
-import { type CouchLike, type CouchRuntime, type TargetState } from './manager.types.js';
-export declare const pendingCount: (st: TargetState | undefined) => number;
-export declare const getState: (rt: CouchRuntime, st: TargetState) => Promise<CouchState>;
-export declare const ensureWire: (rt: CouchRuntime, st: TargetState, d: ChannelDecision) => Promise<CouchLike>;