@lifestreamdynamics/vault-cli 1.0.0

package/dist/sync/config.js

@@ -0,0 +1,100 @@
+/**
+ * Sync configuration persistence.
+ * Manages ~/.lsvault/syncs.json — the list of all configured sync pairs.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import crypto from 'node:crypto';
+const CONFIG_DIR = path.join(os.homedir(), '.lsvault');
+const SYNCS_FILE = path.join(CONFIG_DIR, 'syncs.json');
+/**
+ * Read all sync configurations from disk.
+ */
+export function loadSyncConfigs() {
+    if (!fs.existsSync(SYNCS_FILE)) {
+        return [];
+    }
+    try {
+        const raw = fs.readFileSync(SYNCS_FILE, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Write all sync configurations to disk.
+ */
+export function saveSyncConfigs(configs) {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    fs.writeFileSync(SYNCS_FILE, JSON.stringify(configs, null, 2) + '\n');
+}
+/**
+ * Find a sync config by its ID.
+ */
+export function getSyncConfig(id) {
+    return loadSyncConfigs().find(c => c.id === id);
+}
+/**
+ * Find a sync config by vault ID.
+ * Returns the first match (a vault should typically only have one sync config).
+ */
+export function getSyncConfigByVaultId(vaultId) {
+    return loadSyncConfigs().find(c => c.vaultId === vaultId);
+}
+/**
+ * Create a new sync configuration.
+ * Returns the created config with a generated ID.
+ */
+export function createSyncConfig(opts) {
+    const configs = loadSyncConfigs();
+    // Check for duplicate vault+path combinations
+    const existing = configs.find(c => c.vaultId === opts.vaultId && c.localPath === opts.localPath);
+    if (existing) {
+        throw new Error(`Sync already exists for vault ${opts.vaultId} at ${opts.localPath} (id: ${existing.id})`);
+    }
+    const config = {
+        id: crypto.randomUUID(),
+        vaultId: opts.vaultId,
+        localPath: opts.localPath,
+        mode: opts.mode ?? 'sync',
+        onConflict: opts.onConflict ?? 'newer',
+        ignore: opts.ignore ?? ['.git', '.DS_Store', 'node_modules'],
+        lastSyncAt: new Date(0).toISOString(),
+        syncInterval: opts.syncInterval,
+        autoSync: opts.autoSync ?? false,
+    };
+    configs.push(config);
+    saveSyncConfigs(configs);
+    return config;
+}
+/**
+ * Delete a sync configuration by ID.
+ * Returns true if the config was found and deleted.
+ */
+export function deleteSyncConfig(id) {
+    const configs = loadSyncConfigs();
+    const index = configs.findIndex(c => c.id === id);
+    if (index === -1)
+        return false;
+    configs.splice(index, 1);
+    saveSyncConfigs(configs);
+    return true;
+}
+/**
+ * Update the lastSyncAt timestamp for a sync config.
+ */
+export function updateLastSync(id, timestamp) {
+    const configs = loadSyncConfigs();
+    const config = configs.find(c => c.id === id);
+    if (!config)
+        throw new Error(`Sync config not found: ${id}`);
+    config.lastSyncAt = timestamp ?? new Date().toISOString();
+    saveSyncConfigs(configs);
+}

package/dist/sync/conflict.d.ts

@@ -0,0 +1,30 @@
+import type { FileState, ConflictStrategy } from './types.js';
+export interface ConflictInfo {
+    /** Document path (relative) */
+    docPath: string;
+    /** Local file state */
+    local: FileState;
+    /** Remote file state */
+    remote: FileState;
+    /** Previous known state (from last sync) */
+    lastKnown: FileState | undefined;
+}
+export type ConflictResolution = 'local' | 'remote';
+/**
+ * Detect if a file has a bidirectional conflict.
+ * A conflict exists when both local and remote have changed since last sync.
+ */
+export declare function detectConflict(local: FileState, remote: FileState, lastLocal: FileState | undefined, lastRemote: FileState | undefined): boolean;
+/**
+ * Resolve a conflict using the specified strategy.
+ */
+export declare function resolveConflict(strategy: ConflictStrategy, local: FileState, remote: FileState): ConflictResolution;
+/**
+ * Create a conflict backup file with a timestamped name.
+ * Returns the path of the created conflict file.
+ */
+export declare function createConflictFile(localPath: string, docPath: string, content: string, source: 'local' | 'remote'): string;
+/**
+ * Format a conflict log entry.
+ */
+export declare function formatConflictLog(docPath: string, resolution: ConflictResolution, conflictFilePath: string | null): string;

package/dist/sync/conflict.js

@@ -0,0 +1,60 @@
+/**
+ * Conflict detection and resolution for bidirectional sync.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+/**
+ * Detect if a file has a bidirectional conflict.
+ * A conflict exists when both local and remote have changed since last sync.
+ */
+export function detectConflict(local, remote, lastLocal, lastRemote) {
+    if (!lastLocal || !lastRemote) {
+        // First sync — conflict if hashes differ
+        return local.hash !== remote.hash;
+    }
+    const localChanged = local.hash !== lastLocal.hash;
+    const remoteChanged = remote.hash !== lastRemote.hash;
+    return localChanged && remoteChanged;
+}
+/**
+ * Resolve a conflict using the specified strategy.
+ */
+export function resolveConflict(strategy, local, remote) {
+    switch (strategy) {
+        case 'local':
+            return 'local';
+        case 'remote':
+            return 'remote';
+        case 'newer':
+            return new Date(local.mtime) >= new Date(remote.mtime) ? 'local' : 'remote';
+        case 'ask':
+            // 'ask' cannot be resolved automatically — caller must handle interactively.
+            // Default to 'newer' as fallback when non-interactive.
+            return new Date(local.mtime) >= new Date(remote.mtime) ? 'local' : 'remote';
+    }
+}
+/**
+ * Create a conflict backup file with a timestamped name.
+ * Returns the path of the created conflict file.
+ */
+export function createConflictFile(localPath, docPath, content, source) {
+    const ext = path.extname(docPath);
+    const base = docPath.slice(0, -ext.length);
+    const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+    const conflictPath = `${base}.conflicted.${source}.${timestamp}${ext}`;
+    const absPath = path.join(localPath, conflictPath);
+    const dir = path.dirname(absPath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(absPath, content, 'utf-8');
+    return conflictPath;
+}
+/**
+ * Format a conflict log entry.
+ */
+export function formatConflictLog(docPath, resolution, conflictFilePath) {
+    const ts = new Date().toISOString();
+    const conflictNote = conflictFilePath ? ` (backup: ${conflictFilePath})` : '';
+    return `[${ts}] CONFLICT ${docPath}: resolved=${resolution}${conflictNote}`;
+}

package/dist/sync/daemon-worker.d.ts

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

package/dist/sync/daemon-worker.js

@@ -0,0 +1,128 @@
+/**
+ * Daemon worker process.
+ * Runs as a detached background process, managing watchers for all autoSync syncs.
+ * Designed to be spawned by daemon.ts startDaemon().
+ */
+import { loadSyncConfigs } from './config.js';
+import { resolveIgnorePatterns } from './ignore.js';
+import { createWatcher } from './watcher.js';
+import { createRemotePoller } from './remote-poller.js';
+import { removePid } from './daemon.js';
+import { loadConfig } from '../config.js';
+import { LifestreamVaultClient } from '@lifestreamdynamics/vault-sdk';
+const managed = [];
+function log(msg) {
+    const ts = new Date().toISOString();
+    process.stdout.write(`[${ts}] ${msg}\n`);
+}
+function createClient() {
+    const config = loadConfig();
+    if (!config.apiKey) {
+        throw new Error('No API key configured. Run `lsvault auth login` first.');
+    }
+    return new LifestreamVaultClient({
+        baseUrl: config.apiUrl,
+        apiKey: config.apiKey,
+    });
+}
+async function start() {
+    log('Daemon starting...');
+    const configs = loadSyncConfigs().filter(c => c.autoSync);
+    if (configs.length === 0) {
+        log('No auto-sync configurations found. Daemon has nothing to do.');
+        removePid();
+        process.exit(0);
+    }
+    log(`Found ${configs.length} auto-sync configuration(s)`);
+    const client = createClient();
+    for (const config of configs) {
+        try {
+            const ignorePatterns = resolveIgnorePatterns(config.ignore, config.localPath);
+            const { watcher, stop: stopWatcher } = createWatcher(client, config, {
+                ignorePatterns,
+                onLog: (msg) => log(msg),
+                onConflictLog: (msg) => log(`CONFLICT: ${msg}`),
+                onError: (err) => log(`ERROR [${config.id.slice(0, 8)}]: ${err.message}`),
+            });
+            let stopPoller;
+            if (config.mode === 'sync') {
+                const pollIntervalMs = parseSyncInterval(config.syncInterval) || 30000;
+                const poller = createRemotePoller(client, config, {
+                    ignorePatterns,
+                    intervalMs: pollIntervalMs,
+                    onLog: (msg) => log(msg),
+                    onConflictLog: (msg) => log(`CONFLICT: ${msg}`),
+                    onError: (err) => log(`ERROR [${config.id.slice(0, 8)}]: ${err.message}`),
+                });
+                stopPoller = poller.stop;
+            }
+            managed.push({ syncId: config.id, watcher, stopWatcher, stopPoller });
+            log(`Started sync: ${config.id.slice(0, 8)} (${config.localPath})`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            log(`Failed to start sync ${config.id.slice(0, 8)}: ${msg}`);
+        }
+    }
+    if (managed.length === 0) {
+        log('No syncs could be started. Exiting.');
+        removePid();
+        process.exit(1);
+    }
+    log(`Daemon running with ${managed.length} sync(s)`);
+}
+async function shutdown() {
+    log('Daemon shutting down...');
+    for (const sync of managed) {
+        try {
+            sync.stopPoller?.();
+            await sync.stopWatcher();
+            log(`Stopped sync: ${sync.syncId.slice(0, 8)}`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            log(`Error stopping sync ${sync.syncId.slice(0, 8)}: ${msg}`);
+        }
+    }
+    removePid();
+    log('Daemon stopped.');
+    process.exit(0);
+}
+/**
+ * Parse a human-readable sync interval string to milliseconds.
+ * Supports: "30s", "5m", "1h", or plain number (ms).
+ */
+function parseSyncInterval(interval) {
+    if (!interval)
+        return null;
+    const match = interval.match(/^(\d+)(s|m|h)?$/);
+    if (!match)
+        return null;
+    const value = parseInt(match[1], 10);
+    switch (match[2]) {
+        case 's': return value * 1000;
+        case 'm': return value * 60 * 1000;
+        case 'h': return value * 60 * 60 * 1000;
+        default: return value;
+    }
+}
+// Signal handlers
+process.on('SIGTERM', shutdown);
+process.on('SIGINT', shutdown);
+// Uncaught error recovery
+process.on('uncaughtException', (err) => {
+    log(`UNCAUGHT ERROR: ${err.message}`);
+    log(err.stack ?? '');
+    // Try to recover — don't exit
+});
+process.on('unhandledRejection', (reason) => {
+    const msg = reason instanceof Error ? reason.message : String(reason);
+    log(`UNHANDLED REJECTION: ${msg}`);
+    // Try to recover — don't exit
+});
+// Start
+start().catch((err) => {
+    log(`FATAL: ${err.message}`);
+    removePid();
+    process.exit(1);
+});

package/dist/sync/daemon.d.ts

@@ -0,0 +1,44 @@
+declare const DAEMON_DIR: string;
+declare const PID_FILE: string;
+declare const LOG_FILE: string;
+export interface DaemonStatus {
+    running: boolean;
+    pid: number | null;
+    logFile: string;
+    uptime: number | null;
+    startedAt: string | null;
+}
+/**
+ * Read the daemon PID from the PID file.
+ */
+export declare function readPid(): number | null;
+/**
+ * Write the daemon PID to the PID file.
+ */
+export declare function writePid(pid: number): void;
+/**
+ * Remove the PID file.
+ */
+export declare function removePid(): void;
+/**
+ * Check if a process with the given PID is running.
+ */
+export declare function isProcessRunning(pid: number): boolean;
+/**
+ * Get the current daemon status.
+ */
+export declare function getDaemonStatus(): DaemonStatus;
+/**
+ * Rotate log files if they exceed the max size.
+ */
+export declare function rotateLogIfNeeded(logFile?: string): void;
+/**
+ * Start the daemon as a detached child process.
+ * Returns the PID of the spawned process.
+ */
+export declare function startDaemon(logFile?: string): number;
+/**
+ * Stop the running daemon.
+ */
+export declare function stopDaemon(): boolean;
+export { DAEMON_DIR, PID_FILE, LOG_FILE };

package/dist/sync/daemon.js

@@ -0,0 +1,174 @@
+/**
+ * Background daemon process management.
+ * Manages starting, stopping, and checking the status of the sync daemon.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { spawn } from 'node:child_process';
+const DAEMON_DIR = path.join(os.homedir(), '.lsvault', 'daemon');
+const PID_FILE = path.join(DAEMON_DIR, 'daemon.pid');
+const LOG_FILE = path.join(DAEMON_DIR, 'daemon.log');
+const MAX_LOG_SIZE = 10 * 1024 * 1024; // 10MB
+const MAX_LOG_AGE_DAYS = 7;
+/**
+ * Ensure the daemon directory exists.
+ */
+function ensureDaemonDir() {
+    if (!fs.existsSync(DAEMON_DIR)) {
+        fs.mkdirSync(DAEMON_DIR, { recursive: true });
+    }
+}
+/**
+ * Read the daemon PID from the PID file.
+ */
+export function readPid() {
+    if (!fs.existsSync(PID_FILE))
+        return null;
+    try {
+        const content = fs.readFileSync(PID_FILE, 'utf-8').trim();
+        const pid = parseInt(content, 10);
+        return isNaN(pid) ? null : pid;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Write the daemon PID to the PID file.
+ */
+export function writePid(pid) {
+    ensureDaemonDir();
+    fs.writeFileSync(PID_FILE, String(pid) + '\n');
+}
+/**
+ * Remove the PID file.
+ */
+export function removePid() {
+    if (fs.existsSync(PID_FILE)) {
+        fs.unlinkSync(PID_FILE);
+    }
+}
+/**
+ * Check if a process with the given PID is running.
+ */
+export function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0); // Signal 0 doesn't kill, just checks
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get the current daemon status.
+ */
+export function getDaemonStatus() {
+    const pid = readPid();
+    const running = pid !== null && isProcessRunning(pid);
+    // Clean up stale PID file
+    if (pid !== null && !running) {
+        removePid();
+    }
+    let startedAt = null;
+    let uptime = null;
+    if (running && pid !== null) {
+        try {
+            const pidStat = fs.statSync(PID_FILE);
+            startedAt = pidStat.birthtime.toISOString();
+            uptime = Math.floor((Date.now() - pidStat.birthtimeMs) / 1000);
+        }
+        catch {
+            // Ignore stat errors
+        }
+    }
+    return {
+        running,
+        pid: running ? pid : null,
+        logFile: LOG_FILE,
+        uptime,
+        startedAt,
+    };
+}
+/**
+ * Rotate log files if they exceed the max size.
+ */
+export function rotateLogIfNeeded(logFile) {
+    const targetLog = logFile ?? LOG_FILE;
+    if (!fs.existsSync(targetLog))
+        return;
+    try {
+        const stat = fs.statSync(targetLog);
+        if (stat.size > MAX_LOG_SIZE) {
+            const rotated = `${targetLog}.${Date.now()}.old`;
+            fs.renameSync(targetLog, rotated);
+        }
+        // Clean up old rotated logs
+        const dir = path.dirname(targetLog);
+        const baseName = path.basename(targetLog);
+        const entries = fs.readdirSync(dir);
+        const maxAge = MAX_LOG_AGE_DAYS * 24 * 60 * 60 * 1000;
+        for (const entry of entries) {
+            if (entry.startsWith(baseName + '.') && entry.endsWith('.old')) {
+                const entryPath = path.join(dir, entry);
+                const entryStat = fs.statSync(entryPath);
+                if (Date.now() - entryStat.mtimeMs > maxAge) {
+                    fs.unlinkSync(entryPath);
+                }
+            }
+        }
+    }
+    catch {
+        // Ignore rotation errors
+    }
+}
+/**
+ * Start the daemon as a detached child process.
+ * Returns the PID of the spawned process.
+ */
+export function startDaemon(logFile) {
+    const status = getDaemonStatus();
+    if (status.running) {
+        throw new Error(`Daemon is already running (PID: ${status.pid})`);
+    }
+    ensureDaemonDir();
+    const targetLog = logFile ?? LOG_FILE;
+    rotateLogIfNeeded(targetLog);
+    const logFd = fs.openSync(targetLog, 'a');
+    // Spawn the daemon worker as a detached process
+    const workerPath = path.join(import.meta.dirname, 'daemon-worker.js');
+    const child = spawn(process.execPath, [workerPath], {
+        detached: true,
+        stdio: ['ignore', logFd, logFd],
+        env: { ...process.env, LSVAULT_DAEMON: '1' },
+    });
+    if (!child.pid) {
+        fs.closeSync(logFd);
+        throw new Error('Failed to spawn daemon process');
+    }
+    writePid(child.pid);
+    child.unref();
+    fs.closeSync(logFd);
+    return child.pid;
+}
+/**
+ * Stop the running daemon.
+ */
+export function stopDaemon() {
+    const pid = readPid();
+    if (pid === null || !isProcessRunning(pid)) {
+        removePid();
+        return false;
+    }
+    try {
+        process.kill(pid, 'SIGTERM');
+        removePid();
+        return true;
+    }
+    catch {
+        removePid();
+        return false;
+    }
+}
+export { DAEMON_DIR, PID_FILE, LOG_FILE };

package/dist/sync/diff.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Diff generation for sync operations.
+ * Compares local and remote file states to determine what actions are needed.
+ */
+import type { FileState, SyncState } from './types.js';
+export type SyncAction = 'create' | 'update' | 'delete';
+export type SyncDirection = 'upload' | 'download';
+export interface SyncDiffEntry {
+    /** Document path (relative, forward slashes) */
+    path: string;
+    /** What needs to happen */
+    action: SyncAction;
+    /** Direction of the operation */
+    direction: SyncDirection;
+    /** File size in bytes (for progress reporting) */
+    sizeBytes: number;
+    /** Human-readable reason for this change */
+    reason: string;
+}
+export interface SyncDiff {
+    /** Files to upload (local -> remote) */
+    uploads: SyncDiffEntry[];
+    /** Files to download (remote -> local) */
+    downloads: SyncDiffEntry[];
+    /** Files to delete */
+    deletes: SyncDiffEntry[];
+    /** Total bytes to transfer */
+    totalBytes: number;
+}
+/**
+ * Compute the diff between local and remote state for a pull operation.
+ * Pull = download remote changes to local.
+ */
+export declare function computePullDiff(localFiles: Record<string, FileState>, remoteFiles: Record<string, FileState>, lastState: SyncState): SyncDiff;
+/**
+ * Compute the diff between local and remote state for a push operation.
+ * Push = upload local changes to remote.
+ */
+export declare function computePushDiff(localFiles: Record<string, FileState>, remoteFiles: Record<string, FileState>, lastState: SyncState): SyncDiff;
+/**
+ * Format a diff for human-readable display.
+ */
+export declare function formatDiff(diff: SyncDiff): string;