@lifestreamdynamics/vault-cli 1.0.0

package/dist/commands/docs.js

@@ -0,0 +1,194 @@
+import chalk from 'chalk';
+import { getClient } from '../client.js';
+import { addGlobalFlags, resolveFlags } from '../utils/flags.js';
+import { createOutput, handleError } from '../utils/output.js';
+import { createCredentialManager } from '../lib/credential-manager.js';
+export function registerDocCommands(program) {
+    const docs = program.command('docs').description('Read, write, move, and delete documents in a vault');
+    addGlobalFlags(docs.command('list')
+        .description('List documents in a vault, optionally filtered by directory')
+        .argument('<vaultId>', 'Vault ID')
+        .option('--dir <path>', 'Filter by directory path')
+        .addHelpText('after', `
+EXAMPLES
+  lsvault docs list abc123
+  lsvault docs list abc123 --dir notes/meetings`))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching documents...');
+        try {
+            const client = getClient();
+            const documents = await client.documents.list(vaultId, _opts.dir);
+            out.stopSpinner();
+            out.list(documents.map(doc => ({
+                path: doc.path,
+                title: doc.title || '',
+                tags: Array.isArray(doc.tags) ? doc.tags.join(', ') : '',
+                sizeBytes: doc.sizeBytes,
+            })), {
+                emptyMessage: 'No documents found.',
+                columns: [
+                    { key: 'path', header: 'Path' },
+                    { key: 'title', header: 'Title' },
+                    { key: 'tags', header: 'Tags' },
+                    { key: 'sizeBytes', header: 'Size' },
+                ],
+                textFn: (doc) => {
+                    const title = doc.title ? chalk.dim(` -- ${String(doc.title)}`) : '';
+                    const tags = doc.tags ? chalk.blue(` [${String(doc.tags)}]`) : '';
+                    return `${chalk.cyan(String(doc.path))}${title}${tags}`;
+                },
+            });
+            if (flags.output === 'text' && documents.length > 0) {
+                out.status(chalk.dim(`\n${documents.length} document(s)`));
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch documents');
+        }
+    });
+    addGlobalFlags(docs.command('get')
+        .description('Print document content to stdout, or show metadata with --meta')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<path>', 'Document path (e.g., notes/todo.md)')
+        .option('--meta', 'Show metadata instead of content')
+        .addHelpText('after', `
+EXAMPLES
+  lsvault docs get abc123 notes/todo.md
+  lsvault docs get abc123 notes/todo.md --meta
+  lsvault docs get abc123 notes/todo.md > local-copy.md`))
+        .action(async (vaultId, docPath, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        try {
+            const client = getClient();
+            const result = await client.documents.get(vaultId, docPath);
+            // Auto-decrypt if the document is encrypted
+            if (result.document.encrypted && !_opts.meta) {
+                const credManager = createCredentialManager();
+                const vaultKey = await credManager.getVaultKey(vaultId);
+                if (!vaultKey) {
+                    out.error('Document is encrypted but no vault key found.');
+                    out.status(chalk.dim('Import the key with: lsvault vaults import-key ' + vaultId + ' --key <key>'));
+                    process.exitCode = 1;
+                    return;
+                }
+                const decrypted = await client.documents.getEncrypted(vaultId, docPath, vaultKey);
+                out.raw(decrypted.content);
+                return;
+            }
+            if (_opts.meta) {
+                const doc = result.document;
+                out.record({
+                    path: doc.path,
+                    title: doc.title,
+                    sizeBytes: doc.sizeBytes,
+                    tags: Array.isArray(doc.tags) ? doc.tags.join(', ') : '',
+                    encrypted: doc.encrypted ? 'yes' : 'no',
+                    contentHash: doc.contentHash,
+                    fileModifiedAt: doc.fileModifiedAt,
+                    createdAt: doc.createdAt,
+                    updatedAt: doc.updatedAt,
+                });
+            }
+            else {
+                out.raw(result.content);
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to get document');
+        }
+    });
+    addGlobalFlags(docs.command('put')
+        .description('Create or update a document by reading content from stdin')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<path>', 'Document path (must end with .md)')
+        .addHelpText('after', `
+EXAMPLES
+  echo "# Hello" | lsvault docs put abc123 notes/hello.md
+  cat local-file.md | lsvault docs put abc123 docs/imported.md`))
+        .action(async (vaultId, docPath, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Reading stdin...');
+        try {
+            const content = await new Promise((resolve) => {
+                let data = '';
+                process.stdin.on('data', (chunk) => data += chunk);
+                process.stdin.on('end', () => resolve(data));
+            });
+            out.startSpinner('Uploading document...');
+            const client = getClient();
+            // Check if vault is encrypted and auto-encrypt
+            const vault = await client.vaults.get(vaultId);
+            let doc;
+            if (vault.encryptionEnabled) {
+                const credManager = createCredentialManager();
+                const vaultKey = await credManager.getVaultKey(vaultId);
+                if (!vaultKey) {
+                    out.failSpinner('Failed to save document');
+                    out.error('Vault is encrypted but no vault key found.');
+                    out.status(chalk.dim('Import the key with: lsvault vaults import-key ' + vaultId + ' --key <key>'));
+                    process.exitCode = 1;
+                    return;
+                }
+                doc = await client.documents.putEncrypted(vaultId, docPath, content, vaultKey);
+            }
+            else {
+                doc = await client.documents.put(vaultId, docPath, content);
+            }
+            out.success(`Document saved: ${chalk.cyan(doc.path)} (${doc.sizeBytes} bytes)`, {
+                path: doc.path,
+                sizeBytes: doc.sizeBytes,
+                encrypted: doc.encrypted,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to save document');
+        }
+    });
+    addGlobalFlags(docs.command('delete')
+        .description('Permanently delete a document from a vault')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<path>', 'Document path to delete'))
+        .action(async (vaultId, docPath, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Deleting document...');
+        try {
+            const client = getClient();
+            await client.documents.delete(vaultId, docPath);
+            out.success(`Deleted: ${chalk.cyan(docPath)}`, { path: docPath, deleted: true });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to delete document');
+        }
+    });
+    addGlobalFlags(docs.command('move')
+        .description('Move or rename a document within a vault')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<source>', 'Current document path')
+        .argument('<dest>', 'New document path')
+        .option('--overwrite', 'Overwrite if destination already exists')
+        .addHelpText('after', `
+EXAMPLES
+  lsvault docs move abc123 notes/old.md notes/new.md
+  lsvault docs move abc123 draft.md published/final.md --overwrite`))
+        .action(async (vaultId, source, dest, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Moving document...');
+        try {
+            const client = getClient();
+            const result = await client.documents.move(vaultId, source, dest, _opts.overwrite);
+            out.success(`Moved: ${chalk.cyan(result.source)} -> ${chalk.cyan(result.destination)}`, {
+                source: result.source,
+                destination: result.destination,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to move document');
+        }
+    });
+}

package/dist/commands/hooks.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerHookCommands(program: Command): void;

package/dist/commands/hooks.js

@@ -0,0 +1,159 @@
+import chalk from 'chalk';
+import { getClient } from '../client.js';
+import { addGlobalFlags, resolveFlags } from '../utils/flags.js';
+import { createOutput, handleError } from '../utils/output.js';
+export function registerHookCommands(program) {
+    const hooks = program.command('hooks').description('Manage vault event hooks (auto-tag, template, etc.)');
+    addGlobalFlags(hooks.command('list')
+        .description('List all hooks for a vault')
+        .argument('<vaultId>', 'Vault ID'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching hooks...');
+        try {
+            const client = getClient();
+            const hookList = await client.hooks.list(vaultId);
+            out.stopSpinner();
+            out.list(hookList.map(hook => ({
+                name: hook.name,
+                id: hook.id,
+                triggerEvent: hook.triggerEvent,
+                actionType: hook.actionType,
+                isActive: hook.isActive,
+            })), {
+                emptyMessage: 'No hooks found.',
+                columns: [
+                    { key: 'name', header: 'Name' },
+                    { key: 'triggerEvent', header: 'Trigger' },
+                    { key: 'actionType', header: 'Action' },
+                    { key: 'isActive', header: 'Active' },
+                ],
+                textFn: (hook) => {
+                    const lines = [chalk.cyan(`  ${String(hook.name)}`)];
+                    lines.push(`  ID:      ${String(hook.id)}`);
+                    lines.push(`  Trigger: ${String(hook.triggerEvent)}`);
+                    lines.push(`  Action:  ${String(hook.actionType)}`);
+                    lines.push(`  Active:  ${hook.isActive ? chalk.green('Yes') : chalk.red('No')}`);
+                    return lines.join('\n');
+                },
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch hooks');
+        }
+    });
+    addGlobalFlags(hooks.command('create')
+        .description('Create a new hook')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<name>', 'Hook name')
+        .requiredOption('--trigger <event>', 'Trigger event (e.g., document.create)')
+        .requiredOption('--action <type>', 'Action type (e.g., auto-tag, template)')
+        .requiredOption('--config <json>', 'Action configuration as JSON')
+        .option('--filter <json>', 'Trigger filter as JSON'))
+        .action(async (vaultId, name, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        let actionConfig;
+        try {
+            actionConfig = JSON.parse(String(_opts.config));
+        }
+        catch {
+            out.error('--config must be valid JSON');
+            process.exitCode = 2;
+            return;
+        }
+        let triggerFilter;
+        if (_opts.filter) {
+            try {
+                triggerFilter = JSON.parse(String(_opts.filter));
+            }
+            catch {
+                out.error('--filter must be valid JSON');
+                process.exitCode = 2;
+                return;
+            }
+        }
+        out.startSpinner('Creating hook...');
+        try {
+            const client = getClient();
+            const params = {
+                name,
+                triggerEvent: String(_opts.trigger),
+                actionType: String(_opts.action),
+                actionConfig,
+            };
+            if (triggerFilter)
+                params.triggerFilter = triggerFilter;
+            const hook = await client.hooks.create(vaultId, params);
+            out.success('Hook created successfully!', {
+                id: hook.id,
+                name: hook.name,
+                triggerEvent: hook.triggerEvent,
+                actionType: hook.actionType,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to create hook');
+        }
+    });
+    addGlobalFlags(hooks.command('delete')
+        .description('Delete a hook')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<hookId>', 'Hook ID'))
+        .action(async (vaultId, hookId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Deleting hook...');
+        try {
+            const client = getClient();
+            await client.hooks.delete(vaultId, hookId);
+            out.success('Hook deleted successfully', { id: hookId, deleted: true });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to delete hook');
+        }
+    });
+    addGlobalFlags(hooks.command('executions')
+        .description('List recent executions for a hook')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<hookId>', 'Hook ID'))
+        .action(async (vaultId, hookId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching executions...');
+        try {
+            const client = getClient();
+            const executions = await client.hooks.listExecutions(vaultId, hookId);
+            out.stopSpinner();
+            out.list(executions.map(exec => ({
+                id: exec.id,
+                status: exec.status,
+                durationMs: exec.durationMs,
+                error: exec.error || null,
+                createdAt: exec.createdAt,
+            })), {
+                emptyMessage: 'No executions found.',
+                columns: [
+                    { key: 'status', header: 'Status' },
+                    { key: 'id', header: 'ID' },
+                    { key: 'durationMs', header: 'Duration (ms)' },
+                    { key: 'createdAt', header: 'Time' },
+                ],
+                textFn: (exec) => {
+                    const statusColor = String(exec.status) === 'success' ? chalk.green : chalk.red;
+                    const lines = [`  ${statusColor(String(exec.status).toUpperCase())}  ${String(exec.id)}`];
+                    if (exec.durationMs !== null)
+                        lines.push(`  Duration: ${String(exec.durationMs)}ms`);
+                    if (exec.error)
+                        lines.push(`  Error: ${chalk.red(String(exec.error))}`);
+                    lines.push(`  Time: ${new Date(String(exec.createdAt)).toLocaleString()}`);
+                    return lines.join('\n');
+                },
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch executions');
+        }
+    });
+}

package/dist/commands/keys.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerKeyCommands(program: Command): void;

package/dist/commands/keys.js

@@ -0,0 +1,165 @@
+import chalk from 'chalk';
+import { getClient } from '../client.js';
+import { addGlobalFlags, resolveFlags } from '../utils/flags.js';
+import { createOutput, handleError } from '../utils/output.js';
+export function registerKeyCommands(program) {
+    const keys = program.command('keys').description('Create, list, update, and revoke API keys');
+    addGlobalFlags(keys.command('list')
+        .description('List all API keys for the current user'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching API keys...');
+        try {
+            const client = getClient();
+            const apiKeys = await client.apiKeys.list();
+            out.stopSpinner();
+            out.list(apiKeys.map(key => ({
+                name: key.name,
+                prefix: key.prefix,
+                scopes: key.scopes.join(', '),
+                isActive: key.isActive,
+                expiresAt: key.expiresAt || null,
+                lastUsedAt: key.lastUsedAt || null,
+            })), {
+                emptyMessage: 'No API keys found.',
+                columns: [
+                    { key: 'name', header: 'Name' },
+                    { key: 'prefix', header: 'Prefix' },
+                    { key: 'scopes', header: 'Scopes' },
+                    { key: 'isActive', header: 'Active' },
+                ],
+                textFn: (key) => {
+                    const lines = [chalk.cyan(`  ${String(key.name)}`)];
+                    lines.push(`  Prefix: ${String(key.prefix)}`);
+                    lines.push(`  Scopes: ${String(key.scopes)}`);
+                    lines.push(`  Active: ${key.isActive ? chalk.green('Yes') : chalk.red('No')}`);
+                    if (key.expiresAt)
+                        lines.push(`  Expires: ${new Date(String(key.expiresAt)).toLocaleString()}`);
+                    if (key.lastUsedAt)
+                        lines.push(`  Last used: ${new Date(String(key.lastUsedAt)).toLocaleString()}`);
+                    return lines.join('\n');
+                },
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch API keys');
+        }
+    });
+    addGlobalFlags(keys.command('get')
+        .description('Show detailed information about an API key')
+        .argument('<keyId>', 'API key ID'))
+        .action(async (keyId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching API key...');
+        try {
+            const client = getClient();
+            const key = await client.apiKeys.get(keyId);
+            out.stopSpinner();
+            out.record({
+                id: key.id,
+                name: key.name,
+                prefix: key.prefix,
+                scopes: key.scopes.join(', '),
+                isActive: key.isActive,
+                vaultId: key.vaultId || null,
+                expiresAt: key.expiresAt || null,
+                lastUsedAt: key.lastUsedAt || null,
+                createdAt: key.createdAt,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch API key');
+        }
+    });
+    addGlobalFlags(keys.command('create')
+        .description('Create a new API key and display it (shown only once)')
+        .argument('<name>', 'Descriptive name for the API key')
+        .option('--scopes <scopes>', 'Comma-separated scopes (e.g., read,write)', 'read,write')
+        .option('--vault <vaultId>', 'Restrict key to a specific vault')
+        .option('--expires <date>', 'Expiry date (ISO 8601 format, e.g., 2025-12-31)')
+        .addHelpText('after', `
+EXAMPLES
+  lsvault keys create "CI Deploy Key" --scopes read,write
+  lsvault keys create "Read Only" --scopes read --vault abc123
+  lsvault keys create "Temp Key" --expires 2025-06-01`))
+        .action(async (name, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Creating API key...');
+        try {
+            const client = getClient();
+            const params = {
+                name,
+                scopes: String(_opts.scopes || 'read,write').split(',').map((s) => s.trim()),
+            };
+            if (_opts.vault)
+                params.vaultId = String(_opts.vault);
+            if (_opts.expires)
+                params.expiresAt = String(_opts.expires);
+            const apiKey = await client.apiKeys.create(params);
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.record({ key: apiKey.key, name: apiKey.name, prefix: apiKey.prefix, scopes: apiKey.scopes.join(', ') });
+            }
+            else {
+                out.warn('\nIMPORTANT: Save this key securely. It cannot be retrieved later.\n');
+                process.stdout.write(chalk.green.bold(`API Key: ${apiKey.key}\n`));
+                process.stdout.write(`\nName:   ${apiKey.name}\n`);
+                process.stdout.write(`Prefix: ${apiKey.prefix}\n`);
+                process.stdout.write(`Scopes: ${apiKey.scopes.join(', ')}\n`);
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to create API key');
+        }
+    });
+    addGlobalFlags(keys.command('update')
+        .description('Update an API key name or active status')
+        .argument('<keyId>', 'API key ID')
+        .option('--name <name>', 'New name for the key')
+        .option('--active', 'Re-enable the key')
+        .option('--inactive', 'Disable the key without revoking it'))
+        .action(async (keyId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        if (!_opts.name && !_opts.active && !_opts.inactive) {
+            out.error('Must specify at least one update option (--name, --active, or --inactive)');
+            process.exitCode = 2;
+            return;
+        }
+        out.startSpinner('Updating API key...');
+        try {
+            const client = getClient();
+            const params = {};
+            if (_opts.name)
+                params.name = String(_opts.name);
+            if (_opts.active)
+                params.isActive = true;
+            if (_opts.inactive)
+                params.isActive = false;
+            const updated = await client.apiKeys.update(keyId, params);
+            out.success('API key updated successfully', { name: updated.name, isActive: updated.isActive });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to update API key');
+        }
+    });
+    addGlobalFlags(keys.command('revoke')
+        .description('Permanently revoke and delete an API key')
+        .argument('<keyId>', 'API key ID'))
+        .action(async (keyId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Revoking API key...');
+        try {
+            const client = getClient();
+            await client.apiKeys.delete(keyId);
+            out.success('API key revoked successfully', { id: keyId, revoked: true });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to revoke API key');
+        }
+    });
+}

package/dist/commands/publish.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerPublishCommands(program: Command): void;

package/dist/commands/publish.js

@@ -0,0 +1,138 @@
+import { getClient } from '../client.js';
+import { addGlobalFlags, resolveFlags } from '../utils/flags.js';
+import { createOutput, handleError } from '../utils/output.js';
+import chalk from 'chalk';
+export function registerPublishCommands(program) {
+    const publish = program.command('publish').description('Publish documents to public profile pages');
+    addGlobalFlags(publish.command('list')
+        .description('List your published documents')
+        .argument('<vaultId>', 'Vault ID (required by route)'))
+        .action(async (vaultId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching published documents...');
+        try {
+            const client = getClient();
+            const docs = await client.publish.listMine(vaultId);
+            out.stopSpinner();
+            out.list(docs.map(doc => ({
+                slug: doc.slug,
+                documentPath: doc.documentPath,
+                documentTitle: doc.documentTitle || '',
+                isPublished: doc.isPublished,
+                seoTitle: doc.seoTitle || '',
+                updatedAt: doc.updatedAt,
+            })), {
+                emptyMessage: 'No published documents found.',
+                columns: [
+                    { key: 'slug', header: 'Slug' },
+                    { key: 'documentPath', header: 'Path' },
+                    { key: 'isPublished', header: 'Published' },
+                    { key: 'seoTitle', header: 'SEO Title' },
+                ],
+                textFn: (doc) => {
+                    const lines = [chalk.cyan(`  ${String(doc.slug)}`)];
+                    lines.push(`  Path:      ${String(doc.documentPath)}`);
+                    if (doc.documentTitle)
+                        lines.push(`  Title:     ${String(doc.documentTitle)}`);
+                    lines.push(`  Published: ${doc.isPublished ? chalk.green('Yes') : chalk.red('No')}`);
+                    if (doc.seoTitle)
+                        lines.push(`  SEO Title: ${String(doc.seoTitle)}`);
+                    lines.push(`  Updated:   ${new Date(String(doc.updatedAt)).toLocaleString()}`);
+                    return lines.join('\n');
+                },
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch published documents');
+        }
+    });
+    addGlobalFlags(publish.command('create')
+        .description('Publish a document')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<docPath>', 'Document path (e.g., blog/post.md)')
+        .requiredOption('--slug <slug>', 'URL-friendly slug for the published page')
+        .option('--title <title>', 'SEO title')
+        .option('--description <description>', 'SEO description')
+        .option('--og-image <url>', 'Open Graph image URL'))
+        .action(async (vaultId, docPath, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Publishing document...');
+        try {
+            const client = getClient();
+            const params = {
+                slug: String(_opts.slug),
+            };
+            if (_opts.title)
+                params.seoTitle = String(_opts.title);
+            if (_opts.description)
+                params.seoDescription = String(_opts.description);
+            if (_opts.ogImage)
+                params.ogImage = String(_opts.ogImage);
+            const pub = await client.publish.create(vaultId, docPath, params);
+            out.success('Document published successfully!', {
+                slug: pub.slug,
+                isPublished: pub.isPublished,
+                seoTitle: pub.seoTitle || null,
+                seoDescription: pub.seoDescription || null,
+                publishedAt: pub.publishedAt,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to publish document');
+        }
+    });
+    addGlobalFlags(publish.command('update')
+        .description('Update a published document')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<docPath>', 'Document path (e.g., blog/post.md)')
+        .requiredOption('--slug <slug>', 'URL-friendly slug (required for updates)')
+        .option('--title <title>', 'SEO title')
+        .option('--description <description>', 'SEO description')
+        .option('--og-image <url>', 'Open Graph image URL'))
+        .action(async (vaultId, docPath, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Updating published document...');
+        try {
+            const client = getClient();
+            const params = {
+                slug: String(_opts.slug),
+            };
+            if (_opts.title)
+                params.seoTitle = String(_opts.title);
+            if (_opts.description)
+                params.seoDescription = String(_opts.description);
+            if (_opts.ogImage)
+                params.ogImage = String(_opts.ogImage);
+            const pub = await client.publish.update(vaultId, docPath, params);
+            out.success('Published document updated successfully', {
+                slug: pub.slug,
+                seoTitle: pub.seoTitle || null,
+                seoDescription: pub.seoDescription || null,
+                updatedAt: pub.updatedAt,
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to update published document');
+        }
+    });
+    addGlobalFlags(publish.command('delete')
+        .description('Unpublish a document')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<docPath>', 'Document path (e.g., blog/post.md)'))
+        .action(async (vaultId, docPath, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Unpublishing document...');
+        try {
+            const client = getClient();
+            await client.publish.delete(vaultId, docPath);
+            out.success('Document unpublished successfully', { path: docPath, unpublished: true });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to unpublish document');
+        }
+    });
+}

package/dist/commands/search.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerSearchCommands(program: Command): void;