@hwip/cli 0.0.1 → 0.1.1

package/dist/cli.js

@@ -0,0 +1,813 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const hwip_hook_js_1 = require("./hwip-hook.js");
+const errors_js_1 = require("./errors.js");
+const args_js_1 = require("./args.js");
+const config_js_1 = require("./config.js");
+const gate_js_1 = require("./gate.js");
+const presence_js_1 = require("./presence.js");
+const key_changes_js_1 = require("./key-changes.js");
+const notify_failure_js_1 = require("./notify-failure.js");
+const http_failure_js_1 = require("./http-failure.js");
+const redact_js_1 = require("./redact.js");
+const usage_js_1 = require("./usage.js");
+const remote_agents_js_1 = require("./remote-agents.js");
+const remote_hook_js_1 = require("./remote-hook.js");
+// Every command module below is loaded by the case that runs it, not up
+// front. The build is CommonJS, so a static import is a require at startup —
+// and `notify` (every agent turn) and `remote-hook` (every prompt) would pay
+// for the listener daemon (ws, LAN transfer, turn watching) they never use.
+// Only what those two hot paths need stays static above; cli-lazy-load.test.ts
+// holds the line.
+const detectBranchAndProject = () => {
+    const dir = (0, config_js_1.detectProjectDir)();
+    const project = dir.split('/').filter(Boolean).pop() ?? 'project';
+    let branch;
+    try {
+        branch = (0, child_process_1.execFileSync)('git', ['-C', dir, 'rev-parse', '--abbrev-ref', 'HEAD'], {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+        if (!branch || branch === 'HEAD')
+            branch = undefined;
+    }
+    catch { /* not a git repo */ }
+    return { branch, project };
+};
+// ── Output ──────────────────────────────────────────────────────
+const printUsage = (command) => {
+    console.log((command ? (0, usage_js_1.commandUsage)(command) : null) ?? (0, usage_js_1.usageText)());
+};
+const printError = (message, isJson) => {
+    if (isJson) {
+        console.error(JSON.stringify({ error: message, status: 'error' }));
+    }
+    else {
+        console.error(`Error: ${message}`);
+    }
+};
+const printJson = (data) => {
+    console.log(JSON.stringify(data, null, 2));
+};
+// ── Commands ────────────────────────────────────────────────────
+/**
+ * Per-request limit when a hook runs notify (`--auto`). The agent's turn waits
+ * on the hook, and its calls run in a row: the device list, then for a long
+ * body an upload request and the S3 upload, then the send. Four calls at 6 s
+ * stay under the 60 s the installed Gemini, Codex and Copilot hooks allow (templates.ts).
+ */
+const HOOK_REQUEST_TIMEOUT_MS = 6_000;
+const createHook = (args, timeoutMs) => {
+    const config = (0, config_js_1.loadConfig)();
+    const apiKey = args.key || (0, config_js_1.resolvedEnv)('HWIP_API_KEY') || config.apiKey;
+    const isJson = (0, args_js_1.flagOn)(args, 'json');
+    if (!apiKey) {
+        printError('API key required. Run "hwip install" or set HWIP_API_KEY', isJson);
+        return null;
+    }
+    let baseUrl;
+    try {
+        baseUrl = (0, config_js_1.resolveBaseUrl)(args['base-url'], config, (0, config_js_1.keyIsFromFile)(args.key, config));
+    }
+    catch (err) {
+        printError(err instanceof Error ? err.message : String(err), isJson);
+        return null;
+    }
+    return new hwip_hook_js_1.HwipHook({
+        apiKey,
+        baseUrl,
+        ...(timeoutMs && { timeout: timeoutMs }),
+    });
+};
+/**
+ * `hwip trust [deviceId] [--reset] [--yes]` — fingerprints, and which device
+ * keys the listener seals for (trust-command.ts).
+ */
+const handleTrust = async (args) => {
+    const [{ initDeviceCrypto }, { createDeviceDirectory }, { flagText, parseTrustArgs, runTrust }] = await Promise.all([import('./crypto.js'), import('./device-directory.js'), import('./trust-command.js')]);
+    const config = (0, config_js_1.loadConfig)();
+    const apiKey = flagText(args.key) ?? (0, config_js_1.resolvedEnv)('HWIP_API_KEY') ?? config.apiKey ?? '';
+    // The device list is asked for only when `trust` has something to say about it (a device to pin, or the listing).
+    let directory;
+    const directoryFor = (report) => {
+        try {
+            directory ??= createDeviceDirectory({ apiKey, baseUrl: (0, config_js_1.resolveBaseUrl)(flagText(args['base-url']), config, (0, config_js_1.keyIsFromFile)(flagText(args.key), config)), log: (line) => console.error(line) });
+        }
+        catch (err) {
+            if (report)
+                console.error(`hwip trust: ${err instanceof Error ? err.message : String(err)}`);
+            return undefined;
+        }
+        return directory;
+    };
+    const registeredKey = async (deviceId) => directoryFor(true)?.publicKeyOf(deviceId) ?? null;
+    // The listing is an extra: with no API key or no answer, `hwip trust` shows what it did before.
+    // A broken configuration is said once instead: an empty list would read as "no devices".
+    let trustConfigSaid = false;
+    const devices = async () => {
+        if (!apiKey)
+            return [];
+        const directory = directoryFor(false);
+        if (directory) {
+            try {
+                return await directory.devices();
+            }
+            catch {
+                return [];
+            }
+        }
+        if (!trustConfigSaid) {
+            trustConfigSaid = true;
+            try {
+                (0, config_js_1.resolveBaseUrl)(flagText(args['base-url']), config, (0, config_js_1.keyIsFromFile)(flagText(args.key), config));
+            }
+            catch (err) {
+                console.error(`hwip trust: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        return [];
+    };
+    const parsed = parseTrustArgs(args);
+    if ('error' in parsed) {
+        console.error(parsed.error);
+        return 2;
+    }
+    return runTrust(parsed, {
+        path: config_js_1.TRUST_FILE,
+        devicePublicKey: initDeviceCrypto,
+        registeredKey,
+        devices,
+        confirm: async (question) => {
+            // Nobody to ask: an unanswered question is not a yes, and says why.
+            if (process.stdin.isTTY !== true) {
+                console.error('hwip trust: no terminal to ask on — compare the fingerprints, then run it again with --yes');
+                return false;
+            }
+            try {
+                const { confirm } = await import('@inquirer/prompts');
+                return await confirm({ message: question, default: false });
+            }
+            catch (err) {
+                // Ctrl-C lands here too; anything else is worth a line.
+                if (!(err instanceof Error && err.name === 'ExitPromptError')) {
+                    console.error(`hwip trust: the question could not be asked (${err instanceof Error ? err.message : String(err)})`);
+                }
+                return false;
+            }
+        },
+        print: (line) => console.log(line),
+        printError: (line) => console.error(line),
+    });
+};
+/** Current tmux session name (the rename key), or null when not inside tmux. */
+const detectCurrentTmuxSession = () => {
+    if (!process.env.TMUX)
+        return null;
+    try {
+        const name = (0, child_process_1.execFileSync)('tmux', ['display-message', '-p', '#S'], { encoding: 'utf-8' }).trim();
+        return name || null;
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * `hwip rename "<name>"` — set THIS agent session's display name in the app.
+ * Auto-detects the current tmux session + this machine's listener device id
+ * (`computeListenerDeviceId`, the same id the listener registers, so the
+ * rename lands on the right device). `--clear` resets to the computed label.
+ */
+const handleRename = async (args) => {
+    const isJson = (0, args_js_1.flagOn)(args, 'json');
+    const clearing = (0, args_js_1.flagOn)(args, 'clear');
+    const alias = args._arg1 || '';
+    if (!alias && !clearing) {
+        printError('Usage: hwip rename "New name"  (or --clear to reset to default)', isJson);
+        return 2;
+    }
+    const sessionName = args.session || detectCurrentTmuxSession();
+    if (!sessionName) {
+        printError('No tmux session detected. Run inside a `hwip cc` session, or pass --session <name>.', isJson);
+        return 2;
+    }
+    const deviceId = args.device || (await import('./listener.js')).computeListenerDeviceId();
+    const hook = createHook(args);
+    if (!hook)
+        return 3;
+    try {
+        await hook.renameAgentSession(deviceId, sessionName, clearing ? '' : alias);
+        if (isJson)
+            printJson({ session: sessionName, alias: clearing ? null : alias, status: 'ok' });
+        else
+            console.log(clearing ? `Reset name for ${sessionName}` : `Renamed ${sessionName} → ${alias}`);
+        return 0;
+    }
+    catch (err) {
+        return handleError(err, isJson);
+    }
+};
+/**
+ * `hwip forget <session>` — drop an ended session from this machine's record,
+ * which is what takes it out of the app's past list (and out of the resume
+ * whitelist, the same pair the phone's row-delete means).
+ *
+ * `--ended` does it for every remembered name tmux no longer has: a machine
+ * that launches agents under a fresh name per task collects rows nothing ever
+ * deletes, and naming each one by hand is not the answer to fifty of them.
+ *
+ * The order mirrors the listener's own delete handler (`listener.ts:1701-1721`)
+ * so the two ways to forget a session cannot disagree about what is allowed.
+ */
+const handleForget = async (args) => {
+    const isJson = (0, args_js_1.flagOn)(args, 'json');
+    const { isSubagentSessionName, sessionLiveness, silenceListenerLog } = await import('./listener.js');
+    const { forgetSession } = await import('./session-registry.js');
+    // The tmux socket discovery under `sessionLiveness` logs for a daemon with a
+    // redirected stdout, not for this command. A person reading the output wants
+    // those lines — a failed probe is the only explanation for an "unknown" — but
+    // in a --json line they break the parse.
+    if (isJson)
+        silenceListenerLog();
+    const name = typeof args._arg1 === 'string' ? args._arg1 : '';
+    const sweeping = (0, args_js_1.flagOn)(args, 'ended');
+    if (name && sweeping) {
+        printError('Usage: hwip forget <session>  (or --ended, not both)', isJson);
+        return 2;
+    }
+    if (sweeping)
+        return forgetEveryEndedSession(isJson, isSubagentSessionName);
+    if (!name) {
+        printError('Usage: hwip forget <session>  (or --ended to drop every session tmux no longer has)', isJson);
+        return 2;
+    }
+    // A subagent pane has no registry row — the sweep never remembers panes — so
+    // "never seen" would be a true answer to the wrong question.
+    if (isSubagentSessionName(name)) {
+        printError(`${name} is a subagent pane — those have no record to forget`, isJson);
+        return 1;
+    }
+    const state = sessionLiveness(name);
+    if (state === 'running') {
+        printError(`${name} is still running — 'tmux kill-session -t ${name}' first`, isJson);
+        return 1;
+    }
+    // Not the same as "it ended": tmux answered nothing. Deleting on that would
+    // take a live session's record and chat history on the strength of a failed
+    // question.
+    if (state === 'unknown') {
+        printError(`could not ask tmux whether ${name} is running — nothing was forgotten`, isJson);
+        return 1;
+    }
+    const outcome = forgetSession(name);
+    if (outcome === 'unknown') {
+        printError(`${name}: never seen on this machine`, isJson);
+        return 1;
+    }
+    if (isJson)
+        printJson({ session: name, status: outcome });
+    else if (outcome === 'scrollback_kept') {
+        console.log(`Forgot ${name} — dropped from the record, but its chat scrollback would not delete`);
+    }
+    else {
+        console.log(`Forgot ${name}`);
+    }
+    return 0;
+};
+/**
+ * `hwip worktree` lists the worktrees `--wt` made and what keeps each;
+ * `hwip worktree clean` removes the ones nothing keeps (`--dry-run`: only says).
+ * The same judgement the listener makes when a session ends (`worktree.ts`),
+ * run on demand for the ones it left, or never saw end.
+ */
+const handleWorktree = async (args) => {
+    const sub = typeof args._arg1 === 'string' ? args._arg1 : '';
+    if (sub && sub !== 'list' && sub !== 'clean') {
+        console.error(`hwip worktree: unknown subcommand '${sub}' (list, clean)`);
+        return 2;
+    }
+    const dryRun = (0, args_js_1.flagOn)(args, 'dry-run');
+    if (dryRun && sub !== 'clean') {
+        console.error("hwip worktree: --dry-run belongs to 'hwip worktree clean'");
+        return 2;
+    }
+    const { readPaneCwds, reconcileWorktrees, tmuxRun, worktreeStatuses } = await import('./worktree.js');
+    // The daemon's tmux socket, not only the default one: a pane read from the wrong server is a session read as over.
+    const { tmuxArgs } = await import('./listener.js');
+    const panes = await readPaneCwds((tmuxCmd, timeout) => tmuxRun(tmuxArgs(tmuxCmd), timeout));
+    if (sub !== 'clean') {
+        // The list only reads: without tmux it still says what holds each worktree, just not which are in use.
+        if (!panes)
+            console.error('hwip worktree: could not ask tmux which sessions are running — "in use" is not shown');
+        const statuses = await worktreeStatuses(panes ?? []);
+        if (statuses.length === 0)
+            console.log('No worktrees made by hwip --wt. (`git worktree list` shows every worktree.)');
+        for (const { row, state } of statuses)
+            console.log(`${row.path}  (${row.branch})  ${state}`);
+        return 0;
+    }
+    if (!panes) {
+        console.error('hwip worktree: could not ask tmux which sessions are running — nothing was judged');
+        return 1;
+    }
+    const report = await reconcileWorktrees({ paneCwds: panes, manual: true, dryRun });
+    for (const r of report.removed) {
+        console.log(`${dryRun ? 'Would remove' : 'Removed'} ${r.path}${r.branchDeleted ? ` (branch ${r.branch} deleted)` : ''}`);
+    }
+    for (const path of report.gone)
+        console.log(`${dryRun ? 'Would forget' : 'Forgot'} ${path} (directory already gone)`);
+    for (const k of report.kept)
+        console.log(`Kept ${k.path} — ${k.reasons.join(', ')}`);
+    for (const path of report.inUse)
+        console.log(`In use ${path}`);
+    const total = report.removed.length + report.kept.length + report.inUse.length + report.gone.length;
+    if (total === 0)
+        console.log('No worktrees made by hwip --wt.');
+    // A refusal is the judgement working; a removal git turned down after the check passed is not.
+    return report.kept.some((k) => k.removeFailed) ? 1 : 0;
+};
+const forgetEveryEndedSession = async (isJson, isSubagentSessionName) => {
+    const { liveSessionNames } = await import('./listener.js');
+    const { forgetEnded } = await import('./session-registry.js');
+    // One question for the whole sweep, asked before anything is deleted: a
+    // per-name probe would let tmux go away halfway through and turn the rest of
+    // the registry into "ended".
+    const running = liveSessionNames();
+    if (running === null) {
+        printError('no tmux server answered — nothing was forgotten', isJson);
+        return 1;
+    }
+    const live = new Set(running);
+    // A subagent pane is not in that list and never will be: panes are mapped by
+    // the daemon's sweep, and this process has no such map. Unknown is the honest
+    // answer, and it is the one that leaves the row alone — a guard against a
+    // pane name reaching the registry, not something today's registry contains
+    // (`listener.ts`: the sweep never remembers panes), so the lines below that
+    // report it stay unprinted until that changes.
+    const liveness = (name) => {
+        if (isSubagentSessionName(name))
+            return 'unknown';
+        return live.has(name) ? 'running' : 'ended';
+    };
+    const sweep = forgetEnded(liveness);
+    if (isJson) {
+        printJson(sweep);
+        return 0;
+    }
+    const { forgotten, scrollbackKept, kept, unreachable } = sweep;
+    for (const name of forgotten) {
+        const note = scrollbackKept.includes(name) ? ' — chat scrollback would not delete' : '';
+        console.log(`Forgot ${name}${note}`);
+    }
+    for (const name of unreachable)
+        console.log(`Left ${name} alone — could not tell whether it is running`);
+    const tail = unreachable.length > 0 ? `, left ${unreachable.length} undecided` : '';
+    if (forgotten.length === 0)
+        console.log(`Nothing to forget — ${kept.length} running${tail}`);
+    else
+        console.log(`Forgot ${forgotten.length} ended session(s), kept ${kept.length} running${tail}`);
+    return 0;
+};
+/** Parse a gate count flag; garbage input falls back to the default (never accidentally silences). */
+const gateCount = (raw, fallback) => {
+    const n = typeof raw === 'string' ? Number(raw) : NaN;
+    return Number.isFinite(n) && n >= 0 ? n : fallback;
+};
+const readStdin = async () => {
+    let stdin = '';
+    for await (const chunk of process.stdin)
+        stdin += chunk;
+    return stdin;
+};
+/**
+ * Internal — invoked by the Gemini/Codex prompt-submit hooks that
+ * `hwip setup` registers, never typed by users (hence absent from help).
+ * Reads the hook JSON on stdin; prints additionalContext JSON on a match
+ * (remote-origin detection, ADR-0002). Always exits 0: the hook only adds
+ * context and must never block a prompt.
+ */
+const handleRemoteHook = async (args) => {
+    const agent = args._arg1;
+    if (!(0, remote_hook_js_1.isRemoteHookAgent)(agent))
+        return 0;
+    try {
+        const out = (0, remote_hook_js_1.runRemoteHook)(agent, await readStdin());
+        if (out)
+            console.log(out);
+    }
+    catch {
+        /* never block a prompt */
+    }
+    return 0;
+};
+/**
+ * `hwip notify --channel <channelId|name> …` — push to a channel this account owns.
+ *
+ * Not the agent hook's path: it skips the project mute and the push gate (a person
+ * typed this), sends plain text, and never fills a
+ * title or body from the branch name. The server decides ownership; a name is
+ * resolved against `GET /channels` first (channel.ts).
+ */
+const handleChannelNotify = async (args) => {
+    const isJson = (0, args_js_1.flagOn)(args, 'json');
+    const { parseChannelNotify, PLAINTEXT_NOTE, resolveChannel } = await import('./channel.js');
+    const parsed = parseChannelNotify(args);
+    if ('error' in parsed) {
+        printError(parsed.error, isJson);
+        return 2;
+    }
+    const hook = createHook(args);
+    if (!hook)
+        return 3;
+    try {
+        const target = resolveChannel(await hook.listChannels(), parsed.ref);
+        if ('error' in target) {
+            printError(target.error, isJson);
+            return 2;
+        }
+        console.error(PLAINTEXT_NOTE);
+        let result;
+        try {
+            result = await hook.notify({ ...parsed.payload, channelId: target.channelId });
+        }
+        catch (err) {
+            if (err instanceof errors_js_1.HwipError && err.status === 403 && !(err instanceof errors_js_1.QuotaExceededError)) {
+                printError(`${err.message} — only the channel's owner can send to it`, isJson);
+                return 1;
+            }
+            throw err;
+        }
+        if (isJson) {
+            printJson({ pushId: result.pushId, channelId: target.channelId, encrypted: false, status: 'ok' });
+        }
+        else {
+            console.log(`Push sent to ${target.name ? `"${target.name}" ` : ''}(${target.channelId}): ${result.pushId}`);
+        }
+        return 0;
+    }
+    catch (err) {
+        return handleError(err, isJson);
+    }
+};
+/** `hwip channel list` — the channels this account owns and follows. */
+const handleChannel = async (args) => {
+    const isJson = (0, args_js_1.flagOn)(args, 'json');
+    if (args._arg1 !== 'list') {
+        printError('Usage: hwip channel list', isJson);
+        return 2;
+    }
+    const hook = createHook(args);
+    if (!hook)
+        return 3;
+    try {
+        const { channelLines } = await import('./channel.js');
+        const channels = await hook.listChannels();
+        if (isJson)
+            printJson(channels);
+        else
+            for (const line of channelLines(channels))
+                console.log(line);
+        return 0;
+    }
+    catch (err) {
+        return handleError(err, isJson);
+    }
+};
+const handleNotify = async (args) => {
+    const isJson = (0, args_js_1.flagOn)(args, 'json');
+    if (args.channel !== undefined)
+        return handleChannelNotify(args);
+    const projectDir = (0, config_js_1.detectProjectDir)();
+    if ((0, gate_js_1.isMuted)(projectDir))
+        return 0;
+    // --auto: apply the shared push-gate before sending. Inputs default to
+    // GATE_DEFAULTS ("assume real work") so dumb hooks keep their historical
+    // always-push behavior in normal mode, while the /hwip-mode quiet | /hwip-mode loud
+    // dial now works for every hook-driven agent. Gated-out → silent success.
+    // With no dial the mode falls back to --pushmode-default, then to quiet.
+    // Quiet still pushes when the user has left the terminal (presence.ts).
+    if ((0, args_js_1.flagOn)(args, 'auto')) {
+        const marker = (0, gate_js_1.normalizeMarker)(typeof args.marker === 'string' ? args.marker : undefined);
+        const pushMode = (0, gate_js_1.autoPushMode)(projectDir, args[gate_js_1.PUSHMODE_DEFAULT_FLAG]);
+        const verdict = (0, gate_js_1.decidePush)({
+            toolCount: gateCount(args[gate_js_1.TOOL_COUNT_FLAG], gate_js_1.GATE_DEFAULTS.toolCount),
+            nonReadonlyCount: gateCount(args[gate_js_1.NONREADONLY_COUNT_FLAG], gate_js_1.GATE_DEFAULTS.nonReadonlyCount),
+            alreadyAsked: gate_js_1.GATE_DEFAULTS.alreadyAsked,
+            marker,
+            pushMode,
+            away: (0, presence_js_1.awayForGate)(pushMode, marker),
+        });
+        if (!verdict.push)
+            return 0;
+        if (verdict.priority === 'high' && !args.priority)
+            args.priority = 'high';
+    }
+    // Past the gates, this IS a push attempt — its outcome is recorded for
+    // `hwip verify` and the plugin (notify-failure.ts), since hooks discard stderr.
+    const hook = createHook(args, (0, args_js_1.flagOn)(args, 'auto') ? HOOK_REQUEST_TIMEOUT_MS : undefined);
+    if (!hook) {
+        (0, notify_failure_js_1.recordNotifyFailure)({ kind: 'no-key', status: null, code: null });
+        return 3;
+    }
+    try {
+        const sessionId = args.session || (0, config_js_1.resolvedEnv)('HWIP_SESSION_ID') || undefined;
+        // When body isn't supplied (common case for hook-driven invocations like
+        // `hwip notify --title "Task done"`), auto-fill with branch + project so
+        // the user can tell which session finished without opening the app.
+        let title = args.title;
+        let body = args.body;
+        if (!body) {
+            const { branch, project } = detectBranchAndProject();
+            body = branch ? `${project} · ${branch}` : project;
+        }
+        if (!title)
+            title = 'Task done';
+        const result = await (0, notify_failure_js_1.withNotifyFailureRecord)(() => hook.notify({
+            title,
+            body,
+            url: args.url,
+            type: args.type || 'hook',
+            priority: args.priority || undefined,
+            targetDeviceId: args.device,
+            sessionId,
+        }));
+        if (isJson) {
+            printJson({ pushId: result.pushId, status: 'ok' });
+        }
+        else {
+            console.log(`Push sent: ${result.pushId}`);
+        }
+        return 0;
+    }
+    catch (err) {
+        return handleError(err, isJson);
+    }
+};
+const handleList = async (args) => {
+    const isJson = (0, args_js_1.flagOn)(args, 'json');
+    const hook = createHook(args);
+    if (!hook)
+        return 3;
+    try {
+        // Clamp to the documented 1-20 range; a non-numeric value falls back to
+        // the server default instead of sending limit=NaN in the query string.
+        const rawLimit = args.limit ? Number(args.limit) : NaN;
+        const limit = Number.isFinite(rawLimit) ? Math.min(20, Math.max(1, Math.floor(rawLimit))) : undefined;
+        const result = await hook.list({
+            limit,
+            type: args.type,
+        });
+        if (isJson) {
+            printJson(result);
+        }
+        else {
+            if (result.pushes.length === 0) {
+                console.log('No pushes found.');
+            }
+            else {
+                for (const p of result.pushes) {
+                    // Sealed for the phone: this host holds no key to open it.
+                    const title = p.isEncrypted ? '[encrypted]' : (p.title ?? '(no title)');
+                    const time = new Date(p.createdAt).toLocaleString();
+                    console.log(`  ${p.pushId}  [${p.type}]  ${title}  (${time})`);
+                }
+                if (result.hasMore)
+                    console.log(`  ... more available (use --limit to increase)`);
+            }
+        }
+        return 0;
+    }
+    catch (err) {
+        return handleError(err, isJson);
+    }
+};
+const handleDismiss = async (args) => {
+    const isJson = (0, args_js_1.flagOn)(args, 'json');
+    const hook = createHook(args);
+    if (!hook)
+        return 3;
+    try {
+        if ((0, args_js_1.flagOn)(args, 'all')) {
+            const result = await hook.dismissAll();
+            if (isJson) {
+                printJson({ dismissed: result.dismissed, status: 'ok' });
+            }
+            else {
+                console.log(`Dismissed ${result.dismissed} pushes.`);
+            }
+        }
+        else {
+            const pushId = args._arg1;
+            if (!pushId) {
+                printError('Push ID required. Usage: hwip dismiss <push-id> or hwip dismiss --all', isJson);
+                return 1;
+            }
+            await hook.dismiss(pushId);
+            if (isJson) {
+                printJson({ dismissed: true, pushId, status: 'ok' });
+            }
+            else {
+                console.log(`Dismissed: ${pushId}`);
+            }
+        }
+        return 0;
+    }
+    catch (err) {
+        return handleError(err, isJson);
+    }
+};
+const handleTest = async (args) => {
+    const isJson = (0, args_js_1.flagOn)(args, 'json');
+    const hook = createHook(args);
+    if (!hook) {
+        (0, notify_failure_js_1.recordNotifyFailure)({ kind: 'no-key', status: null, code: null });
+        return 3;
+    }
+    try {
+        const result = await (0, notify_failure_js_1.withNotifyFailureRecord)(() => hook.notify({
+            title: 'Hwip Test',
+            body: `CLI connected successfully (v${config_js_1.VERSION})`,
+        }));
+        if (isJson) {
+            printJson({ pushId: result.pushId, status: 'ok', message: 'Test notification sent' });
+        }
+        else {
+            console.log(`Test notification sent: ${result.pushId}`);
+        }
+        return 0;
+    }
+    catch (err) {
+        return handleError(err, isJson);
+    }
+};
+// ── Error Handler ───────────────────────────────────────────────
+const handleError = (err, isJson) => {
+    if (err instanceof errors_js_1.QuotaExceededError) {
+        printError(err.message, isJson);
+        return 2;
+    }
+    if (err instanceof errors_js_1.AuthenticationError) {
+        printError(err.message, isJson);
+        return 3;
+    }
+    if (err instanceof errors_js_1.HwipError) {
+        printError(err.message, isJson);
+        return 1;
+    }
+    printError(err instanceof Error ? err.message : 'Unknown error', isJson);
+    return 1;
+};
+// ── Passthrough ─────────────────────────────────────────────────
+/**
+ * Collect raw argv after the given subcommand token so flags like
+ * `--resume` reach the wrapped agent verbatim instead of being swallowed
+ * by `parseArgs`. Returns [] when the command isn't found.
+ */
+const collectPassthrough = (argv, cmd) => {
+    const idx = argv.indexOf(cmd, 2);
+    return idx >= 0 ? argv.slice(idx + 1) : [];
+};
+// ── Main ────────────────────────────────────────────────────────
+/** The commands that show, and clear, the recorded key changes. */
+const KEY_CHANGE_SURFACES = new Set(['verify', 'trust', 'test', 'notify', 'ask']);
+const main = async () => {
+    const { args, sendArgv } = (0, args_js_1.parseCliArgv)(process.argv);
+    const command = args._command;
+    if ((0, args_js_1.flagOn)(args, 'version', true)) {
+        console.log(config_js_1.VERSION);
+        return 0;
+    }
+    // Remote-control subcommands (`hwip cc` / `hwip codex` / …) come from the
+    // registry — one table row per agent, no hardcoded cases. Pass the typed
+    // command token to collectPassthrough (aliases map to the same agent).
+    const remote = (0, remote_agents_js_1.findAgentBySubcommand)(command);
+    // Before any command runs.
+    if ((0, args_js_1.asksForUsage)(process.argv, args, remote !== undefined)) {
+        // `hwip notify --help` and `hwip help notify` print that command's usage;
+        // no command, or a word that is not one, prints all of them.
+        printUsage((0, usage_js_1.usageTarget)(args));
+        return 0;
+    }
+    // Before any request, the listener's socket included — but after `--version`
+    // and usage, which must answer whatever the environment holds.
+    try {
+        await (0, http_failure_js_1.useProxyFromEnv)(process.env, (0, config_js_1.loadConfig)());
+    }
+    catch (err) {
+        // A hook's stderr is thrown away; leave the reason where `hwip-mode` reads
+        // it. `network`: nothing was sent, and that is why.
+        if (command === 'notify')
+            (0, notify_failure_js_1.recordNotifyFailure)({ kind: 'network', status: null, code: 'PROXY_CONFIG' });
+        throw err;
+    }
+    if (remote) {
+        const { handleAgentSession, splitAgentOptions } = await import('./wrapper.js');
+        const { opts, rest, error } = splitAgentOptions(collectPassthrough(process.argv, command));
+        if (error) {
+            console.error(`hwip: ${error}`);
+            return 2;
+        }
+        return handleAgentSession(remote, rest, opts);
+    }
+    for (const flag of (0, args_js_1.unknownFlags)(args))
+        console.error(`hwip ${command}: unknown flag --${flag} (ignored)`);
+    // A yes/no flag with a value that is neither (`--dry-run=maybe`) stops the command before it does anything.
+    const badValue = (0, args_js_1.badFlagValue)(args);
+    if (badValue) {
+        // The value is whatever was typed (a key pasted after a yes/no flag is possible): cleaned like the error path below.
+        console.error((0, redact_js_1.redactSecrets)(`hwip ${command}: ${badValue}`));
+        return 2;
+    }
+    // A device whose key changed waits beside the pins until a person is shown it (key-changes.ts): these are the commands
+    // a person types. At a terminal only — a hook's `hwip notify … 2>/dev/null` would take it unseen.
+    if (KEY_CHANGE_SURFACES.has(command))
+        (0, key_changes_js_1.showKeyChanges)(config_js_1.TRUST_FILE, process.stderr);
+    switch (command) {
+        case 'install':
+        case 'setup':
+            return (await import('./installer.js')).handleInstall(args);
+        case 'login':
+            return (await import('./login.js')).handleLogin(args);
+        case 'uninstall':
+            return (await import('./uninstall.js')).handleUninstall(args);
+        case 'verify':
+            return (await import('./verify.js')).handleVerify(args);
+        case 'check-update':
+            return (await import('./check-update.js')).handleCheckUpdate(args);
+        case 'notify':
+            return handleNotify(args);
+        case 'channel':
+            return handleChannel(args);
+        case 'ask':
+            return (await import('./ask.js')).handleAsk(args);
+        case 'ask-context':
+            return (await import('./ask-context-switch.js')).handleAskContext(args);
+        case 'file-view':
+            return (await import('./file-view-switch.js')).handleFileView(args);
+        // `hwip agent send` is the name (C82); `hwip send` is the older one for the same command.
+        case 'agent':
+        case 'send': {
+            // Read-only and local: before `createHook`, so no API key is needed (no exit 3).
+            if (command === 'agent' && args._arg1 === 'list')
+                return (await import('./agent-list.js')).handleAgentList(args);
+            if (command === 'agent' && args._arg1 === 'read')
+                return (await import('./agent-read.js')).handleAgentRead(args);
+            const { agentSubcommandError, liveSendDeps, parseSendArgs, runSend, sendReadsStdin } = await import('./send.js');
+            const named = command === 'agent' ? 'agent send' : 'send';
+            const unknown = command === 'agent' ? agentSubcommandError(String(args._arg1)) : null;
+            if (unknown) {
+                console.error(unknown);
+                return 2;
+            }
+            const send = parseSendArgs(sendArgv, sendReadsStdin(sendArgv) ? await readStdin() : undefined, named);
+            if ('error' in send) {
+                console.error(send.error);
+                return 2;
+            }
+            const hook = createHook(args);
+            if (!hook)
+                return 3;
+            return runSend(send, liveSendDeps(hook), named);
+        }
+        case 'list':
+            return handleList(args);
+        case 'dismiss':
+            return handleDismiss(args);
+        case 'rename':
+            return handleRename(args);
+        case 'forget':
+            return handleForget(args);
+        case 'worktree':
+            return handleWorktree(args);
+        case 'test':
+            return handleTest(args);
+        case 'trust':
+            return handleTrust(args);
+        case 'schedule':
+            return (await import('./schedule-command.js')).handleSchedule(collectPassthrough(process.argv, command));
+        case 'sh': {
+            const { handleShellSession, splitAgentOptions } = await import('./wrapper.js');
+            const { opts, rest, error } = splitAgentOptions(collectPassthrough(process.argv, command));
+            if (error || rest.length || opts.worktree) {
+                console.error(`hwip: ${error ?? "'hwip sh' takes only --label <x> and --detach"}`);
+                return 2;
+            }
+            return handleShellSession(opts);
+        }
+        case 'mcp':
+            return (await import('./mcp.js')).handleMcp();
+        case 'listener':
+            return (await import('./listener.js')).handleListener(args);
+        case 'remote-hook':
+            return handleRemoteHook(args);
+        default:
+            printError(`Unknown command: ${command}`, (0, args_js_1.flagOn)(args, 'json', true));
+            printUsage();
+            return 1;
+    }
+};
+main().then((code) => process.exit(code), (err) => {
+    console.error((0, redact_js_1.redactSecrets)(err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+});