@lifestreamdynamics/vault-cli 1.0.0

package/dist/commands/search.js

@@ -0,0 +1,61 @@
+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 registerSearchCommands(program) {
+    addGlobalFlags(program.command('search')
+        .description('Full-text search across all documents')
+        .argument('<query>', 'Search query (PostgreSQL websearch syntax)')
+        .option('--vault <vaultId>', 'Limit search to a specific vault')
+        .option('--tags <tags>', 'Filter by tags (comma-separated)')
+        .option('--limit <n>', 'Maximum number of results', '20')
+        .addHelpText('after', `
+EXAMPLES
+  lsvault search "meeting notes"
+  lsvault search "project plan" --vault abc123
+  lsvault search "typescript" --tags dev,code --limit 5`))
+        .action(async (query, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Searching...');
+        try {
+            const client = getClient();
+            const response = await client.search.search({
+                q: query,
+                vault: _opts.vault,
+                tags: _opts.tags,
+                limit: parseInt(String(_opts.limit || '20'), 10),
+            });
+            out.stopSpinner();
+            if (flags.output === 'text') {
+                out.status(chalk.dim(`${response.total} result(s) for "${response.query}":\n`));
+            }
+            out.list(response.results.map(r => ({
+                title: r.title || r.path,
+                path: r.path,
+                vaultName: r.vaultName,
+                tags: r.tags.join(', '),
+                snippet: r.snippet ? r.snippet.replace(/<[^>]+>/g, '') : '',
+            })), {
+                emptyMessage: 'No results found.',
+                columns: [
+                    { key: 'title', header: 'Title' },
+                    { key: 'path', header: 'Path' },
+                    { key: 'vaultName', header: 'Vault' },
+                    { key: 'tags', header: 'Tags' },
+                ],
+                textFn: (r) => {
+                    const tags = r.tags ? chalk.blue(` [${String(r.tags)}]`) : '';
+                    const lines = [`${chalk.cyan(String(r.title))}${tags}`];
+                    lines.push(`  ${chalk.dim(String(r.vaultName))} / ${chalk.dim(String(r.path))}`);
+                    if (r.snippet)
+                        lines.push(`  ${String(r.snippet)}`);
+                    return lines.join('\n');
+                },
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Search failed');
+        }
+    });
+}

package/dist/commands/shares.d.ts

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

package/dist/commands/shares.js

@@ -0,0 +1,121 @@
+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 registerShareCommands(program) {
+    const shares = program.command('shares').description('Create, list, and revoke document share links');
+    addGlobalFlags(shares.command('list')
+        .description('List share links for a document')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<docPath>', 'Document path (e.g., notes/meeting.md)'))
+        .action(async (vaultId, docPath, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching share links...');
+        try {
+            const client = getClient();
+            const links = await client.shares.list(vaultId, docPath);
+            out.stopSpinner();
+            out.list(links.map(link => ({
+                id: link.id,
+                tokenPrefix: link.tokenPrefix,
+                permission: link.permission,
+                viewCount: link.viewCount,
+                maxViews: link.maxViews || null,
+                isActive: link.isActive,
+                expiresAt: link.expiresAt || null,
+                createdAt: link.createdAt,
+            })), {
+                emptyMessage: 'No share links found for this document.',
+                columns: [
+                    { key: 'tokenPrefix', header: 'Token' },
+                    { key: 'permission', header: 'Permission' },
+                    { key: 'viewCount', header: 'Views' },
+                    { key: 'isActive', header: 'Active' },
+                ],
+                textFn: (link) => {
+                    const lines = [chalk.cyan(`  ${String(link.tokenPrefix)}...`)];
+                    lines.push(`  ID:         ${String(link.id)}`);
+                    lines.push(`  Permission: ${String(link.permission)}`);
+                    lines.push(`  Views:      ${String(link.viewCount)}${link.maxViews ? `/${String(link.maxViews)}` : ''}`);
+                    lines.push(`  Active:     ${link.isActive ? chalk.green('Yes') : chalk.red('No')}`);
+                    if (link.expiresAt)
+                        lines.push(`  Expires:    ${new Date(String(link.expiresAt)).toLocaleString()}`);
+                    lines.push(`  Created:    ${new Date(String(link.createdAt)).toLocaleString()}`);
+                    return lines.join('\n');
+                },
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch share links');
+        }
+    });
+    addGlobalFlags(shares.command('create')
+        .description('Create a share link for a document')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<docPath>', 'Document path (e.g., notes/meeting.md)')
+        .option('--permission <perm>', 'Permission level: view or edit', 'view')
+        .option('--password <password>', 'Password to protect the link')
+        .option('--expires <date>', 'Expiration date (ISO 8601)')
+        .option('--max-views <count>', 'Maximum number of views'))
+        .action(async (vaultId, docPath, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Creating share link...');
+        try {
+            const client = getClient();
+            const params = {};
+            if (_opts.permission)
+                params.permission = String(_opts.permission);
+            if (_opts.password)
+                params.password = String(_opts.password);
+            if (_opts.expires)
+                params.expiresAt = String(_opts.expires);
+            if (_opts.maxViews)
+                params.maxViews = parseInt(String(_opts.maxViews), 10);
+            const result = await client.shares.create(vaultId, docPath, params);
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.record({
+                    token: result.fullToken,
+                    id: result.shareLink.id,
+                    permission: result.shareLink.permission,
+                    expiresAt: result.shareLink.expiresAt || null,
+                    maxViews: result.shareLink.maxViews || null,
+                });
+            }
+            else {
+                out.warn('\nIMPORTANT: Save this token. It cannot be retrieved later.\n');
+                process.stdout.write(chalk.green.bold(`Token: ${result.fullToken}\n`));
+                process.stdout.write(`\nID:         ${result.shareLink.id}\n`);
+                process.stdout.write(`Permission: ${result.shareLink.permission}\n`);
+                if (result.shareLink.expiresAt) {
+                    process.stdout.write(`Expires:    ${new Date(result.shareLink.expiresAt).toLocaleString()}\n`);
+                }
+                if (result.shareLink.maxViews) {
+                    process.stdout.write(`Max views:  ${result.shareLink.maxViews}\n`);
+                }
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to create share link');
+        }
+    });
+    addGlobalFlags(shares.command('revoke')
+        .description('Revoke a share link')
+        .argument('<vaultId>', 'Vault ID')
+        .argument('<shareId>', 'Share link ID'))
+        .action(async (vaultId, shareId, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Revoking share link...');
+        try {
+            const client = getClient();
+            await client.shares.revoke(vaultId, shareId);
+            out.success('Share link revoked successfully', { id: shareId, revoked: true });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to revoke share link');
+        }
+    });
+}

package/dist/commands/subscription.d.ts

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

package/dist/commands/subscription.js

@@ -0,0 +1,166 @@
+import chalk from 'chalk';
+import { getClient } from '../client.js';
+import { addGlobalFlags, resolveFlags } from '../utils/flags.js';
+import { createOutput, handleError } from '../utils/output.js';
+import { formatBytes } from '../utils/format.js';
+export function registerSubscriptionCommands(program) {
+    const sub = program.command('subscription').description('View plans, manage subscription, and access billing');
+    addGlobalFlags(sub.command('status')
+        .description('Show current plan, active status, and resource usage'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching subscription...');
+        try {
+            const client = getClient();
+            const data = await client.subscription.get();
+            out.stopSpinner();
+            if (flags.output === 'json') {
+                out.record({
+                    tier: data.subscription.tier,
+                    isActive: data.subscription.isActive,
+                    expiresAt: data.subscription.expiresAt,
+                    ...data.usage,
+                });
+            }
+            else {
+                const s = data.subscription;
+                process.stdout.write(`Plan:       ${chalk.green(s.tier)}\n`);
+                process.stdout.write(`Active:     ${s.isActive ? chalk.green('yes') : chalk.red('no')}\n`);
+                process.stdout.write(`Expires:    ${s.expiresAt || chalk.dim('never')}\n`);
+                process.stdout.write('\n');
+                process.stdout.write(chalk.dim('Usage:') + '\n');
+                process.stdout.write(`  Vaults:            ${data.usage.vaultCount}\n`);
+                process.stdout.write(`  Storage:           ${formatBytes(data.usage.totalStorageBytes)}\n`);
+                process.stdout.write(`  API calls today:   ${data.usage.apiCallsToday}\n`);
+                process.stdout.write(`  AI tokens:         ${data.usage.aiTokens}\n`);
+                process.stdout.write(`  Hook executions:   ${data.usage.hookExecutions}\n`);
+                process.stdout.write(`  Webhook deliveries: ${data.usage.webhookDeliveries}\n`);
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch subscription');
+        }
+    });
+    addGlobalFlags(sub.command('plans')
+        .description('List available subscription plans and their limits'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching plans...');
+        try {
+            const client = getClient();
+            const plans = await client.subscription.listPlans();
+            out.stopSpinner();
+            out.list(plans.map(p => ({ name: p.name, tier: p.tier, ...p.limits })), {
+                emptyMessage: 'No plans available.',
+                columns: [
+                    { key: 'name', header: 'Name' },
+                    { key: 'tier', header: 'Tier' },
+                ],
+                textFn: (p) => {
+                    const lines = [`${chalk.cyan(String(p.name))} (${String(p.tier)})`];
+                    for (const [key, val] of Object.entries(p)) {
+                        if (key !== 'name' && key !== 'tier') {
+                            lines.push(`  ${key}: ${String(val)}`);
+                        }
+                    }
+                    return lines.join('\n');
+                },
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch plans');
+        }
+    });
+    addGlobalFlags(sub.command('upgrade')
+        .description('Start a checkout session to upgrade your plan')
+        .argument('<tier>', 'Target tier: pro or business')
+        .requiredOption('--return-url <url>', 'URL to redirect after checkout')
+        .addHelpText('after', `
+EXAMPLES
+  lsvault subscription upgrade pro --return-url https://app.example.com/settings`))
+        .action(async (tier, _opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Creating checkout session...');
+        try {
+            const client = getClient();
+            const session = await client.subscription.createCheckoutSession(tier, String(_opts.returnUrl));
+            out.success('Checkout session created', { url: session.url });
+            if (flags.output === 'text') {
+                process.stdout.write(`Open this URL to complete upgrade: ${chalk.cyan(session.url)}\n`);
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to create checkout session');
+        }
+    });
+    addGlobalFlags(sub.command('cancel')
+        .description('Cancel your current subscription')
+        .option('--reason <text>', 'Reason for cancellation'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Cancelling subscription...');
+        try {
+            const client = getClient();
+            await client.subscription.cancel(_opts.reason);
+            out.success('Subscription cancelled', { cancelled: true });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to cancel subscription');
+        }
+    });
+    addGlobalFlags(sub.command('portal')
+        .description('Get a URL to the billing management portal')
+        .requiredOption('--return-url <url>', 'URL to redirect after portal session'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Creating portal session...');
+        try {
+            const client = getClient();
+            const portal = await client.subscription.createPortalSession(String(_opts.returnUrl));
+            out.success('Portal session created', { url: portal.url });
+            if (flags.output === 'text') {
+                process.stdout.write(`Open this URL to manage billing: ${chalk.cyan(portal.url)}\n`);
+            }
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to create portal session');
+        }
+    });
+    addGlobalFlags(sub.command('invoices')
+        .description('List past invoices and payment history'))
+        .action(async (_opts) => {
+        const flags = resolveFlags(_opts);
+        const out = createOutput(flags);
+        out.startSpinner('Fetching invoices...');
+        try {
+            const client = getClient();
+            const invoices = await client.subscription.listInvoices();
+            out.stopSpinner();
+            out.list(invoices.map(inv => ({
+                date: inv.createdAt,
+                amount: `${(inv.amount / 100).toFixed(2)} ${inv.currency.toUpperCase()}`,
+                status: inv.status,
+                invoiceUrl: inv.invoiceUrl || null,
+            })), {
+                emptyMessage: 'No invoices found.',
+                columns: [
+                    { key: 'date', header: 'Date' },
+                    { key: 'amount', header: 'Amount' },
+                    { key: 'status', header: 'Status' },
+                ],
+                textFn: (inv) => {
+                    const status = String(inv.status) === 'paid' ? chalk.green(String(inv.status)) : chalk.yellow(String(inv.status));
+                    return `${String(inv.date)}  ${String(inv.amount)}  ${status}${inv.invoiceUrl ? `  ${chalk.dim(String(inv.invoiceUrl))}` : ''}`;
+                },
+            });
+        }
+        catch (err) {
+            handleError(out, err, 'Failed to fetch invoices');
+        }
+    });
+}

package/dist/commands/sync.d.ts

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