@lifestreamdynamics/vault-cli 1.0.0

package/dist/sync/remote-poller.js

@@ -0,0 +1,145 @@
+/**
+ * Remote change poller for continuous sync.
+ * Periodically checks the remote vault for changes and pulls them down.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { shouldIgnore } from './ignore.js';
+import { loadSyncState, saveSyncState, hashFileContent, buildRemoteFileState } from './state.js';
+import { updateLastSync } from './config.js';
+import { resolveConflict, detectConflict, createConflictFile, formatConflictLog } from './conflict.js';
+/**
+ * Creates and starts a remote poller for a sync configuration.
+ * Returns a stop function.
+ */
+export function createRemotePoller(client, config, options) {
+    const { ignorePatterns, intervalMs = 30000, onLog, onConflictLog, onError, onLocalWrite, } = options;
+    const log = (msg) => onLog?.(`[poll:${config.id.slice(0, 8)}] ${msg}`);
+    let timer = null;
+    let polling = false;
+    async function poll() {
+        if (polling)
+            return; // Skip if previous poll still in progress
+        polling = true;
+        try {
+            const remoteDocs = await client.documents.list(config.vaultId);
+            const state = loadSyncState(config.id);
+            let changes = 0;
+            for (const doc of remoteDocs) {
+                if (shouldIgnore(doc.path, ignorePatterns))
+                    continue;
+                const lastRemote = state.remote[doc.path];
+                // Detect remote changes by comparing mtime
+                const remoteChanged = !lastRemote || doc.fileModifiedAt !== lastRemote.mtime;
+                if (!remoteChanged)
+                    continue;
+                // Fetch the full content
+                const { content } = await client.documents.get(config.vaultId, doc.path);
+                const remoteHash = hashFileContent(content);
+                // Skip if hash hasn't actually changed
+                if (lastRemote && remoteHash === lastRemote.hash) {
+                    // Update mtime in state but skip file operations
+                    state.remote[doc.path] = buildRemoteFileState(doc.path, content, doc.fileModifiedAt);
+                    continue;
+                }
+                const localFile = path.join(config.localPath, doc.path);
+                const localExists = fs.existsSync(localFile);
+                if (localExists) {
+                    const localContent = fs.readFileSync(localFile, 'utf-8');
+                    const localHash = hashFileContent(localContent);
+                    if (localHash === remoteHash) {
+                        // Content is already the same — just update state
+                        state.local[doc.path] = { path: doc.path, hash: localHash, mtime: new Date().toISOString(), size: Buffer.byteLength(localContent) };
+                        state.remote[doc.path] = buildRemoteFileState(doc.path, content, doc.fileModifiedAt);
+                        continue;
+                    }
+                    // Check for conflict
+                    const lastLocal = state.local[doc.path];
+                    const localState = { path: doc.path, hash: localHash, mtime: fs.statSync(localFile).mtime.toISOString(), size: Buffer.byteLength(localContent) };
+                    const remoteState = { path: doc.path, hash: remoteHash, mtime: doc.fileModifiedAt, size: Buffer.byteLength(content) };
+                    if (detectConflict(localState, remoteState, lastLocal, lastRemote)) {
+                        const resolution = resolveConflict(config.onConflict, localState, remoteState);
+                        let conflictFile = null;
+                        if (resolution === 'remote') {
+                            conflictFile = createConflictFile(config.localPath, doc.path, localContent, 'local');
+                            onLocalWrite?.(doc.path);
+                            fs.writeFileSync(localFile, content, 'utf-8');
+                            log(`Conflict: ${doc.path} — used remote, saved local as ${conflictFile}`);
+                        }
+                        else {
+                            conflictFile = createConflictFile(config.localPath, doc.path, content, 'remote');
+                            await client.documents.put(config.vaultId, doc.path, localContent);
+                            log(`Conflict: ${doc.path} — used local, saved remote as ${conflictFile}`);
+                        }
+                        onConflictLog?.(formatConflictLog(doc.path, resolution, conflictFile));
+                        state.local[doc.path] = resolution === 'remote' ? remoteState : localState;
+                        state.remote[doc.path] = resolution === 'remote'
+                            ? buildRemoteFileState(doc.path, content, doc.fileModifiedAt)
+                            : buildRemoteFileState(doc.path, localContent, new Date().toISOString());
+                        changes++;
+                        continue;
+                    }
+                }
+                // No conflict — download the file
+                const dir = path.dirname(localFile);
+                if (!fs.existsSync(dir)) {
+                    fs.mkdirSync(dir, { recursive: true });
+                }
+                onLocalWrite?.(doc.path);
+                fs.writeFileSync(localFile, content, 'utf-8');
+                log(`Pulled: ${doc.path}`);
+                changes++;
+                state.local[doc.path] = {
+                    path: doc.path,
+                    hash: remoteHash,
+                    mtime: new Date().toISOString(),
+                    size: Buffer.byteLength(content),
+                };
+                state.remote[doc.path] = buildRemoteFileState(doc.path, content, doc.fileModifiedAt);
+            }
+            // Check for remote deletions
+            for (const docPath of Object.keys(state.remote)) {
+                if (shouldIgnore(docPath, ignorePatterns))
+                    continue;
+                const stillExists = remoteDocs.some(d => d.path === docPath);
+                if (!stillExists) {
+                    const localFile = path.join(config.localPath, docPath);
+                    if (fs.existsSync(localFile)) {
+                        fs.unlinkSync(localFile);
+                        log(`Deleted local: ${docPath} (removed from remote)`);
+                        changes++;
+                    }
+                    delete state.local[docPath];
+                    delete state.remote[docPath];
+                }
+            }
+            if (changes > 0) {
+                saveSyncState(state);
+                updateLastSync(config.id);
+                log(`Poll complete: ${changes} change(s)`);
+            }
+        }
+        catch (err) {
+            onError?.(err instanceof Error ? err : new Error(String(err)));
+        }
+        finally {
+            polling = false;
+        }
+    }
+    // Initial poll
+    poll().catch(err => onError?.(err instanceof Error ? err : new Error(String(err))));
+    // Start interval
+    timer = setInterval(() => {
+        poll().catch(err => onError?.(err instanceof Error ? err : new Error(String(err))));
+    }, intervalMs);
+    log(`Polling every ${intervalMs / 1000}s`);
+    return {
+        stop: () => {
+            if (timer) {
+                clearInterval(timer);
+                timer = null;
+            }
+            log('Stopped polling');
+        },
+    };
+}

package/dist/sync/state.d.ts

@@ -0,0 +1,32 @@
+import type { SyncState, FileState } from './types.js';
+/**
+ * Load sync state for a given sync configuration.
+ * Returns a fresh empty state if no state file exists.
+ */
+export declare function loadSyncState(syncId: string): SyncState;
+/**
+ * Save sync state to disk.
+ */
+export declare function saveSyncState(state: SyncState): void;
+/**
+ * Delete sync state for a given sync configuration.
+ * Returns true if the state file was found and deleted.
+ */
+export declare function deleteSyncState(syncId: string): boolean;
+/**
+ * Compute SHA-256 hash of a file's content.
+ */
+export declare function hashFileContent(content: string | Buffer): string;
+/**
+ * Build a FileState entry from a file path on the local filesystem.
+ * The docPath should be the relative document path (forward slashes).
+ */
+export declare function buildFileState(absolutePath: string, docPath: string): FileState;
+/**
+ * Build a FileState entry from remote content (e.g., from the API).
+ */
+export declare function buildRemoteFileState(docPath: string, content: string, updatedAt: string): FileState;
+/**
+ * Check if a file has changed compared to a known state.
+ */
+export declare function hasFileChanged(current: FileState, known: FileState): boolean;

package/dist/sync/state.js

@@ -0,0 +1,98 @@
+/**
+ * Sync state tracking.
+ * Manages per-sync state files at ~/.lsvault/sync-state/<syncId>.json.
+ * Tracks file hashes and modification times for change detection.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import crypto from 'node:crypto';
+const STATE_DIR = path.join(os.homedir(), '.lsvault', 'sync-state');
+function stateFilePath(syncId) {
+    return path.join(STATE_DIR, `${syncId}.json`);
+}
+/**
+ * Load sync state for a given sync configuration.
+ * Returns a fresh empty state if no state file exists.
+ */
+export function loadSyncState(syncId) {
+    const filePath = stateFilePath(syncId);
+    if (!fs.existsSync(filePath)) {
+        return {
+            syncId,
+            local: {},
+            remote: {},
+            updatedAt: new Date(0).toISOString(),
+        };
+    }
+    try {
+        const raw = fs.readFileSync(filePath, 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return {
+            syncId,
+            local: {},
+            remote: {},
+            updatedAt: new Date(0).toISOString(),
+        };
+    }
+}
+/**
+ * Save sync state to disk.
+ */
+export function saveSyncState(state) {
+    if (!fs.existsSync(STATE_DIR)) {
+        fs.mkdirSync(STATE_DIR, { recursive: true });
+    }
+    state.updatedAt = new Date().toISOString();
+    fs.writeFileSync(stateFilePath(state.syncId), JSON.stringify(state, null, 2) + '\n');
+}
+/**
+ * Delete sync state for a given sync configuration.
+ * Returns true if the state file was found and deleted.
+ */
+export function deleteSyncState(syncId) {
+    const filePath = stateFilePath(syncId);
+    if (!fs.existsSync(filePath))
+        return false;
+    fs.unlinkSync(filePath);
+    return true;
+}
+/**
+ * Compute SHA-256 hash of a file's content.
+ */
+export function hashFileContent(content) {
+    return crypto.createHash('sha256').update(content).digest('hex');
+}
+/**
+ * Build a FileState entry from a file path on the local filesystem.
+ * The docPath should be the relative document path (forward slashes).
+ */
+export function buildFileState(absolutePath, docPath) {
+    const content = fs.readFileSync(absolutePath);
+    const stat = fs.statSync(absolutePath);
+    return {
+        path: docPath,
+        hash: hashFileContent(content),
+        mtime: stat.mtime.toISOString(),
+        size: stat.size,
+    };
+}
+/**
+ * Build a FileState entry from remote content (e.g., from the API).
+ */
+export function buildRemoteFileState(docPath, content, updatedAt) {
+    return {
+        path: docPath,
+        hash: hashFileContent(content),
+        mtime: updatedAt,
+        size: Buffer.byteLength(content, 'utf-8'),
+    };
+}
+/**
+ * Check if a file has changed compared to a known state.
+ */
+export function hasFileChanged(current, known) {
+    return current.hash !== known.hash;
+}

package/dist/sync/types.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Type definitions for the sync engine.
+ */
+export type SyncMode = 'pull' | 'push' | 'sync';
+export type ConflictStrategy = 'newer' | 'local' | 'remote' | 'ask';
+/**
+ * Persisted configuration for a single vault sync.
+ * Stored in ~/.lsvault/syncs.json.
+ */
+export interface SyncConfig {
+    /** Unique identifier for this sync configuration */
+    id: string;
+    /** Remote vault ID */
+    vaultId: string;
+    /** Absolute local filesystem path */
+    localPath: string;
+    /** Sync direction: pull (remote->local), push (local->remote), sync (bidirectional) */
+    mode: SyncMode;
+    /** How to resolve conflicts */
+    onConflict: ConflictStrategy;
+    /** Glob patterns to ignore (relative to localPath) */
+    ignore: string[];
+    /** ISO 8601 timestamp of last successful sync */
+    lastSyncAt: string;
+    /** Sync interval for auto-sync (e.g., '5m', '1h') */
+    syncInterval?: string;
+    /** Whether auto-sync is enabled */
+    autoSync: boolean;
+}
+/**
+ * Per-file tracking entry in sync state.
+ */
+export interface FileState {
+    /** Document path (relative, using forward slashes) */
+    path: string;
+    /** SHA-256 hash of the file content */
+    hash: string;
+    /** Last modified time as ISO 8601 timestamp */
+    mtime: string;
+    /** File size in bytes */
+    size: number;
+}
+/**
+ * Persisted state for a single sync configuration.
+ * Stored in ~/.lsvault/sync-state/<syncId>.json.
+ */
+export interface SyncState {
+    /** Corresponding sync config ID */
+    syncId: string;
+    /** Map of document path -> file state for local files */
+    local: Record<string, FileState>;
+    /** Map of document path -> file state for remote files */
+    remote: Record<string, FileState>;
+    /** ISO 8601 timestamp when state was last updated */
+    updatedAt: string;
+}
+/**
+ * Options for creating a new sync configuration.
+ */
+export interface CreateSyncOptions {
+    vaultId: string;
+    localPath: string;
+    mode?: SyncMode;
+    onConflict?: ConflictStrategy;
+    ignore?: string[];
+    syncInterval?: string;
+    autoSync?: boolean;
+}

package/dist/sync/types.js

@@ -0,0 +1,4 @@
+/**
+ * Type definitions for the sync engine.
+ */
+export {};

package/dist/sync/watcher.d.ts

@@ -0,0 +1,23 @@
+import { type FSWatcher } from 'chokidar';
+import type { LifestreamVaultClient } from '@lifestreamdynamics/vault-sdk';
+import type { SyncConfig } from './types.js';
+export interface WatcherOptions {
+    /** Patterns to ignore */
+    ignorePatterns: string[];
+    /** Callback for log messages */
+    onLog?: (message: string) => void;
+    /** Callback for conflict log messages */
+    onConflictLog?: (message: string) => void;
+    /** Callback for errors */
+    onError?: (error: Error) => void;
+    /** Debounce delay in ms (default: 500) */
+    debounceMs?: number;
+}
+/**
+ * Creates and starts a file watcher for a sync configuration.
+ * Returns a cleanup function to stop watching.
+ */
+export declare function createWatcher(client: LifestreamVaultClient, config: SyncConfig, options: WatcherOptions): {
+    watcher: FSWatcher;
+    stop: () => Promise<void>;
+};

package/dist/sync/watcher.js

@@ -0,0 +1,207 @@
+/**
+ * Local file watcher for continuous sync.
+ * Uses chokidar to detect file changes and triggers sync operations.
+ */
+import path from 'node:path';
+import { randomBytes } from 'node:crypto';
+import { watch } from 'chokidar';
+import { shouldIgnore } from './ignore.js';
+import { hashFileContent, loadSyncState, saveSyncState, buildRemoteFileState } from './state.js';
+import { updateLastSync } from './config.js';
+import { resolveConflict, detectConflict, createConflictFile, formatConflictLog } from './conflict.js';
+import fs from 'node:fs';
+/** TTL set to prevent sync loops — files written by sync are ignored for 5s */
+class RecentlyWrittenSet {
+    map = new Map();
+    ttlMs;
+    constructor(ttlMs = 5000) {
+        this.ttlMs = ttlMs;
+    }
+    add(filePath) {
+        this.map.set(filePath, Date.now());
+    }
+    has(filePath) {
+        const ts = this.map.get(filePath);
+        if (!ts)
+            return false;
+        if (Date.now() - ts > this.ttlMs) {
+            this.map.delete(filePath);
+            return false;
+        }
+        return true;
+    }
+    clear() {
+        this.map.clear();
+    }
+}
+/**
+ * Creates and starts a file watcher for a sync configuration.
+ * Returns a cleanup function to stop watching.
+ */
+export function createWatcher(client, config, options) {
+    const { ignorePatterns, onLog, onConflictLog, onError, debounceMs = 500 } = options;
+    const recentlyWritten = new RecentlyWrittenSet();
+    const pendingChanges = new Map();
+    const log = (msg) => onLog?.(`[sync:${config.id.slice(0, 8)}] ${msg}`);
+    function toDocPath(absPath) {
+        const rel = path.relative(config.localPath, absPath);
+        return rel.split(path.sep).join('/');
+    }
+    /**
+     * Handles a detected conflict between local and remote versions of a file.
+     * Creates a backup of the losing side and applies the winning resolution.
+     * Returns the resolution chosen, or 'skip' if no actual conflict was detected.
+     */
+    async function handleConflict(params) {
+        const { absPath, docPath, localContent, localHash, lastLocal, lastRemote, remoteContent, remoteHash, remoteUpdatedAt, state } = params;
+        const localState = { path: docPath, hash: localHash, mtime: new Date().toISOString(), size: Buffer.byteLength(localContent) };
+        const remoteState = { path: docPath, hash: remoteHash, mtime: remoteUpdatedAt, size: Buffer.byteLength(remoteContent) };
+        if (!detectConflict(localState, remoteState, lastLocal, lastRemote)) {
+            return 'skip';
+        }
+        const resolution = resolveConflict(config.onConflict, localState, remoteState);
+        let conflictFile = null;
+        if (resolution === 'local') {
+            conflictFile = createConflictFile(config.localPath, docPath, remoteContent, 'remote');
+            await client.documents.put(config.vaultId, docPath, localContent);
+            log(`Conflict: ${docPath} — used local, saved remote as ${conflictFile}`);
+        }
+        else {
+            conflictFile = createConflictFile(config.localPath, docPath, localContent, 'local');
+            recentlyWritten.add(docPath);
+            const tmpFile = absPath + '.tmp.' + randomBytes(4).toString('hex');
+            fs.writeFileSync(tmpFile, remoteContent, 'utf-8');
+            fs.renameSync(tmpFile, absPath);
+            log(`Conflict: ${docPath} — used remote, saved local as ${conflictFile}`);
+        }
+        onConflictLog?.(formatConflictLog(docPath, resolution, conflictFile));
+        state.local[docPath] = resolution === 'local' ? localState : remoteState;
+        state.remote[docPath] = resolution === 'local'
+            ? buildRemoteFileState(docPath, localContent, new Date().toISOString())
+            : buildRemoteFileState(docPath, remoteContent, remoteUpdatedAt);
+        saveSyncState(state);
+        return resolution;
+    }
+    async function handleFileChange(absPath) {
+        const docPath = toDocPath(absPath);
+        if (shouldIgnore(docPath, ignorePatterns))
+            return;
+        if (!docPath.endsWith('.md'))
+            return;
+        if (recentlyWritten.has(docPath)) {
+            log(`Skipping ${docPath} (recently written by sync)`);
+            return;
+        }
+        try {
+            const content = fs.readFileSync(absPath, 'utf-8');
+            const localHash = hashFileContent(content);
+            const state = loadSyncState(config.id);
+            const lastLocal = state.local[docPath];
+            const lastRemote = state.remote[docPath];
+            // Check remote for conflicts in bidirectional mode
+            if (config.mode === 'sync' && lastRemote) {
+                try {
+                    const remote = await client.documents.get(config.vaultId, docPath);
+                    const remoteHash = hashFileContent(remote.content);
+                    if (remoteHash !== lastRemote.hash) {
+                        const result = await handleConflict({
+                            absPath, docPath, localContent: content, localHash,
+                            lastLocal, lastRemote,
+                            remoteContent: remote.content, remoteHash,
+                            remoteUpdatedAt: remote.document.updatedAt, state,
+                        });
+                        if (result !== 'skip')
+                            return;
+                    }
+                }
+                catch {
+                    // Remote check failed — proceed with push
+                }
+            }
+            // No conflict — push the change
+            if (config.mode === 'push' || config.mode === 'sync') {
+                await client.documents.put(config.vaultId, docPath, content);
+                log(`Pushed: ${docPath}`);
+                state.local[docPath] = { path: docPath, hash: localHash, mtime: new Date().toISOString(), size: Buffer.byteLength(content) };
+                state.remote[docPath] = buildRemoteFileState(docPath, content, new Date().toISOString());
+                saveSyncState(state);
+                updateLastSync(config.id);
+            }
+        }
+        catch (err) {
+            onError?.(err instanceof Error ? err : new Error(String(err)));
+        }
+    }
+    async function handleFileDelete(absPath) {
+        const docPath = toDocPath(absPath);
+        if (shouldIgnore(docPath, ignorePatterns))
+            return;
+        if (!docPath.endsWith('.md'))
+            return;
+        if (recentlyWritten.has(docPath))
+            return;
+        try {
+            if (config.mode === 'push' || config.mode === 'sync') {
+                await client.documents.delete(config.vaultId, docPath);
+                log(`Deleted remote: ${docPath}`);
+                const state = loadSyncState(config.id);
+                delete state.local[docPath];
+                delete state.remote[docPath];
+                saveSyncState(state);
+                updateLastSync(config.id);
+            }
+        }
+        catch (err) {
+            onError?.(err instanceof Error ? err : new Error(String(err)));
+        }
+    }
+    const watcher = watch(config.localPath, {
+        ignoreInitial: true,
+        persistent: true,
+        awaitWriteFinish: { stabilityThreshold: debounceMs },
+        ignored: (filePath) => {
+            const rel = path.relative(config.localPath, filePath);
+            if (!rel || rel === '.')
+                return false;
+            const docPath = rel.split(path.sep).join('/');
+            return shouldIgnore(docPath, ignorePatterns);
+        },
+    });
+    watcher.on('add', (absPath) => {
+        clearTimeout(pendingChanges.get(absPath));
+        pendingChanges.set(absPath, setTimeout(() => {
+            pendingChanges.delete(absPath);
+            handleFileChange(absPath).catch(err => onError?.(err instanceof Error ? err : new Error(String(err))));
+        }, debounceMs));
+    });
+    watcher.on('change', (absPath) => {
+        clearTimeout(pendingChanges.get(absPath));
+        pendingChanges.set(absPath, setTimeout(() => {
+            pendingChanges.delete(absPath);
+            handleFileChange(absPath).catch(err => onError?.(err instanceof Error ? err : new Error(String(err))));
+        }, debounceMs));
+    });
+    watcher.on('unlink', (absPath) => {
+        clearTimeout(pendingChanges.get(absPath));
+        pendingChanges.set(absPath, setTimeout(() => {
+            pendingChanges.delete(absPath);
+            handleFileDelete(absPath).catch(err => onError?.(err instanceof Error ? err : new Error(String(err))));
+        }, debounceMs));
+    });
+    watcher.on('error', (err) => {
+        onError?.(err instanceof Error ? err : new Error(String(err)));
+    });
+    log('Watching for changes...');
+    return {
+        watcher,
+        stop: async () => {
+            for (const timeout of pendingChanges.values()) {
+                clearTimeout(timeout);
+            }
+            pendingChanges.clear();
+            recentlyWritten.clear();
+            await watcher.close();
+            log('Stopped watching');
+        },
+    };
+}

package/dist/utils/flags.d.ts

@@ -0,0 +1,18 @@
+import type { Command } from 'commander';
+export type OutputFormat = 'text' | 'json' | 'table';
+export interface GlobalFlags {
+    output: OutputFormat;
+    verbose: boolean;
+    quiet: boolean;
+    noColor: boolean;
+    dryRun: boolean;
+}
+/**
+ * Add universal flags to a command.
+ * Call this on each leaf command (action command) to register the flags.
+ */
+export declare function addGlobalFlags(cmd: Command): Command;
+/**
+ * Resolve global flags from parsed options, applying TTY detection defaults.
+ */
+export declare function resolveFlags(opts: Record<string, unknown>): GlobalFlags;

package/dist/utils/flags.js

@@ -0,0 +1,31 @@
+import chalk from 'chalk';
+/**
+ * Add universal flags to a command.
+ * Call this on each leaf command (action command) to register the flags.
+ */
+export function addGlobalFlags(cmd) {
+    return cmd
+        .option('-o, --output <format>', 'Output format: text, json, table (default: auto)')
+        .option('-v, --verbose', 'Verbose output (debug info)')
+        .option('-q, --quiet', 'Minimal output (errors only)')
+        .option('--no-color', 'Disable colored output')
+        .option('--dry-run', 'Preview changes (where applicable)');
+}
+/**
+ * Resolve global flags from parsed options, applying TTY detection defaults.
+ */
+export function resolveFlags(opts) {
+    const isTTY = process.stdout.isTTY ?? false;
+    const noColor = opts.noColor === true || opts.color === false;
+    const format = opts.output ?? (isTTY ? 'text' : 'json');
+    if (noColor) {
+        chalk.level = 0;
+    }
+    return {
+        output: format,
+        verbose: opts.verbose === true,
+        quiet: opts.quiet === true,
+        noColor,
+        dryRun: opts.dryRun === true,
+    };
+}

package/dist/utils/format.d.ts

@@ -0,0 +1,2 @@
+export declare function formatBytes(bytes: number): string;
+export declare function formatUptime(seconds: number): string;

package/dist/utils/format.js

@@ -0,0 +1,22 @@
+export function formatBytes(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(1024));
+    return `${(bytes / Math.pow(1024, i)).toFixed(1)} ${units[i]}`;
+}
+export function formatUptime(seconds) {
+    const days = Math.floor(seconds / 86400);
+    const hours = Math.floor((seconds % 86400) / 3600);
+    const mins = Math.floor((seconds % 3600) / 60);
+    const secs = seconds % 60;
+    const parts = [];
+    if (days > 0)
+        parts.push(`${days}d`);
+    if (hours > 0)
+        parts.push(`${hours}h`);
+    parts.push(`${mins}m`);
+    if (days === 0)
+        parts.push(`${secs}s`);
+    return parts.join(' ');
+}