ftown-bridge 0.19.44 → 0.19.49

package/dist/sessions-commands.js

@@ -3,6 +3,7 @@
  * Local API client for ftown cross-session control.
  * Installed to ~/.ftown/ftown-sessions by ftown-bridge.
  */
+import { Command, CommanderError } from 'commander';
 import { api as request, loadPointer, listSessions, fetchInbox, sendMail } from './cli-client.js';
 import { MAIL_TYPES, AUTOMATION_REMOVED_MESSAGE, formatMailMessage, } from './wire-types.js';
 async function api(method, path, body, headers) {
@@ -32,29 +33,6 @@ async function resolveFanout(mode, self) {
         .filter((s) => s.parentSessionId === parent && s.id !== self)
         .map((s) => s.id);
 }
-function flag(args, name) {
-    const i = args.indexOf(name);
-    if (i === -1 || i + 1 >= args.length)
-        return undefined;
-    return args[i + 1];
-}
-function hasFlag(args, name) {
-    return args.includes(name);
-}
-/** Positional args, skipping flags and the values of value-taking flags. */
-function positionals(args, valueFlags) {
-    const out = [];
-    for (let i = 0; i < args.length; i++) {
-        const a = args[i];
-        if (a.startsWith('--')) {
-            if (valueFlags.includes(a))
-                i++;
-            continue;
-        }
-        out.push(a);
-    }
-    return out;
-}
 async function fetchUsageRow(id) {
     const [{ data: usageData }, sessionData] = await Promise.all([
         api('GET', `/api/sessions/${id}/usage`),
@@ -114,319 +92,309 @@ function formatUsageTable(rows) {
     const render = (row) => row.map((cell, i) => cell.padEnd(widths[i])).join('  ').trimEnd();
     return [render(header), ...body.map(render)].join('\n');
 }
-function usage() {
-    console.error(`Usage: ftown sessions <command> [options]
-
-Commands:
-  list                          List sessions
-  create [options]              Spawn a new agent session
-  get <session-id>              Session metadata
-  screen <session-id>           Print terminal lines
-  grep <session-id>             Search terminal output
-  keys <session-id> <text>      Send keys to a running session
-  tell <target> <message...>    Send mail to another session's inbox
-  inbox | mail                  Read own inbox (requires FTOWN_SESSION_ID)
-  running <session-id>          Check if session PTY is running
-  usage <session-id...>         Model/token usage per session (--json for raw)
-  remove <session-id>           Stop and remove a session (archived as a tombstone)
-  archive                       List archived (removed) sessions
-  revive <session-id>           Recreate a removed session from its tombstone
-
-Tell targets (one of):
-  <session-id>                  Explicit target session id
-  --parent                      Message FTOWN_SESSION_ID's parent session
-  --children                    Message all sessions parented to FTOWN_SESSION_ID
-  --siblings                    Message sessions sharing my parent (excluding me)
-
-Tell options:
-  --type <t>                    message | task | result | escalation (default: message)
-  --thread <id>                 Thread id for grouping replies
-  --keys                        Inject as terminal keystrokes instead of mail (last resort)
-
-Inbox options:
-  --peek                        Do not mark messages as delivered
-  --limit <n>                   Max messages
-  --all                         Include already-delivered messages
-  --json                        Raw JSON output
-
-Create options:
-  --shell <type>                Harness override; omitted inherits the current session (otherwise claude)
-  --prompt <text>               Initial message
-  --workdir <path>              Working directory
-  --create-workdir              Create --workdir if it does not exist
-  --name <label>                Dashboard name
-  --command <cmd>               Full command override
-  --parent                      Link parent to FTOWN_SESSION_ID or X-Ftown-Session-Id
-  --parent-id <uuid>            Explicit parent session id
-  --model <name>                Model (cursor, codex)
-  --json                        Output raw JSON (default for most commands)
-
-Screen/grep options:
-  --offset <n>                  Pagination offset (default: 0)
-  --limit <n>                   Max lines/matches (default: 200)
-
-Grep options:
-  --pattern <regex>             Required for grep
-
-Reads ~/.ftown/bridge.json (ftown-bridge must be running).`);
+function sessionProgram() {
+    const program = new Command().name('ftown sessions').description('List, create, read and drive ftown agent sessions');
+    program.exitOverride();
+    program.configureOutput({ writeOut: (text) => console.log(text.trimEnd()), writeErr: (text) => console.error(text.trimEnd()) });
+    const command = (name, description) => program.command(name).description(description)
+        .option('--json', 'Machine-readable JSON output (the default for most commands)')
+        .option('--plain', 'Human-readable output where supported');
+    const run = (name, args, cmd) => executeSessionCommand(name, args, cmd.opts());
+    command('list', 'List sessions').action((_opts, cmd) => run('list', [], cmd));
+    command('create', 'Spawn a new agent session')
+        .option('--shell <type>', 'Harness override; otherwise inherit the current session')
+        .option('--prompt <text>', 'Initial message').option('--workdir <path>', 'Working directory')
+        .option('--create-workdir', 'Create the working directory if missing')
+        .option('--name <label>', 'Dashboard name').option('--command <cmd>', 'Full command override')
+        .option('--parent', 'Link to the current session').option('--parent-id <uuid>', 'Explicit parent session')
+        .option('--model <name>', 'Model override')
+        .option('--orchestrator', 'Compatibility flag (no additional prompt or environment changes)')
+        .action((_opts, cmd) => run('create', [], cmd));
+    for (const name of ['get', 'running', 'remove', 'revive']) {
+        command(`${name} <session-id>`, { get: 'Session metadata', running: 'Check if session PTY is running', remove: 'Stop and remove a session', revive: 'Recreate an archived session' }[name])
+            .action((id, _opts, cmd) => run(name, [id], cmd));
+    }
+    command('screen <session-id>', 'Print terminal lines')
+        .option('--offset <n>', 'Pagination offset', '0').option('--limit <n>', 'Max lines', '200')
+        .action((id, _opts, cmd) => run('screen', [id], cmd));
+    command('grep <session-id>', 'Search terminal output')
+        .requiredOption('--pattern <regex>', 'Search expression').option('--offset <n>', 'Match offset', '0')
+        .option('--limit <n>', 'Max matches', '100')
+        .action((id, _opts, cmd) => run('grep', [id], cmd));
+    command('keys <session-id> <text...>', 'Send keys to a running session')
+        .action((id, text, _opts, cmd) => run('keys', [id, ...text], cmd));
+    command('tell [target] [message...]', 'Send mail to another session inbox')
+        .option('--parent', 'Message the current session parent').option('--children', 'Message its children')
+        .option('--siblings', 'Message its siblings').option('--keys', 'Inject terminal keystrokes instead of mail')
+        .option('--type <t>', `Mail type: ${MAIL_TYPES.join(' | ')}`).option('--thread <id>', 'Reply thread')
+        .action((target, text, _opts, cmd) => run('tell', [...(target === undefined ? [] : [target]), ...text], cmd));
+    command('inbox', 'Read own inbox (requires FTOWN_SESSION_ID)').alias('mail')
+        .option('--peek', 'Do not mark delivered').option('--limit <n>', 'Max messages').option('--all', 'Include delivered messages')
+        .action((_opts, cmd) => run('inbox', [], cmd));
+    command('usage <session-id...>', 'Model/token usage per session')
+        .action((ids, _opts, cmd) => run('usage', ids, cmd));
+    command('archive', 'List archived sessions').action((_opts, cmd) => run('archive', [], cmd));
+    return program;
 }
 export async function runSessions(argv) {
     if (['loop', 'loops', 'loop-list'].includes(argv[0])) {
         console.error(`ftown sessions: ${AUTOMATION_REMOVED_MESSAGE}`);
         return 1;
     }
-    if (argv.length === 0 || argv[0] === '--help' || argv[0] === '-h') {
-        usage();
-        return argv.length === 0 ? 1 : 0;
-    }
-    const cmd = argv[0];
-    const rest = argv.slice(1);
-    const jsonOut = !hasFlag(rest, '--plain');
+    const program = sessionProgram();
     try {
-        switch (cmd) {
-            case 'list': {
-                const { data } = await api('GET', '/api/sessions');
-                console.log(jsonOut ? JSON.stringify(data, null, 2) : formatSessionList(data));
-                break;
-            }
-            case 'create': {
-                const shellType = flag(rest, '--shell');
-                const prompt = flag(rest, '--prompt');
-                const workingDir = flag(rest, '--workdir');
-                const name = flag(rest, '--name');
-                const command = flag(rest, '--command');
-                const model = flag(rest, '--model');
-                const parentId = flag(rest, '--parent-id');
-                const useParent = hasFlag(rest, '--parent');
-                const createWorkdir = hasFlag(rest, '--create-workdir');
-                const body = {};
-                if (shellType)
-                    body.shellType = shellType;
-                if (prompt)
-                    body.prompt = prompt;
-                if (workingDir)
-                    body.workingDir = workingDir;
-                if (name)
-                    body.name = name;
-                if (command)
-                    body.command = command;
-                if (model)
-                    body.model = model;
-                if (parentId)
-                    body.parentSessionId = parentId;
-                else if (useParent)
-                    body.parentSessionId = true;
-                if (createWorkdir)
-                    body.createMissingWorkingDir = true;
-                const caller = process.env.FTOWN_SESSION_ID?.trim();
-                const headers = caller ? { 'X-Ftown-Session-Id': caller } : undefined;
-                const { data } = await api('POST', '/api/sessions', body, headers);
-                console.log(jsonOut ? JSON.stringify(data, null, 2) : formatCreated(data));
-                break;
-            }
-            case 'get': {
-                const id = rest.find((a) => !a.startsWith('--'));
-                if (!id)
-                    throw new Error('Missing session-id');
-                const { data } = await api('GET', `/api/sessions/${id}`);
+        if (argv.length === 0) {
+            program.outputHelp({ error: true });
+            return 1;
+        }
+        await program.parseAsync(argv, { from: 'user' });
+        return 0;
+    }
+    catch (error) {
+        if (error instanceof CommanderError)
+            return error.exitCode;
+        console.error(`ftown sessions: ${error instanceof Error ? error.message : String(error)}`);
+        return 1;
+    }
+}
+async function executeSessionCommand(cmd, rest, options) {
+    const jsonOut = !options.plain;
+    switch (cmd) {
+        case 'list': {
+            const { data } = await api('GET', '/api/sessions');
+            console.log(jsonOut ? JSON.stringify(data, null, 2) : formatSessionList(data));
+            break;
+        }
+        case 'create': {
+            const shellType = options.shell;
+            const prompt = options.prompt;
+            const workingDir = options.workdir;
+            const name = options.name;
+            const command = options.command;
+            const model = options.model;
+            const parentId = options.parentId;
+            const useParent = !!options.parent;
+            const createWorkdir = !!options.createWorkdir;
+            const body = {};
+            if (shellType)
+                body.shellType = shellType;
+            if (prompt)
+                body.prompt = prompt;
+            if (workingDir)
+                body.workingDir = workingDir;
+            if (name)
+                body.name = name;
+            if (command)
+                body.command = command;
+            if (model)
+                body.model = model;
+            if (parentId)
+                body.parentSessionId = parentId;
+            else if (useParent)
+                body.parentSessionId = true;
+            if (createWorkdir)
+                body.createMissingWorkingDir = true;
+            const caller = process.env.FTOWN_SESSION_ID?.trim();
+            const headers = caller ? { 'X-Ftown-Session-Id': caller } : undefined;
+            const { data } = await api('POST', '/api/sessions', body, headers);
+            console.log(jsonOut ? JSON.stringify(data, null, 2) : formatCreated(data));
+            break;
+        }
+        case 'get': {
+            const id = rest[0];
+            if (!id)
+                throw new Error('Missing session-id');
+            const { data } = await api('GET', `/api/sessions/${id}`);
+            console.log(JSON.stringify(data, null, 2));
+            break;
+        }
+        case 'screen': {
+            const id = rest[0];
+            if (!id)
+                throw new Error('Missing session-id');
+            const offset = options.offset ?? '0';
+            const limit = options.limit ?? '200';
+            const { data } = await api('GET', `/api/sessions/${id}/screen?offset=${offset}&limit=${limit}`);
+            if (jsonOut) {
                 console.log(JSON.stringify(data, null, 2));
-                break;
             }
-            case 'screen': {
-                const id = rest.find((a) => !a.startsWith('--'));
-                if (!id)
-                    throw new Error('Missing session-id');
-                const offset = flag(rest, '--offset') ?? '0';
-                const limit = flag(rest, '--limit') ?? '200';
-                const { data } = await api('GET', `/api/sessions/${id}/screen?offset=${offset}&limit=${limit}`);
-                if (jsonOut) {
-                    console.log(JSON.stringify(data, null, 2));
-                }
-                else {
-                    const lines = data.lines ?? [];
-                    for (const line of lines)
-                        console.log(line);
-                }
-                break;
+            else {
+                const lines = data.lines ?? [];
+                for (const line of lines)
+                    console.log(line);
             }
-            case 'grep': {
-                const id = rest.find((a) => !a.startsWith('--'));
-                const pattern = flag(rest, '--pattern');
-                if (!id)
-                    throw new Error('Missing session-id');
-                if (!pattern)
-                    throw new Error('Missing --pattern');
-                const offset = parseInt(flag(rest, '--offset') ?? '0', 10);
-                const limit = parseInt(flag(rest, '--limit') ?? '100', 10);
-                const { data } = await api('POST', `/api/sessions/${id}/grep`, {
-                    pattern,
-                    offset,
-                    limit,
-                });
-                console.log(JSON.stringify(data, null, 2));
-                break;
+            break;
+        }
+        case 'grep': {
+            const id = rest[0];
+            const pattern = options.pattern;
+            if (!id)
+                throw new Error('Missing session-id');
+            if (!pattern)
+                throw new Error('Missing --pattern');
+            const offset = parseInt(options.offset ?? '0', 10);
+            const limit = parseInt(options.limit ?? '100', 10);
+            const { data } = await api('POST', `/api/sessions/${id}/grep`, {
+                pattern,
+                offset,
+                limit,
+            });
+            console.log(JSON.stringify(data, null, 2));
+            break;
+        }
+        case 'keys': {
+            const positional = rest;
+            const id = positional[0];
+            const keys = positional.slice(1).join(' ');
+            if (!id || !keys)
+                throw new Error('Usage: keys <session-id> <text>');
+            await api('POST', `/api/sessions/${id}/keys`, { keys });
+            console.log(JSON.stringify({ sent: true, sessionId: id }));
+            break;
+        }
+        case 'tell': {
+            const useParent = !!options.parent;
+            const useChildren = !!options.children;
+            const useSiblings = !!options.siblings;
+            const useKeys = !!options.keys;
+            const mailType = options.type;
+            const threadId = options.thread;
+            const fanCount = [useParent, useChildren, useSiblings].filter(Boolean).length;
+            if (fanCount > 1) {
+                throw new Error('Use only one of --parent, --children, --siblings');
             }
-            case 'keys': {
-                const positional = rest.filter((a) => !a.startsWith('--'));
-                const id = positional[0];
-                const keys = positional.slice(1).join(' ');
-                if (!id || !keys)
-                    throw new Error('Usage: keys <session-id> <text>');
-                await api('POST', `/api/sessions/${id}/keys`, { keys });
-                console.log(JSON.stringify({ sent: true, sessionId: id }));
-                break;
+            if (mailType && !MAIL_TYPES.includes(mailType)) {
+                throw new Error(`Invalid --type "${mailType}" — use one of: ${MAIL_TYPES.join(', ')}`);
             }
-            case 'tell': {
-                const useParent = hasFlag(rest, '--parent');
-                const useChildren = hasFlag(rest, '--children');
-                const useSiblings = hasFlag(rest, '--siblings');
-                const useKeys = hasFlag(rest, '--keys');
-                const mailType = flag(rest, '--type');
-                const threadId = flag(rest, '--thread');
-                const fanCount = [useParent, useChildren, useSiblings].filter(Boolean).length;
-                if (fanCount > 1) {
-                    throw new Error('Use only one of --parent, --children, --siblings');
-                }
-                if (mailType && !MAIL_TYPES.includes(mailType)) {
-                    throw new Error(`Invalid --type "${mailType}" — use one of: ${MAIL_TYPES.join(', ')}`);
-                }
-                const positional = positionals(rest, ['--type', '--thread']);
-                const self = process.env.FTOWN_SESSION_ID?.trim();
-                let targets;
-                let message;
-                if (fanCount === 1) {
-                    message = positional.join(' ');
-                    targets = await resolveFanout(useParent ? 'parent' : useChildren ? 'children' : 'siblings', self);
-                }
-                else {
-                    const target = positional[0];
-                    message = positional.slice(1).join(' ');
-                    if (!target) {
-                        throw new Error('Usage: tell <target|--parent|--children|--siblings> <message...>');
-                    }
-                    targets = [target];
-                }
+            const positional = rest;
+            const self = process.env.FTOWN_SESSION_ID?.trim();
+            let targets;
+            let message;
+            if (fanCount === 1) {
+                message = positional.join(' ');
                 if (!message)
                     throw new Error('Missing message');
-                if (targets.length === 0)
-                    throw new Error('No matching target sessions');
-                const fromName = self
-                    ? (await listSessionInfo()).find((s) => s.id === self)?.name
-                    : undefined;
-                for (const target of targets) {
-                    try {
-                        if (useKeys) {
-                            // Explicit keystroke injection into the target terminal (legacy path).
-                            const reqBody = { text: message };
-                            if (self)
-                                reqBody.from = self;
-                            const { data } = await api('POST', `/api/sessions/${target}/message`, reqBody);
-                            console.log(JSON.stringify({ target, ...data }));
-                        }
-                        else {
-                            const reqBody = { body: message };
-                            if (self)
-                                reqBody.from = self;
-                            if (fromName)
-                                reqBody.fromName = fromName;
-                            if (mailType)
-                                reqBody.type = mailType;
-                            if (threadId)
-                                reqBody.threadId = threadId;
-                            const data = await sendMail(loadPointer(), target, reqBody);
-                            console.log(JSON.stringify({ target, ...data }));
-                        }
-                    }
-                    catch (err) {
-                        const msg = err instanceof Error ? err.message : String(err);
-                        console.log(JSON.stringify({ target, error: msg }));
-                    }
-                }
-                break;
+                targets = await resolveFanout(useParent ? 'parent' : useChildren ? 'children' : 'siblings', self);
             }
-            case 'inbox':
-            case 'mail': {
-                const self = process.env.FTOWN_SESSION_ID?.trim();
-                if (!self)
-                    throw new Error('inbox requires FTOWN_SESSION_ID to be set');
-                const limit = flag(rest, '--limit');
-                const messages = await fetchInbox(loadPointer(), self, { peek: hasFlag(rest, '--peek'), all: hasFlag(rest, '--all'), ...(limit ? { limit: Number(limit) } : {}) });
-                if (hasFlag(rest, '--json')) {
-                    console.log(JSON.stringify({ messages }, null, 2));
+            else {
+                const target = positional[0];
+                message = positional.slice(1).join(' ');
+                if (!target) {
+                    throw new Error('Usage: tell <target|--parent|--children|--siblings> <message...>');
                 }
-                else if (messages.length === 0) {
-                    console.log('(no mail)');
+                targets = [target];
+            }
+            if (!message)
+                throw new Error('Missing message');
+            if (targets.length === 0)
+                throw new Error('No matching target sessions');
+            const fromName = self
+                ? (await listSessionInfo()).find((s) => s.id === self)?.name
+                : undefined;
+            for (const target of targets) {
+                try {
+                    if (useKeys) {
+                        // Explicit keystroke injection into the target terminal (legacy path).
+                        const reqBody = { text: message };
+                        if (self)
+                            reqBody.from = self;
+                        const { data } = await api('POST', `/api/sessions/${target}/message`, reqBody);
+                        console.log(JSON.stringify({ target, ...data }));
+                    }
+                    else {
+                        const reqBody = { body: message };
+                        if (self)
+                            reqBody.from = self;
+                        if (fromName)
+                            reqBody.fromName = fromName;
+                        if (mailType)
+                            reqBody.type = mailType;
+                        if (threadId)
+                            reqBody.threadId = threadId;
+                        const data = await sendMail(loadPointer(), target, reqBody);
+                        console.log(JSON.stringify({ target, ...data }));
+                    }
                 }
-                else {
-                    for (const m of messages)
-                        console.log(formatMailMessage(m));
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    console.log(JSON.stringify({ target, error: msg }));
                 }
-                break;
             }
-            case 'running': {
-                const id = rest.find((a) => !a.startsWith('--'));
-                if (!id)
-                    throw new Error('Missing session-id');
-                const { data } = await api('GET', `/api/sessions/${id}/running`);
-                console.log(JSON.stringify(data, null, 2));
-                break;
+            break;
+        }
+        case 'inbox':
+        case 'mail': {
+            const self = process.env.FTOWN_SESSION_ID?.trim();
+            if (!self)
+                throw new Error('inbox requires FTOWN_SESSION_ID to be set');
+            const limit = options.limit;
+            const messages = await fetchInbox(loadPointer(), self, { peek: !!options.peek, all: !!options.all, ...(limit ? { limit: Number(limit) } : {}) });
+            if (!!options.json) {
+                console.log(JSON.stringify({ messages }, null, 2));
             }
-            case 'usage': {
-                const ids = rest.filter((a) => !a.startsWith('--'));
-                if (ids.length === 0)
-                    throw new Error('Missing session-id');
-                const rows = await Promise.all(ids.map(fetchUsageRow));
-                if (hasFlag(rest, '--json')) {
-                    console.log(JSON.stringify({ sessions: rows }, null, 2));
-                }
-                else {
-                    console.log(formatUsageTable(rows));
-                }
-                break;
+            else if (messages.length === 0) {
+                console.log('(no mail)');
             }
-            case 'remove': {
-                const id = rest.find((a) => !a.startsWith('--'));
-                if (!id)
-                    throw new Error('Missing session-id');
-                const { data } = await api('DELETE', `/api/sessions/${id}`);
-                console.log(jsonOut ? JSON.stringify(data, null, 2) : `removed ${id}`);
-                break;
+            else {
+                for (const m of messages)
+                    console.log(formatMailMessage(m));
             }
-            case 'archive': {
-                const { data } = await api('GET', '/api/archive');
-                const archived = data.archived ?? [];
-                const summary = archived.map((s) => ({
-                    id: s.id,
-                    name: s.name,
-                    removedAt: s.removedAt,
-                    shellType: s.shellType,
-                }));
-                console.log(jsonOut
-                    ? JSON.stringify({ archived: summary }, null, 2)
-                    : summary
-                        .map((s) => `${s.id}  ${s.removedAt}  ${s.shellType ?? ''}  ${s.name ?? ''}`.trimEnd())
-                        .join('\n'));
-                break;
+            break;
+        }
+        case 'running': {
+            const id = rest[0];
+            if (!id)
+                throw new Error('Missing session-id');
+            const { data } = await api('GET', `/api/sessions/${id}/running`);
+            console.log(JSON.stringify(data, null, 2));
+            break;
+        }
+        case 'usage': {
+            const ids = rest;
+            if (ids.length === 0)
+                throw new Error('Missing session-id');
+            const rows = await Promise.all(ids.map(fetchUsageRow));
+            if (!!options.json) {
+                console.log(JSON.stringify({ sessions: rows }, null, 2));
             }
-            case 'revive': {
-                const id = rest.find((a) => !a.startsWith('--'));
-                if (!id)
-                    throw new Error('Missing session-id');
-                const { data } = await api('POST', `/api/sessions/${id}/revive`);
-                console.log(jsonOut ? JSON.stringify(data, null, 2) : formatCreated(data));
-                break;
+            else {
+                console.log(formatUsageTable(rows));
             }
-            default:
-                usage();
-                return 1;
+            break;
+        }
+        case 'remove': {
+            const id = rest[0];
+            if (!id)
+                throw new Error('Missing session-id');
+            const { data } = await api('DELETE', `/api/sessions/${id}`);
+            console.log(jsonOut ? JSON.stringify(data, null, 2) : `removed ${id}`);
+            break;
+        }
+        case 'archive': {
+            const { data } = await api('GET', '/api/archive');
+            const archived = data.archived ?? [];
+            const summary = archived.map((s) => ({
+                id: s.id,
+                name: s.name,
+                removedAt: s.removedAt,
+                shellType: s.shellType,
+            }));
+            console.log(jsonOut
+                ? JSON.stringify({ archived: summary }, null, 2)
+                : summary
+                    .map((s) => `${s.id}  ${s.removedAt}  ${s.shellType ?? ''}  ${s.name ?? ''}`.trimEnd())
+                    .join('\n'));
+            break;
+        }
+        case 'revive': {
+            const id = rest[0];
+            if (!id)
+                throw new Error('Missing session-id');
+            const { data } = await api('POST', `/api/sessions/${id}/revive`);
+            console.log(jsonOut ? JSON.stringify(data, null, 2) : formatCreated(data));
+            break;
         }
     }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        console.error(`ftown sessions: ${msg}`);
-        return 1;
-    }
-    return 0;
 }
 function formatSessionList(data) {
     const sessions = data.sessions ?? [];