@hwip/cli 0.0.1 → 0.1.0

package/dist/blocked-prompt-seal.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptStillShown = exports.createPromptSealer = exports.PROMPT_SEAL_RETRY_MS = void 0;
+/**
+ * Turns the dialog a blocked session shows into the sealed summary the session
+ * report carries (`blockedPrompt`, hwip SERVER-API.md).
+ *
+ * `observe` is called once per session per report cycle, synchronously, with the
+ * pane the state was read from. Sealing is async (key lookup, ECDH), so the first
+ * cycle that sees a prompt starts the seal and `sealing()` says when it is done:
+ * the listener holds that report for it a short while (`withSettledPrompts`), since
+ * the server pushes the moment a session turns blocked and the phone reads the
+ * prompt for the push's buttons right then. The sealed object is kept while the
+ * prompt id is unchanged, so an unchanged prompt makes an unchanged report.
+ *
+ * A prompt that cannot be parsed, has no one to seal for, or fails to seal is left
+ * out: the session reports the bare `blocked` state, as it did before. Nothing
+ * here logs the dialog text, the plaintext or the ciphertext.
+ */
+const blocked_prompt_js_1 = require("./blocked-prompt.js");
+/** After a failed seal or an empty recipient list, how long before the same prompt is tried again. */
+exports.PROMPT_SEAL_RETRY_MS = 30_000;
+const createPromptSealer = (deps) => {
+    const now = deps.now ?? Date.now;
+    const entries = new Map();
+    const start = (name, entry, plaintext) => {
+        entry.busy = true;
+        entry.sealing = (async () => {
+            try {
+                const recipients = await deps.recipients();
+                if (recipients.length === 0) {
+                    entry.retryAt = now() + exports.PROMPT_SEAL_RETRY_MS;
+                    return;
+                }
+                const sealed = await deps.seal(plaintext, recipients);
+                entry.wire = { id: entry.id, at: entry.at, sealed };
+            }
+            catch (err) {
+                // The message of a crypto error names no content; the dialog text is never in it.
+                deps.log?.(`blocked prompt for ${name}: seal failed (${err instanceof Error ? err.message : String(err)})`);
+                entry.retryAt = now() + exports.PROMPT_SEAL_RETRY_MS;
+            }
+            finally {
+                entry.busy = false;
+                entry.sealing = undefined;
+            }
+        })();
+    };
+    return {
+        observe: (name, state, paneText) => {
+            const parsed = state === 'blocked' && paneText !== null ? (0, blocked_prompt_js_1.parseBlockedDialog)(paneText) : undefined;
+            if (!parsed) {
+                entries.delete(name);
+                return undefined;
+            }
+            let entry = entries.get(name);
+            if (entry?.id !== parsed.id) {
+                entry = { id: parsed.id, at: new Date(now()).toISOString(), busy: false };
+                entries.set(name, entry);
+            }
+            if (entry.wire)
+                return entry.wire;
+            if (!entry.busy && (entry.retryAt === undefined || now() >= entry.retryAt)) {
+                entry.retryAt = undefined;
+                const plaintext = (0, blocked_prompt_js_1.promptPlaintext)(parsed, { sessionName: name, deviceId: deps.deviceId(), at: entry.at });
+                // A prompt too big for the cap is not retried: the screen would not shrink.
+                if (plaintext === undefined)
+                    entry.retryAt = Number.POSITIVE_INFINITY;
+                else
+                    start(name, entry, plaintext);
+            }
+            return undefined;
+        },
+        prune: (live) => {
+            for (const name of entries.keys()) {
+                if (!live.has(name))
+                    entries.delete(name);
+            }
+        },
+        sealing: () => {
+            const running = [...entries.values()].flatMap((e) => (e.sealing ? [e.sealing] : []));
+            return running.length > 0 ? Promise.all(running).then(() => undefined) : undefined;
+        },
+    };
+};
+exports.createPromptSealer = createPromptSealer;
+/** True when the pane shows the prompt `id` right now (a fresh capture, not the one a report was made from). */
+const promptStillShown = (id, paneText) => paneText !== null && (0, blocked_prompt_js_1.parseBlockedDialog)(paneText)?.id === id;
+exports.promptStillShown = promptStillShown;

package/dist/blocked-prompt.d.ts

@@ -0,0 +1,57 @@
+/** Dialog titles whose layout was captured and is read. */
+export declare const KNOWN_TITLES: readonly string[];
+export declare const MAX_DETAIL_LINES = 12;
+export declare const MAX_DETAIL_LINE_CHARS = 300;
+export declare const MAX_LABEL_CHARS = 200;
+export declare const MAX_OPTIONS = 9;
+/** The plaintext a prompt is sealed from stays under this; the server's cap on the sealed body is 8 KiB. */
+export declare const MAX_PROMPT_BYTES: number;
+export interface PromptOption {
+    /** The number the dialog shows. */
+    n: number;
+    label: string;
+    /** Named keys (`ALLOWED_KEYS` in listener.ts) that pick this option from the highlight the pane shows now. */
+    keys: string[];
+    /** Choosing it grants more than this one request ("don't ask again", "always", "for this session"). */
+    persistent?: true;
+}
+export interface ParsedPrompt {
+    /** Hash of the dialog as shown, highlight included: moving the highlight is a different prompt. */
+    id: string;
+    title: string;
+    subtitle?: string;
+    detail: string[];
+    detailTruncated?: true;
+    note?: string;
+    question: string;
+    options: PromptOption[];
+}
+export declare const isPromptId: (value: unknown) => value is string;
+/** The dialog at the bottom of `pane`, or undefined when it is not one this module reads. */
+export declare const parseBlockedDialog: (pane: string) => ParsedPrompt | undefined;
+/** What the app opens: the prompt plus which session and listener it belongs to, and when it was first seen. */
+export interface PromptPlaintext {
+    v: 1;
+    sessionName: string;
+    deviceId: string;
+    at: string;
+    id: string;
+    kind: 'permission';
+    title: string;
+    subtitle?: string;
+    detail: string[];
+    detailTruncated?: true;
+    note?: string;
+    question: string;
+    options: PromptOption[];
+}
+/**
+ * The JSON to seal, within MAX_PROMPT_BYTES: detail lines go from the end until it fits.
+ * Undefined when even a prompt without detail does not fit.
+ */
+export declare const promptPlaintext: (prompt: ParsedPrompt, ctx: {
+    sessionName: string;
+    deviceId: string;
+    at: string;
+}) => string | undefined;
+//# sourceMappingURL=blocked-prompt.d.ts.map

package/dist/blocked-prompt.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptPlaintext = exports.parseBlockedDialog = exports.isPromptId = exports.MAX_PROMPT_BYTES = exports.MAX_OPTIONS = exports.MAX_LABEL_CHARS = exports.MAX_DETAIL_LINE_CHARS = exports.MAX_DETAIL_LINES = exports.KNOWN_TITLES = void 0;
+/**
+ * What a blocked Claude Code session is waiting for, read off its screen.
+ *
+ * The state detector (`agent-state.ts`) only says "blocked". The app wants to
+ * draw the question: which tool, which command, which answers. This module
+ * reads the approval dialog at the bottom of the pane into that summary. Pure:
+ * the listener owns tmux, sealing and timing (`blocked-prompt-seal.ts`).
+ *
+ * Layout read (Claude Code, captured from a live session; see the fixtures in
+ * `blocked-prompt.test.ts`):
+ *
+ *     ─────────────  full-width rule: the dialog starts below the last one
+ *      Bash command  title
+ *      Run shell command  subtitle (optional)
+ *     ╌╌╌╌╌╌╌╌╌╌╌╌╌  dashed rule
+ *      rtk ls -la .  detail (the command, or the diff of an edit)
+ *     ╌╌╌╌╌╌╌╌╌╌╌╌╌
+ *      This command requires approval  note (optional)
+ *
+ *      Do you want to proceed?  question
+ *      ❯ 1. Yes  options, `❯` marks the highlighted one
+ *        2. Yes, and don’t ask again for: rtk ls *
+ *        3. No
+ *
+ *      Esc to cancel · Tab to amend  footer
+ *
+ * Only the titles in `KNOWN_TITLES` are read. Another dialog (a plan, a
+ * question to the user, an MCP tool) has no captured layout, so it yields
+ * nothing and the session keeps reporting the bare `blocked` state.
+ */
+const node_crypto_1 = require("node:crypto");
+/** Dialog titles whose layout was captured and is read. */
+exports.KNOWN_TITLES = ['Bash command', 'Edit file', 'Create file'];
+exports.MAX_DETAIL_LINES = 12;
+exports.MAX_DETAIL_LINE_CHARS = 300;
+exports.MAX_LABEL_CHARS = 200;
+exports.MAX_OPTIONS = 9;
+/** The plaintext a prompt is sealed from stays under this; the server's cap on the sealed body is 8 KiB. */
+exports.MAX_PROMPT_BYTES = 2 * 1024;
+/** The shape of a prompt id on the wire: what `ifPrompt` may carry (the server checks the same). */
+const PROMPT_ID = /^[A-Za-z0-9_-]{1,64}$/;
+const isPromptId = (value) => typeof value === 'string' && PROMPT_ID.test(value);
+exports.isPromptId = isPromptId;
+const FULL_RULE = /^─{20,}$/;
+const DASHED_RULE = /^╌{20,}$/;
+const OPTION = /^\s*([❯>])?\s*(\d{1,2})\.\s+(\S.*)$/;
+const FOOTER = /^\s*(esc to cancel|enter to select)/i;
+// A choice that grants more than this one request: "don't ask again", "always allow", "allow all edits during this
+// session", "… for this session". Wider on purpose — a miss lets the app skip its extra confirmation.
+const PERSISTENT = /don.?t ask again|never ask|always|allow all|this session|from now on/i;
+/** The character the highlight is drawn with. A pane without it is not a dialog this module can answer. */
+const HIGHLIGHT = '❯';
+const cut = (text, max) => {
+    if (text.length <= max)
+        return text;
+    const head = text.slice(0, max);
+    const last = head.charCodeAt(head.length - 1);
+    return last >= 0xd800 && last <= 0xdbff ? head.slice(0, -1) : head;
+};
+const idOf = (region) => (0, node_crypto_1.createHash)('sha256').update(region.join('\n')).digest('hex').slice(0, 16);
+/** `down`×k or `up`×k to reach option `to` from option `from`, then `enter`. */
+const keysFor = (from, to) => [...Array(Math.abs(to - from)).fill(to > from ? 'down' : 'up'), 'enter'];
+/** The dialog at the bottom of `pane`, or undefined when it is not one this module reads. */
+const parseBlockedDialog = (pane) => {
+    const lines = pane.split('\n').map((l) => l.trimEnd());
+    // The question is the last "…?" line whose next non-blank line is option 1.
+    let qAt = -1;
+    for (let i = lines.length - 2; i >= 0; i--) {
+        if (!lines[i].endsWith('?'))
+            continue;
+        const next = lines.slice(i + 1).find((l) => l !== '');
+        if (next !== undefined && OPTION.exec(next)?.[2] === '1') {
+            qAt = i;
+            break;
+        }
+    }
+    if (qAt < 0)
+        return undefined;
+    // The dialog starts below the last full-width rule above the question and ends at its footer;
+    // whatever the terminal draws below (a status line, its own rule) is not part of it.
+    let top = -1;
+    for (let i = qAt - 1; i >= 0; i--) {
+        if (FULL_RULE.test(lines[i])) {
+            top = i;
+            break;
+        }
+    }
+    if (top < 0)
+        return undefined;
+    let end = lines.length;
+    while (end > qAt + 1 && lines[end - 1] === '')
+        end--;
+    for (let i = qAt + 1; i < end; i++) {
+        if (FOOTER.test(lines[i])) {
+            end = i + 1;
+            break;
+        }
+    }
+    const region = lines.slice(top + 1, end);
+    const q = qAt - (top + 1);
+    const options = [];
+    for (const line of region.slice(q + 1)) {
+        if (line === '' || FOOTER.test(line))
+            continue;
+        const m = OPTION.exec(line);
+        if (m) {
+            options.push({ n: Number(m[2]), label: m[3].trim(), selected: m[1] === HIGHLIGHT });
+        }
+        else if (options.length > 0 && /^\s{3,}\S/.test(line)) {
+            // A long label wraps onto an indented line.
+            const last = options[options.length - 1];
+            last.label = `${last.label} ${line.trim()}`;
+        }
+        else {
+            return undefined;
+        }
+    }
+    if (options.length < 2 || options.length > exports.MAX_OPTIONS)
+        return undefined;
+    if (!options.every((o, i) => o.n === i + 1))
+        return undefined;
+    const selected = options.findIndex((o) => o.selected);
+    if (selected < 0 || options.filter((o) => o.selected).length !== 1)
+        return undefined;
+    // Above the question: title, subtitle, dashed rule, detail, dashed rule, note.
+    const head = region.slice(0, q);
+    const title = head.find((l) => l.trim() !== '')?.trim();
+    if (!title || !exports.KNOWN_TITLES.includes(title))
+        return undefined;
+    const body = head.slice(head.findIndex((l) => l.trim() !== '') + 1);
+    const firstDash = body.findIndex((l) => DASHED_RULE.test(l));
+    const before = (firstDash < 0 ? body : body.slice(0, firstDash)).map((l) => l.trim()).filter(Boolean);
+    const rest = firstDash < 0 ? [] : body.slice(firstDash + 1);
+    const secondDash = rest.findIndex((l) => DASHED_RULE.test(l));
+    const detailLines = (secondDash < 0 ? rest : rest.slice(0, secondDash)).map((l) => l.replace(/^ /, ''));
+    while (detailLines.length > 0 && detailLines[detailLines.length - 1].trim() === '')
+        detailLines.pop();
+    const after = secondDash < 0 ? [] : rest.slice(secondDash + 1).map((l) => l.trim()).filter(Boolean);
+    const prompt = {
+        id: idOf(region),
+        title,
+        detail: detailLines.slice(0, exports.MAX_DETAIL_LINES).map((l) => cut(l, exports.MAX_DETAIL_LINE_CHARS)),
+        question: cut(region[q].trim(), exports.MAX_LABEL_CHARS),
+        options: options.map((o, i) => ({
+            n: o.n,
+            label: cut(o.label, exports.MAX_LABEL_CHARS),
+            keys: keysFor(selected, i),
+            ...(PERSISTENT.test(o.label) ? { persistent: true } : {}),
+        })),
+    };
+    if (before.length > 0)
+        prompt.subtitle = cut(before.join(' '), exports.MAX_LABEL_CHARS);
+    if (after.length > 0)
+        prompt.note = cut(after.join(' '), exports.MAX_LABEL_CHARS);
+    if (detailLines.length > exports.MAX_DETAIL_LINES || detailLines.some((l) => l.length > exports.MAX_DETAIL_LINE_CHARS)) {
+        prompt.detailTruncated = true;
+    }
+    return prompt;
+};
+exports.parseBlockedDialog = parseBlockedDialog;
+/**
+ * The JSON to seal, within MAX_PROMPT_BYTES: detail lines go from the end until it fits.
+ * Undefined when even a prompt without detail does not fit.
+ */
+const promptPlaintext = (prompt, ctx) => {
+    const { id, ...fields } = prompt;
+    const base = { v: 1, ...ctx, id, kind: 'permission', ...fields };
+    let json = JSON.stringify(base);
+    while (Buffer.byteLength(json) > exports.MAX_PROMPT_BYTES) {
+        if (base.detail.length === 0)
+            return undefined;
+        base.detail = base.detail.slice(0, -1);
+        base.detailTruncated = true;
+        json = JSON.stringify(base);
+    }
+    return json;
+};
+exports.promptPlaintext = promptPlaintext;

package/dist/channel.d.ts

@@ -0,0 +1,67 @@
+import type { NotifyPayload } from './types.js';
+/**
+ * The part of a channel `GET /channels` returns that this CLI shows. The record
+ * also carries fields that are not for a terminal or a `--json` pipe (a
+ * webhook secret, the index tag), so the list is rebuilt from these and
+ * nothing else is passed along.
+ */
+export interface ChannelSummary {
+    channelId: string;
+    name: string;
+    description?: string;
+    isPublic: boolean;
+    subscriberCount: number;
+    ownerId: string;
+    /** Whether the account owns it, as the server says. Absent from a server that does not send it yet. */
+    isOwner?: boolean;
+    createdAt?: string;
+}
+/** The channels in a `GET /channels` answer; a row without an id or a name is dropped, not guessed. */
+export declare const parseChannels: (data: unknown) => ChannelSummary[];
+/**
+ * What `hwip channel list` prints. The server says per channel whether the
+ * account owns it (`isOwner`), and answers with the owned ones first. A server
+ * that does not send the field yet gives the rows no way to say so — an API key
+ * cannot learn its own user id — so such a row shows its owner and leaves the
+ * comparison to the person (the server refuses `notify --channel` for a channel
+ * the account does not own).
+ */
+export declare const channelLines: (channels: readonly ChannelSummary[]) => string[];
+export type ChannelRef = {
+    channelId: string;
+    name?: string;
+} | {
+    error: string;
+};
+/**
+ * Which channel `--channel <ref>` means. An id in the list wins; otherwise the
+ * name must match exactly one channel *the account owns* — a channel it only
+ * follows with the same name does not make the name ambiguous, and is never
+ * the target. Two owned channels with one name are refused rather than picked:
+ * a push to the wrong channel reaches strangers. An id the list does not hold is
+ * passed on as it is — the server decides whether it exists and is the account's.
+ *
+ * A server that does not say who owns what (`isOwner` absent on any row) leaves
+ * every name match a candidate, as before: ambiguity is then refused, and a
+ * channel the account does not own is refused by the server.
+ */
+export declare const resolveChannel: (channels: readonly ChannelSummary[], ref: string) => ChannelRef;
+export interface ChannelNotify {
+    ref: string;
+    payload: Omit<NotifyPayload, 'channelId'>;
+}
+/**
+ * The flags of `hwip notify --channel`, or what is wrong with them.
+ *
+ * A channel push is not the agent hook's push: the gate (`--auto`), the device
+ * and the session flags mean "this agent session", and none of them go to a
+ * channel — refusing them is better than dropping them silently, and the
+ * default title and body a hook gets from the branch name would publish a
+ * project name to subscribers.
+ */
+export declare const parseChannelNotify: (args: Readonly<Record<string, string | boolean>>) => ChannelNotify | {
+    error: string;
+};
+/** Printed to stderr on every channel push: whatever the account's end-to-end setting, this one is readable by the server. */
+export declare const PLAINTEXT_NOTE = "Channel pushes are sent as plain text, not sealed \u2014 the server can read this one even with end-to-end encryption on.";
+//# sourceMappingURL=channel.d.ts.map

package/dist/channel.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLAINTEXT_NOTE = exports.parseChannelNotify = exports.resolveChannel = exports.channelLines = exports.parseChannels = void 0;
+const text = (value) => (typeof value === 'string' && value ? value : undefined);
+/** The channels in a `GET /channels` answer; a row without an id or a name is dropped, not guessed. */
+const parseChannels = (data) => {
+    if (!Array.isArray(data))
+        return [];
+    const channels = [];
+    for (const raw of data) {
+        if (!raw || typeof raw !== 'object')
+            continue;
+        const row = raw;
+        const channelId = text(row.channelId);
+        const name = text(row.name);
+        if (!channelId || !name)
+            continue;
+        const description = text(row.description);
+        const createdAt = text(row.createdAt);
+        channels.push({
+            channelId,
+            name,
+            ...(description && { description }),
+            isPublic: row.isPublic === true,
+            subscriberCount: typeof row.subscriberCount === 'number' ? row.subscriberCount : 0,
+            ownerId: text(row.ownerId) ?? '',
+            ...(typeof row.isOwner === 'boolean' && { isOwner: row.isOwner }),
+            ...(createdAt && { createdAt }),
+        });
+    }
+    return channels;
+};
+exports.parseChannels = parseChannels;
+/**
+ * What `hwip channel list` prints. The server says per channel whether the
+ * account owns it (`isOwner`), and answers with the owned ones first. A server
+ * that does not send the field yet gives the rows no way to say so — an API key
+ * cannot learn its own user id — so such a row shows its owner and leaves the
+ * comparison to the person (the server refuses `notify --channel` for a channel
+ * the account does not own).
+ */
+const channelLines = (channels) => {
+    if (channels.length === 0)
+        return ['No channels.'];
+    const idWidth = Math.max(...channels.map((c) => c.channelId.length));
+    const nameWidth = Math.max(...channels.map((c) => c.name.length));
+    const lines = channels.map((c) => {
+        const subs = `${c.subscriberCount} ${c.subscriberCount === 1 ? 'subscriber' : 'subscribers'}`;
+        const role = c.isOwner === true ? 'yours' : c.isOwner === false ? 'following' : c.ownerId ? `owner ${c.ownerId.slice(0, 8)}` : 'owner unknown';
+        return `  ${c.channelId.padEnd(idWidth)}  ${c.name.padEnd(nameWidth)}  ${c.isPublic ? 'public ' : 'private'}  ${subs}  ${role}`;
+    });
+    lines.push('', 'Only an owner can send to a channel.');
+    return lines;
+};
+exports.channelLines = channelLines;
+/**
+ * Which channel `--channel <ref>` means. An id in the list wins; otherwise the
+ * name must match exactly one channel *the account owns* — a channel it only
+ * follows with the same name does not make the name ambiguous, and is never
+ * the target. Two owned channels with one name are refused rather than picked:
+ * a push to the wrong channel reaches strangers. An id the list does not hold is
+ * passed on as it is — the server decides whether it exists and is the account's.
+ *
+ * A server that does not say who owns what (`isOwner` absent on any row) leaves
+ * every name match a candidate, as before: ambiguity is then refused, and a
+ * channel the account does not own is refused by the server.
+ */
+const resolveChannel = (channels, ref) => {
+    const known = channels.every((c) => typeof c.isOwner === 'boolean');
+    const byId = channels.find((c) => c.channelId === ref);
+    if (byId) {
+        if (known && !byId.isOwner)
+            return { error: `you follow "${byId.name}" (${byId.channelId}) but do not own it — only the owner can send to a channel` };
+        return { channelId: byId.channelId, name: byId.name };
+    }
+    const named = channels.filter((c) => c.name === ref);
+    const byName = known ? named.filter((c) => c.isOwner) : named;
+    if (byName.length === 1)
+        return { channelId: byName[0].channelId, name: byName[0].name };
+    if (byName.length > 1) {
+        const ids = byName.map((c) => c.channelId).join(', ');
+        return { error: `${byName.length} channels are named "${ref}" (${ids}) — use the channelId` };
+    }
+    if (known && named.length > 0) {
+        return { error: `you follow "${ref}" (${named.map((c) => c.channelId).join(', ')}) but do not own a channel by that name — only the owner can send to a channel` };
+    }
+    if (/^ch_/.test(ref))
+        return { channelId: ref };
+    return { error: `no channel named "${ref}" — 'hwip channel list' shows the channels; use a channelId or an exact name` };
+};
+exports.resolveChannel = resolveChannel;
+const PRIORITIES = ['low', 'normal', 'high', 'urgent'];
+const TYPES = ['note', 'link', 'file', 'hook'];
+/**
+ * The flags of `hwip notify --channel`, or what is wrong with them.
+ *
+ * A channel push is not the agent hook's push: the gate (`--auto`), the device
+ * and the session flags mean "this agent session", and none of them go to a
+ * channel — refusing them is better than dropping them silently, and the
+ * default title and body a hook gets from the branch name would publish a
+ * project name to subscribers.
+ */
+const parseChannelNotify = (args) => {
+    const ref = args.channel;
+    if (typeof ref !== 'string' || !ref.trim())
+        return { error: '--channel needs a channelId or a channel name' };
+    for (const flag of ['auto', 'device', 'session']) {
+        if (args[flag] !== undefined)
+            return { error: `--${flag} is for agent sessions and cannot be combined with --channel` };
+    }
+    const title = typeof args.title === 'string' ? args.title : undefined;
+    const body = typeof args.body === 'string' ? args.body : undefined;
+    if (!title && !body)
+        return { error: 'a channel push needs --title or --body' };
+    const type = typeof args.type === 'string' ? args.type : 'hook';
+    if (!TYPES.includes(type))
+        return { error: `--type must be one of ${TYPES.join(', ')}` };
+    const priority = typeof args.priority === 'string' ? args.priority : undefined;
+    if (priority && !PRIORITIES.includes(priority)) {
+        return { error: `--priority must be one of ${PRIORITIES.join(', ')}` };
+    }
+    const url = typeof args.url === 'string' ? args.url : undefined;
+    return {
+        ref: ref.trim(),
+        payload: {
+            ...(title && { title }),
+            ...(body && { body }),
+            ...(url && { url }),
+            type: type,
+            ...(priority && { priority: priority }),
+        },
+    };
+};
+exports.parseChannelNotify = parseChannelNotify;
+/** Printed to stderr on every channel push: whatever the account's end-to-end setting, this one is readable by the server. */
+exports.PLAINTEXT_NOTE = 'Channel pushes are sent as plain text, not sealed — the server can read this one even with end-to-end encryption on.';

package/dist/check-update.d.ts

@@ -0,0 +1,28 @@
+/**
+ * How to update. A global install is what `hwip` on PATH runs — `npx @hwip/cli
+ * install` only re-ran setup from a fresh download and left it as it was —
+ * and the daemon keeps the old build until it restarts.
+ */
+export declare const UPDATE_HINT = "npm i -g @hwip/cli \u2014 the next `hwip cc` restarts the listener on it (or run: hwip listener --restart)";
+/** Semver-ish compare: returns true when `latest` is strictly newer than `current`. */
+export declare const isNewer: (latest: string, current: string) => boolean;
+/**
+ * The mcp-server version this CLI will actually run. It ships as a dependency
+ * (see mcp.ts), so it is pinned at install time — no longer "whatever npx
+ * fetched last". Returns null on a broken install rather than throwing; the
+ * report degrades to "latest is vX" the way it always did for this package.
+ */
+export declare const installedMcpServerVersion: () => string | null;
+/**
+ * One line for `hwip cc` when a newer CLI is out, or undefined. Asks npm at
+ * most once a day, briefly, and remembers the answer; an offline day keeps
+ * the last known version rather than asking again on every launch.
+ */
+export declare const cachedUpdateNotice: (deps?: {
+    now?: () => number;
+    latest?: () => Promise<string | null>;
+    file?: string;
+    env?: NodeJS.ProcessEnv;
+}) => Promise<string | undefined>;
+export declare const handleCheckUpdate: (args: Record<string, string | boolean>) => Promise<number>;
+//# sourceMappingURL=check-update.d.ts.map