@kikedealba/recap 0.0.0-stage → 0.9.1

package/dist/capture/capture.js

@@ -0,0 +1,109 @@
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { which } from '@kikedealba/kit/platform';
+import { exists, readText } from "../core/fsutil.js";
+import { isRecord } from "../core/json.js";
+import { home } from "../core/paths.js";
+import { exec, spawnDetached } from "../core/proc.js";
+import { selfCommand, stableCommand } from "../core/self.js";
+import { trimmed } from "../core/text.js";
+import { RecapError } from "../errors.js";
+import { parseEnvelope } from '@kikedealba/kit/envelope';
+export function appCandidates() {
+    const override = process.env['RECAP_APP'];
+    return [...(override ? [override] : []), path.join(home(), 'Applications', 'Recap.app'), '/Applications/Recap.app'];
+}
+export function findRecapApp() {
+    if (process.platform !== 'darwin')
+        return null;
+    return appCandidates().find((app) => exists(path.join(app, 'Contents', 'MacOS', 'recap')) || exists(path.join(app, 'Contents', 'MacOS', 'recap-capture'))) ?? null;
+}
+export async function findCapture() {
+    const app = findRecapApp();
+    if (app)
+        return { kind: 'app', app };
+    const override = process.env['RECAP_CAPTURE'];
+    if (override && exists(override))
+        return { kind: 'binary', binary: override };
+    const binary = await which('recap-capture');
+    return binary ? { kind: 'binary', binary } : null;
+}
+export function captureUnavailable() {
+    const hint = process.platform === 'darwin'
+        ? 'Install Recap.app with `recap setup` (it downloads it from the GitHub release), or set RECAP_APP.'
+        : 'Recording is only available on macOS for now. Record with any app and process the file with `recap import <file>`.';
+    return new RecapError('CAPTURE_UNAVAILABLE', 'The recorder (recap-capture) is not available on this machine', { hint });
+}
+export async function liveWorkerCommand(ctx) {
+    return [...(await stableCommand(ctx)), 'live-worker'];
+}
+export function workerPath(command, env = process.env) {
+    if (command[0] === selfCommand()[0])
+        return null;
+    return [path.dirname(process.execPath), ...(env['PATH'] ?? '').split(path.delimiter)].filter((dir, index, all) => dir.length > 0 && all.indexOf(dir) === index).join(path.delimiter);
+}
+export function hasCaptureBinary(app) {
+    return exists(path.join(app, 'Contents', 'MacOS', 'recap-capture'));
+}
+export async function launchArguments(app, dir, log, modern = hasCaptureBinary(app), ctx) {
+    if (!modern)
+        return ['-g', '-n', '-a', app, '--stdout', log, '--stderr', log, '--args', 'record', dir];
+    const worker = await liveWorkerCommand(ctx);
+    const searchPath = workerPath(worker, ctx?.env);
+    const env = ['--env', `RECAP_LIVE_WORKER=${JSON.stringify(worker)}`, ...(searchPath === null ? [] : ['--env', `PATH=${searchPath}`])];
+    return ['-g', '-n', '-a', app, ...env, '--stdout', log, '--stderr', log, '--args', 'capture', 'record', dir];
+}
+export async function launchRecorder(dir) {
+    const launcher = await findCapture();
+    if (!launcher)
+        throw captureUnavailable();
+    const log = path.join(dir, 'recorder.log');
+    if (launcher.kind === 'app') {
+        const result = await exec('/usr/bin/open', await launchArguments(launcher.app, dir, log));
+        if (result.status !== 0)
+            throw new RecapError('LAUNCH_FAILED', `Cannot launch ${path.basename(launcher.app)}: ${trimmed(result.stderr)}`);
+        return;
+    }
+    spawnDetached(launcher.binary, ['record', dir, '--live-worker', JSON.stringify(await liveWorkerCommand())], log);
+}
+function readReport(text) {
+    if (text === null)
+        return null;
+    const envelope = parseEnvelope(text);
+    const data = envelope?.data ?? (() => {
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return null;
+        }
+    })();
+    if (!isRecord(data) || typeof data['microphone'] !== 'string' || typeof data['screen'] !== 'string')
+        return null;
+    return { microphone: data['microphone'], screen: data['screen'] };
+}
+export async function capturePermissions(launcher, request) {
+    const args = ['permissions', ...(request ? ['--request'] : []), '--json'];
+    if (launcher.kind === 'binary') {
+        const result = await exec(launcher.binary, args);
+        const report = readReport(result.stdout);
+        if (!report)
+            throw new RecapError('PERMISSIONS_UNKNOWN', `recap-capture did not report its permissions. ${trimmed(result.stderr)}`);
+        return report;
+    }
+    const work = mkdtempSync(path.join(tmpdir(), 'recap-permissions-'));
+    try {
+        const out = path.join(work, 'out.json');
+        const err = path.join(work, 'err.log');
+        const tail = hasCaptureBinary(launcher.app) ? ['--stdout', out, '--stderr', err, '--args', 'capture', ...args] : ['--stderr', err, '--args', 'permissions', '--out', out, ...(request ? [] : ['--check'])];
+        const result = await exec('/usr/bin/open', ['-W', '-g', '-n', '-a', launcher.app, ...tail]);
+        const report = readReport(readText(out));
+        if (!report)
+            throw new RecapError('PERMISSIONS_UNKNOWN', `Recap.app did not report its permissions. ${trimmed(result.stderr + (readText(err) ?? ''))}`);
+        return report;
+    }
+    finally {
+        rmSync(work, { recursive: true, force: true });
+    }
+}

package/dist/capture/import.js

@@ -0,0 +1,80 @@
+import { rmSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { isoDate } from "../core/dates.js";
+import { MeetingStore, updateMeeting } from "../core/meeting.js";
+import { exec } from "../core/proc.js";
+import { suffix, trimmed } from "../core/text.js";
+import { requireTool } from "../core/tools.js";
+import { RecapError } from "../errors.js";
+import { AUDIO_FILE, VIDEO_FILE } from "../media/media.js";
+import { inspectMedia } from "../media/probe.js";
+export function importMode(info, requested) {
+    if (requested === 'remote' && info.audioTracks < 2) {
+        throw new RecapError('IMPORT_UNSUITABLE', 'A remote meeting needs two audio tracks (microphone and call audio); import it as --in-person');
+    }
+    if (requested)
+        return requested;
+    return info.videoTracks > 0 && info.audioTracks >= 2 ? 'remote' : 'in-person';
+}
+export function importArguments(source, mode, target) {
+    const base = ['-hide_banner', '-loglevel', 'error', '-nostdin', '-y', '-i', source];
+    if (mode === 'remote' && target.endsWith('.mov'))
+        return [...base, '-map', '0:v:0', '-map', '0:a', '-c', 'copy', '-f', 'mov', target];
+    if (mode === 'remote')
+        return [...base, '-vn', '-map', '0:a', '-c:a', 'aac', '-b:a', '128k', '-f', 'mp4', target];
+    return [...base, '-vn', '-map', '0:a:0', '-c:a', 'aac', '-b:a', '128k', '-f', 'mp4', target];
+}
+export function importTimes(info, file) {
+    const duration = Number.isFinite(info.duration) ? info.duration : 0;
+    const tagged = info.creationTime ? Date.parse(info.creationTime) : Number.NaN;
+    let started;
+    if (!Number.isNaN(tagged) && tagged > 0)
+        started = tagged;
+    else {
+        let modified = Date.now();
+        try {
+            modified = statSync(file).mtimeMs;
+        }
+        catch {
+            modified = Date.now();
+        }
+        started = modified - duration * 1000;
+    }
+    const startedAt = new Date(Math.round(started / 1000) * 1000);
+    return { startedAt, endedAt: new Date(startedAt.getTime() + Math.round(duration) * 1000) };
+}
+export async function importRecording(config, file, options) {
+    const source = path.resolve(file);
+    try {
+        if (!statSync(source).isFile())
+            throw new Error('not a file');
+    }
+    catch {
+        throw new RecapError('FILE_NOT_FOUND', `${file} is not a readable file`);
+    }
+    const info = await inspectMedia(source, config);
+    if (info.audioTracks === 0)
+        throw new RecapError('IMPORT_UNSUITABLE', `${path.basename(source)} has no audio track`);
+    const mode = importMode(info, options.mode);
+    const ffmpeg = await requireTool('ffmpeg', config);
+    const { startedAt, endedAt } = importTimes(info, source);
+    const title = options.title && trimmed(options.title).length > 0 ? trimmed(options.title) : path.basename(source, path.extname(source));
+    const created = new MeetingStore(config).create({ title, mode, now: startedAt });
+    try {
+        const target = path.join(created.dir, mode === 'remote' && info.videoTracks > 0 ? VIDEO_FILE : AUDIO_FILE);
+        const result = await exec(ffmpeg, importArguments(source, mode, target));
+        if (result.status !== 0)
+            throw new RecapError('FFMPEG_FAILED', suffix(trimmed(result.stderr), 500));
+        const meeting = updateMeeting(created.dir, (item) => {
+            item.status = 'recorded';
+            item.startedAt = isoDate(startedAt);
+            item.endedAt = isoDate(endedAt);
+            item['importedFrom'] = source;
+        });
+        return { meeting, dir: created.dir };
+    }
+    catch (error) {
+        rmSync(created.dir, { recursive: true, force: true });
+        throw error;
+    }
+}

package/dist/capture/recording.js

@@ -0,0 +1,125 @@
+import { rmSync } from 'node:fs';
+import { loadConfig } from "../core/config.js";
+import { clearActive, currentRecording, loadActive, saveActive } from "../core/active.js";
+import { isoNow } from "../core/dates.js";
+import { exists } from "../core/fsutil.js";
+import { MeetingStore, isActiveStatus, loadMeeting, recordingPath, updateMeeting } from "../core/meeting.js";
+import { isAlive, signalProcess, waitUntil } from "../core/proc.js";
+import { RecapError } from "../errors.js";
+import { launchRecorder } from "./capture.js";
+import path from 'node:path';
+export function defaultTitle(mode) {
+    return mode === 'remote' ? 'Remote meeting' : 'In-person meeting';
+}
+export async function startRecording(options) {
+    const current = currentRecording();
+    if (current)
+        throw new RecapError('ALREADY_RECORDING', `"${current.meeting.title}" is already being recorded. Stop it first.`);
+    const config = options.config ?? loadConfig();
+    const store = new MeetingStore(config);
+    const { meeting, dir } = store.create({
+        title: options.title.length === 0 ? defaultTitle(options.mode) : options.title,
+        mode: options.mode,
+        display: options.display,
+        bitaEntryId: options.bitaEntryId,
+        bita: options.bita,
+    });
+    try {
+        await launchRecorder(dir);
+    }
+    catch (error) {
+        rmSync(dir, { recursive: true, force: true });
+        throw error;
+    }
+    let latest = meeting;
+    const settled = await waitUntil(options.timeout, 0.25, () => {
+        try {
+            latest = loadMeeting(dir);
+        }
+        catch {
+            return false;
+        }
+        return latest.status !== 'starting';
+    });
+    if (latest.status === 'failed') {
+        throw new RecapError('RECORDER_FAILED', latest.error ?? `The recorder failed to start. See ${path.join(dir, 'recorder.log')}`);
+    }
+    if (!settled || latest.status !== 'recording') {
+        if (latest.recorderPid !== undefined)
+            signalProcess(latest.recorderPid, 'SIGKILL');
+        try {
+            updateMeeting(dir, (item) => {
+                item.status = 'failed';
+                item.error = `The recorder did not confirm within ${Math.trunc(options.timeout)}s`;
+            });
+        }
+        catch {
+            undefined;
+        }
+        throw new RecapError('RECORDER_TIMEOUT', `The recorder did not start within ${Math.trunc(options.timeout)}s. Check the permissions with \`recap setup\`.`);
+    }
+    saveActive({ meetingId: latest.id, dir, mode: options.mode, startedAt: latest.startedAt ?? isoNow() });
+    return { meeting: latest, dir };
+}
+async function stopRecorder(meeting, dir, timeout) {
+    const pid = meeting.recorderPid;
+    if (pid === undefined)
+        throw new RecapError('RECORDER_UNKNOWN', `The recorder process for "${meeting.title}" is unknown`);
+    signalProcess(pid, 'SIGINT');
+    let current = meeting;
+    const stopped = await waitUntil(timeout, 0.25, () => {
+        try {
+            current = loadMeeting(dir);
+        }
+        catch {
+            return !isAlive(pid);
+        }
+        return current.status === 'recorded' || current.status === 'failed' || !isAlive(pid);
+    });
+    if (!stopped)
+        signalProcess(pid, 'SIGKILL');
+    if (isActiveStatus(current.status)) {
+        current = updateMeeting(dir, (item) => {
+            item.status = exists(recordingPath(dir, item.mode)) ? 'recorded' : 'failed';
+            item.endedAt = isoNow();
+            delete item.recorderPid;
+            item.error = 'The recorder exited without closing the file cleanly';
+        });
+    }
+    return current;
+}
+export async function stopRecording(timeout) {
+    const current = currentRecording();
+    if (!current)
+        throw new RecapError('NOT_RECORDING', 'There is no active recording');
+    const meeting = await stopRecorder(current.meeting, current.active.dir, timeout);
+    clearActive();
+    return { meeting, dir: current.active.dir };
+}
+export async function discardRecording(reference, bitaEntryId) {
+    const store = new MeetingStore(loadConfig());
+    let target;
+    if (bitaEntryId !== undefined) {
+        const found = store.find(bitaEntryId);
+        if (!found)
+            throw new RecapError('MEETING_NOT_FOUND', `No meeting is linked to bita entry ${bitaEntryId}`);
+        target = found;
+    }
+    else if (reference !== undefined) {
+        target = store.resolve(reference);
+    }
+    else {
+        const current = currentRecording();
+        if (!current)
+            throw new RecapError('NOT_RECORDING', 'There is no active recording. Pass the meeting to delete.');
+        target = { meeting: current.meeting, dir: current.active.dir };
+    }
+    const { meeting, dir } = target;
+    if (meeting.recorderPid !== undefined && isAlive(meeting.recorderPid)) {
+        await stopRecorder(meeting, dir, 15).catch(() => undefined);
+    }
+    if (loadActive()?.meetingId === meeting.id)
+        clearActive();
+    rmSync(dir, { recursive: true, force: true });
+    return { meeting, dir };
+}

package/dist/cli/args.js

@@ -0,0 +1,83 @@
+import { usageError } from "../errors.js";
+export class Args {
+    positionals;
+    flags;
+    booleans;
+    constructor(positionals, flags, booleans) {
+        this.positionals = positionals;
+        this.flags = flags;
+        this.booleans = booleans;
+    }
+    has(name) {
+        return this.booleans.has(name);
+    }
+    value(name) {
+        return this.flags.get(name);
+    }
+    int(name) {
+        const raw = this.flags.get(name);
+        if (raw === undefined)
+            return undefined;
+        if (!/^[+-]?\d+$/.test(raw.trim()))
+            throw usageError(`--${name} expects a whole number, got "${raw}"`);
+        return Number(raw.trim());
+    }
+    number(name) {
+        const raw = this.flags.get(name);
+        if (raw === undefined)
+            return undefined;
+        const value = Number(raw);
+        if (raw.trim().length === 0 || !Number.isFinite(value))
+            throw usageError(`--${name} expects a number, got "${raw}"`);
+        return value;
+    }
+    get json() {
+        return this.booleans.has('json');
+    }
+}
+const GLOBAL_BOOLEANS = ['json', 'help'];
+export function parseArgs(argv, spec) {
+    const booleanNames = new Set([...GLOBAL_BOOLEANS, ...(spec.booleans ?? [])]);
+    const valueNames = new Set(spec.values ?? []);
+    const positionals = [];
+    const flags = new Map();
+    const booleans = new Set();
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index] ?? '';
+        if (arg === '--') {
+            positionals.push(...argv.slice(index + 1));
+            break;
+        }
+        if (arg === '-h') {
+            booleans.add('help');
+            continue;
+        }
+        if (arg.startsWith('--') && arg.length > 2) {
+            const body = arg.slice(2);
+            const eq = body.indexOf('=');
+            const name = eq === -1 ? body : body.slice(0, eq);
+            if (booleanNames.has(name)) {
+                if (eq !== -1)
+                    throw usageError(`--${name} does not take a value`);
+                booleans.add(name);
+                continue;
+            }
+            if (!valueNames.has(name))
+                throw usageError(`Unknown option --${name}`);
+            if (eq !== -1) {
+                flags.set(name, body.slice(eq + 1));
+                continue;
+            }
+            const next = argv[index + 1];
+            if (next === undefined)
+                throw usageError(`--${name} needs a value`);
+            flags.set(name, next);
+            index += 1;
+            continue;
+        }
+        positionals.push(arg);
+    }
+    if (spec.maxPositionals !== undefined && positionals.length > spec.maxPositionals)
+        throw usageError(`Unexpected argument "${positionals[spec.maxPositionals]}"`);
+    return new Args(positionals, flags, booleans);
+}

package/dist/cli/commands/ask.js

@@ -0,0 +1,127 @@
+import { currentRecording } from "../../core/active.js";
+import { loadConfig } from "../../core/config.js";
+import { isoNow } from "../../core/dates.js";
+import { MeetingStore, loadMeeting, resolveTarget } from "../../core/meeting.js";
+import { signalNumber, signalTree } from "../../core/proc.js";
+import { trimmed } from "../../core/text.js";
+import { RecapError, asRecapError, usageError } from "../../errors.js";
+import { BitaClient, docsClient, meetingTarget } from "../../bita/client.js";
+import { runAsk } from "../../live/ask.js";
+import { isValidAskId, makeAskId, performAsk, removeBoard } from "../../live/asking.js";
+import { loadProjectContext, meetingProject, meetingProjectName } from "../../live/context.js";
+import { jsonLine } from "../../live/files.js";
+import { encodeAnswer, encodeAskEvent } from "../../live/stream.js";
+import { parseArgs } from "../args.js";
+import { output } from "../output.js";
+function target(args, config) {
+    const dir = args.value('dir');
+    if (dir !== undefined)
+        return { meeting: loadMeeting(dir), dir };
+    if (args.has('active')) {
+        const current = currentRecording();
+        if (!current)
+            throw new RecapError('NOT_RECORDING', 'There is no active recording');
+        return { meeting: current.meeting, dir: current.active.dir };
+    }
+    return resolveTarget(new MeetingStore(config), args.value('meeting'), args.int('bita-entry'));
+}
+function validate(args) {
+    if (args.has('sources')) {
+        if (!args.value('project') && !args.has('active') && !args.value('meeting') && args.value('bita-entry') === undefined) {
+            throw usageError('--sources needs --project, --active, --meeting or --bita-entry');
+        }
+        return;
+    }
+    const targets = [args.has('active'), args.value('meeting') !== undefined, args.value('bita-entry') !== undefined, args.value('dir') !== undefined].filter(Boolean).length;
+    if (targets !== 1)
+        throw usageError('Choose one of --active, --meeting or --bita-entry');
+    const window = args.int('window');
+    if (window !== undefined && window <= 0)
+        throw usageError('--window must be positive');
+    if (args.has('auto') && trimmed(args.value('question') ?? '').length === 0)
+        throw usageError('--auto needs --question');
+    const questionMs = args.int('question-ms');
+    if (questionMs !== undefined && questionMs < 0)
+        throw usageError('--question-ms must not be negative');
+    const channel = args.value('channel');
+    if (channel !== undefined && channel !== 'mic' && channel !== 'system')
+        throw usageError('--channel takes mic or system');
+    const askId = args.value('ask-id');
+    if (askId !== undefined && !isValidAskId(askId))
+        throw usageError('--ask-id takes lowercase letters, digits and dashes');
+}
+const SPEC = {
+    booleans: ['active', 'auto', 'sources', 'json-stream'],
+    values: ['meeting', 'bita-entry', 'dir', 'question-ms', 'channel', 'ask-id', 'question', 'window', 'project'],
+    maxPositionals: 0,
+};
+function installCleanup(dir, id, child) {
+    for (const signal of ['SIGTERM', 'SIGINT', 'SIGHUP']) {
+        process.on(signal, () => {
+            const pid = child();
+            if (pid !== null)
+                signalTree(pid, 'SIGKILL');
+            removeBoard(dir, id);
+            process.exit(128 + signalNumber(signal));
+        });
+    }
+}
+async function answer(args, emit) {
+    const config = loadConfig();
+    const found = target(args, config);
+    const id = args.value('ask-id') ?? makeAskId();
+    const now = isoNow();
+    const question = args.value('question');
+    const questionMs = args.int('question-ms');
+    const channel = args.value('channel');
+    let childPid = null;
+    installCleanup(found.dir, id, () => childPid);
+    return performAsk({ dir: found.dir, id, question, auto: args.has('auto'), now, questionMs, channel }, async () => {
+        const docs = await docsClient(config, meetingTarget(found.meeting));
+        const context = await loadProjectContext(await meetingProject(found.meeting, docs), found.meeting.bitaDocsRoot, docs);
+        return runAsk(config, { meeting: found.meeting, dir: found.dir, question, windowSeconds: args.int('window') ?? 180, now, auto: args.has('auto'), questionMs, channel, askId: id }, context, emit, (pid) => {
+            childPid = pid;
+        });
+    });
+}
+export async function askCommand(argv) {
+    const json = argv.includes('--json');
+    if (argv.includes('--json-stream')) {
+        try {
+            const args = parseArgs(argv, SPEC);
+            validate(args);
+            await answer(args, (event) => process.stdout.write(`${jsonLine(encodeAskEvent(event))}\n`));
+            return 0;
+        }
+        catch (error) {
+            const failure = asRecapError(error);
+            process.stdout.write(`${jsonLine(encodeAskEvent({ type: 'error', code: failure.code, message: failure.message }))}\n`);
+            return failure.exitCode;
+        }
+    }
+    return output('ask', json, async () => {
+        const args = parseArgs(argv, SPEC);
+        validate(args);
+        if (args.has('sources')) {
+            const config = loadConfig();
+            const found = args.has('active') || args.value('meeting') !== undefined || args.value('bita-entry') !== undefined ? target(args, config) : null;
+            const docs = found ? await docsClient(config, meetingTarget(found.meeting)) : await docsClient(config, {});
+            const name = args.value('project') ?? (found ? meetingProjectName(found.meeting) : null);
+            const context = await loadProjectContext(name, found?.meeting.bitaDocsRoot, docs ?? (await BitaClient.create(config, {})));
+            const lines = [`Project: ${context.project ?? '(none)'}`, `Docs: ${context.docsRoot ?? '(unknown)'}`, ...context.repos.map((repo) => `Repo: ${repo.slug} ${repo.path}${repo.exists ? '' : ' (missing)'}`)];
+            return { data: { project: context.project ?? undefined, docsRoot: context.docsRoot ?? undefined, repos: context.repos }, text: lines.join('\n') };
+        }
+        const result = await answer(args, (event) => {
+            if (json)
+                return;
+            if (event.type === 'delta')
+                process.stdout.write(event.text);
+            else if (event.type === 'progress')
+                process.stderr.write(`· ${event.text}\n`);
+        });
+        let text = json ? '' : '\n';
+        if (result.sources.length > 0)
+            text += `\nFuentes:\n${result.sources.map((source) => `- ${source.label}`).join('\n')}`;
+        return { data: encodeAnswer(result), text: text.replace(/^\n+|\n+$/g, '').length === 0 ? '' : text };
+    });
+}

package/dist/cli/commands/config.js

@@ -0,0 +1,40 @@
+import { loadConfig, saveConfig } from "../../core/config.js";
+import { CONFIG_KEYS, applyConfigValue, configSnapshot, configValue, configValueText, parseConfigKey } from "../../core/live-settings.js";
+import { configFile } from "../../core/paths.js";
+import { usageError } from "../../errors.js";
+import { parseArgs } from "../args.js";
+import { output } from "../output.js";
+export async function configCommand(argv) {
+    const [sub, ...rest] = argv;
+    if (sub === 'get') {
+        return output('config get', rest.includes('--json'), () => {
+            const args = parseArgs(rest, { maxPositionals: 1 });
+            const config = loadConfig();
+            const settings = configSnapshot(config.live);
+            const raw = args.positionals[0];
+            if (raw !== undefined) {
+                const key = parseConfigKey(raw);
+                const value = configValue(key, config.live);
+                return { data: { path: configFile(), key, value, settings }, text: configValueText(value) };
+            }
+            return { data: { path: configFile(), settings }, text: CONFIG_KEYS.map((key) => `${key} = ${configValueText(settings[key] ?? null)}`).join('\n') };
+        });
+    }
+    if (sub === 'set') {
+        return output('config set', rest.includes('--json'), () => {
+            const args = parseArgs(rest, { maxPositionals: 2 });
+            const [rawKey, raw] = args.positionals;
+            if (rawKey === undefined || raw === undefined)
+                throw usageError('Usage: recap config set <key> <value>');
+            const config = loadConfig();
+            const key = parseConfigKey(rawKey);
+            config.live = applyConfigValue(key, raw, config.live);
+            saveConfig(config);
+            const value = configValue(key, config.live);
+            return { data: { path: configFile(), key, value, settings: configSnapshot(config.live) }, text: `${key} = ${configValueText(value)}` };
+        });
+    }
+    return output('config', argv.includes('--json'), () => {
+        throw usageError('Usage: recap config get [key] | recap config set <key> <value>', `Keys: ${CONFIG_KEYS.join(', ')}`);
+    });
+}

package/dist/cli/commands/hook.js

@@ -0,0 +1,94 @@
+import { readFileSync } from 'node:fs';
+import { currentRecording } from "../../core/active.js";
+import { loadConfig } from "../../core/config.js";
+import { isoNow } from "../../core/dates.js";
+import { MeetingStore, updateMeeting } from "../../core/meeting.js";
+import { processInBackground } from "../../core/self.js";
+import { RecapError, describeError, errorMessage } from "../../errors.js";
+import { decodeHookEvent, describeAction, eventSnapshot, eventTarget, planHook } from "../../bita/hook.js";
+import { discardRecording, startRecording, stopRecording } from "../../capture/recording.js";
+function log(message) {
+    process.stdout.write(`${isoNow()} recap bita-hook: ${message}\n`);
+}
+export async function handleHookEvent(event) {
+    const active = currentRecording();
+    const action = planHook(event, active?.meeting.bitaEntryId);
+    log(`${event.event} #${event.entry.id} kind=${event.entry.kind ?? '-'}: ${describeAction(action)}`);
+    try {
+        switch (action.type) {
+            case 'start': {
+                const record = await startRecording({ title: event.entry.description, mode: action.mode, bitaEntryId: event.entry.id, bita: eventTarget(event), timeout: 90 });
+                updateMeeting(record.dir, (meeting) => {
+                    meeting.bitaEntry = eventSnapshot(event);
+                });
+                log(`recording ${record.dir}`);
+                break;
+            }
+            case 'stopAndProcess': {
+                const record = await stopRecording(60);
+                updateMeeting(record.dir, (meeting) => {
+                    meeting.bitaEntry = eventSnapshot(event);
+                });
+                if (record.meeting.status === 'recorded') {
+                    processInBackground(record.meeting.id, record.dir);
+                    log(`processing ${record.dir}`);
+                }
+                break;
+            }
+            case 'processIfRecorded': {
+                const found = new MeetingStore(loadConfig()).find(event.entry.id);
+                if (!found) {
+                    log(`nothing to do: no meeting for entry #${event.entry.id}`);
+                    break;
+                }
+                if (found.meeting.status !== 'recorded' || Object.keys(found.meeting.stages).length > 0) {
+                    log(`nothing to do: ${found.meeting.id} is ${found.meeting.status}`);
+                    break;
+                }
+                updateMeeting(found.dir, (meeting) => {
+                    meeting.bitaEntry = eventSnapshot(event);
+                });
+                processInBackground(found.meeting.id, found.dir);
+                log(`processing ${found.dir}`);
+                break;
+            }
+            case 'stopWithoutProcessing': {
+                const record = await stopRecording(60);
+                log(`stopped without processing ${record.dir}`);
+                break;
+            }
+            case 'discard': {
+                const record = await discardRecording(undefined, event.entry.id);
+                log(`discarded ${record.dir}`);
+                break;
+            }
+            case 'ignore':
+                log(`nothing to do: ${action.reason}`);
+                break;
+        }
+        return 0;
+    }
+    catch (error) {
+        if (error instanceof RecapError && error.code === 'MEETING_NOT_FOUND') {
+            log(`nothing to do: ${error.message}`);
+            return 0;
+        }
+        log(`failed: ${describeError(error)}`);
+        return 1;
+    }
+}
+export async function bitaHookCommand(argv) {
+    if (argv.includes('--help')) {
+        process.stdout.write('recap bita-hook: handle a bita timer event read from stdin (registered through the kit tool registry by `recap setup`).\n');
+        return 0;
+    }
+    let event;
+    try {
+        event = decodeHookEvent(readFileSync(0, 'utf8'));
+    }
+    catch (error) {
+        log(`ignored: unreadable event (${errorMessage(error)})`);
+        return 1;
+    }
+    return handleHookEvent(event);
+}