@kikedealba/recap 0.0.0-stage → 0.9.1

package/dist/cli/commands/live.js

@@ -0,0 +1,23 @@
+import { loadConfig } from "../../core/config.js";
+import { isoNow } from "../../core/dates.js";
+import { isDirectory } from "../../core/fsutil.js";
+import { MeetingStore } from "../../core/meeting.js";
+import { describeError } from "../../errors.js";
+import { LiveWorker, makeLiveDetector } from "../../live/worker.js";
+export async function liveWorkerCommand(argv) {
+    const log = (message) => process.stderr.write(`${isoNow()} ${message}\n`);
+    try {
+        const reference = argv.find((arg) => !arg.startsWith('--'));
+        if (!reference)
+            throw new Error('Usage: recap live-worker <meeting dir or id>');
+        const config = loadConfig();
+        const dir = isDirectory(reference) ? reference : new MeetingStore(config).resolve(reference).dir;
+        const worker = new LiveWorker(dir, config, log, { detectorFactory: (meetingDir, meeting) => makeLiveDetector(meetingDir, meeting, config, log) });
+        await worker.run();
+        return 0;
+    }
+    catch (error) {
+        log(`live worker failed: ${describeError(error)}`);
+        return 1;
+    }
+}

package/dist/cli/commands/media.js

@@ -0,0 +1,53 @@
+import { loadConfig } from "../../core/config.js";
+import { MeetingStore, resolveTarget } from "../../core/meeting.js";
+import { meetingRecord } from "../../core/record.js";
+import { formatBytes } from "../../core/text.js";
+import { usageError } from "../../errors.js";
+import { VIDEO_PRESETS, pathSize } from "../../media/media.js";
+import { compressVideo, deleteMeeting, pruneMeeting, stripVideo } from "../../media/operations.js";
+import { parseArgs } from "../args.js";
+import { output } from "../output.js";
+export async function stripVideoCommand(argv) {
+    return output('strip-video', argv.includes('--json'), async () => {
+        const args = parseArgs(argv, { booleans: ['prune-intermediates'], values: ['bita-entry'], maxPositionals: 1 });
+        const config = loadConfig();
+        const { meeting, dir } = resolveTarget(new MeetingStore(config), args.positionals[0], args.int('bita-entry'));
+        const before = pathSize(dir);
+        const updated = await stripVideo(config, meeting, dir, args.has('prune-intermediates'));
+        return { data: meetingRecord(updated, dir), text: `Removed the video from "${updated.title}": ${formatBytes(before)} -> ${formatBytes(pathSize(dir))}` };
+    });
+}
+export async function compressVideoCommand(argv) {
+    return output('compress-video', argv.includes('--json'), async () => {
+        const args = parseArgs(argv, { booleans: ['prune-intermediates'], values: ['bita-entry', 'preset'], maxPositionals: 1 });
+        const preset = args.value('preset');
+        if (!preset || !VIDEO_PRESETS.includes(preset))
+            throw usageError(`--preset takes one of ${VIDEO_PRESETS.join(', ')}`);
+        const config = loadConfig();
+        const { meeting, dir } = resolveTarget(new MeetingStore(config), args.positionals[0], args.int('bita-entry'));
+        const before = pathSize(dir);
+        const updated = await compressVideo(config, meeting, dir, preset, args.has('prune-intermediates'));
+        return { data: meetingRecord(updated, dir), text: `Compressed the video of "${updated.title}" (${preset}): ${formatBytes(before)} -> ${formatBytes(pathSize(dir))}` };
+    });
+}
+export async function pruneCommand(argv) {
+    return output('prune', argv.includes('--json'), () => {
+        const args = parseArgs(argv, { booleans: ['intermediates'], values: ['bita-entry'], maxPositionals: 1 });
+        if (!args.has('intermediates'))
+            throw usageError('Choose what to prune: --intermediates');
+        const config = loadConfig();
+        const { meeting, dir } = resolveTarget(new MeetingStore(config), args.positionals[0], args.int('bita-entry'));
+        const before = pathSize(dir);
+        const updated = pruneMeeting(meeting, dir);
+        return { data: meetingRecord(updated, dir), text: `Pruned "${updated.title}": ${formatBytes(before)} -> ${formatBytes(pathSize(dir))}` };
+    });
+}
+export async function deleteCommand(argv) {
+    return output('delete', argv.includes('--json'), () => {
+        const args = parseArgs(argv, { values: ['bita-entry'], maxPositionals: 1 });
+        const config = loadConfig();
+        const { meeting, dir } = resolveTarget(new MeetingStore(config), args.positionals[0], args.int('bita-entry'));
+        const deleted = deleteMeeting(meeting, dir);
+        return { data: deleted, text: `Deleted "${meeting.title}", freed ${formatBytes(deleted.freedBytes)}` };
+    });
+}

package/dist/cli/commands/proposals.js

@@ -0,0 +1,76 @@
+import { loadConfig } from "../../core/config.js";
+import { expandTilde } from "../../core/paths.js";
+import { readText } from "../../core/fsutil.js";
+import { MeetingStore, resolveTarget } from "../../core/meeting.js";
+import { RecapError, usageError } from "../../errors.js";
+import { docsClient, meetingTarget } from "../../bita/client.js";
+import { ProposalReview, loadProposals, proposalJson } from "../../bita/proposals.js";
+import { parseArgs } from "../args.js";
+import { output } from "../output.js";
+function line(proposal) {
+    const section = proposal.section !== null ? ` › ${proposal.section}` : '';
+    return `${proposal.n}. [${proposal.status}] ${proposal.pageTitle}${section}: ${proposal.title}`;
+}
+function meeting(args, config) {
+    const bitaEntry = args.int('bita-entry');
+    return resolveTarget(new MeetingStore(config), bitaEntry === undefined ? args.positionals[0] : undefined, bitaEntry);
+}
+function number(args) {
+    const raw = args.value('bita-entry') === undefined ? args.positionals[1] : args.positionals[0];
+    if (raw === undefined || !/^\d+$/.test(raw))
+        throw new RecapError('PROPOSAL_REQUIRED', 'Pass the proposal number');
+    return Number(raw);
+}
+const noBita = { invoke: async () => ({ ok: false, errorCode: 'DEPENDENCY_MISSING', errorMessage: 'bita not found' }) };
+async function review(args, config, required) {
+    const found = meeting(args, config);
+    const docs = await docsClient(config, meetingTarget(found.meeting));
+    if (!docs && required)
+        throw new RecapError('DEPENDENCY_MISSING', 'bita not found. Install it with `npm install -g @kikedealba/bita`');
+    return new ProposalReview(found.dir, docs ?? noBita);
+}
+export async function proposalsCommand(argv) {
+    const [sub, ...rest] = argv;
+    const json = rest.includes('--json');
+    const spec = { values: ['bita-entry', ...(sub === 'accept' ? ['md'] : [])], maxPositionals: 2 };
+    switch (sub) {
+        case 'ls':
+            return output('proposals ls', json, () => {
+                const args = parseArgs(rest, spec);
+                const proposals = loadProposals(meeting(args, loadConfig()).dir)?.proposals ?? [];
+                return { data: { proposals: proposals.map(proposalJson) }, text: proposals.length === 0 ? 'No proposals' : proposals.map(line).join('\n') };
+            });
+        case 'show':
+            return output('proposals show', json, async () => {
+                const args = parseArgs(rest, spec);
+                const reviewer = await review(args, loadConfig(), false);
+                const proposal = reviewer.proposal(number(args));
+                const markdown = readText(proposal.file);
+                const diff = proposal.status === 'pending' || proposal.status === 'stale' ? await reviewer.diff(proposal) : null;
+                let text = `${line(proposal)}\n\n${proposal.rationale}`;
+                if (markdown !== null)
+                    text += `\n\n${markdown}`;
+                return { data: { proposal: proposalJson(proposal), markdown: markdown ?? undefined, diff: diff ?? undefined }, text };
+            });
+        case 'accept':
+            return output('proposals accept', json, async () => {
+                const args = parseArgs(rest, spec);
+                const reviewer = await review(args, loadConfig(), true);
+                const md = args.value('md');
+                const proposal = await reviewer.accept(number(args), md === undefined ? undefined : expandTilde(md));
+                const text = proposal.status === 'stale' ? `Proposal ${proposal.n} conflicts with the current page; it is now stale` : `Applied proposal ${proposal.n} to ${proposal.pageTitle}`;
+                return { data: { proposal: proposalJson(proposal) }, text };
+            });
+        case 'reject':
+            return output('proposals reject', json, async () => {
+                const args = parseArgs(rest, spec);
+                const reviewer = await review(args, loadConfig(), true);
+                const proposal = await reviewer.reject(number(args));
+                return { data: { proposal: proposalJson(proposal) }, text: `Rejected proposal ${proposal.n}` };
+            });
+        default:
+            return output('proposals', argv.includes('--json'), () => {
+                throw usageError('Usage: recap proposals ls|show|accept|reject <meeting> [n] [--bita-entry id]');
+            });
+    }
+}

package/dist/cli/commands/query.js

@@ -0,0 +1,172 @@
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { loadConfig } from "../../core/config.js";
+import { isoNow } from "../../core/dates.js";
+import { readText } from "../../core/fsutil.js";
+import { MeetingStore, durationSeconds, loadMeeting, reconcile, updateMeeting } from "../../core/meeting.js";
+import { waitUntil } from "../../core/proc.js";
+import { meetingRecord } from "../../core/record.js";
+import { processInBackground } from "../../core/self.js";
+import { formatDuration, padEnd } from "../../core/text.js";
+import { RecapError, usageError } from "../../errors.js";
+import { saveMinutes } from "../../bita/wrapup.js";
+import { Pipeline } from "../../pipeline/pipeline.js";
+import { STAGES, allStagesSatisfied, isStage } from "../../pipeline/stages.js";
+import { saveSummary, summaryPromptFor } from "../../pipeline/summary.js";
+import { parseArgs } from "../args.js";
+import { output, stderrLine } from "../output.js";
+export async function listCommand(argv) {
+    return output('list', argv.includes('--json'), () => {
+        const args = parseArgs(argv, { values: ['limit'], maxPositionals: 0 });
+        const limit = args.int('limit') ?? 20;
+        const store = new MeetingStore(loadConfig());
+        const all = store.all();
+        const records = (limit > 0 ? all.slice(0, limit) : all).map((item) => ({ item, record: meetingRecord(item.meeting, item.dir) }));
+        const lines = records.map(({ item }) => {
+            const m = item.meeting;
+            return `${m.id}  ${padEnd(m.mode, 9)} ${padEnd(m.status, 10)} ${padEnd(formatDuration(durationSeconds(m)), 8)} ${m.title}`;
+        });
+        return { data: records.map(({ record }) => record), text: lines.length === 0 ? `No meetings in ${store.root}` : lines.join('\n') };
+    });
+}
+function locate(store, reference, bitaEntry) {
+    if (bitaEntry !== undefined) {
+        const found = store.find(bitaEntry);
+        if (!found)
+            throw new RecapError('MEETING_NOT_FOUND', `No meeting is linked to bita entry ${bitaEntry}`);
+        return found;
+    }
+    return store.resolve(reference ?? 'last');
+}
+export async function showCommand(argv) {
+    return output('show', argv.includes('--json'), () => {
+        const args = parseArgs(argv, { booleans: ['path'], values: ['bita-entry'], maxPositionals: 1 });
+        const { meeting, dir } = locate(new MeetingStore(loadConfig()), args.positionals[0], args.int('bita-entry'));
+        const record = meetingRecord(meeting, dir, true);
+        if (args.has('path'))
+            return { data: record, text: dir };
+        const summary = readText(path.join(dir, 'summary.md'));
+        if (summary !== null)
+            return { data: record, text: summary };
+        let text = `${meeting.title}\n${meeting.id}  ${meeting.mode}  ${meeting.status}  ${formatDuration(durationSeconds(meeting))}\n${dir}`;
+        if (meeting.error)
+            text += `\nError: ${meeting.error}`;
+        return { data: record, text };
+    });
+}
+function stageOption(value, name) {
+    if (value === undefined)
+        return undefined;
+    if (!isStage(value))
+        throw usageError(`--${name} takes one of ${STAGES.join(', ')}`);
+    return value;
+}
+export async function processCommand(argv) {
+    const json = argv.includes('--json');
+    return output('process', json, async () => {
+        const args = parseArgs(argv, { booleans: ['background'], values: ['from', 'only'], maxPositionals: 1 });
+        const from = stageOption(args.value('from'), 'from');
+        const only = stageOption(args.value('only'), 'only');
+        const config = loadConfig();
+        const { meeting, dir } = new MeetingStore(config).resolve(args.positionals[0] ?? 'last');
+        if (args.has('background')) {
+            processInBackground(meeting.id, dir, [...(from ? ['--from', from] : []), ...(only ? ['--only', only] : [])]);
+            return { data: meetingRecord(meeting, dir), text: `Processing "${meeting.title}" in the background\n${path.join(dir, 'process.log')}` };
+        }
+        const pipeline = new Pipeline(dir, config, (line) => {
+            if (!json)
+                stderrLine(line);
+        });
+        const result = await pipeline.run(from, only);
+        const summary = path.join(dir, 'summary.md');
+        const text = readText(summary) !== null ? `Processed "${result.title}"\n${summary}` : `Processed "${result.title}" [${result.status}]\n${dir}`;
+        return { data: meetingRecord(result, dir), text };
+    });
+}
+export async function promptCommand(argv) {
+    return output('prompt', false, () => {
+        const args = parseArgs(argv, { maxPositionals: 1 });
+        const { meeting, dir } = new MeetingStore(loadConfig()).resolve(args.positionals[0] ?? 'last');
+        return { data: '', text: `Directorio de la reunión: ${dir}\n\n${summaryPromptFor(meeting, dir)}` };
+    });
+}
+export async function saveSummaryCommand(argv) {
+    return output('save-summary', argv.includes('--json'), async () => {
+        const args = parseArgs(argv, { maxPositionals: 2 });
+        const [reference, file] = args.positionals;
+        if (!reference || !file)
+            throw usageError('Usage: recap save-summary <meeting> <file|->');
+        const config = loadConfig();
+        const { meeting, dir } = new MeetingStore(config).resolve(reference);
+        let body;
+        try {
+            body = file === '-' ? readFileSync(0, 'utf8') : readFileSync(file, 'utf8');
+        }
+        catch (error) {
+            throw new RecapError('FILE_UNREADABLE', `Cannot read ${file}: ${error.message}`);
+        }
+        saveSummary(body, meeting, dir);
+        if (meeting.bitaEntryId !== undefined)
+            await saveMinutes(meeting, dir, config);
+        const updated = updateMeeting(dir, (current) => {
+            current.stages['summarize'] = { status: 'done', updatedAt: isoNow() };
+            if (allStagesSatisfied({ ...meeting, stages: current.stages }))
+                current.status = 'processed';
+        });
+        return { data: meetingRecord(updated, dir), text: path.join(dir, 'summary.md') };
+    });
+}
+export function failedStage(meeting) {
+    return Object.entries(meeting.stages).find(([, state]) => state.status === 'failed') ?? null;
+}
+export function isSettled(meeting) {
+    if (meeting.status === 'processed' || meeting.status === 'failed')
+        return true;
+    if (meeting.status === 'recorded')
+        return failedStage(meeting) !== null;
+    return false;
+}
+export function describeWait(meeting, dir) {
+    const lines = [`${meeting.title} [${meeting.status}] ${formatDuration(durationSeconds(meeting))}`];
+    const failed = failedStage(meeting);
+    if (failed)
+        lines.push(`Failed at ${failed[0]}: ${failed[1].error ?? 'no reason given'}`);
+    const wrapup = meeting.wrapup;
+    if (wrapup) {
+        lines.push(`Title   : ${wrapup.title ?? meeting.title}`);
+        lines.push(`Project : ${wrapup.project ?? '(none)'}${wrapup.projectResolved ? '' : ' — not clear from the meeting'}`);
+        if (wrapup.pageId !== undefined)
+            lines.push(`Page    : #${wrapup.pageId}${wrapup.pageCreated ? ' (new)' : ''}`);
+        lines.push(`Backlog : ${Object.keys(wrapup.backlogKeys).length} items`);
+    }
+    lines.push(path.join(dir, 'summary.md'));
+    return lines.join('\n');
+}
+export async function waitCommand(argv) {
+    return output('wait', argv.includes('--json'), async () => {
+        const args = parseArgs(argv, { values: ['bita-entry', 'timeout'], maxPositionals: 1 });
+        const bitaEntry = args.int('bita-entry');
+        const timeout = args.number('timeout') ?? 900;
+        const store = new MeetingStore(loadConfig());
+        let found = null;
+        const settled = await waitUntil(timeout, 2, () => {
+            try {
+                if (found)
+                    found = { meeting: reconcile(loadMeeting(found.dir), found.dir), dir: found.dir };
+                else
+                    found = bitaEntry !== undefined ? store.find(bitaEntry) : store.resolve(args.positionals[0]);
+            }
+            catch {
+                if (!found)
+                    found = null;
+            }
+            return found !== null && isSettled(found.meeting);
+        });
+        const result = found;
+        if (!result)
+            throw new RecapError('MEETING_NOT_FOUND', bitaEntry !== undefined ? `No meeting is linked to bita entry ${bitaEntry}` : 'No meeting found');
+        if (!settled)
+            throw new RecapError('WAIT_TIMEOUT', `"${result.meeting.title}" is still ${result.meeting.status} after ${Math.trunc(timeout)}s`);
+        return { data: meetingRecord(result.meeting, result.dir), text: describeWait(result.meeting, result.dir) };
+    });
+}

package/dist/cli/commands/recording.js

@@ -0,0 +1,102 @@
+import path from 'node:path';
+import { currentRecording } from "../../core/active.js";
+import { loadConfig } from "../../core/config.js";
+import { MeetingStore, durationSeconds } from "../../core/meeting.js";
+import { meetingRecord } from "../../core/record.js";
+import { processInBackground } from "../../core/self.js";
+import { formatDuration } from "../../core/text.js";
+import { RecapError, usageError } from "../../errors.js";
+import { discardRecording, startRecording, stopRecording } from "../../capture/recording.js";
+import { importRecording } from "../../capture/import.js";
+import { Pipeline } from "../../pipeline/pipeline.js";
+import { bitaLinked } from "../../setup/integration.js";
+import { parseArgs } from "../args.js";
+import { output, stderrLine } from "../output.js";
+function modeFrom(remote, inPerson, required) {
+    if (remote && inPerson)
+        throw usageError('Choose only one of --remote or --in-person');
+    if (remote)
+        return 'remote';
+    if (inPerson)
+        return 'in-person';
+    if (required)
+        throw new RecapError('MODE_REQUIRED', 'Choose --remote or --in-person');
+    return undefined;
+}
+export async function startCommand(argv) {
+    return output('start', argv.includes('--json'), async () => {
+        const args = parseArgs(argv, { booleans: ['remote', 'in-person'], values: ['display', 'bita-entry', 'timeout'] });
+        const mode = modeFrom(args.has('remote'), args.has('in-person'), true);
+        const located = await startRecording({
+            title: args.positionals.join(' '),
+            mode,
+            display: args.int('display'),
+            bitaEntryId: args.int('bita-entry'),
+            timeout: args.number('timeout') ?? 60,
+        });
+        return { data: meetingRecord(located.meeting, located.dir), text: `Recording ${located.meeting.mode} meeting "${located.meeting.title}"\n${located.dir}` };
+    });
+}
+export async function stopCommand(argv) {
+    return output('stop', argv.includes('--json'), async () => {
+        const args = parseArgs(argv, { booleans: ['no-process'], values: ['timeout'], maxPositionals: 0 });
+        const { meeting, dir } = await stopRecording(args.number('timeout') ?? 60);
+        let text = `Stopped "${meeting.title}" after ${formatDuration(durationSeconds(meeting))}\n${dir}`;
+        if (!args.has('no-process') && meeting.status === 'recorded') {
+            processInBackground(meeting.id, dir);
+            text += `\nProcessing in the background; follow it with \`recap status\` or ${path.join(dir, 'process.log')}`;
+        }
+        return { data: meetingRecord(meeting, dir), text };
+    });
+}
+export async function discardCommand(argv) {
+    return output('discard', argv.includes('--json'), async () => {
+        const args = parseArgs(argv, { values: ['bita-entry'], maxPositionals: 1 });
+        const { meeting, dir } = await discardRecording(args.positionals[0], args.int('bita-entry'));
+        return { data: meetingRecord(meeting, dir), text: `Discarded "${meeting.title}"` };
+    });
+}
+export async function statusCommand(argv) {
+    return output('status', argv.includes('--json'), async () => {
+        parseArgs(argv, { maxPositionals: 0 });
+        const config = loadConfig();
+        const linked = await bitaLinked(config);
+        const current = currentRecording();
+        if (current) {
+            const elapsed = durationSeconds(current.meeting);
+            return {
+                data: { recording: true, active: meetingRecord(current.meeting, current.active.dir), elapsedSeconds: elapsed, bitaLinked: linked },
+                text: `Recording ${current.meeting.mode} meeting "${current.meeting.title}" for ${formatDuration(elapsed)}\n${current.active.dir}`,
+            };
+        }
+        const latest = new MeetingStore(config).all()[0];
+        let text = 'Not recording';
+        if (latest)
+            text += `\nLatest: ${latest.meeting.id} [${latest.meeting.status}] "${latest.meeting.title}"`;
+        text += `\nbita: ${linked ? 'linked (meetings started from bita are recorded)' : 'not linked'}`;
+        return { data: { recording: false, latest: latest ? meetingRecord(latest.meeting, latest.dir) : undefined, bitaLinked: linked }, text };
+    });
+}
+export async function importCommand(argv) {
+    const json = argv.includes('--json');
+    return output('import', json, async () => {
+        const args = parseArgs(argv, { booleans: ['remote', 'in-person', 'no-process', 'background'], values: ['title'], maxPositionals: 1 });
+        const file = args.positionals[0];
+        if (!file)
+            throw usageError('Usage: recap import <audio or video file> [--title <title>] [--remote|--in-person] [--no-process|--background]');
+        const config = loadConfig();
+        const located = await importRecording(config, file, { title: args.value('title'), mode: modeFrom(args.has('remote'), args.has('in-person'), false) });
+        if (args.has('no-process'))
+            return { data: meetingRecord(located.meeting, located.dir), text: `Imported "${located.meeting.title}"\n${located.dir}` };
+        if (args.has('background')) {
+            processInBackground(located.meeting.id, located.dir);
+            return { data: meetingRecord(located.meeting, located.dir), text: `Imported "${located.meeting.title}"; processing in the background\n${path.join(located.dir, 'process.log')}` };
+        }
+        const pipeline = new Pipeline(located.dir, config, (line) => {
+            if (!json)
+                stderrLine(line);
+        });
+        const result = await pipeline.run();
+        return { data: meetingRecord(result, located.dir), text: `Imported and processed "${result.title}" [${result.status}]\n${located.dir}` };
+    });
+}

package/dist/cli/commands/setup.js

@@ -0,0 +1,132 @@
+import { existsSync } from 'node:fs';
+import { release } from 'node:os';
+import { MODELS, loadConfig, rootDir, saveConfig, vadModelPath, whisperModelPath } from "../../core/config.js";
+import { padEnd } from "../../core/text.js";
+import { CHECKED_TOOLS, configuredPath, installHint, locateTool } from "../../core/tools.js";
+import { errorMessage, usageError } from "../../errors.js";
+import { BitaClient } from "../../bita/client.js";
+import { capturePermissions, findCapture, findRecapApp } from "../../capture/capture.js";
+import { download, installMissing, installRecapApp } from "../../setup/deps.js";
+import { installAgents, parseAgents, register } from "../../setup/integration.js";
+import { removeLegacyHook } from "../../setup/legacy.js";
+import { parseArgs } from "../args.js";
+import { output, stderrLine } from "../output.js";
+export async function setupCommand(argv) {
+    const json = argv.includes('--json');
+    return output('setup', json, async () => {
+        const args = parseArgs(argv, {
+            booleans: ['skip-permissions', 'skip-models', 'skip-bita', 'install-deps', 'skip-app', 'skip-agents'],
+            values: ['agents'],
+            maxPositionals: 0,
+        });
+        let agentChoice;
+        try {
+            agentChoice = args.has('skip-agents') ? 'none' : parseAgents(args.value('agents'));
+        }
+        catch (error) {
+            throw usageError(errorMessage(error));
+        }
+        const progress = (line) => {
+            if (!json)
+                stderrLine(line);
+        };
+        const checks = [];
+        checks.push({ name: 'platform', ok: true, detail: `${process.platform} ${release()} ${process.arch}` });
+        const config = loadConfig();
+        if (args.has('install-deps')) {
+            const report = await installMissing(config, progress);
+            for (const item of report.manual)
+                checks.push({ name: 'install', ok: false, detail: item });
+        }
+        const tools = { ...(config.tools ?? {}) };
+        for (const tool of CHECKED_TOOLS) {
+            const found = await locateTool(tool, config);
+            const optional = tool === 'bita';
+            checks.push({ name: tool, ok: found !== null || optional, detail: found ?? `${optional ? 'optional, ' : ''}missing: ${installHint(tool)}` });
+            if (found && configuredPath(tool, config) === undefined)
+                tools[tool] = found;
+        }
+        if (JSON.stringify(tools) !== JSON.stringify(config.tools ?? {})) {
+            config.tools = tools;
+            saveConfig(config);
+        }
+        if (process.platform === 'darwin' && !findRecapApp() && !args.has('skip-app')) {
+            try {
+                progress('Installing Recap.app (the recorder)...');
+                await installRecapApp(progress);
+            }
+            catch (error) {
+                checks.push({ name: 'app', ok: false, detail: `could not install Recap.app: ${errorMessage(error)}` });
+            }
+        }
+        const capture = await findCapture();
+        checks.push({
+            name: 'capture',
+            ok: capture !== null || process.platform !== 'darwin',
+            detail: capture
+                ? capture.kind === 'app'
+                    ? capture.app
+                    : capture.binary
+                : process.platform === 'darwin'
+                    ? 'Recap.app is missing; run `recap setup` without --skip-app'
+                    : 'recording is not available on this system; use `recap import <file>`',
+        });
+        checks.push({ name: 'root', ok: true, detail: rootDir(config) });
+        for (const [name, model, target] of [
+            ['whisper', MODELS.whisper, whisperModelPath(config)],
+            ['vad', MODELS.vad, vadModelPath()],
+        ]) {
+            if (!existsSync(target) && !args.has('skip-models')) {
+                try {
+                    await download(model.url, target, progress);
+                }
+                catch (error) {
+                    checks.push({ name: `download:${name}`, ok: false, detail: errorMessage(error) });
+                }
+            }
+            const present = existsSync(target);
+            checks.push({ name: `model:${name}`, ok: present, detail: present ? target : 'missing: run `recap setup` without --skip-models' });
+        }
+        const bita = args.has('skip-bita') ? null : await BitaClient.create(config, {});
+        const subscribe = capture !== null && bita !== null;
+        try {
+            const file = await register(capture !== null, subscribe);
+            checks.push({ name: 'registry', ok: true, detail: file });
+        }
+        catch (error) {
+            checks.push({ name: 'registry', ok: false, detail: errorMessage(error) });
+        }
+        if (bita) {
+            const removed = await removeLegacyHook(bita);
+            checks.push({
+                name: 'bita-hook',
+                ok: subscribe,
+                detail: subscribe
+                    ? `subscribed to bita events through the kit registry${removed > 0 ? `; removed ${removed} old bita hook${removed === 1 ? '' : 's'}` : ''}`
+                    : 'not subscribed: recording is not available here',
+            });
+        }
+        for (const step of await installAgents(agentChoice)) {
+            checks.push({ name: `agent:${step.agent}`, ok: step.state !== 'failed', detail: `${step.item}: ${step.detail}` });
+        }
+        if (capture) {
+            try {
+                const report = await capturePermissions(capture, !args.has('skip-permissions'));
+                const rerun = args.has('skip-permissions') ? '; run `recap setup` in a terminal to grant it' : '';
+                checks.push({ name: 'microphone', ok: report.microphone === 'granted', detail: report.microphone === 'granted' ? 'granted' : `${report.microphone}${rerun}` });
+                checks.push({
+                    name: 'screen',
+                    ok: report.screen === 'granted',
+                    detail: report.screen === 'granted'
+                        ? 'granted'
+                        : `${report.screen}: enable Recap in System Settings > Privacy & Security > Screen & System Audio Recording (only needed for --remote)${rerun}`,
+                });
+            }
+            catch (error) {
+                checks.push({ name: 'permissions', ok: false, detail: errorMessage(error) });
+            }
+        }
+        const text = checks.map((check) => `${check.ok ? 'ok ' : '!! '} ${padEnd(check.name, 14)} ${check.detail}`).join('\n');
+        return { data: checks, text };
+    });
+}

package/dist/cli/output.js

@@ -0,0 +1,24 @@
+import { errorEnvelope, successEnvelope, writeJson } from '@kikedealba/kit/envelope';
+import { asRecapError } from "../errors.js";
+import { SCHEMA_VERSION } from "../version.js";
+export async function output(command, json, body) {
+    try {
+        const { data, text } = await body();
+        if (json)
+            writeJson(successEnvelope(SCHEMA_VERSION, command, data));
+        else if (text.length > 0)
+            process.stdout.write(`${text}\n`);
+        return 0;
+    }
+    catch (error) {
+        const failure = asRecapError(error);
+        if (json)
+            writeJson(errorEnvelope(SCHEMA_VERSION, command, { code: failure.code, message: failure.message, ...(failure.hint ? { hint: failure.hint } : {}) }));
+        else
+            process.stderr.write(`recap: ${failure.message} [${failure.code}]${failure.hint ? `\n${failure.hint}` : ''}\n`);
+        return failure.exitCode;
+    }
+}
+export function stderrLine(text) {
+    process.stderr.write(`${text}\n`);
+}