firedrill-run 2.2.4 → 3.0.0

package/dist/cli/src/simple/native-tools.js

@@ -0,0 +1,780 @@
+// Hosted tool sessions for the simple CLI: start saved tool versions outside
+// any drill, list and stop those sessions, and connect an agent on this machine
+// to them through a loopback proxy. A session is root's mixed tool setup, the
+// same review, estimate and approval the web app and the remote MCP use. Root
+// decides each selected service's lane: a reviewed catalog service runs on the
+// shared tool pool, and any other version, an uploaded custom package included,
+// runs in its own isolated runtime. Nothing runs on this machine. Starting
+// reserves credits only after the human approves the quoted maximum. Only
+// versions saved in the workspace can start; the interactive picker adopts
+// selected catalog releases without starting them before review. Sessions started before mixed
+// setups stay readable, stoppable and connectable by their id.
+import { randomUUID } from 'node:crypto';
+import { approveCredits } from './credit-approval.js';
+import { CliError } from '../http.js';
+import { selectOne, terminalText } from '../prompts.js';
+import { requestInput } from '../request-input.js';
+import { selectedWorkspace } from '../world-access.js';
+import { errorCode, isTransient, jitteredInterval, retryTransient, sleep } from '../native/control-plane.js';
+import { openIsolatedGrant, revokeGrant } from '../native/isolated-access.js';
+import { STANDALONE_ACCESS_ERRORS, StandaloneProxy } from '../native/standalone-proxy.js';
+import { getStandaloneBatch, stopStandaloneBatch, STANDALONE_ACTIVE, STANDALONE_TERMINAL, } from '../native/standalone-tools.js';
+import { admitSetup, getSetup, getSetupOption, listSetupOptions, listSetups, parseSetupInput, quoteSetup, recoverSetup, replaceSetup, reviewSetup, setupItems, stopSetup, SETUP_CATEGORIES, SETUP_CHILD_ENDED, SETUP_ENDED, SETUP_MAX_SECONDS, SETUP_MAX_SELECTIONS, SETUP_MIN_SECONDS, SETUP_RUNNING, } from '../native/tool-setups.js';
+import { amount } from './plan-apply.js';
+import { checkRenewalArguments, RENEWAL_VERBS, toolRenewalCommand } from './tool-renewal.js';
+import { toolStateCommand } from './tool-state.js';
+import { chooseStartCatalog } from './tool-start-catalog.js';
+/** The commands this module owns under `firedrill tools`. */
+export const NATIVE_TOOL_ACTIONS = new Set(['runnable', 'start', 'sessions', 'session', 'access', 'state']);
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const DURATIONS = [
+    { value: 3_600, label: '1 hour' }, { value: 4 * 3_600, label: '4 hours' },
+    { value: 24 * 3_600, label: '1 day' }, { value: 7 * 24 * 3_600, label: '7 days' },
+];
+/** Option pages read for the interactive picker (32 versions per page). */
+const PICKER_PAGES = 5;
+/** Option pages read to find the versions named on the command line (100 per page). */
+const LOOKUP_PAGES = 20;
+/** An estimate this close to expiry is not approved: a session is quoted only once. */
+const QUOTE_MARGIN_MS = 60_000;
+const FOLLOW_MS = 3_000;
+const FOLLOW_LIMIT_MS = 15 * 60_000;
+/** How often access re-reads the session, so it ends when the session does. */
+const ACCESS_POLL_MS = 30_000;
+/** Time allowed to revoke this access's isolated connections after it stops (Ctrl-C included). */
+const REVOKE_MS = 15_000;
+const tty = (options) => !options.json && !!process.stdin.isTTY && !!process.stderr.isTTY;
+const scopeOf = (options) => selectedWorkspace({ workspace: options.workspace, signal: options.signal,
+    interactive: tty(options), openBrowser: options.openBrowser && !options.json });
+function pageNumber(value) {
+    if (value === undefined)
+        return undefined;
+    if (!/^[1-9][0-9]{0,8}$/.test(value))
+        throw new CliError('arguments_invalid', 'Use --page with a number of 1 or more.', 2);
+    return Number(value);
+}
+function duration(seconds) {
+    if (seconds % 86_400 === 0)
+        return `${seconds / 86_400} day${seconds === 86_400 ? '' : 's'}`;
+    if (seconds % 3_600 === 0)
+        return `${seconds / 3_600} hour${seconds === 3_600 ? '' : 's'}`;
+    if (seconds % 60 === 0)
+        return `${seconds / 60} minutes`;
+    return `${seconds} seconds`;
+}
+/** Plain words for root's session, admission and instance states; anything else is shown as given. */
+const STATE_TEXT = {
+    reviewed: 'reviewed, not approved (nothing reserved)', admitting: 'approved, starting', admitted: 'approved',
+    needs_attention: 'needs attention', queued: 'approved, waiting for capacity', starting: 'starting',
+    preparing: 'preparing', effect_pending: 'applying its starting data', prepared: 'prepared', active: 'running', draining: 'stopping',
+    closing: 'stopping', reconciling: 'confirming an uncertain step', stopped: 'stopped', cancelled: 'cancelled', canceled: 'cancelled',
+    rejected: 'not started: capacity refused', failed: 'failed', expired: 'expired', closed: 'closed',
+};
+const stateText = (state) => STATE_TEXT[state] ?? state;
+const LANE_TEXT = { pooled: 'shared pool', isolated: 'isolated' };
+const running = (item) => item.instance_state === SETUP_RUNNING && item.terminal_at === null;
+/** A child that will not change without the human: running, ended, cancelled or waiting for attention. */
+const childSettled = (item) => running(item) || item.terminal_at !== null || item.admission_state === 'cancelled'
+    || item.admission_state === 'needs_attention' || (item.instance_state !== null && SETUP_CHILD_ENDED.has(item.instance_state));
+const settled = (setup, items) => setup.approved_at === null || setup.stop_requested_at !== null
+    || SETUP_ENDED.has(setup.state) || items.every(childSettled);
+/**
+ * A mixed tool session's summary. `viewer` is the signed-in member when the
+ * session may be someone else's: root lists every member's sessions, but only
+ * the member who started one can stop or extend it, so those next steps are
+ * offered to that member only.
+ */
+function setupText(setup, items, viewer) {
+    const own = viewer === undefined || setup.actor_id === viewer.toLowerCase();
+    return [
+        `Tool session ${setup.id}: ${stateText(setup.state)} (${duration(setup.duration_seconds)} per tool)`,
+        ...items.map((one) => `  ${one.position + 1}. ${terminalText(one.name)}  service ${terminalText(one.service_key)}, ${one.operations.length} operations, `
+            + `${LANE_TEXT[one.lane]}  ${stateText(one.instance_state ?? one.admission_state)}${one.failure_code ? ` (${terminalText(one.failure_code)})` : ''}`
+            + `${one.instance_id ? `  instance ${one.instance_id}` : ''}`),
+        items.some(running) ? `Connect an agent on this machine: firedrill tools access ${setup.id}` : null,
+        items.some((one) => one.lane === 'pooled' && one.instance_id) ? 'Save or change a shared-pool tool\'s data: firedrill tools state <instance-id>' : null,
+        own && items.some((one) => one.lane === 'pooled' && running(one)) && !setup.stop_requested_at
+            ? `Extend its shared-pool tools: firedrill tools session ${setup.id} renew --seconds <n>` : null,
+        SETUP_ENDED.has(setup.state) || setup.stop_requested_at ? null
+            : own ? `Stop it: firedrill tools session ${setup.id} stop` : 'Started by another member; only they can stop or extend it.',
+    ].filter((line) => line !== null).join('\n');
+}
+/** A session started before mixed setups (history). */
+function batchText(batch) {
+    const until = batch.expires_at ? `, until ${terminalText(batch.expires_at)}` : '';
+    return [
+        `Tool session ${batch.id}: ${stateText(batch.state)} (${duration(batch.duration_seconds)}${until})`,
+        ...batch.instances.map((one) => `  ${one.position + 1}. ${terminalText(one.name)} ${terminalText(one.version)}  service ${terminalText(one.service_key)}`
+            + `, ${one.operations.length} operations  ${stateText(one.state)}  instance ${one.id}`),
+        batch.state === STANDALONE_ACTIVE ? `Connect an agent on this machine: firedrill tools access ${batch.id}` : null,
+        batch.state === STANDALONE_ACTIVE ? 'Save or change a tool\'s data: firedrill tools state <instance-id>' : null,
+        batch.state === STANDALONE_ACTIVE && !batch.stop_requested_at ? `Extend it: firedrill tools session ${batch.id} renew --seconds <n>` : null,
+        STANDALONE_TERMINAL.has(batch.state) ? null : `Stop it: firedrill tools session ${batch.id} stop`,
+    ].filter((line) => line !== null).join('\n');
+}
+function quoteText(quotes, items) {
+    const first = quotes.quotes[0];
+    const money = (one, units) => amount(units, one.credit_scale, one.denomination);
+    // One total only when every quote is in the same unit; otherwise each maximum is shown on its own.
+    const sameUnit = quotes.quotes.every((one) => one.denomination === first.denomination && one.credit_scale === first.credit_scale);
+    const total = quotes.quotes.reduce((sum, one) => sum + one.maximum_units, 0);
+    const label = (one) => one.lane === 'pooled'
+        ? (one.component === 'baseline' ? 'shared pool preparation' : 'shared pool running time')
+        : `${terminalText(items[one.position ?? 0]?.name ?? 'tool')} (${(one.position ?? 0) + 1}, isolated) running time`;
+    const earliest = quotes.quotes.reduce((soonest, one) => Date.parse(one.expires_at) < Date.parse(soonest) ? one.expires_at : soonest, first.expires_at);
+    return [
+        `Cloud-work estimate (maximum, reserved only once approved)${sameUnit ? `: ${money(first, total)}` : ', every part below:'}`,
+        ...quotes.quotes.map((one) => `  ${label(one)}: up to ${money(one, one.maximum_units)}`),
+        `Estimate expires: ${terminalText(earliest)}`,
+    ].join('\n');
+}
+const live = (one) => Date.parse(one.expires_at) - Date.now() > QUOTE_MARGIN_MS;
+/** Every version the picker can offer: available ones only, bounded and said when cut. */
+async function pickable(scope, options) {
+    const rows = [];
+    for (let page = 1; page <= PICKER_PAGES; page++) {
+        const result = await listSetupOptions(scope, { page, pageSize: 32, search: options.search, signal: options.signal });
+        rows.push(...result.results.filter((one) => one.available));
+        if (!result.next)
+            return { rows, more: false };
+    }
+    return { rows, more: true };
+}
+/** The saved versions named on the command line, read from the option pages (bounded). */
+async function optionsFor(scope, ids, options) {
+    const found = new Map();
+    for (let page = 1; page <= LOOKUP_PAGES && found.size < ids.length; page++) {
+        const result = await listSetupOptions(scope, { page, pageSize: 100, signal: options.signal });
+        for (const one of result.results)
+            if (ids.includes(one.implementation_id))
+                found.set(one.implementation_id, one);
+        if (!result.next)
+            break;
+    }
+    return found;
+}
+/** One selection per chosen version: its one service (or --service, or a choice) with every operation it has. */
+async function selectionsFor(scope, ids, options, known) {
+    const found = known ? new Map(known.map((one) => [one.implementation_id, one])) : await optionsFor(scope, ids, options);
+    const selections = [];
+    for (const implementationId of ids) {
+        const option = found.get(implementationId);
+        if (!option)
+            throw new CliError('tool_unavailable', `Tool version ${implementationId} is not saved in this workspace. List saved versions with firedrill tools runnable. Nothing was started.`, 2);
+        const label = `${option.name} ${option.version}`;
+        if (!option.available)
+            throw new CliError('tool_unavailable', `${label} cannot start in a tool session. Nothing was started.`, 2);
+        let service = options.service !== undefined ? option.services.find((one) => one.service_key === options.service) : undefined;
+        if (options.service !== undefined && !service) {
+            throw new CliError('arguments_invalid', `${label} has no service "${options.service}". Its services: ${option.services.map((one) => one.service_key).join(', ')}.`, 2);
+        }
+        if (!service && option.services.length === 1)
+            service = option.services[0];
+        if (!service && tty(options)) {
+            service = await selectOne(`Which service of ${label}?`, option.services.map((one) => ({ value: one, label: one.service_key,
+                detail: `${one.operation_count} operations, ${LANE_TEXT[one.lane]}${one.has_preview ? ', with a preview' : ''}` })), options.signal);
+        }
+        if (!service) {
+            throw new CliError('tool_service_required', `${label} has several services (${option.services.map((one) => one.service_key).join(', ')}). Use --service <key>. Nothing was started.`, 2);
+        }
+        const detail = await getSetupOption(scope, { implementationId, serviceKey: service.service_key, signal: options.signal });
+        // Packaged starting data: a seed or saved dataset is chosen in a --file selection.
+        selections.push({ implementation_id: implementationId, service_key: service.service_key, operations: [...detail.operations], seed_id: null, dataset_id: null });
+    }
+    return selections;
+}
+async function chooseSeconds(options, fromFile) {
+    if (options.seconds !== undefined) {
+        if (!/^[1-9][0-9]{0,8}$/.test(options.seconds) || Number(options.seconds) < SETUP_MIN_SECONDS || Number(options.seconds) > SETUP_MAX_SECONDS) {
+            throw new CliError('tool_duration_invalid', `Use --seconds with a whole number from ${SETUP_MIN_SECONDS} to ${SETUP_MAX_SECONDS} (one year). Nothing was started.`, 2);
+        }
+        if (fromFile !== null && Number(options.seconds) !== fromFile)
+            throw new CliError('arguments_invalid', 'The selection file already sets duration_seconds; leave out --seconds.', 2);
+        return Number(options.seconds);
+    }
+    if (fromFile !== null)
+        return fromFile;
+    if (tty(options))
+        return await selectOne('How long should each tool run?', DURATIONS, options.signal);
+    throw new CliError('tool_duration_required', 'Use --seconds <n> to say how long the tools run. Nothing was started.', 2);
+}
+/** A session is quoted once, so an expired estimate is never approved: close the unused review, then review again. */
+function expiredReview(setupId) {
+    return new CliError('tool_quote_expired', 'This session\'s estimate has expired or expires within a minute, and a session is quoted only once. '
+        + `Nothing was reserved or started. Close this unused review with firedrill tools session ${setupId} stop --approve-tool-change, `
+        + `then review the same tools again with firedrill tools session ${setupId} replace --approve-tool-change, `
+        + 'or choose a new selection with firedrill tools start without --request-key.', 2);
+}
+/**
+ * `tools start [<version-id>...] [--service <key>] [--seconds <n>] [--file <selection.json>]
+ * [--approve-tool-change] [--request-key <key>] [--usage-quote <key>] [--follow]`.
+ */
+async function start(args, options, emit) {
+    const ids = args.slice(1).map((one) => one.toLowerCase());
+    if (ids.length > SETUP_MAX_SELECTIONS || !ids.every((one) => UUID.test(one)) || new Set(ids).size !== ids.length) {
+        throw new CliError('arguments_invalid', `Use tools start with up to ${SETUP_MAX_SELECTIONS} different version ids from firedrill tools runnable, or none to choose.`, 2);
+    }
+    if (options.file !== undefined && ids.length)
+        throw new CliError('arguments_invalid', 'Use either --file or tool version ids, not both.', 2);
+    if (options.request !== undefined && !UUID.test(options.request))
+        throw new CliError('arguments_invalid', 'Use --request-key with the key tools start printed.', 2);
+    if (options.quote !== undefined && (!UUID.test(options.quote) || options.request === undefined)) {
+        throw new CliError('arguments_invalid', 'Use --usage-quote with the quote key and --request-key that tools start printed together.', 2);
+    }
+    const scope = await scopeOf(options);
+    const signal = options.signal;
+    const requestKey = (options.request ?? randomUUID()).toLowerCase();
+    const recovery = `firedrill tools start --request-key ${requestKey}`;
+    // A review already made under this key is continued, never made again.
+    let setup = options.request ? await recoverSetup(scope, { requestKey, signal }) : null;
+    let items = null;
+    if (!setup) {
+        let durationSeconds;
+        let selections;
+        if (options.file !== undefined) {
+            const input = parseSetupInput(JSON.parse(await requestInput(options.file, signal, 1024 * 1024)));
+            durationSeconds = await chooseSeconds(options, input.durationSeconds);
+            selections = input.selections;
+        }
+        else {
+            let chosen = ids;
+            if (!chosen.length) {
+                if (!tty(options))
+                    throw new CliError('tool_selection_required', 'Use tools start <version-id>... (ids from firedrill tools runnable) or --file <selection.json>. Nothing was started.', 2);
+                const { rows, more } = await pickable(scope, options);
+                if (more)
+                    process.stderr.write(`Showing the first ${rows.length} tools; narrow the list with --search.\n`);
+                chosen = await chooseStartCatalog(scope, rows, { search: options.search, signal, requestKey });
+                // Newly adopted catalog versions require fresh canonical option reads.
+            }
+            selections = await selectionsFor(scope, chosen, options);
+            durationSeconds = await chooseSeconds(options, null);
+        }
+        emit('tool_start_intent', { request_key: requestKey, duration_seconds: durationSeconds, selections }, `Tool start request: ${requestKey}\nIf interrupted, continue with ${recovery}. Do not start again with a new request.`);
+        try {
+            ({ setup, items } = await retryTransient(() => reviewSetup(scope, { requestKey, durationSeconds, selections, signal }), { signal, attempts: 3 }));
+        }
+        catch (error) {
+            // Only an unanswered review may have landed; a refusal or a bad local input is reported as it is.
+            if (signal.aborted || !isTransient(error))
+                throw error;
+            setup = await recoverSetup(scope, { requestKey, signal }).catch(() => null);
+            if (!setup)
+                throw new CliError('tool_start_unconfirmed', `The review was not confirmed. Continue with ${recovery}; nothing new is reviewed or charged twice.`);
+        }
+    }
+    const reviewed = setup;
+    let children = items ?? await setupItems(scope, { setup: reviewed, signal });
+    if (setup.state === 'reviewed' && setup.approved_at === null && setup.stop_requested_at === null) {
+        // Quoting reserves nothing. Root keeps one estimate per session and replays it for its quote key only,
+        // so a later run admits exactly the estimate the human saw. An approval holds only for that key.
+        const original = setup.quote_request_key;
+        const given = options.quote?.toLowerCase();
+        if (given !== undefined && original !== null && given !== original)
+            throw new CliError('idempotency_conflict', 'That quote key is not this setup’s original estimate. Read the original setup before continuing. Nothing was admitted.', 2);
+        const quoteKey = original ?? given ?? randomUUID();
+        let notice = '';
+        if (given !== undefined && original === null)
+            notice = 'No estimate was quoted before under that quote key, so this is a new one. ';
+        else if (given !== undefined && given !== original)
+            notice = `This session's estimate was quoted under ${original}, not the key given, so it needs its own approval. `;
+        const quoted = children;
+        const quotes = await retryTransient(() => quoteSetup(scope, { setup: reviewed, items: quoted, requestKey: quoteKey, signal }), { signal, attempts: 3 });
+        if (!quotes.quotes.every(live))
+            throw expiredReview(setup.id);
+        let approved = options.approve === true && (!quotes.quotes.some(quote => quote.credit_approval_required) || (original !== null && given === original));
+        const interactive = tty(options);
+        if (!approved && interactive)
+            process.stderr.write(setupText(setup, children) + '\n');
+        emit('tool_start_quote', quotes, `${notice}${quoteText(quotes, children)}`);
+        if (!approved && interactive) {
+            approved = await selectOne(`Start ${children.length} tool${children.length === 1 ? '' : 's'} for ${duration(setup.duration_seconds)} each?`, [
+                { value: false, label: 'Not now', detail: 'Nothing is reserved or started.' },
+                { value: true, label: 'Start tools', detail: 'Reserves up to the estimate above. The tools run in the cloud, not on this machine.' },
+            ], signal);
+        }
+        if (!approved) {
+            throw new CliError('tool_change_consent_required', `${notice}Nothing was reserved or started. Show the human this estimate; after they approve it: `
+                + `${recovery} --usage-quote ${quoteKey} --approve-tool-change`, 2);
+        }
+        const creditApproval = await approveCredits(quotes.quotes, options, interactive, `${recovery} --usage-quote ${quoteKey} --approve-tool-change`);
+        try {
+            setup = await retryTransient(() => admitSetup(scope, { quotes, signal, creditApproval }), { signal, attempts: 3 });
+        }
+        catch (error) {
+            if (signal.aborted)
+                throw error;
+            // An unanswered approval may have landed: the session says, and nothing is approved twice.
+            const current = await getSetup(scope, { setupId: quotes.setup_id, signal }).catch(() => null);
+            if (!current || current.approved_at === null) {
+                // Root admits only a current estimate; an expired one is never approved, so the unused review is closed instead.
+                if (errorCode(error) === 'native_tool_setup_quote_expired')
+                    throw expiredReview(quotes.setup_id);
+                if (error instanceof CliError && error.httpStatus !== null && !isTransient(error))
+                    throw error;
+                throw new CliError('tool_start_unconfirmed', `The approval was not confirmed. Check firedrill tools session ${quotes.setup_id}; if it is still reviewed, run ${recovery} --usage-quote ${quoteKey} --approve-tool-change.`);
+            }
+            setup = current;
+        }
+        const admitted = setup;
+        children = await setupItems(scope, { setup: admitted, signal }).catch(() => children);
+    }
+    if (!setup)
+        throw new CliError('tool_start_unconfirmed', 'The tool session was not confirmed. Recover the original request before starting another.');
+    if (options.follow) {
+        const deadline = Date.now() + FOLLOW_LIMIT_MS;
+        let shown = '';
+        while (!settled(setup, children) && Date.now() < deadline) {
+            const text = setupText(setup, children);
+            if (text !== shown) {
+                emit('tool_session', { ...setup, items: children }, text);
+                shown = text;
+            }
+            if (!await sleep(jitteredInterval(FOLLOW_MS), signal))
+                return;
+            const setupId = setup.id;
+            const current = await retryTransient(() => getSetup(scope, { setupId, signal }), { signal, attempts: 4 });
+            children = await retryTransient(() => setupItems(scope, { setup: current, signal }), { signal, attempts: 4 });
+            setup = current;
+        }
+    }
+    emit('tool_session', { ...setup, items: children }, setupText(setup, children)
+        + (settled(setup, children) ? '' : `\nFollow it: firedrill tools session ${setup.id}`));
+}
+/** `tools runnable [--search <text>] [--page <n>]`: saved versions and the lane each service would start in. */
+async function runnable(options, emit) {
+    const scope = await scopeOf(options);
+    const page = await listSetupOptions(scope, { page: pageNumber(options.page), pageSize: 32, search: options.search, signal: options.signal });
+    const lines = page.results.map((one) => `${one.implementation_id}  ${terminalText(one.name)} ${terminalText(one.version)}  `
+        + (one.available ? one.services.map((service) => `${terminalText(service.service_key)} (${LANE_TEXT[service.lane]}, ${service.operation_count} operations`
+            + `${service.has_preview ? ', preview' : ''})`).join('; ') : 'cannot start in a tool session'));
+    const shownTo = ((page.page ?? 1) - 1) * 32 + page.results.length;
+    emit('tool_runnable', page, [
+        ...(lines.length ? lines : ['No saved tool version matches. Browse firedrill tools catalog and save one with firedrill tools save <release-id>, '
+                + 'or push your own package with firedrill tools push (neither starts anything).']),
+        page.count > shownTo ? `${page.count - shownTo} more: add --page ${(page.page ?? 1) + 1}` : null,
+        lines.length ? 'Start: firedrill tools start <version-id>... --seconds <n> [--service <key>]' : null,
+    ].filter((line) => line !== null).join('\n'));
+}
+/** `tools sessions [--state all|active|preparing|closed] [--search <text>] [--page <n>]` (`pending` still means `preparing`). */
+async function sessions(options, emit) {
+    const category = options.state === 'pending' ? 'preparing' : options.state;
+    if (category !== undefined && !SETUP_CATEGORIES.includes(category)) {
+        throw new CliError('arguments_invalid', `Use --state ${SETUP_CATEGORIES.join('|')}.`, 2);
+    }
+    const scope = await scopeOf(options);
+    const page = await listSetups(scope, { page: pageNumber(options.page), category: category, search: options.search, signal: options.signal });
+    const lines = page.results.map((one) => `${one.id}  ${stateText(one.state)}  ${one.item_count} tool${one.item_count === 1 ? '' : 's'}`
+        + `, ${duration(one.duration_seconds)} per tool, created ${terminalText(one.created_at)}`);
+    const shownTo = ((page.page ?? 1) - 1) * 25 + page.results.length;
+    emit('tool_sessions', page, [
+        ...(lines.length ? lines : ['No tool sessions match.']),
+        page.count > shownTo ? `${page.count - shownTo} more: add --page ${(page.page ?? 1) + 1}` : null,
+        'Details: firedrill tools session <session-id>',
+    ].filter((line) => line !== null).join('\n'));
+}
+/** A session by id: a mixed setup, or a session started before them (read by its batch id, for history). */
+async function sessionById(scope, id, signal) {
+    try {
+        const setup = await getSetup(scope, { setupId: id, signal });
+        return { setup, items: await setupItems(scope, { setup, signal }) };
+    }
+    catch (error) {
+        if (!(error instanceof CliError && error.httpStatus === 404))
+            throw error;
+        return { batch: await getStandaloneBatch(scope, { batchId: id, signal }) };
+    }
+}
+async function stopConsent(text, id, options) {
+    let approved = options.approve === true;
+    if (!approved && tty(options)) {
+        process.stderr.write(text + '\n');
+        approved = await selectOne('Stop this tool session?', [
+            { value: false, label: 'Keep it running' },
+            { value: true, label: 'Stop the session', detail: 'Every tool in it stops and its access ends. Usage is settled by the service.' },
+        ], options.signal);
+    }
+    if (!approved)
+        throw new CliError('tool_change_consent_required', `Nothing was stopped. After the human approves: firedrill tools session ${id} stop --approve-tool-change`, 2);
+}
+/**
+ * The shared-pool batch a renewal extends: a session started before mixed setups is that batch; a mixed setup's
+ * pooled tools run as one batch on the shared pool. Isolated tools keep their own lifetime.
+ */
+async function renewalTarget(scope, found, signal) {
+    if ('batch' in found)
+        return { sessionId: found.batch.id, batch: found.batch, isolatedTools: 0 };
+    const { setup, items } = found;
+    const pooled = [...new Set(items.flatMap((one) => one.lane === 'pooled' && one.pooled_batch_id ? [one.pooled_batch_id] : []))];
+    if (!pooled.length) {
+        throw new CliError('tool_renewal_unavailable', 'Renewal extends shared-pool tools, and this session has none on the shared pool. '
+            + 'Isolated tools keep their own end time. Nothing was sent.', 2);
+    }
+    if (pooled.length > 1)
+        throw new CliError('native_response_unconfirmed', 'This session\'s shared-pool tools could not be confirmed as one batch. Nothing was sent.');
+    const batch = await getStandaloneBatch(scope, { batchId: pooled[0], signal });
+    return { sessionId: setup.id, batch, isolatedTools: items.filter((one) => one.lane === 'isolated').length };
+}
+/**
+ * `tools session <session-id> replace [--request-key <key>] [--approve-tool-change]`: root copies a stopped,
+ * never-approved session's exact tools, seeds and duration into a new review. Nothing is reserved or started;
+ * the new review's estimate is approved with tools start --request-key. Every attempt sends the same request key,
+ * so root returns the same replacement and refuses a key that belongs to another original.
+ */
+async function replaceReview(scope, found, options, emit) {
+    if ('batch' in found) {
+        throw new CliError('tool_replacement_unavailable', 'Only a session reviewed with firedrill tools start can be reviewed again this way. '
+            + 'Start a new request without --request-key. Nothing was sent.', 2);
+    }
+    const { setup, items } = found;
+    const signal = options.signal;
+    if (setup.actor_id !== scope.owner.toLowerCase()) {
+        throw new CliError('native_tool_setup_owner_only', `Tool session ${setup.id} was started by another member, and only they can review it again. Nothing was sent.`, 2);
+    }
+    if (setup.approved_at !== null) {
+        throw new CliError('native_tool_setup_replacement_requires_unused_stop', `Tool session ${setup.id} was approved, so it is never reviewed again. `
+            + 'Start a new request with firedrill tools start. Nothing was sent.', 2);
+    }
+    if (setup.stop_requested_at === null) {
+        throw new CliError('native_tool_setup_replacement_requires_unused_stop', `Close this unapproved review first: firedrill tools session ${setup.id} stop `
+            + `--approve-tool-change. Then review the same tools again with firedrill tools session ${setup.id} replace --approve-tool-change. Nothing was sent.`, 2);
+    }
+    const requestKey = (options.request ?? randomUUID()).toLowerCase();
+    const again = `firedrill tools session ${setup.id} replace --request-key ${requestKey} --approve-tool-change`;
+    let approved = options.approve === true;
+    if (!approved && tty(options)) {
+        process.stderr.write(setupText(setup, items) + '\n');
+        approved = await selectOne('Review these tools again as a new session?', [
+            { value: false, label: 'Not now', detail: 'Nothing is sent.' },
+            { value: true, label: 'Review again', detail: 'A new review with the same tools, seeds and duration. It reserves and starts nothing; its estimate needs approval next.' },
+        ], signal);
+    }
+    if (!approved) {
+        throw new CliError('tool_change_consent_required', `Nothing was sent. After the human approves: ${options.request === undefined
+            ? `firedrill tools session ${setup.id} replace --approve-tool-change` : again}`, 2);
+    }
+    emit('tool_replacement_intent', { previous_setup_id: setup.id, request_key: requestKey }, `Replacement request: ${requestKey}\nIf interrupted, continue with ${again}. Do not start again under a new key.`);
+    let replacement;
+    try {
+        replacement = await retryTransient(() => replaceSetup(scope, { setupId: setup.id, requestKey, signal }), { signal, attempts: 3 });
+    }
+    catch (error) {
+        // Only an unanswered request may have landed; a refusal is reported as it is.
+        if (signal.aborted || !isTransient(error))
+            throw error;
+        // A generic lookup by request key does not expose replacement provenance.
+        // Only this same-source/key POST proves the exact relationship again.
+        throw new CliError('tool_replacement_unconfirmed', `The replacement review was not confirmed. Continue with ${again}; do not submit a different key.`);
+    }
+    const after = await setupItems(scope, { setup: replacement, signal }).catch(() => []);
+    const next = replacement.approved_at !== null || replacement.stop_requested_at !== null
+        ? `This replacement already has a later action. Inspect it with firedrill tools session ${replacement.id}. No new start was submitted.`
+        : `This review has not been approved. Show the human its estimate and continue with firedrill tools start --request-key ${requestKey}.`;
+    emit('tool_session_replacement', { previous_setup_id: setup.id, ...replacement, items: after }, `${setupText(replacement, after)}\nReview of the same tools confirmed. ${next}`);
+}
+/**
+ * `tools session <session-id> [stop|replace] [--approve-tool-change]`, and its renewal commands
+ * (`renew`, `renewals`, `renewal`, `cancel-renewal`, `renewal-request`, `withdraw-renewal`).
+ */
+async function session(args, options, emit) {
+    const [, sessionId, verb, value] = args;
+    const renewing = verb !== undefined && RENEWAL_VERBS.has(verb);
+    if (!sessionId || !UUID.test(sessionId) || args.length > (renewing ? 4 : 3)
+        || (verb !== undefined && verb !== 'stop' && verb !== 'replace' && !renewing)) {
+        throw new CliError('arguments_invalid', 'Use tools session <session-id>, tools session <session-id> stop|replace, or tools session <session-id> renew --seconds <n> '
+            + '(also renewals, renewal <renewal-id>, cancel-renewal <renewal-id>, renewal-request <key>, withdraw-renewal <key>).', 2);
+    }
+    const renewalOptions = { json: options.json, signal: options.signal, seconds: options.seconds, request: options.request,
+        quote: options.quote, approve: options.approve, approveCredits: options.approveCredits, page: options.page };
+    if (renewing)
+        checkRenewalArguments(verb, value, renewalOptions);
+    else if (verb === 'replace') {
+        if ([options.seconds, options.quote, options.page, options.approveCredits].some((one) => one !== undefined)
+            || (options.request !== undefined && !UUID.test(options.request))) {
+            throw new CliError('arguments_invalid', 'Use tools session <session-id> replace [--request-key <key>] [--approve-tool-change].', 2);
+        }
+    }
+    else if ([options.seconds, options.request, options.quote, options.page, options.approveCredits].some((one) => one !== undefined)) {
+        throw new CliError('arguments_invalid', 'Use --seconds, --request-key, --usage-quote and --page only with the renewal and replace commands of tools session.', 2);
+    }
+    const scope = await scopeOf(options);
+    const found = await sessionById(scope, sessionId.toLowerCase(), options.signal);
+    if (renewing)
+        return toolRenewalCommand(scope, await renewalTarget(scope, found, options.signal), verb, value, renewalOptions, emit);
+    if (verb === 'replace')
+        return replaceReview(scope, found, options, emit);
+    if ('batch' in found) {
+        const batch = found.batch;
+        if (verb === undefined) {
+            emit('tool_session', batch, batchText(batch));
+            return;
+        }
+        if (STANDALONE_TERMINAL.has(batch.state)) {
+            emit('tool_session', batch, `${batchText(batch)}\nThis session already ended; nothing was sent.`);
+            return;
+        }
+        await stopConsent(batchText(batch), batch.id, options);
+        // Stopping is idempotent, so an unanswered request is simply repeated.
+        const stopped = await retryTransient(() => stopStandaloneBatch(scope, { batchId: batch.id, signal: options.signal }), { signal: options.signal, attempts: 3 });
+        // This summary has no approval field. The pre-stop state can be stale if
+        // another client admitted the original meanwhile, so do not infer funding.
+        emit('tool_session', stopped, `${batchText(stopped)}\nStop recorded. Any admitted resources still need cleanup and usage settlement; `
+            + `this does not prove storage is gone. Check with firedrill tools session ${stopped.id}.`);
+        return;
+    }
+    const { setup, items } = found;
+    if (verb === undefined) {
+        emit('tool_session', { ...setup, items }, setupText(setup, items, scope.owner));
+        return;
+    }
+    if (SETUP_ENDED.has(setup.state)) {
+        emit('tool_session', { ...setup, items }, `${setupText(setup, items, scope.owner)}\nThis session already ended; nothing was sent.`);
+        return;
+    }
+    // Root stops a mixed session for the member who started it only (others get a generic refusal), so ask nobody else to approve.
+    if (setup.actor_id !== scope.owner.toLowerCase()) {
+        throw new CliError('native_tool_setup_owner_only', `Tool session ${setup.id} was started by another member, and only they can stop it. It ends on its own at its scheduled time. Nothing was sent.`, 2);
+    }
+    await stopConsent(setupText(setup, items), setup.id, options);
+    const stopped = await retryTransient(() => stopSetup(scope, { setupId: setup.id, signal: options.signal }), { signal: options.signal, attempts: 3 });
+    const after = await setupItems(scope, { setup: stopped, signal: options.signal }).catch(() => items);
+    // A setup stopped before its approval only cancels its reviewed tools: nothing was admitted or reserved.
+    emit('tool_session', { ...stopped, items: after }, stopped.approved_at === null
+        ? `${setupText(stopped, after)}\nThis unapproved review is closed. Nothing was reserved or started. Review the same tools again with `
+            + `firedrill tools session ${stopped.id} replace --approve-tool-change, or choose new ones with firedrill tools start.`
+        : `${setupText(stopped, after)}\nStop requested. The service retires every tool and settles its usage; `
+            + `this does not prove storage is gone. Check with firedrill tools session ${stopped.id}.`);
+}
+function servedText(tool) {
+    const head = `  ${terminalText(tool.name)} (${terminalText(tool.service_key)}, ${LANE_TEXT[tool.lane]})\n    MCP (Streamable HTTP): ${tool.mcp}`;
+    if (tool.lane === 'pooled')
+        return `${head}\n    Operations (POST JSON {operation, arguments, idempotency_key?}): ${tool.invoke}`;
+    return `${head}\n    Operations: POST ${tool.operations}/<service_key>/<operation_name> with {"arguments": {...}} and an Idempotency-Key UUID;`
+        + ` read one back with GET ${tool.requests}/<key>`;
+}
+/**
+ * `tools access <session-id> [--allow-writes] [--approve-tool-change]`: serve
+ * every running tool of the session on loopback URLs until Ctrl-C or until the
+ * session ends. Read-only operations unless --allow-writes (which still needs
+ * write access to the workspace). Each isolated tool needs a scoped connection,
+ * created with the human's consent and revoked when access ends.
+ */
+async function access(args, options, emit) {
+    const [, sessionId] = args;
+    if (!sessionId || !UUID.test(sessionId) || args.length !== 2)
+        throw new CliError('arguments_invalid', 'Use tools access <session-id> [--allow-writes].', 2);
+    const scope = await scopeOf(options);
+    const found = await sessionById(scope, sessionId.toLowerCase(), options.signal);
+    if ('batch' in found)
+        return accessBatch(scope, found.batch, options, emit);
+    let { setup, items } = found;
+    const now = items.filter(running);
+    if (!now.length) {
+        throw new CliError('native_tool_access_unavailable', `No tool in session ${setup.id} is running (${stateText(setup.state)}), so there is nothing to connect to.`
+            + (SETUP_ENDED.has(setup.state) || setup.stop_requested_at ? '' : ` Follow it with firedrill tools session ${setup.id}.`), 2);
+    }
+    const mode = options.allowWrites ? 'interactive' : 'read';
+    const isolated = now.filter((one) => one.lane === 'isolated');
+    if (isolated.length) {
+        let approved = options.approve === true;
+        if (!approved && tty(options)) {
+            approved = await selectOne(`Connect ${isolated.length} isolated tool${isolated.length === 1 ? '' : 's'} to this machine?`, [
+                { value: false, label: 'Cancel', detail: 'Nothing is connected.' },
+                { value: true, label: 'Connect', detail: 'Creates one scoped connection per isolated tool, kept in workspace history and revoked when access ends. Its synthetic tool data comes to this machine.' },
+            ], options.signal);
+        }
+        if (!approved) {
+            throw new CliError('tool_change_consent_required', 'Each isolated tool is connected through its own scoped connection, kept in workspace history and revoked when '
+                + 'access ends, and its synthetic tool data comes to this machine. Nothing was connected. After the human approves: '
+                + `firedrill tools access ${setup.id}${options.allowWrites ? ' --allow-writes' : ''} --approve-tool-change`, 2);
+        }
+    }
+    // The shared pool runs every pooled child of a setup as one batch; its active instances are served with short-lived credentials.
+    const pooled = now.filter((one) => one.lane === 'pooled');
+    let instances = [];
+    if (pooled.length) {
+        const batch = await getStandaloneBatch(scope, { batchId: pooled[0].pooled_batch_id, signal: options.signal });
+        const ids = new Set(pooled.map((one) => one.instance_id));
+        instances = batch.instances.filter((one) => ids.has(one.id) && one.state === STANDALONE_ACTIVE);
+    }
+    const stop = new AbortController();
+    const signal = AbortSignal.any([options.signal, stop.signal]);
+    const grants = [];
+    let proxy = null;
+    let fatal = null;
+    try {
+        for (const one of isolated) {
+            // The original key is reported before anything is sent, so a connection created during a lost answer or Ctrl-C can be found.
+            const requestKey = randomUUID();
+            emit('tool_connection_prepared', { session_id: setup.id, instance_id: one.instance_id, request_key: requestKey }, `Connecting ${terminalText(one.name)} (connection request ${requestKey}).`);
+            try {
+                grants.push(await openIsolatedGrant(scope, { instanceId: one.instance_id, serviceKey: one.service_key, operations: one.operations, mode, requestKey, signal }));
+            }
+            catch (error) {
+                // One isolated tool that cannot be connected does not stop the others; the reason is reported, nothing is reissued.
+                // An unconfirmed connection is reported even after Ctrl-C: it names the original and whether it was revoked.
+                const code = errorCode(error) ?? 'native_tool_access_unavailable';
+                if (!signal.aborted || code === 'tool_connection_unconfirmed') {
+                    emit('tool_access_not_served', { session_id: setup.id, instance_id: one.instance_id, request_key: requestKey, code }, `${terminalText(one.name)} is not served here: ${error instanceof Error ? terminalText(error.message) : 'its connection failed'}`);
+                }
+                if (signal.aborted)
+                    throw error;
+            }
+        }
+        if (!instances.length && !grants.length) {
+            throw new CliError('native_tool_access_unavailable', 'None of the running tools could be connected here, for the reasons above. Nothing is being served.', 2);
+        }
+        const started = await StandaloneProxy.start({ scope, instances, isolated: grants, mode, signal,
+            onEnded: (instanceId, code) => {
+                emit('tool_access_ended', { session_id: setup.id, instance_id: instanceId, code }, code === STANDALONE_ACCESS_ERRORS.connectionEnded
+                    ? `Tool ${instanceId} is no longer served here: its connection expired or was revoked. It is not renewed; run tools access ${setup.id} again for a new one.`
+                    : `Tool ${instanceId} is no longer reachable here (${terminalText(code)}).`);
+                if (proxy && !proxy.serving.length)
+                    stop.abort();
+            },
+            onFatal: (error) => { fatal = error; stop.abort(); } });
+        proxy = started;
+        const tools = items.filter((one) => one.instance_id !== null && started.serving.includes(one.instance_id)).map((one) => {
+            const grant = grants.find((row) => row.instance_id === one.instance_id);
+            return { instance_id: one.instance_id, name: one.name, service_key: one.service_key, ...started.urls(one.instance_id),
+                ...(grant ? { connection_id: grant.grant_id, connection_expires_at: grant.expires_at } : {}) };
+        });
+        emit('tool_access_ready', { session_id: setup.id, mode, tools }, [
+            `Serving ${tools.length} tool${tools.length === 1 ? '' : 's'} of session ${setup.id} on this machine (${mode === 'read' ? 'read-only operations' : 'reads and writes'}):`,
+            ...tools.map(servedText),
+            'Point your agent\'s MCP client at an MCP URL. These URLs work only on this machine and only while this command runs; keep them out of chat, files and reports.',
+            'Leave this running. Ctrl-C ends access and revokes its isolated connections; the tools keep running until their session ends or is stopped.',
+        ].join('\n'));
+        // Ends with Ctrl-C, when root says the session or every served tool stopped, or when access is refused for good.
+        while (!signal.aborted) {
+            if (!await sleep(jitteredInterval(ACCESS_POLL_MS), signal))
+                break;
+            try {
+                const current = await getSetup(scope, { setupId: setup.id, signal });
+                items = await setupItems(scope, { setup: current, signal });
+                setup = current;
+            }
+            catch (error) {
+                if (signal.aborted)
+                    break;
+                if (isTransient(error))
+                    continue;
+                throw error;
+            }
+            if (SETUP_ENDED.has(setup.state) || setup.stop_requested_at)
+                break;
+            for (const one of items)
+                if (one.instance_id && started.serving.includes(one.instance_id) && !running(one))
+                    started.end(one.instance_id, STANDALONE_ACCESS_ERRORS.ended);
+            if (!started.serving.length)
+                break;
+        }
+    }
+    finally {
+        await proxy?.close();
+        // Ctrl-C aborted the command's own signal, so revocation gets its own bounded time.
+        const revoked = await Promise.all(grants.map((grant) => revokeGrant(scope, grant.instance_id, grant.grant_id, AbortSignal.timeout(REVOKE_MS))));
+        grants.forEach((grant, index) => {
+            if (!revoked[index]) {
+                emit('tool_access_revoke_unconfirmed', { session_id: setup.id, instance_id: grant.instance_id, connection_id: grant.grant_id }, `Revoking connection ${grant.grant_id} was not confirmed; it ends with the tool. Revoke it now: firedrill tools disconnect ${grant.instance_id} ${grant.grant_id} --approve-tool-change`);
+            }
+        });
+    }
+    if (fatal)
+        throw fatal;
+    emit('tool_access_closed', { session_id: setup.id, state: setup.state }, SETUP_ENDED.has(setup.state) || setup.stop_requested_at ? `The tool session is ${stateText(setup.state)}; access ended.`
+        : 'Access ended on this machine. The tools keep running until their session ends.');
+}
+/** `tools access` for a session started before mixed setups: its pooled instances only. */
+async function accessBatch(scope, initial, options, emit) {
+    let batch = initial;
+    if (batch.state !== STANDALONE_ACTIVE) {
+        throw new CliError('native_tool_access_unavailable', `This tool session is ${stateText(batch.state)}, so there is nothing to connect to yet.`
+            + (STANDALONE_TERMINAL.has(batch.state) ? '' : ` Follow it with firedrill tools session ${batch.id}.`), 2);
+    }
+    const mode = options.allowWrites ? 'interactive' : 'read';
+    const stop = new AbortController();
+    const signal = AbortSignal.any([options.signal, stop.signal]);
+    let fatal = null;
+    const proxy = await StandaloneProxy.start({ scope, instances: batch.instances, mode, signal,
+        onEnded: (instanceId, code) => {
+            emit('tool_access_ended', { session_id: batch.id, instance_id: instanceId, code }, `Tool ${instanceId} is no longer reachable here (${terminalText(code)}).`);
+            if (!proxy.serving.length)
+                stop.abort();
+        },
+        onFatal: (error) => { fatal = error; stop.abort(); } });
+    const tools = batch.instances.filter((one) => proxy.serving.includes(one.id))
+        .map((one) => ({ instance_id: one.id, name: `${one.name} ${one.version}`, service_key: one.service_key, ...proxy.urls(one.id) }));
+    emit('tool_access_ready', { session_id: batch.id, mode, tools }, [
+        `Serving ${tools.length} tool${tools.length === 1 ? '' : 's'} of session ${batch.id} on this machine (${mode === 'read' ? 'read-only operations' : 'reads and writes'}):`,
+        ...tools.map(servedText),
+        'Point your agent\'s MCP client at an MCP URL. These URLs work only on this machine and only while this command runs; keep them out of chat, files and reports.',
+        'Leave this running. Ctrl-C ends access; the tools keep running until their session ends or is stopped.',
+    ].join('\n'));
+    try {
+        while (!signal.aborted) {
+            if (!await sleep(jitteredInterval(ACCESS_POLL_MS), signal))
+                break;
+            try {
+                batch = await getStandaloneBatch(scope, { batchId: batch.id, signal });
+            }
+            catch (error) {
+                if (signal.aborted)
+                    break;
+                if (isTransient(error))
+                    continue;
+                throw error;
+            }
+            if (batch.state !== STANDALONE_ACTIVE)
+                break;
+            for (const one of batch.instances)
+                if (one.state !== STANDALONE_ACTIVE)
+                    proxy.end(one.id, STANDALONE_ACCESS_ERRORS.ended);
+        }
+    }
+    finally {
+        await proxy.close();
+    }
+    if (fatal)
+        throw fatal;
+    emit('tool_access_closed', { session_id: batch.id, state: batch.state }, batch.state === STANDALONE_ACTIVE ? 'Access ended on this machine. The tools keep running until their session ends.'
+        : `The tool session is ${stateText(batch.state)}; access ended.`);
+}
+export async function nativeToolsCommand(args, options, emit) {
+    const action = args[0];
+    const allowed = {
+        runnable: ['search', 'page'], start: ['file', 'seconds', 'service', 'request', 'quote', 'approve', 'approveCredits', 'follow', 'search'],
+        sessions: ['state', 'search', 'page'], session: ['approve', 'approveCredits', 'seconds', 'request', 'quote', 'page'], access: ['allowWrites', 'approve'],
+        state: ['file', 'request', 'approve', 'approveCredits', 'page', 'seconds', 'quote'],
+    };
+    const flags = { file: '--file', seconds: '--seconds', service: '--service',
+        request: '--request-key', quote: '--usage-quote', approve: '--approve-tool-change', approveCredits: '--approve-credits', follow: '--follow', state: '--state', search: '--search', page: '--page', allowWrites: '--allow-writes' };
+    const extra = Object.keys(flags)
+        .filter((flag) => options[flag] !== undefined && options[flag] !== false && !allowed[action]?.includes(flag));
+    if (extra.length)
+        throw new CliError('arguments_invalid', `tools ${action} does not take ${extra.map((flag) => flags[flag]).join(', ')}.`, 2);
+    if (action === 'runnable') {
+        if (args.length !== 1)
+            throw new CliError('arguments_invalid', 'Use tools runnable [--search <text>] [--page <n>].', 2);
+        return runnable(options, emit);
+    }
+    if (action === 'start')
+        return start(args, options, emit);
+    if (action === 'sessions') {
+        if (args.length !== 1)
+            throw new CliError('arguments_invalid', 'Use tools sessions [--state all|active|preparing|closed] [--search <text>] [--page <n>].', 2);
+        return sessions(options, emit);
+    }
+    if (action === 'session')
+        return session(args, options, emit);
+    if (action === 'access')
+        return access(args, options, emit);
+    if (action === 'state') {
+        if (args.length < 2)
+            throw new CliError('arguments_invalid', 'Use tools state <instance-id> (instance ids from firedrill tools session <session-id>).', 2);
+        return toolStateCommand(await scopeOf(options), args.slice(1), { json: options.json, signal: options.signal, file: options.file,
+            request: options.request, approve: options.approve, approveCredits: options.approveCredits, page: options.page, seconds: options.seconds, quote: options.quote }, emit);
+    }
+    throw new CliError('arguments_invalid', 'Use tools runnable, tools start, tools sessions, tools session <session-id> [stop | renew], tools access <session-id> '
+        + 'or tools state <instance-id>.', 2);
+}