@workjournal/cli 0.3.4 → 0.5.0

package/dist/index.js

@@ -1,13 +1,15 @@
 #!/usr/bin/env node
+import { API_PATHS, apiGet, requireAuth } from './api-client.js';
 import { loginFinish, loginInteractive, loginStart } from './auth.js';
 import { createEntry, deleteEntry, getEntry, lastEntries, listEntries, searchEntries, } from './commands/entries.js';
 import { exportJournal } from './commands/export.js';
 import { deleteInvite, listInvites, newInvite } from './commands/invites.js';
-import { createJournal, deleteJournal, getJournal, listJournals, selectJournal, } from './commands/journals.js';
+import { createJournal, deleteJournal, getJournal, listJournals, renameJournal, selectJournal, setJournalSlug, } from './commands/journals.js';
 import { deleteShare, listShares } from './commands/shares.js';
+import { getWorkspace, listWorkspaces, selectWorkspace } from './commands/workspaces.js';
 import { readConfig } from './config.js';
 import { CONFIG_DIR, clearCredentials, clearLoginState, readCredentials } from './credentials.js';
-import { findProjectConfig, getProjectConfigPath } from './project-config.js';
+import { findProjectConfig, getProjectConfigPath, rewriteProjectConfigAt, } from './project-config.js';
 // ── Arg parsing ─────────────────────────────────────────────────────────────
 const rawArgs = process.argv.slice(2);
 const jsonOutput = rawArgs.includes('--json');
@@ -31,17 +33,64 @@ function parseFlags(argv) {
     }
     return { flags, positional };
 }
-// ── Journal ID resolution ───────────────────────────────────────────────────
-function resolveJournalId() {
-    const projectConfig = findProjectConfig();
-    if (projectConfig)
-        return projectConfig.journal_id;
+/**
+ * Migrate a legacy `{ journal_id }` project config by walking workspaces and
+ * journals to find the entry whose `id` matches. Rewrites the file in place
+ * on success. Returns `null` if migration can't run (offline, deleted journal,
+ * not authenticated).
+ */
+async function migrateLegacyProjectConfig(journalId, configPath) {
+    const token = await requireAuth();
+    let workspaces;
+    try {
+        const result = await apiGet(API_PATHS.workspaces, token);
+        workspaces = result.data;
+    }
+    catch {
+        return null;
+    }
+    for (const ws of workspaces) {
+        try {
+            const journals = await apiGet(API_PATHS.journals(ws.slug), token);
+            const match = journals.data.find((j) => j.id === journalId);
+            if (match) {
+                rewriteProjectConfigAt(configPath, ws.slug, match.slug);
+                process.stderr.write(`Migrated .workjournal: journal_id ${journalId} → ${ws.slug}/${match.slug}\n`);
+                return { workspaceSlug: ws.slug, journalSlug: match.slug };
+            }
+        }
+        catch {
+            // Skip this workspace and try the next one.
+        }
+    }
+    return null;
+}
+async function resolveActiveSelection() {
+    const stored = findProjectConfig();
+    if (stored) {
+        if (stored.kind === 'v2')
+            return stored.config;
+        // Legacy v1 — try to migrate by resolving the UUID via the API.
+        process.stderr.write(`Found legacy .workjournal at ${stored.path} (journal_id: ${stored.config.journal_id}).\n` +
+            'Attempting one-shot migration to slug-based selection…\n');
+        const migrated = await migrateLegacyProjectConfig(stored.config.journal_id, stored.path);
+        if (migrated)
+            return migrated;
+        process.stderr.write('\nCould not migrate the legacy selection. The journal may have been deleted, or you are offline.\n' +
+            'Re-select with:\n' +
+            '  workjournal workspaces list\n' +
+            '  workjournal journals list <workspaceSlug>\n' +
+            '  workjournal journals select <workspaceSlug> <journalSlug>\n');
+        process.exit(1);
+    }
     const config = readConfig();
-    if (config.journal)
-        return config.journal;
+    if (config.workspaceSlug && config.journalSlug) {
+        return { workspaceSlug: config.workspaceSlug, journalSlug: config.journalSlug };
+    }
     process.stderr.write(`No journal selected. To select one:
-  workjournal journals list          List available journals
-  workjournal journals select <id>   Set active journal
+  workjournal workspaces list
+  workjournal journals list <workspaceSlug>
+  workjournal journals select <workspaceSlug> <journalSlug>
 `);
     process.exit(1);
 }
@@ -105,207 +154,330 @@ async function routeAuth(argv) {
             process.exit(1);
     }
 }
-async function routeEntries(journalId, argv) {
+async function routeWorkspaces(argv) {
     const sub = argv[0];
     switch (sub) {
         case undefined:
         case 'list':
-            await listEntries(journalId, jsonOutput);
+            await listWorkspaces(jsonOutput);
             break;
-        case 'write': {
-            const { flags } = parseFlags(argv.slice(1));
-            const summary = flags['-s'] ?? flags['--summary'];
-            const body = flags['-b'] ?? flags['--body'];
-            if (!summary || !body) {
-                process.stderr.write('Usage: workjournal journals <id> entries write -s <summary> -b <body>\n');
+        case 'get': {
+            const slug = argv[1];
+            if (!slug) {
+                process.stderr.write('Usage: workjournal workspaces get <workspaceSlug>\n');
                 process.exit(1);
             }
-            await createEntry(journalId, summary, body, jsonOutput);
+            await getWorkspace(slug, jsonOutput);
             break;
         }
-        case 'last': {
-            const count = Number.parseInt(argv[1] ?? '1', 10);
-            if (Number.isNaN(count) || count < 1) {
-                process.stderr.write('Usage: workjournal journals <id> entries last [count]\n');
+        case 'select': {
+            const slug = argv[1];
+            if (!slug) {
+                process.stderr.write('Usage: workjournal workspaces select <workspaceSlug>\n');
                 process.exit(1);
             }
-            await lastEntries(journalId, count, jsonOutput);
+            await selectWorkspace(slug);
             break;
         }
+        default:
+            process.stderr.write(`Unknown workspaces subcommand: ${sub}\n` +
+                'Usage: workjournal workspaces <list|get|select>\n');
+            process.exit(1);
+    }
+}
+async function routeJournals(argv) {
+    const sub = argv[0];
+    if (sub === undefined) {
+        // Shortcut: workjournal journals → show selected journal details
+        const sel = await resolveActiveSelection();
+        await getJournal(sel.workspaceSlug, sel.journalSlug, jsonOutput);
+        return;
+    }
+    switch (sub) {
+        case 'list': {
+            // `list [workspaceSlug]` — falls back to selected workspace if omitted.
+            const wsSlug = argv[1] ?? readConfig().workspaceSlug;
+            if (!wsSlug) {
+                process.stderr.write('Usage: workjournal journals list <workspaceSlug>\n' +
+                    '(or run `workjournal workspaces select <slug>` first)\n');
+                process.exit(1);
+            }
+            await listJournals(wsSlug, jsonOutput);
+            return;
+        }
         case 'get': {
-            const index = argv[1];
-            if (!index) {
-                process.stderr.write('Usage: workjournal journals <id> entries get <index>\n');
+            const ws = argv[1];
+            const j = argv[2];
+            if (!ws || !j) {
+                process.stderr.write('Usage: workjournal journals get <workspaceSlug> <journalSlug>\n');
                 process.exit(1);
             }
-            await getEntry(journalId, index, jsonOutput);
-            break;
+            await getJournal(ws, j, jsonOutput);
+            return;
+        }
+        case 'new':
+        case 'create': {
+            const { flags, positional } = parseFlags(argv.slice(1));
+            const ws = positional[0];
+            const name = positional[1];
+            if (!ws || !name) {
+                process.stderr.write('Usage: workjournal journals new <workspaceSlug> <name> [--slug <slug>]\n');
+                process.exit(1);
+            }
+            const slug = flags['--slug'];
+            await createJournal(ws, name, slug, jsonOutput);
+            return;
         }
         case 'delete': {
-            const index = argv[1];
-            if (!index) {
-                process.stderr.write('Usage: workjournal journals <id> entries delete <index>\n');
+            const ws = argv[1];
+            const j = argv[2];
+            if (!ws || !j) {
+                process.stderr.write('Usage: workjournal journals delete <workspaceSlug> <journalSlug>\n');
                 process.exit(1);
             }
-            await deleteEntry(journalId, index, jsonOutput);
-            break;
+            await deleteJournal(ws, j, jsonOutput);
+            return;
         }
-        case 'search': {
-            const query = argv[1];
-            if (!query) {
-                process.stderr.write('Usage: workjournal journals <id> entries search <query>\n');
+        case 'rename': {
+            const ws = argv[1];
+            const j = argv[2];
+            const newName = argv[3];
+            if (!ws || !j || !newName) {
+                process.stderr.write('Usage: workjournal journals rename <workspaceSlug> <journalSlug> <newName>\n');
                 process.exit(1);
             }
-            await searchEntries(journalId, query, jsonOutput);
-            break;
+            await renameJournal(ws, j, newName, jsonOutput);
+            return;
+        }
+        case 'set-slug': {
+            const ws = argv[1];
+            const j = argv[2];
+            const newSlug = argv[3];
+            if (!ws || !j || !newSlug) {
+                process.stderr.write('Usage: workjournal journals set-slug <workspaceSlug> <journalSlug> <newSlug>\n');
+                process.exit(1);
+            }
+            await setJournalSlug(ws, j, newSlug, jsonOutput);
+            return;
+        }
+        case 'select': {
+            const ws = argv[1];
+            const j = argv[2];
+            if (!ws || !j) {
+                process.stderr.write('Usage: workjournal journals select <workspaceSlug> <journalSlug>\n');
+                process.exit(1);
+            }
+            await selectJournal(ws, j);
+            return;
         }
         default:
-            process.stderr.write(`Unknown entries subcommand: ${sub}\n`);
+            process.stderr.write(`Unknown journals subcommand: ${sub}\n` +
+                'Usage: workjournal journals <list|get|new|delete|rename|set-slug|select>\n');
             process.exit(1);
     }
 }
-async function routeShares(journalId, argv) {
+async function routeEntries(argv) {
     const sub = argv[0];
     switch (sub) {
         case undefined:
-        case 'list':
-            await listShares(journalId, jsonOutput);
-            break;
+        case 'list': {
+            const ws = argv[1];
+            const j = argv[2];
+            if (!ws || !j) {
+                process.stderr.write('Usage: workjournal entries list <workspaceSlug> <journalSlug>\n');
+                process.exit(1);
+            }
+            await listEntries(ws, j, jsonOutput);
+            return;
+        }
+        case 'write': {
+            const ws = argv[1];
+            const j = argv[2];
+            if (!ws || !j) {
+                process.stderr.write('Usage: workjournal entries write <workspaceSlug> <journalSlug> -s <summary> -b <body>\n');
+                process.exit(1);
+            }
+            const { flags } = parseFlags(argv.slice(3));
+            const summary = flags['-s'] ?? flags['--summary'];
+            const body = flags['-b'] ?? flags['--body'];
+            if (!summary || !body) {
+                process.stderr.write('Usage: workjournal entries write <workspaceSlug> <journalSlug> -s <summary> -b <body>\n');
+                process.exit(1);
+            }
+            await createEntry(ws, j, summary, body, jsonOutput);
+            return;
+        }
+        case 'last': {
+            const ws = argv[1];
+            const j = argv[2];
+            if (!ws || !j) {
+                process.stderr.write('Usage: workjournal entries last <workspaceSlug> <journalSlug> [count]\n');
+                process.exit(1);
+            }
+            const count = Number.parseInt(argv[3] ?? '1', 10);
+            if (Number.isNaN(count) || count < 1) {
+                process.stderr.write('Usage: workjournal entries last <workspaceSlug> <journalSlug> [count]\n');
+                process.exit(1);
+            }
+            await lastEntries(ws, j, count, jsonOutput);
+            return;
+        }
+        case 'get': {
+            const ws = argv[1];
+            const j = argv[2];
+            const index = argv[3];
+            if (!ws || !j || !index) {
+                process.stderr.write('Usage: workjournal entries get <workspaceSlug> <journalSlug> <index>\n');
+                process.exit(1);
+            }
+            await getEntry(ws, j, index, jsonOutput);
+            return;
+        }
         case 'delete': {
-            const email = argv[1];
-            if (!email) {
-                process.stderr.write('Usage: workjournal journals <id> shares delete <email>\n');
+            const ws = argv[1];
+            const j = argv[2];
+            const index = argv[3];
+            if (!ws || !j || !index) {
+                process.stderr.write('Usage: workjournal entries delete <workspaceSlug> <journalSlug> <index>\n');
                 process.exit(1);
             }
-            await deleteShare(journalId, email, jsonOutput);
-            break;
+            await deleteEntry(ws, j, index, jsonOutput);
+            return;
+        }
+        case 'search': {
+            const ws = argv[1];
+            const j = argv[2];
+            const query = argv[3];
+            if (!ws || !j || !query) {
+                process.stderr.write('Usage: workjournal entries search <workspaceSlug> <journalSlug> <query>\n');
+                process.exit(1);
+            }
+            await searchEntries(ws, j, query, jsonOutput);
+            return;
         }
         default:
-            process.stderr.write(`Unknown shares subcommand: ${sub}\n`);
+            process.stderr.write(`Unknown entries subcommand: ${sub}\n` +
+                'Usage: workjournal entries <list|write|last|get|delete|search>\n');
             process.exit(1);
     }
 }
-async function routeInvites(journalId, argv) {
+async function routeShares(argv) {
     const sub = argv[0];
     switch (sub) {
         case undefined:
-        case 'list':
-            await listInvites(journalId, jsonOutput);
-            break;
-        case 'new': {
-            const email = argv[1];
-            if (!email) {
-                process.stderr.write('Usage: workjournal journals <id> invites new <email>\n');
+        case 'list': {
+            const ws = argv[1];
+            const j = argv[2];
+            if (!ws || !j) {
+                process.stderr.write('Usage: workjournal shares list <workspaceSlug> <journalSlug>\n');
                 process.exit(1);
             }
-            await newInvite(journalId, email, jsonOutput);
-            break;
+            await listShares(ws, j, jsonOutput);
+            return;
         }
         case 'delete': {
-            const invitationId = argv[1];
-            if (!invitationId) {
-                process.stderr.write('Usage: workjournal journals <id> invites delete <invitation_id>\n');
+            const ws = argv[1];
+            const j = argv[2];
+            const email = argv[3];
+            if (!ws || !j || !email) {
+                process.stderr.write('Usage: workjournal shares delete <workspaceSlug> <journalSlug> <email>\n');
                 process.exit(1);
             }
-            await deleteInvite(journalId, invitationId, jsonOutput);
-            break;
+            await deleteShare(ws, j, email, jsonOutput);
+            return;
         }
         default:
-            process.stderr.write(`Unknown invites subcommand: ${sub}\n`);
+            process.stderr.write(`Unknown shares subcommand: ${sub}\nUsage: workjournal shares <list|delete>\n`);
             process.exit(1);
     }
 }
-async function routeJournalResource(journalId, argv) {
+async function routeInvites(argv) {
     const sub = argv[0];
     switch (sub) {
         case undefined:
-            await getJournal(journalId, jsonOutput);
-            break;
-        case 'entries':
-            await routeEntries(journalId, argv.slice(1));
-            break;
-        case 'shares':
-            await routeShares(journalId, argv.slice(1));
-            break;
-        case 'invites':
-            await routeInvites(journalId, argv.slice(1));
-            break;
-        case 'export': {
-            const { flags } = parseFlags(argv.slice(1));
-            const format = flags['-f'] ?? flags['--format'] ?? 'json';
-            if (!['json', 'md', 'csv'].includes(format)) {
-                process.stderr.write('Invalid format. Use: -f json|md|csv\n');
+        case 'list': {
+            const ws = argv[1];
+            const j = argv[2];
+            if (!ws || !j) {
+                process.stderr.write('Usage: workjournal invites list <workspaceSlug> <journalSlug>\n');
                 process.exit(1);
             }
-            const outputPath = flags['-p'] ?? flags['--path'];
-            await exportJournal(journalId, format, outputPath);
-            break;
+            await listInvites(ws, j, jsonOutput);
+            return;
+        }
+        case 'new':
+        case 'create': {
+            const ws = argv[1];
+            const j = argv[2];
+            const email = argv[3];
+            if (!ws || !j || !email) {
+                process.stderr.write('Usage: workjournal invites new <workspaceSlug> <journalSlug> <email>\n');
+                process.exit(1);
+            }
+            await newInvite(ws, j, email, jsonOutput);
+            return;
+        }
+        case 'delete': {
+            const ws = argv[1];
+            const j = argv[2];
+            const invitationId = argv[3];
+            if (!ws || !j || !invitationId) {
+                process.stderr.write('Usage: workjournal invites delete <workspaceSlug> <journalSlug> <invitationId>\n');
+                process.exit(1);
+            }
+            await deleteInvite(ws, j, invitationId, jsonOutput);
+            return;
         }
         default:
-            process.stderr.write(`Unknown subcommand: ${sub}\n`);
+            process.stderr.write(`Unknown invites subcommand: ${sub}\nUsage: workjournal invites <list|new|delete>\n`);
             process.exit(1);
     }
 }
-async function routeJournals(argv) {
-    const sub = argv[0];
-    if (sub === undefined) {
-        // Shortcut: workjournal journals → show selected journal details
-        const journalId = resolveJournalId();
-        await getJournal(journalId, jsonOutput);
-        return;
-    }
-    if (sub === 'list') {
-        await listJournals(jsonOutput);
-        return;
-    }
-    if (sub === 'new') {
-        const name = argv[1];
-        if (!name) {
-            process.stderr.write('Usage: workjournal journals new <name>\n');
-            process.exit(1);
-        }
-        await createJournal(name, jsonOutput);
-        return;
-    }
-    if (sub === 'delete') {
-        const id = argv[1];
-        if (!id) {
-            process.stderr.write('Usage: workjournal journals delete <journal_id>\n');
-            process.exit(1);
-        }
-        await deleteJournal(id, jsonOutput);
-        return;
+async function routeExport(argv) {
+    const ws = argv[0];
+    const j = argv[1];
+    if (!ws || !j) {
+        process.stderr.write('Usage: workjournal export <workspaceSlug> <journalSlug> [-f json|md|csv] [-p <path>]\n');
+        process.exit(1);
     }
-    if (sub === 'select') {
-        const id = argv[1];
-        if (!id) {
-            process.stderr.write('Usage: workjournal journals select <journal_id>\n');
-            process.exit(1);
-        }
-        await selectJournal(id);
-        return;
+    const { flags } = parseFlags(argv.slice(2));
+    const format = flags['-f'] ?? flags['--format'] ?? 'json';
+    if (!['json', 'md', 'csv'].includes(format)) {
+        process.stderr.write('Invalid format. Use: -f json|md|csv\n');
+        process.exit(1);
     }
-    // Not a known subcommand — treat as a journal ID
-    const journalId = sub;
-    await routeJournalResource(journalId, argv.slice(1));
+    const outputPath = flags['-p'] ?? flags['--path'];
+    await exportJournal(ws, j, format, outputPath);
 }
 async function routeConfig(argv) {
     const sub = argv[0];
     if (sub === 'show') {
         const projectPath = getProjectConfigPath();
-        const projectCfg = findProjectConfig();
+        const stored = findProjectConfig();
         const globalCfg = readConfig();
         process.stdout.write('Project config:\n');
-        if (projectPath && projectCfg) {
-            process.stdout.write(`  Path:       ${projectPath}\n`);
-            process.stdout.write(`  journal_id: ${projectCfg.journal_id}\n`);
+        if (projectPath && stored) {
+            process.stdout.write(`  Path: ${projectPath}\n`);
+            if (stored.kind === 'v2') {
+                process.stdout.write(`  Workspace: ${stored.config.workspaceSlug}\n`);
+                process.stdout.write(`  Journal:   ${stored.config.journalSlug}\n`);
+            }
+            else {
+                process.stdout.write(`  Legacy journal_id: ${stored.config.journal_id}\n`);
+                process.stdout.write('  (will migrate on next command that needs the selection)\n');
+            }
         }
         else {
             process.stdout.write('  (none)\n');
         }
         process.stdout.write('Global config:\n');
-        if (globalCfg.journal) {
-            process.stdout.write(`  journal: ${globalCfg.journal}\n`);
+        if (globalCfg.workspaceSlug || globalCfg.journalSlug) {
+            if (globalCfg.workspaceSlug) {
+                process.stdout.write(`  Workspace: ${globalCfg.workspaceSlug}\n`);
+            }
+            if (globalCfg.journalSlug) {
+                process.stdout.write(`  Journal:   ${globalCfg.journalSlug}\n`);
+            }
         }
         else {
             process.stdout.write('  (none)\n');
@@ -323,31 +495,42 @@ function printHelp() {
 Usage:
   workjournal                                           List entries in selected journal
 
-Selected journal (workjournal journal ...):
-  workjournal journal                                   Show selected journal details
-  workjournal journal entries                            List entries
-  workjournal journal entries write -s <summary> -b <body>
-                                                        Create a new entry
-  workjournal journal entries last [count]               Show most recent entries (full body)
-  workjournal journal entries get <index>                Show a single entry by index
-  workjournal journal entries delete <index>             Delete an entry by index
-  workjournal journal entries search <query>             Search entries
-  workjournal journal shares                             List members
-  workjournal journal shares delete <email>              Remove a member
-  workjournal journal invites                            List invitations
-  workjournal journal invites new <email>                Invite a collaborator
-  workjournal journal invites delete <id>                Revoke an invitation
-  workjournal journal export [-f json|md|csv] [-p <path>]
-                                                        Export journal data
+Workspaces:
+  workjournal workspaces list                            List your workspaces
+  workjournal workspaces get <ws>                        Show workspace details
+  workjournal workspaces select <ws>                     Set active workspace
+
+Journals:
+  workjournal journals list [<ws>]                       List journals in workspace
+  workjournal journals get <ws> <j>                      Show journal details
+  workjournal journals new <ws> <name> [--slug <slug>]   Create a new journal
+  workjournal journals delete <ws> <j>                   Delete a journal
+  workjournal journals rename <ws> <j> <newName>         Rename a journal
+  workjournal journals set-slug <ws> <j> <newSlug>       Change a journal's slug
+  workjournal journals select <ws> <j>                   Set active journal
+  workjournal journals                                   Show selected journal details
+
+Entries:
+  workjournal entries list <ws> <j>                      List entries
+  workjournal entries write <ws> <j> -s <summary> -b <body>
+                                                         Create a new entry
+  workjournal entries last <ws> <j> [count]              Show most recent entries (full body)
+  workjournal entries get <ws> <j> <index>               Show a single entry by index
+  workjournal entries delete <ws> <j> <index>            Delete an entry by index
+  workjournal entries search <ws> <j> <query>            Search entries
 
-Manage journals (workjournal journals ...):
-  workjournal journals list                              List your journals
-  workjournal journals new <name>                        Create a new journal
-  workjournal journals delete <id>                       Delete a journal
-  workjournal journals select <id>                       Set active journal
-  workjournal journals <id>                              Show journal details
-  workjournal journals <id> entries|shares|invites|export
-                                                        Access resources by journal ID
+Shares (members):
+  workjournal shares list <ws> <j>                       List members
+  workjournal shares delete <ws> <j> <email>             Remove a member
+
+Invites:
+  workjournal invites list <ws> <j>                      List invitations
+  workjournal invites new <ws> <j> <email>               Invite a collaborator
+  workjournal invites delete <ws> <j> <invitationId>     Revoke an invitation
+
+Export:
+  workjournal export <ws> <j> [-f json|md|csv] [-p <path>]
+                                                         Export journal data
 
 Auth:
   workjournal auth login                                 Interactive login
@@ -374,22 +557,44 @@ async function run() {
         }
         if (command === undefined) {
             // Shortcut: workjournal → list entries in selected journal
-            const journalId = resolveJournalId();
-            await listEntries(journalId, jsonOutput);
+            const sel = await resolveActiveSelection();
+            await listEntries(sel.workspaceSlug, sel.journalSlug, jsonOutput);
             return;
         }
         switch (command) {
             case 'auth':
                 await routeAuth(args.slice(1));
                 break;
+            case 'workspaces':
+                await routeWorkspaces(args.slice(1));
+                break;
             case 'journal': {
-                const journalId = resolveJournalId();
-                await routeJournalResource(journalId, args.slice(1));
+                // Shortcut: show selected journal details (matches docs/cli-commands.md)
+                const sel = await resolveActiveSelection();
+                if (args.length > 1) {
+                    process.stderr.write('`workjournal journal` shows the selected journal. Use `workjournal entries`, ' +
+                        '`workjournal shares`, etc. with explicit <workspaceSlug> <journalSlug> for ' +
+                        'resource verbs.\n');
+                    process.exit(1);
+                }
+                await getJournal(sel.workspaceSlug, sel.journalSlug, jsonOutput);
                 break;
             }
             case 'journals':
                 await routeJournals(args.slice(1));
                 break;
+            case 'entries':
+                await routeEntries(args.slice(1));
+                break;
+            case 'shares':
+                await routeShares(args.slice(1));
+                break;
+            case 'invites':
+                await routeInvites(args.slice(1));
+                break;
+            case 'export':
+                await routeExport(args.slice(1));
+                break;
             case 'config':
                 await routeConfig(args.slice(1));
                 break;