@lifestreamdynamics/vault-cli 1.0.1 → 1.2.0

package/dist/commands/vaults.js

@@ -154,4 +154,227 @@ EXAMPLES
             handleError(out, err, 'Failed to import vault key');
         }
     });
+    // vault tree
+    addGlobalFlags(vaults.command('tree')
+        .description('Show vault file tree')
+        .argument('<vaultId>', 'Vault ID'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching vault tree...');
+        try {
+            const client = await getClientAsync();
+            const tree = await client.vaults.getTree(vaultId);
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.raw(JSON.stringify(tree, null, 2) + '\n');
+            }
+            else {
+                function printNode(node, depth) {
+                    const indent = '  '.repeat(depth);
+                    const icon = node.type === 'directory' ? chalk.yellow('📁') : chalk.cyan('📄');
+                    process.stdout.write(`${indent}${icon} ${node.name}\n`);
+                    if (node.children) {
+                        for (const child of node.children)
+                            printNode(child, depth + 1);
+                    }
+                }
+                for (const node of tree)
+                    printNode(node, 0);
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch vault tree');
+        }
+    });
+    // vault archive
+    addGlobalFlags(vaults.command('archive')
+        .description('Archive a vault')
+        .argument('<vaultId>', 'Vault ID'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Archiving vault...');
+        try {
+            const client = await getClientAsync();
+            const vault = await client.vaults.archive(vaultId);
+            out.success(`Vault archived: ${vault.name}`, { id: vault.id, name: vault.name, isArchived: vault.isArchived });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to archive vault');
+        }
+    });
+    // vault unarchive
+    addGlobalFlags(vaults.command('unarchive')
+        .description('Unarchive a vault')
+        .argument('<vaultId>', 'Vault ID'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Unarchiving vault...');
+        try {
+            const client = await getClientAsync();
+            const vault = await client.vaults.unarchive(vaultId);
+            out.success(`Vault unarchived: ${vault.name}`, { id: vault.id, name: vault.name, isArchived: vault.isArchived });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to unarchive vault');
+        }
+    });
+    // vault transfer
+    addGlobalFlags(vaults.command('transfer')
+        .description('Transfer vault ownership to another user')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<targetEmail>', 'Email of the user to transfer to'))
+        .action(async (vaultId, targetEmail, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Transferring vault...');
+        try {
+            const client = await getClientAsync();
+            const vault = await client.vaults.transfer(vaultId, targetEmail);
+            out.success(`Vault transferred to ${targetEmail}`, { id: vault.id, name: vault.name });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to transfer vault');
+        }
+    });
+    // vault export-vault subgroup
+    const exportVault = vaults.command('export-vault').description('Vault export operations');
+    addGlobalFlags(exportVault.command('create')
+        .description('Create a vault export')
+        .argument('<vaultId>', 'Vault ID')
+        .option('--metadata', 'Include metadata in export')
+        .option('--format <fmt>', 'Export format', 'zip'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Creating export...');
+        try {
+            const client = await getClientAsync();
+            const exp = await client.vaults.createExport(vaultId, {
+                includeMetadata: _opts.metadata === true,
+                format: _opts.format || 'zip',
+            });
+            out.success('Export created', { id: exp.id, status: exp.status, format: exp.format });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to create export');
+        }
+    });
+    addGlobalFlags(exportVault.command('list')
+        .description('List vault exports')
+        .argument('<vaultId>', 'Vault ID'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching exports...');
+        try {
+            const client = await getClientAsync();
+            const exports = await client.vaults.listExports(vaultId);
+            out.stopSpinner();
+            out.list(exports.map(e => ({ id: e.id, status: e.status, format: e.format, createdAt: e.createdAt, completedAt: e.completedAt || '' })), {
+                emptyMessage: 'No exports found.',
+                columns: [
+                    { key: 'id', header: 'ID' },
+                    { key: 'status', header: 'Status' },
+                    { key: 'format', header: 'Format' },
+                    { key: 'createdAt', header: 'Created' },
+                    { key: 'completedAt', header: 'Completed' },
+                ],
+                textFn: (e) => `${chalk.cyan(String(e.id))} [${String(e.status)}] ${String(e.format)} created: ${String(e.createdAt)}`,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to list exports');
+        }
+    });
+    addGlobalFlags(exportVault.command('download')
+        .description('Download a vault export')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<exportId>', 'Export ID')
+        .requiredOption('--file <path>', 'Output file path'))
+        .action(async (vaultId, exportId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Downloading export...');
+        try {
+            const { writeFile } = await import('node:fs/promises');
+            const client = await getClientAsync();
+            const blob = await client.vaults.downloadExport(vaultId, exportId);
+            const buffer = Buffer.from(await blob.arrayBuffer());
+            await writeFile(_opts.file, buffer);
+            out.success(`Export downloaded to ${String(_opts.file)}`, { path: _opts.file, size: buffer.length });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to download export');
+        }
+    });
+    // vault mfa subgroup
+    const mfa = vaults.command('mfa').description('Vault MFA configuration');
+    addGlobalFlags(mfa.command('get')
+        .description('Get vault MFA configuration')
+        .argument('<vaultId>', 'Vault ID'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching MFA config...');
+        try {
+            const client = await getClientAsync();
+            const config = await client.vaults.getMfaConfig(vaultId);
+            out.stopSpinner();
+            out.record({
+                mfaRequired: config.mfaRequired,
+                sessionWindowMinutes: config.sessionWindowMinutes,
+                userVerified: config.userVerified,
+                verificationExpiresAt: config.verificationExpiresAt,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch MFA config');
+        }
+    });
+    addGlobalFlags(mfa.command('set')
+        .description('Set vault MFA configuration')
+        .argument('<vaultId>', 'Vault ID')
+        .option('--require', 'Require MFA for vault access')
+        .option('--no-require', 'Disable MFA requirement')
+        .option('--window <minutes>', 'Session window in minutes', '60'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Updating MFA config...');
+        try {
+            const client = await getClientAsync();
+            const config = await client.vaults.setMfaConfig(vaultId, {
+                mfaRequired: _opts.require !== false,
+                sessionWindowMinutes: parseInt(String(_opts.window || '60'), 10),
+            });
+            out.success('MFA config updated', { mfaRequired: config.mfaRequired, sessionWindowMinutes: config.sessionWindowMinutes });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to update MFA config');
+        }
+    });
+    addGlobalFlags(mfa.command('verify')
+        .description('Verify MFA for vault access')
+        .argument('<vaultId>', 'Vault ID')
+        .requiredOption('--method <totp|backup_code>', 'MFA method')
+        .requiredOption('--code <code>', 'MFA code'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Verifying MFA...');
+        try {
+            const client = await getClientAsync();
+            const result = await client.vaults.verifyMfa(vaultId, {
+                method: _opts.method,
+                code: _opts.code,
+            });
+            out.success('MFA verified', { verified: result.verified, expiresAt: result.expiresAt });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to verify MFA');
+        }
+    });
 }

package/dist/index.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
 import { registerAuthCommands } from './commands/auth.js';
+import { registerMfaCommands } from './commands/mfa.js';
 import { registerVaultCommands } from './commands/vaults.js';
 import { registerDocCommands } from './commands/docs.js';
 import { registerSearchCommands } from './commands/search.js';
@@ -18,6 +19,12 @@ import { registerWebhookCommands } from './commands/webhooks.js';
 import { registerConfigCommands } from './commands/config.js';
 import { registerSyncCommands } from './commands/sync.js';
 import { registerVersionCommands } from './commands/versions.js';
+import { registerLinkCommands } from './commands/links.js';
+import { registerCalendarCommands } from './commands/calendar.js';
+import { registerAiCommands } from './commands/ai.js';
+import { registerAnalyticsCommands } from './commands/analytics.js';
+import { registerCustomDomainCommands } from './commands/custom-domains.js';
+import { registerPublishVaultCommands } from './commands/publish-vault.js';
 const program = new Command();
 program
     .name('lsvault')
@@ -43,6 +50,7 @@ LEARN MORE
   lsvault <command> --help                   Show help for a command
   lsvault <command> <subcommand> --help      Show help for a subcommand`);
 registerAuthCommands(program);
+registerMfaCommands(program);
 registerVaultCommands(program);
 registerDocCommands(program);
 registerSearchCommands(program);
@@ -60,4 +68,10 @@ registerWebhookCommands(program);
 registerConfigCommands(program);
 registerSyncCommands(program);
 registerVersionCommands(program);
+registerLinkCommands(program);
+registerCalendarCommands(program);
+registerAiCommands(program);
+registerAnalyticsCommands(program);
+registerCustomDomainCommands(program);
+registerPublishVaultCommands(program);
 program.parse();

package/dist/sync/daemon-worker.js

@@ -10,6 +10,8 @@ import { createRemotePoller } from './remote-poller.js';
 import { removePid } from './daemon.js';
 import { loadConfig } from '../config.js';
 import { LifestreamVaultClient } from '@lifestreamdynamics/vault-sdk';
+import { scanLocalFiles, scanRemoteFiles, computePushDiff, computePullDiff, executePush, executePull } from './engine.js';
+import { loadSyncState } from './state.js';
 const managed = [];
 function log(msg) {
     const ts = new Date().toISOString();
@@ -35,6 +37,66 @@ async function start() {
     }
     log(`Found ${configs.length} auto-sync configuration(s)`);
     const client = createClient();
+    // Startup reconciliation: catch changes made while daemon was stopped
+    for (const config of configs) {
+        try {
+            log(`Reconciling ${config.id.slice(0, 8)} (${config.mode} mode)...`);
+            const ignorePatterns = resolveIgnorePatterns(config.ignore, config.localPath);
+            const lastState = loadSyncState(config.id);
+            const localFiles = scanLocalFiles(config.localPath, ignorePatterns);
+            const remoteFiles = await scanRemoteFiles(client, config.vaultId, ignorePatterns);
+            let pushed = 0;
+            let pulled = 0;
+            let deleted = 0;
+            if (config.mode === 'push' || config.mode === 'sync') {
+                const pushDiff = computePushDiff(localFiles, remoteFiles, lastState);
+                const pushOps = pushDiff.uploads.length + pushDiff.deletes.length;
+                if (pushOps > 0) {
+                    const result = await executePush(client, config, pushDiff);
+                    pushed = result.filesUploaded;
+                    deleted += result.filesDeleted;
+                    if (result.errors.length > 0) {
+                        for (const err of result.errors) {
+                            log(`  Push error: ${err.path}: ${err.error}`);
+                        }
+                    }
+                }
+            }
+            if (config.mode === 'pull' || config.mode === 'sync') {
+                const pullDiff = computePullDiff(localFiles, remoteFiles, lastState);
+                const pullOps = pullDiff.downloads.length + pullDiff.deletes.length;
+                if (pullOps > 0) {
+                    const result = await executePull(client, config, pullDiff);
+                    pulled = result.filesDownloaded;
+                    deleted += result.filesDeleted;
+                    if (result.errors.length > 0) {
+                        for (const err of result.errors) {
+                            log(`  Pull error: ${err.path}: ${err.error}`);
+                        }
+                    }
+                }
+            }
+            const total = pushed + pulled + deleted;
+            if (total > 0) {
+                const parts = [];
+                if (pushed > 0)
+                    parts.push(`${pushed} uploaded`);
+                if (pulled > 0)
+                    parts.push(`${pulled} downloaded`);
+                if (deleted > 0)
+                    parts.push(`${deleted} deleted`);
+                log(`Reconciled ${config.id.slice(0, 8)}: ${parts.join(', ')}`);
+            }
+            else {
+                log(`Reconciled ${config.id.slice(0, 8)}: up to date`);
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            log(`Reconciliation failed for ${config.id.slice(0, 8)}: ${msg}`);
+            // Continue — still start the watcher even if reconciliation fails
+        }
+    }
     for (const config of configs) {
         try {
             const ignorePatterns = resolveIgnorePatterns(config.ignore, config.localPath);

package/dist/sync/daemon.d.ts

@@ -36,9 +36,17 @@ 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;
+export declare function startDaemon(logFile?: string): {
+    pid: number;
+    lingerWarning?: string;
+};
 /**
  * Stop the running daemon.
  */
 export declare function stopDaemon(): boolean;
+/**
+ * Check if systemd linger is enabled for the current user (Linux only).
+ * When linger is disabled, user services stop when the SSH session ends.
+ */
+export declare function checkLingerStatus(): 'enabled' | 'disabled' | 'unknown';
 export { DAEMON_DIR, PID_FILE, LOG_FILE };

package/dist/sync/daemon.js

@@ -150,7 +150,12 @@ export function startDaemon(logFile) {
     writePid(child.pid);
     child.unref();
     fs.closeSync(logFd);
-    return child.pid;
+    const result = { pid: child.pid };
+    const lingerStatus = checkLingerStatus();
+    if (lingerStatus === 'disabled') {
+        result.lingerWarning = 'systemd lingering is not enabled for your user. The daemon will stop when you log out. To fix:\n  sudo loginctl enable-linger $(whoami)';
+    }
+    return result;
 }
 /**
  * Stop the running daemon.
@@ -171,4 +176,20 @@ export function stopDaemon() {
         return false;
     }
 }
+/**
+ * Check if systemd linger is enabled for the current user (Linux only).
+ * When linger is disabled, user services stop when the SSH session ends.
+ */
+export function checkLingerStatus() {
+    if (process.platform !== 'linux')
+        return 'unknown';
+    try {
+        const username = os.userInfo().username;
+        const lingerFile = `/var/lib/systemd/linger/${username}`;
+        return fs.existsSync(lingerFile) ? 'enabled' : 'disabled';
+    }
+    catch {
+        return 'unknown';
+    }
+}
 export { DAEMON_DIR, PID_FILE, LOG_FILE };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lifestreamdynamics/vault-cli",
-  "version": "1.0.1",
+  "version": "1.2.0",
   "description": "Command-line interface for Lifestream Vault",
   "engines": {
     "node": ">=20"
@@ -44,7 +44,7 @@
     "prepublishOnly": "npm run build && npm test"
   },
   "dependencies": {
-    "@lifestreamdynamics/vault-sdk": "^1.0.0",
+    "@lifestreamdynamics/vault-sdk": "^1.2.0",
     "chalk": "^5.4.0",
     "chokidar": "^4.0.3",
     "commander": "^13.0.0",