@agentage/cli 0.0.2 → 0.0.4

package/dist/sync/discover/watcher.js

@@ -0,0 +1,159 @@
+import { statSync, watch as fsWatch } from 'node:fs';
+import { expandPath, scanDiscoverRoots, } from '@agentage/memory-core';
+import { defaultProvisionDeps, provisionAccountVault } from '../../lib/auth/provision.js';
+import { addVault } from '../../lib/vault/vault-registry.js';
+import { loadVaultsConfig, mutateVaultsConfig } from '../../lib/vault/vaults.js';
+const msgOf = (err) => (err instanceof Error ? err.message : String(err));
+// Floors: a 0/near-0 poll interval would busy-loop the daemon; a 0 debounce defeats coalescing.
+const POLL_FLOOR_MS = 1000;
+const DEBOUNCE_FLOOR_MS = 50;
+const isDir = (path) => {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+};
+const defaultWatch = (dir, onChange) => {
+    const w = fsWatch(dir, { persistent: false }, () => onChange());
+    w.on('error', () => { }); // an unreliable fs: the poll fallback still covers the root
+    return w;
+};
+export const createDiscoverWatcher = (deps = {}) => {
+    const getConfig = deps.getConfig ?? (() => loadVaultsConfig().config);
+    const mutate = deps.mutate ?? mutateVaultsConfig;
+    const scan = deps.scan ?? scanDiscoverRoots;
+    const provision = deps.provision ?? ((name) => provisionAccountVault(name, defaultProvisionDeps()));
+    const isDirectory = deps.isDirectory ?? isDir;
+    const watch = deps.watch ?? defaultWatch;
+    const debounceMs = Math.max(DEBOUNCE_FLOOR_MS, deps.debounceMs ?? 500);
+    const pollMs = Math.max(POLL_FLOOR_MS, deps.pollMs ?? 60_000);
+    const log = deps.log ?? (() => { });
+    const watchers = [];
+    let debounceTimer;
+    let pollTimer;
+    let scanning = false;
+    let queued = false;
+    const roots = (config) => (config.discover ?? []).map((r) => expandPath(r.path));
+    const runScan = async () => {
+        let candidates;
+        try {
+            candidates = scan(getConfig());
+        }
+        catch (err) {
+            log(`scan failed: ${msgOf(err)}`);
+            return [];
+        }
+        if (candidates.length === 0)
+            return [];
+        // Fold the candidates onto the FRESH on-disk config inside the cross-process lock (issue #231):
+        // re-read, register any still-absent-and-present folder, save - so a concurrent `vault add` (or
+        // a second daemon) is never clobbered. Return null when nothing changed so the file is left
+        // untouched (a redundant write would loop the daemon's own config watcher).
+        let added = [];
+        try {
+            await mutate((fresh) => {
+                added = [];
+                let next = fresh;
+                for (const c of candidates) {
+                    if (next.vaults?.[c.name])
+                        continue; // registered by a concurrent writer
+                    if (!c.entry.path || !isDirectory(c.entry.path))
+                        continue; // vanished before we wrote it
+                    try {
+                        next = addVault(next, c.name, c.entry);
+                        added.push(c);
+                    }
+                    catch (err) {
+                        log(`register '${c.name}' failed: ${msgOf(err)}`);
+                    }
+                }
+                return added.length > 0 ? next : null;
+            });
+        }
+        catch (err) {
+            log(`save failed: ${msgOf(err)}`);
+            return [];
+        }
+        if (added.length === 0)
+            return [];
+        for (const c of added) {
+            log(`discovered account vault '${c.name}' -> ${c.entry.path}`);
+            void provision(c.name).catch(() => { }); // never fatal: the couch loop re-provisions
+        }
+        return added;
+    };
+    // Serialise scans against themselves; a change during an in-flight scan queues one more pass.
+    const scanNow = async () => {
+        if (scanning) {
+            queued = true;
+            return [];
+        }
+        scanning = true;
+        try {
+            return await runScan();
+        }
+        finally {
+            scanning = false;
+            if (queued) {
+                queued = false;
+                void scanNow();
+            }
+        }
+    };
+    const debounced = () => {
+        if (debounceTimer)
+            clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(() => {
+            debounceTimer = undefined;
+            void scanNow();
+        }, debounceMs);
+        debounceTimer.unref?.();
+    };
+    const closeWatchers = () => {
+        for (const w of watchers.splice(0)) {
+            try {
+                w.close();
+            }
+            catch {
+                // already closed
+            }
+        }
+    };
+    const reschedule = () => {
+        closeWatchers();
+        const config = getConfig();
+        for (const dir of roots(config).filter(isDirectory)) {
+            try {
+                watchers.push(watch(dir, debounced));
+            }
+            catch (err) {
+                log(`watch ${dir} failed: ${msgOf(err)}`);
+            }
+        }
+        // The poll fallback runs while any root is configured (even one not yet a directory), so a root
+        // created after boot is still picked up where fs.watch is unreliable.
+        if (roots(config).length > 0 && !pollTimer) {
+            pollTimer = setInterval(() => void scanNow(), pollMs);
+            pollTimer.unref?.();
+        }
+        else if (roots(config).length === 0 && pollTimer) {
+            clearInterval(pollTimer);
+            pollTimer = undefined;
+        }
+        void scanNow(); // initial scan on boot, and a re-scan whenever the config changes
+    };
+    const stop = () => {
+        closeWatchers();
+        if (debounceTimer) {
+            clearTimeout(debounceTimer);
+            debounceTimer = undefined;
+        }
+        if (pollTimer) {
+            clearInterval(pollTimer);
+            pollTimer = undefined;
+        }
+    };
+    return { reschedule, scanNow, status: () => ({ roots: roots(getConfig()) }), stop };
+};

package/dist/sync/git/conflict.d.ts

@@ -0,0 +1 @@
+export declare const conflictName: (path: string, exists: (candidate: string) => boolean) => string;

package/dist/sync/git/conflict.js

@@ -0,0 +1,16 @@
+// The name for the file that preserves the remote side of a conflict: `x.md` -> `x.conflict.md`.
+// An existing name is never clobbered - a numeric suffix is added instead (`x.conflict-1.md`).
+export const conflictName = (path, exists) => {
+    const slash = path.lastIndexOf('/');
+    const dot = path.lastIndexOf('.');
+    const hasExt = dot > slash + 1; // a dot inside the basename, not a leading dot
+    const stem = hasExt ? path.slice(0, dot) : path;
+    const ext = hasExt ? path.slice(dot) : '';
+    const base = `${stem}.conflict${ext}`;
+    if (!exists(base))
+        return base;
+    let i = 1;
+    while (exists(`${stem}.conflict-${i}${ext}`))
+        i += 1;
+    return `${stem}.conflict-${i}${ext}`;
+};

package/dist/sync/git/cycle.d.ts

@@ -0,0 +1,18 @@
+import { type GitErrorKind, type SyncGit } from './git-exec.js';
+import { type SyncTarget } from './planner.js';
+export interface SyncResult {
+    vault: string;
+    remote: string;
+    ok: boolean;
+    committed: boolean;
+    pushed: boolean;
+    conflicts: string[];
+    skipped?: 'lock' | 'busy' | 'invalid-remote';
+    reason?: GitErrorKind;
+    error?: string;
+}
+export interface CycleDeps {
+    git?: SyncGit;
+    now?: () => string;
+}
+export declare const runSyncCycle: (target: SyncTarget, deps?: CycleDeps) => Promise<SyncResult>;

package/dist/sync/git/cycle.js

@@ -0,0 +1,158 @@
+import { existsSync } from 'node:fs';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { conflictName } from './conflict.js';
+import { createSyncGit, GitError } from './git-exec.js';
+import { isSafeRemoteUrl } from './remote-url.js';
+const branchOf = async (git) => {
+    const out = await git.exec(['symbolic-ref', '--short', 'HEAD']);
+    return out.code === 0 && out.stdout.trim() ? out.stdout.trim() : 'main';
+};
+// Local, uncommitted, non-ignored changes -> one sync commit. Returns whether a commit was made.
+const commitIfDirty = async (git, message) => {
+    await git.run(['add', '-A']);
+    const staged = await git.exec(['diff', '--cached', '--quiet']);
+    if (staged.code === 0)
+        return false;
+    await git.run(['commit', '-m', message]);
+    return true;
+};
+// The ignore rules ride on `.git/info/exclude` (local, uncommitted, gitignore syntax) rather than
+// per-command pathspecs: it is the robust, idempotent mechanism - matching untracked files are
+// never staged by `add -A`, and it leaves no committed `.gitignore` in the user's vault. An empty
+// list clears it (sync everything).
+const writeExclude = async (path, patterns) => {
+    const infoDir = join(path, '.git', 'info');
+    await mkdir(infoDir, { recursive: true });
+    await writeFile(join(infoDir, 'exclude'), patterns.length ? patterns.join('\n') + '\n' : '', 'utf8');
+};
+const ensureRemote = async (git, name, url) => {
+    const remotes = (await git.exec(['remote'])).stdout.split('\n').map((r) => r.trim());
+    if (remotes.includes(name))
+        await git.run(['remote', 'set-url', name, url]);
+    else
+        await git.run(['remote', 'add', name, url]);
+};
+// A previous cycle may have died mid-merge/rebase (daemon crash). A leftover MERGE_HEAD or rebase
+// dir would let commitIfDirty mint a bogus half-merge and wedge every later cycle, so abort any
+// interrupted operation before touching the tree.
+const abortInterrupted = async (git, path) => {
+    const gitDir = join(path, '.git');
+    if (existsSync(join(gitDir, 'MERGE_HEAD'))) {
+        await git.exec(['merge', '--abort']);
+        // The abort refuses when the user edited a merge-touched file meanwhile ("entry not uptodate");
+        // complete the staged merge instead so MERGE_HEAD never leaks into commitIfDirty.
+        if (existsSync(join(gitDir, 'MERGE_HEAD')))
+            await git.exec(['commit', '--no-edit']);
+    }
+    if (existsSync(join(gitDir, 'rebase-merge')) || existsSync(join(gitDir, 'rebase-apply')))
+        await git.exec(['rebase', '--abort']);
+};
+// Reconcile a diverged history keeping BOTH sides. A rebase probes for a true conflict; on a clean
+// replay history stays linear. On conflict the local files are kept as-is and each conflicted
+// file's remote copy is written alongside as `<name>.conflict.md`. The `.conflict.md` copies are
+// staged into the SAME merge commit (`merge --no-commit`), so no single commit boundary ever
+// leaves the remote side merged-away yet unsurfaced. Returns the conflict-copy paths written.
+const reconcile = async (git, cwd, ref, now) => {
+    const rebase = await git.exec(['rebase', ref]);
+    if (rebase.code === 0)
+        return [];
+    const conflicted = (await git.exec(['diff', '--name-only', '--diff-filter=U'])).stdout
+        .split('\n')
+        .map((p) => p.trim())
+        .filter(Boolean);
+    await git.exec(['rebase', '--abort']);
+    const remoteSides = new Map();
+    for (const p of conflicted) {
+        const show = await git.exec(['show', `${ref}:${p}`]);
+        if (show.code === 0)
+            remoteSides.set(p, show.stdout);
+    }
+    // Stage the merge WITHOUT committing (auto-resolving content conflicts to the local side); an
+    // unresolvable conflict (add/add, modify/delete) falls back to keeping ours. Everything stays
+    // staged so the conflict copies land in the very same commit.
+    const merge = await git.exec(['merge', '--no-commit', '-X', 'ours', '--no-edit', ref]);
+    if (merge.code !== 0) {
+        await git.exec(['checkout', '--ours', '--', '.']);
+        await git.run(['add', '-A']);
+    }
+    const written = [];
+    for (const [p, content] of remoteSides) {
+        const name = conflictName(p, (candidate) => existsSync(join(cwd, candidate)));
+        const abs = join(cwd, name);
+        await mkdir(dirname(abs), { recursive: true });
+        await writeFile(abs, content, 'utf8');
+        written.push(name);
+    }
+    await git.run(['add', '-A']);
+    // Self-sufficient close: nothing staged and no merge to conclude = nothing to commit (a bare
+    // `commit --no-edit` would abort on the empty message and wedge the cycle); an absent MERGE_MSG
+    // (recovered state) falls back to an explicit -m.
+    const staged = await git.exec(['diff', '--cached', '--quiet']);
+    const merging = existsSync(join(cwd, '.git', 'MERGE_HEAD'));
+    if (staged.code === 0 && !merging)
+        return written;
+    if (existsSync(join(cwd, '.git', 'MERGE_MSG')))
+        await git.run(['commit', '--no-edit']);
+    else
+        await git.run(['commit', '-m', `sync: merge ${ref} (${now})`]);
+    return written;
+};
+// One tolerant sync cycle for a single target: commit-if-dirty -> ensure remote -> fetch ->
+// pull-rebase (keeping both sides on conflict) -> push. Every git failure is caught and classified
+// so an unreachable remote or a held index.lock is a clean skip that the next cycle catches up.
+export const runSyncCycle = async (target, deps = {}) => {
+    const git = deps.git ?? createSyncGit(target.path);
+    const now = (deps.now ?? (() => new Date().toISOString()))();
+    const base = {
+        vault: target.vault,
+        remote: target.remote,
+        ok: false,
+        committed: false,
+        pushed: false,
+        conflicts: [],
+    };
+    // Defense in depth: the planner already drops unsafe remotes, but never add/set-url one here.
+    if (!isSafeRemoteUrl(target.remote))
+        return { ...base, ok: true, skipped: 'invalid-remote' };
+    let committed = false;
+    let conflicts = [];
+    try {
+        if (!existsSync(target.path))
+            return { ...base, ok: true }; // nothing on disk yet
+        if (!existsSync(join(target.path, '.git')))
+            await git.run(['init', '-b', 'main']);
+        await abortInterrupted(git, target.path);
+        await writeExclude(target.path, target.ignore);
+        await ensureRemote(git, target.remoteName, target.remote);
+        committed = await commitIfDirty(git, `sync: ${now}`);
+        const branch = await branchOf(git);
+        const ref = `${target.remoteName}/${branch}`;
+        const fetch = await git.exec(['fetch', target.remoteName]);
+        if (fetch.code !== 0)
+            throw new GitError(fetch);
+        if ((await git.exec(['rev-parse', '--verify', ref])).code === 0) {
+            conflicts = await reconcile(git, target.path, ref, now);
+        }
+        const push = await git.exec(['push', target.remoteName, `HEAD:${branch}`]);
+        if (push.code !== 0)
+            throw new GitError(push);
+        return { ...base, ok: true, committed, pushed: true, conflicts };
+    }
+    catch (err) {
+        if (err instanceof GitError) {
+            // A concurrent engine mutation holding index.lock -> skip cleanly, retry next cycle.
+            if (err.kind === 'lock')
+                return { ...base, ok: true, committed, conflicts, skipped: 'lock', reason: 'lock' };
+            return { ...base, ok: false, committed, conflicts, reason: err.kind, error: err.message };
+        }
+        return {
+            ...base,
+            ok: false,
+            committed,
+            conflicts,
+            reason: 'other',
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+};

package/dist/sync/git/git-exec.d.ts

@@ -0,0 +1,22 @@
+export type GitErrorKind = 'unreachable' | 'lock' | 'conflict' | 'other';
+export interface GitRunResult {
+    code: number;
+    stdout: string;
+    stderr: string;
+}
+export declare const classifyGitError: (stderr: string) => GitErrorKind;
+export declare class GitError extends Error {
+    readonly kind: GitErrorKind;
+    readonly stderr: string;
+    readonly code: number;
+    constructor(result: GitRunResult);
+}
+export interface SyncGit {
+    exec(args: string[], opts?: {
+        timeoutMs?: number;
+    }): Promise<GitRunResult>;
+    run(args: string[], opts?: {
+        timeoutMs?: number;
+    }): Promise<string>;
+}
+export declare const createSyncGit: (cwd: string) => SyncGit;

package/dist/sync/git/git-exec.js

@@ -0,0 +1,56 @@
+import { execFile } from 'node:child_process';
+// Classify a git failure by its stderr so callers can react: an unreachable remote and a held
+// index.lock are both skip-and-retry (not crashes); a conflict drives the keep-both-sides path.
+export const classifyGitError = (stderr) => {
+    const s = stderr.toLowerCase();
+    if (/index\.lock|another git process|unable to create .*\.lock|cannot lock ref/.test(s))
+        return 'lock';
+    if (/conflict|could not apply|needs merge|automatic merge failed/.test(s))
+        return 'conflict';
+    if (/could not read from remote|connection refused|could not resolve host|repository .* not found|does not appear to be a git repository|unable to access|no route to host|network is unreachable|permission denied \(publickey\)|host key verification failed|does not exist|failed to connect|remote end hung up/.test(s))
+        return 'unreachable';
+    return 'other';
+};
+export class GitError extends Error {
+    kind;
+    stderr;
+    code;
+    constructor(result) {
+        super(result.stderr.trim() || `git exited with code ${result.code}`);
+        this.name = 'GitError';
+        this.kind = classifyGitError(result.stderr);
+        this.stderr = result.stderr;
+        this.code = result.code;
+    }
+}
+const IDENTITY = {
+    GIT_AUTHOR_NAME: 'agentage sync',
+    GIT_AUTHOR_EMAIL: 'sync@agentage.io',
+    GIT_COMMITTER_NAME: 'agentage sync',
+    GIT_COMMITTER_EMAIL: 'sync@agentage.io',
+    GIT_TERMINAL_PROMPT: '0',
+    GIT_SSH_COMMAND: 'ssh -oBatchMode=yes',
+};
+export const createSyncGit = (cwd) => {
+    const exec = (args, opts = {}) => new Promise((resolve) => {
+        execFile('git', args, {
+            cwd,
+            env: { ...process.env, ...IDENTITY },
+            encoding: 'utf8',
+            maxBuffer: 64 * 1024 * 1024,
+            timeout: opts.timeoutMs ?? 0,
+        }, (err, stdout, stderr) => {
+            const code = typeof err?.code === 'number' ? err.code : err ? 1 : 0;
+            resolve({ code, stdout: stdout ?? '', stderr: stderr ?? '' });
+        });
+    });
+    return {
+        exec,
+        async run(args, opts) {
+            const result = await exec(args, opts);
+            if (result.code !== 0)
+                throw new GitError(result);
+            return result.stdout;
+        },
+    };
+};

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

@@ -0,0 +1,30 @@
+import { type VaultsConfig } from '@agentage/memory-core';
+import { type CouchTargetStatus } from '../couch/manager.js';
+import { type DiscoverStatus } from '../discover/watcher.js';
+import { type SyncResult } from './cycle.js';
+import { type SyncTarget } from './planner.js';
+export interface VaultSyncState {
+    vault: string;
+    remote: string;
+    intervalSeconds: number;
+    running: boolean;
+    lastRun?: string;
+    lastError?: string;
+    lastResult?: Pick<SyncResult, 'ok' | 'pushed' | 'committed' | 'conflicts' | 'skipped' | 'reason'>;
+}
+export interface SyncStatus {
+    vaults: VaultSyncState[];
+    couch?: CouchTargetStatus[];
+    discover?: DiscoverStatus;
+}
+export interface SyncManagerDeps {
+    getConfig?: () => VaultsConfig;
+    runCycle?: (target: SyncTarget) => Promise<SyncResult>;
+}
+export interface SyncManager {
+    reschedule(): void;
+    runNow(vault: string): Promise<SyncResult>;
+    status(): SyncStatus;
+    stop(): void;
+}
+export declare const createSyncManager: (deps?: SyncManagerDeps) => SyncManager;

package/dist/sync/git/manager.js

@@ -0,0 +1,114 @@
+import { loadVaultsConfig } from '../../lib/vault/vaults.js';
+import { runSyncCycle } from './cycle.js';
+import { autoSyncTargets, intervalMs, syncTargets } from './planner.js';
+const busy = (t) => ({
+    vault: t.vault,
+    remote: t.remote,
+    ok: true,
+    committed: false,
+    pushed: false,
+    conflicts: [],
+    skipped: 'busy',
+});
+// The daemon-side scheduler: owns per-target timers, serialises each target against itself (an
+// in-process running flag - no overlapping cycles), and records last-run/last-error for status.
+export const createSyncManager = (deps = {}) => {
+    const getConfig = deps.getConfig ?? (() => loadVaultsConfig().config);
+    const runCycle = deps.runCycle ?? runSyncCycle;
+    const states = new Map();
+    const timers = new Map();
+    const keyOf = (t) => `${t.vault}::${t.remoteName}`;
+    const ensureState = (t) => {
+        const existing = states.get(keyOf(t));
+        if (existing) {
+            existing.remote = t.remote;
+            existing.intervalSeconds = t.intervalSeconds;
+            return existing;
+        }
+        const fresh = {
+            vault: t.vault,
+            remote: t.remote,
+            intervalSeconds: t.intervalSeconds,
+            running: false,
+        };
+        states.set(keyOf(t), fresh);
+        return fresh;
+    };
+    const runTarget = async (t) => {
+        const state = ensureState(t);
+        if (state.running)
+            return busy(t); // serialise: no overlapping cycles per target
+        state.running = true;
+        try {
+            const result = await runCycle(t);
+            state.lastRun = new Date().toISOString();
+            state.lastError = result.ok ? undefined : result.error;
+            state.lastResult = {
+                ok: result.ok,
+                pushed: result.pushed,
+                committed: result.committed,
+                conflicts: result.conflicts,
+                skipped: result.skipped,
+                reason: result.reason,
+            };
+            return result;
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            state.lastRun = new Date().toISOString();
+            state.lastError = message;
+            state.lastResult = {
+                ok: false,
+                pushed: false,
+                committed: false,
+                conflicts: [],
+                reason: 'other',
+            };
+            return {
+                vault: t.vault,
+                remote: t.remote,
+                ok: false,
+                committed: false,
+                pushed: false,
+                conflicts: [],
+                reason: 'other',
+                error: message,
+            };
+        }
+        finally {
+            state.running = false;
+        }
+    };
+    const runNow = async (vault) => {
+        const targets = syncTargets(getConfig()).filter((t) => t.vault === vault);
+        if (targets.length === 0)
+            throw new Error(`no sync origin configured for vault '${vault}'`);
+        let last = busy(targets[0]);
+        for (const t of targets)
+            last = await runTarget(t);
+        return last;
+    };
+    const reschedule = () => {
+        for (const timer of timers.values())
+            clearInterval(timer);
+        timers.clear();
+        const all = syncTargets(getConfig());
+        const live = new Set(all.map(keyOf));
+        for (const key of [...states.keys()])
+            if (!live.has(key))
+                states.delete(key);
+        for (const t of all)
+            ensureState(t);
+        for (const t of autoSyncTargets(getConfig())) {
+            const timer = setInterval(() => void runTarget(t), intervalMs(t.intervalSeconds));
+            timer.unref?.();
+            timers.set(keyOf(t), timer);
+        }
+    };
+    const stop = () => {
+        for (const timer of timers.values())
+            clearInterval(timer);
+        timers.clear();
+    };
+    return { reschedule, runNow, status: () => ({ vaults: [...states.values()] }), stop };
+};

package/dist/sync/git/planner.d.ts

@@ -0,0 +1,15 @@
+import { type VaultsConfig } from '@agentage/memory-core';
+export declare const DEFAULT_INTERVAL_SECONDS = 300;
+export declare const DEFAULT_IGNORE: readonly string[];
+export interface SyncTarget {
+    vault: string;
+    path: string;
+    remoteName: string;
+    remote: string;
+    intervalSeconds: number;
+    ignore: string[];
+}
+export declare const resolveIgnore: (ignore: string[] | undefined) => string[];
+export declare const intervalMs: (seconds: number) => number;
+export declare const syncTargets: (config: VaultsConfig) => SyncTarget[];
+export declare const autoSyncTargets: (config: VaultsConfig) => SyncTarget[];

package/dist/sync/git/planner.js

@@ -0,0 +1,46 @@
+import { expandPath } from '@agentage/memory-core';
+import { isSafeRemoteUrl, redactRemoteUrl } from './remote-url.js';
+// The unified schema stores interval as a bare non-negative integer; sync treats it as SECONDS
+// (there is no minutes marker in the schema, so seconds is the least-surprising reading and keeps
+// tests fast). 0 means manual-only (excluded from the daemon auto loop).
+export const DEFAULT_INTERVAL_SECONDS = 300;
+// When `ignore` is absent these editor/runtime files are excluded from sync; a set value REPLACES
+// the defaults, and an empty array syncs everything.
+export const DEFAULT_IGNORE = ['.obsidian/', 'data.json'];
+// The reserved cloud channel is never synced over external git (that path is out of scope here).
+const RESERVED_REMOTE = 'agentage';
+export const resolveIgnore = (ignore) => ignore === undefined ? [...DEFAULT_IGNORE] : ignore;
+export const intervalMs = (seconds) => Math.max(0, Math.floor(seconds)) * 1000;
+// One vault may carry several origins; each gets a distinct remote name within its own repo.
+const remoteNameFor = (index) => (index === 0 ? 'sync' : `sync-${index}`);
+// Flatten (vault, origin) pairs into sync targets. A target needs a local `path` (the working
+// copy to commit/push from) AND an external origin; origin-only entries (cloud remote backends)
+// and the reserved cloud channel are skipped.
+export const syncTargets = (config) => {
+    const out = [];
+    for (const [vault, entry] of Object.entries(config.vaults ?? {})) {
+        if (!entry.path || !entry.origin?.length)
+            continue;
+        entry.origin.forEach((origin, index) => {
+            const remote = origin.remote.trim();
+            if (!remote || remote === RESERVED_REMOTE)
+                return;
+            // One poisoned origin must not run code or kill the whole cycle: skip it with a warning.
+            if (!isSafeRemoteUrl(remote)) {
+                console.warn(`agentage: skipping unsafe remote for vault '${vault}': ${redactRemoteUrl(remote)}`);
+                return;
+            }
+            out.push({
+                vault,
+                path: expandPath(entry.path),
+                remoteName: remoteNameFor(index),
+                remote,
+                intervalSeconds: origin.interval ?? DEFAULT_INTERVAL_SECONDS,
+                ignore: resolveIgnore(origin.ignore),
+            });
+        });
+    }
+    return out;
+};
+// The targets the daemon auto-loop schedules: interval 0 is manual-only and excluded.
+export const autoSyncTargets = (config) => syncTargets(config).filter((t) => t.intervalSeconds > 0);

package/dist/sync/git/remote-url.d.ts

@@ -0,0 +1,3 @@
+export declare const isSafeRemoteUrl: (remote: string) => boolean;
+export declare const assertSafeRemoteUrl: (remote: string) => void;
+export declare const redactRemoteUrl: (remote: string) => string;