@phnx-labs/agents-cli 1.22.117 → 1.22.118

package/dist/lib/browser-client.js

@@ -0,0 +1,234 @@
+/**
+ * browser-client.ts — the ONE process client through which agents-cli talks to
+ * the standalone `browser` CLI (@phnx-labs/browser-cli, PHNX-4101).
+ *
+ * This is the agents-owned half of the browser extraction, and it is
+ * deliberately small. agents-cli no longer carries the CDP/BiDi/Arc drivers, a
+ * browser IPC service, a chrome-data/profile store, a network-capture pipeline,
+ * or the remote SSH driving loop — the standalone engine owns all of it, exactly
+ * as `secrets` took the keychain engine (PHNX-3989), `computer` took the
+ * accessibility engine (PHNX-4075) and `sessions` took the transcript engine
+ * (PHNX-4012). What stays here is what only the fleet CLI can know: which device
+ * a `--device` name resolves to, whether this machine consents to being driven,
+ * who the acting session is, and where an action must be recorded.
+ *
+ * THERE IS NO FALLBACK. A missing executable throws `BROWSER_BIN_MISSING` with
+ * install guidance (DIST-1) rather than silently driving a bundled engine —
+ * agents-cli has none to drive, and a fallback would re-couple the two release
+ * trains this extraction exists to separate.
+ *
+ * Transport — inherited-fd passthrough, not request/response (matches
+ * browser-cli's `bin/browser.cjs` launcher, which forwards fds 3-16):
+ *
+ *   - stdio 0/1/2 are INHERITED. The engine owns the user's terminal: its
+ *     stdout is the command's stdout, its `--json` is the command's `--json`,
+ *     its prompts reach a real tty. agents-cli never re-formats engine output,
+ *     which is what keeps the surface honest as the engine evolves.
+ *   - fd 3 (`BROWSER_CONTEXT_FD`) carries ONE JSON object — the consumer context
+ *     built by `lib/browser/context.ts` — written and closed immediately, so the
+ *     engine reads to EOF and proceeds. The document is read once, before command
+ *     parsing; a malformed one is a hard error, an absent one the standalone case.
+ *   - fd 4 (`BROWSER_EVENTS_FD`) carries NDJSON action events back: one JSON
+ *     object per line, each an action the engine actually performed. agents-cli
+ *     turns those into feed events and `sessions --browser` history
+ *     (`lib/browser/record.ts`). The engine may emit none; it must never block
+ *     on this pipe.
+ *
+ * Both fds are anonymous pipes on the child's side, the same shape
+ * `computer-client.ts` and `secrets-client.ts` settled on after a named FIFO
+ * wedged macOS reads. The context is pushed rather than pulled so the engine
+ * needs no callback into agents-cli — one direction each way, no reentrancy.
+ */
+import { spawn } from 'node:child_process';
+import { realpathSync, existsSync } from 'node:fs';
+import * as path from 'node:path';
+import { findInPath } from './agent-spec/agents.js';
+const INSTALL_HINT = 'npm i -g @phnx-labs/browser-cli';
+/** fd the engine reads its one-shot JSON context from. */
+export const BROWSER_CONTEXT_FD = 3;
+/** fd the engine writes NDJSON action events to. */
+export const BROWSER_EVENTS_FD = 4;
+export class BrowserClientError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'BrowserClientError';
+    }
+}
+export function isBrowserClientError(err) {
+    return err instanceof BrowserClientError;
+}
+let cachedBin;
+function browserEntrypoint(bin) {
+    if (!/\.(cmd|ps1)$/i.test(bin))
+        return bin;
+    const launcher = path.join(path.dirname(bin), 'node_modules', '@phnx-labs', 'browser-cli', 'bin', 'browser.cjs');
+    return existsSync(launcher) ? launcher : bin;
+}
+/**
+ * Accept only the real standalone `browser` executable, never agents-cli's own
+ * `browser` command shim (`exec "$AGENTS_BIN" browser`, `installations/shims.ts`)
+ * — resolving that would recurse into this process. `findInPath` already skips
+ * `~/.agents/.cache/shims`; this guard is the second line, mirroring
+ * `isStandaloneComputer` (agents-cli never shipped a `dist/browser.js` bin, but
+ * the check stays symmetric and future-proof against one).
+ */
+export function isStandaloneBrowser(bin) {
+    let real = browserEntrypoint(bin);
+    try {
+        real = realpathSync(real);
+    }
+    catch { /* spawn reports missing explicit paths */ }
+    return !/\.(cmd|ps1)$/i.test(real) && !real.endsWith(path.join('dist', 'browser.js'));
+}
+/**
+ * Resolve the standalone executable. `BROWSER_BIN` wins so a dev build can be
+ * driven without touching PATH.
+ *
+ * Resolution uses `findInPath`, which skips `~/.agents/.cache/shims` — see
+ * `isStandaloneBrowser` for why that skip is load-bearing.
+ */
+export function resolveBrowserBin() {
+    if (cachedBin)
+        return cachedBin;
+    const explicit = process.env.BROWSER_BIN?.trim();
+    const resolved = explicit && explicit.length > 0 ? (isStandaloneBrowser(explicit) ? explicit : null) : findInPath('browser', { accept: isStandaloneBrowser });
+    if (!resolved) {
+        throw new BrowserClientError('BROWSER_BIN_MISSING', 'The standalone `browser` CLI was not found. Install it with:\n' +
+            `  ${INSTALL_HINT}\n` +
+            'or run `agents setup browser` / `agents clis install browser`, or point $BROWSER_BIN at its executable.');
+    }
+    cachedBin = browserEntrypoint(resolved);
+    return cachedBin;
+}
+/** True when the standalone `browser` CLI is resolvable — the readiness signal
+ * for `agents setup` without a spawn. Never throws. */
+export function browserInstalled() {
+    try {
+        resolveBrowserBin();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** A `.js`/`.cjs`/`.mjs` bin is run through this runtime; a real executable is exec'd directly. */
+export function invocation(bin) {
+    if (/\.[mc]?js$/.test(bin))
+        return { command: process.execPath, prefix: [bin] };
+    return { command: bin, prefix: [] };
+}
+/**
+ * Split a growing buffer into complete NDJSON lines. Pure so the framing rules —
+ * blank lines skipped, a non-JSON line dropped rather than crashing the CLI, a
+ * trailing partial line carried forward — are unit-testable without a spawn.
+ *
+ * A malformed line is dropped, not thrown: these events are telemetry riding
+ * alongside a user-visible action that already happened. Failing the command
+ * because its receipt was unreadable would be strictly worse than losing the
+ * receipt. The action itself already failed loud on its own channel if it failed.
+ */
+export function parseEventLines(buffer) {
+    const events = [];
+    const parts = buffer.split('\n');
+    const rest = parts.pop() ?? '';
+    for (const line of parts) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (parsed && typeof parsed === 'object' && typeof parsed.command === 'string') {
+                events.push(parsed);
+            }
+        }
+        catch {
+            // Unreadable receipt — see above.
+        }
+    }
+    return { events, rest };
+}
+/**
+ * Run the standalone engine with the consumer context on fd 3 and the action
+ * event stream on fd 4. Resolves with the engine's exit code; the caller
+ * propagates it so `agents browser` exits exactly as the engine did.
+ *
+ * Throws `BROWSER_BIN_MISSING` when the standalone is not installed. Every other
+ * failure is the engine's own, reported on the inherited stderr.
+ */
+export async function runBrowser(opts) {
+    const bin = resolveBrowserBin();
+    const { command, prefix } = invocation(bin);
+    const child = spawn(command, [...prefix, ...opts.argv], {
+        stdio: ['inherit', opts.capture ? 'pipe' : 'inherit', 'inherit', 'pipe', 'pipe'],
+        env: {
+            ...process.env,
+            BROWSER_CONTEXT_FD: String(BROWSER_CONTEXT_FD),
+            BROWSER_EVENTS_FD: String(BROWSER_EVENTS_FD),
+        },
+    });
+    const contextPipe = child.stdio[BROWSER_CONTEXT_FD];
+    const eventsPipe = child.stdio[BROWSER_EVENTS_FD];
+    if (contextPipe) {
+        // An engine that exits before reading the context (bad argv, `--help`)
+        // closes fd 3 and we get EPIPE. That is a normal race, not a failure.
+        contextPipe.on('error', () => { });
+        contextPipe.end(JSON.stringify(opts.context) + '\n');
+    }
+    let stdout = '';
+    if (opts.capture && child.stdout) {
+        child.stdout.setEncoding('utf-8');
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk;
+        });
+    }
+    let pending = '';
+    const drained = new Promise((resolve) => {
+        if (!eventsPipe)
+            return resolve();
+        eventsPipe.setEncoding('utf-8');
+        eventsPipe.on('data', (chunk) => {
+            const { events, rest } = parseEventLines(pending + chunk);
+            pending = rest;
+            for (const event of events)
+                opts.onEvent?.(event);
+        });
+        eventsPipe.on('error', () => resolve());
+        eventsPipe.on('end', () => {
+            // A final line with no trailing newline still counts.
+            const { events } = parseEventLines(pending.endsWith('\n') ? pending : pending + '\n');
+            pending = '';
+            for (const event of events)
+                opts.onEvent?.(event);
+            resolve();
+        });
+    });
+    const exitCode = await new Promise((resolve, reject) => {
+        child.on('error', (err) => {
+            reject(new BrowserClientError('BROWSER_SPAWN_FAILED', `Could not run \`${bin}\`: ${err.message}`));
+        });
+        child.on('close', (code, signal) => {
+            // A signalled child has no exit code; report the conventional 128+n so
+            // callers and shells see a non-zero status instead of a false success.
+            if (code == null)
+                return resolve(signal ? 128 + (osSignalNumber(signal) ?? 0) : 1);
+            resolve(code);
+        });
+    });
+    await drained;
+    return { exitCode, stdout };
+}
+/** Signal name → number for the 128+n exit convention. Only the ones a tunnelled
+ * or interrupted engine realistically dies on; anything else contributes 0 and
+ * still yields a non-zero status. */
+function osSignalNumber(signal) {
+    const table = {
+        SIGHUP: 1, SIGINT: 2, SIGQUIT: 3, SIGKILL: 9, SIGPIPE: 13, SIGTERM: 15,
+    };
+    return table[signal];
+}
+/** Test seam: drop the memoized bin so PATH fixtures can re-resolve. */
+export function _resetBrowserClientForTest() {
+    cachedBin = undefined;
+}

package/dist/lib/channels/owner-sink.d.ts

@@ -1,27 +1,10 @@
 import type { Meta } from '../types.js';
-/** Why the owner sink cannot deliver from this box. */
-export type OwnerSinkReason = 'rush-not-on-path' | 'rush-signed-out';
+export type OwnerSinkReason = 'imessage-not-macos' | 'slack-no-token' | 'channel-unsupported';
 export interface OwnerSinkStatus {
-    /** Owner delivery is configured for this fleet (humans.yaml / notify.owner).
-     *  When false, no finding is emitted — an un-opted-in box is not "broken". */
     configured: boolean;
-    /** This box can actually deliver an owner notification right now. */
     reachable: boolean;
-    /** Resolved owner channel (e.g. `imessage`). */
     channel?: string;
-    /** Resolved transport after `notify.transports` mapping (usually === channel). */
     transport?: string;
-    /** Set only when `reachable` is false. */
     reason?: OwnerSinkReason;
 }
-/**
- * Probe whether THIS box can deliver an owner notification right now. Returns
- * `configured:false` (and the caller emits no finding) when the fleet has no
- * owner channel configured — an un-opted-in box is not broken. When configured,
- * reports whether the resolved transport can actually deliver from here.
- *
- * Only the concrete rush-backed failure the lane hits is reported as unreachable;
- * non-rush transports (desktop / mailbox / …) deliver locally and are treated as
- * reachable rather than probed, so this never invents a critical it cannot back.
- */
 export declare function probeOwnerSink(meta: Meta): Promise<OwnerSinkStatus>;

package/dist/lib/channels/owner-sink.js

@@ -2,99 +2,46 @@
  * Owner-delivery-sink reachability probe (RUSH-2262).
  *
  * The feed/notify owner-delivery lane (`agents send --to owner`, `agents feed post
- * --level important` / `--blocked`) reaches the owner over the rush-backed owner
- * channel (iMessage via `rush message send`). That transport can only deliver
- * from a context that BOTH finds the `rush` CLI on PATH and can read its
- * keychain-bound session. So a headless Linux fleet box (no rush) or a non-GUI
- * SSH session on a mac (login keychain locked) structurally cannot escalate —
- * and the failure is silent until a block is filed, surfacing only as the
- * after-the-fact `owner failed: …` line. `agents doctor` had no signal for it,
- * which is exactly the gap RUSH-2258 / RUSH-2262 flagged.
+ * --level important` / `--blocked`) reaches the owner through the channel
+ * providers registered for each configured channel in humans.yaml.
  *
- * At runtime the owner-delivery lane no longer strands this failure: when local
- * delivery fails on a box that structurally cannot reach the owner,
- * `forwardOwnerNotifyToPeer` (owner-forward.ts) hands it to a capable macOS peer
- * over SSH (PHNX-3303). This finding still stands as a diagnostic — the forward
- * is best-effort and only lands when a reachable mac peer exists, so a box that
- * cannot deliver locally is worth surfacing regardless.
+ * Transport capabilities differ by channel and platform:
+ *   - **imessage:** macOS only (osascript → Messages.app). Linux boxes rely on
+ *     the peer-forward in owner-forward.ts to reach a macOS peer.
+ *   - **slack:** requires a `SLACK_BOT_TOKEN` in env or the `webhooks` secrets
+ *     bundle. Platform-independent.
+ *   - **telegram / discord:** requires the Rush daemon (removed); only
+ *     openclaw-telegram is available as a Telegram alternative.
  *
- * This probes the SAME transport the lane uses, from the SAME context doctor runs
- * in, so `agents doctor` can fail loud when this box cannot reach the owner. It is
- * deliberately honest about context: `rush whoami` is what tells a real signed-in
- * session apart from a keychain that is present but unreadable HERE. The session
- * token is a keychain item, NOT `~/.rush/user.yaml` (RUSH-2262), so this never
- * reads that file — checking it is the mistake that made a signed-in box look
- * signed out.
- *
- * `agents send --to owner --dry-run` is NOT this probe: it short-circuits before the
- * `which rush` preflight (`providers/rush.ts`), so it reports `ok:true` on a box
- * with no rush at all. Resolvability (does the envelope build?) and reachability
- * (can this box actually deliver?) are different questions; this answers the
- * second.
+ * `agents send --to owner --dry-run` is NOT this probe: dry-run short-circuits
+ * before the capability check. Resolvability (does the envelope build?) and
+ * reachability (can this box actually deliver?) are different questions; this
+ * answers the second.
  */
-import { execFile } from 'child_process';
-import { promisify } from 'util';
+import { platform } from 'os';
 import { readOwnerDest } from './send.js';
-import { RUSH_CHANNELS } from './providers/rush.js';
-const execFileAsync = promisify(execFile);
-async function rushOnPath() {
-    try {
-        await execFileAsync('which', ['rush'], { timeout: 4000 });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/** Signed-in state from `rush whoami`, read with THIS context's keychain access.
- *  'unknown' (a timeout or output we can't classify) is treated as reachable by
- *  the caller — a slow or unexpected probe must not cry wolf and paint a false
- *  critical. Only a definitive "not logged in" is reported as signed out. */
-async function rushSignedIn() {
-    const classify = (s) => {
-        const out = s.toLowerCase();
-        if (/not (logged in|signed in)/.test(out))
-            return 'no';
-        if (/logged in as|session:\s*valid/.test(out))
-            return 'yes';
-        return 'unknown';
-    };
-    try {
-        const { stdout, stderr } = await execFileAsync('rush', ['whoami'], { timeout: 5000 });
-        return classify(`${stdout}\n${stderr}`);
-    }
-    catch (err) {
-        const e = err;
-        if (e.killed)
-            return 'unknown'; // timed out — do not conclude signed-out
-        // A signed-out rush commonly exits non-zero; trust an explicit message only.
-        return classify(`${e.stdout ?? ''}\n${e.stderr ?? ''}`);
-    }
-}
-/**
- * Probe whether THIS box can deliver an owner notification right now. Returns
- * `configured:false` (and the caller emits no finding) when the fleet has no
- * owner channel configured — an un-opted-in box is not broken. When configured,
- * reports whether the resolved transport can actually deliver from here.
- *
- * Only the concrete rush-backed failure the lane hits is reported as unreachable;
- * non-rush transports (desktop / mailbox / …) deliver locally and are treated as
- * reachable rather than probed, so this never invents a critical it cannot back.
- */
+import { RUSH_CHANNELS, resolveSlackToken } from './providers/rush.js';
 export async function probeOwnerSink(meta) {
     const dest = readOwnerDest(meta);
     if (!dest)
         return { configured: false, reachable: false };
     const channel = dest.channel;
     const transport = meta.notify?.transports?.[channel] ?? channel;
-    if (RUSH_CHANNELS.includes(transport)) {
-        if (!(await rushOnPath())) {
-            return { configured: true, reachable: false, channel, transport, reason: 'rush-not-on-path' };
-        }
-        if ((await rushSignedIn()) === 'no') {
-            return { configured: true, reachable: false, channel, transport, reason: 'rush-signed-out' };
+    if (!RUSH_CHANNELS.includes(transport)) {
+        return { configured: true, reachable: true, channel, transport };
+    }
+    if (transport === 'imessage') {
+        if (platform() !== 'darwin') {
+            return { configured: true, reachable: false, channel, transport, reason: 'imessage-not-macos' };
         }
         return { configured: true, reachable: true, channel, transport };
     }
-    return { configured: true, reachable: true, channel, transport };
+    if (transport === 'slack') {
+        if (resolveSlackToken()) {
+            return { configured: true, reachable: true, channel, transport };
+        }
+        return { configured: true, reachable: false, channel, transport, reason: 'slack-no-token' };
+    }
+    // telegram / discord — daemon removed, no direct transport.
+    return { configured: true, reachable: false, channel, transport, reason: 'channel-unsupported' };
 }

package/dist/lib/channels/providers/rush.d.ts

@@ -1,9 +1,9 @@
-import type { ChannelProvider, SendOptions } from '../registry.js';
-type RushChannel = 'telegram' | 'imessage' | 'slack' | 'discord';
+import type { ChannelProvider } from '../registry.js';
+export type RushChannel = 'telegram' | 'imessage' | 'slack' | 'discord';
 export declare const RUSH_CHANNELS: RushChannel[];
-/** Build the `rush send` argv (exported for tests). */
-export declare function buildRushSendArgs(channel: RushChannel, text: string, opts: SendOptions): string[];
-/** Build the owner-scoped iMessage argv. */
-export declare function buildRushOwnerMessageArgs(text: string): string[];
+/** Build the osascript argv for sending an iMessage. */
+export declare function buildImessageOsascriptArgs(text: string, phone: string): string[];
+export declare function resolveSlackToken(): string | undefined;
+/** Build the Slack chat.postMessage payload (exported for tests). */
+export declare function buildSlackPayload(channel: string, text: string, thread?: string): Record<string, string>;
 export declare const rushProviders: ChannelProvider[];
-export {};

package/dist/lib/channels/providers/rush.js

@@ -1,70 +1,140 @@
 /**
- * Rush channel providers — telegram / imessage / slack / discord.
+ * Channel providers formerly backed by the Rush daemon's live gateways.
  *
- * Addressable channels use `rush send`, which routes through the daemon's live
- * gateways. Owner-scoped iMessage uses `rush message send`; it is backed by the
- * verified Rush owner account and does not require a daemon channel registration.
+ * The desktop-era `rush message send` (iMessage) and `rush send --channel`
+ * (Slack/Telegram/Discord) commands were removed with the daemon in the
+ * thin-client trim (PHNX-3839/3933). This module now delivers directly:
+ *
+ *   - **imessage:** `osascript` → Messages.app (macOS only; Linux boxes
+ *     rely on the peer-forward in owner-forward.ts to reach a macOS peer).
+ *   - **slack:** Slack Web API `chat.postMessage` via `fetch()`, reading
+ *     `SLACK_BOT_TOKEN` from env or the `webhooks` secrets bundle.
+ *   - **telegram / discord:** error — no direct transport; openclaw-telegram
+ *     is available as a separate provider for Telegram.
  */
 import { execFile } from 'child_process';
+import { platform } from 'os';
 import { promisify } from 'util';
 const execFileAsync = promisify(execFile);
 export const RUSH_CHANNELS = ['telegram', 'imessage', 'slack', 'discord'];
-/** Build the `rush send` argv (exported for tests). */
-export function buildRushSendArgs(channel, text, opts) {
-    const args = ['send', text, '--channel', channel, '--id', opts.target, '--json'];
-    if (opts.thread)
-        args.push('--thread', opts.thread);
-    for (const a of opts.attachments ?? [])
-        args.push('--attachment', a);
-    return args;
+// ── iMessage via osascript ──────────────────────────────────────────────
+function escapeAppleScript(s) {
+    return s.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+/** Build the osascript argv for sending an iMessage. */
+export function buildImessageOsascriptArgs(text, phone) {
+    const escapedText = escapeAppleScript(text);
+    const escapedPhone = escapeAppleScript(phone);
+    const script = [
+        'tell application "Messages"',
+        `  set targetBuddy to buddy "${escapedPhone}" of (first account whose service type is iMessage)`,
+        `  send "${escapedText}" to targetBuddy`,
+        'end tell',
+    ].join('\n');
+    return ['-e', script];
+}
+async function sendImessage(text, opts) {
+    const channel = 'imessage';
+    if (opts.dryRun)
+        return { ok: true, channel, id: opts.target };
+    if (platform() !== 'darwin') {
+        return { ok: false, channel, id: opts.target, error: 'iMessage requires macOS (peer-forward handles Linux delivery)' };
+    }
+    if ((opts.attachments?.length ?? 0) > 0) {
+        return { ok: false, channel, id: opts.target, error: 'iMessage attachments not supported via osascript' };
+    }
+    try {
+        await execFileAsync('osascript', buildImessageOsascriptArgs(text, opts.target), { timeout: 10_000 });
+        return { ok: true, channel, id: opts.target };
+    }
+    catch (err) {
+        return { ok: false, channel, id: opts.target, error: err.message };
+    }
+}
+// ── Slack via Web API ───────────────────────────────────────────────────
+export function resolveSlackToken() {
+    // 1. Environment variable (set by `secrets exec` or the daemon).
+    if (process.env.SLACK_BOT_TOKEN) {
+        return process.env.SLACK_BOT_TOKEN;
+    }
+    // 2. Secrets bundle — the webhook receiver bundle carries SLACK_BOT_TOKEN
+    //    when a Slack app is configured for this fleet.
+    try {
+        // Dynamic import to avoid a hard dependency on the secrets subsystem in
+        // contexts where it is unavailable (CI, containers without a secrets store).
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { readAndResolveBundleEnvSync } = require('../../secrets-client.js');
+        const { env } = readAndResolveBundleEnvSync('webhooks', { caller: 'slack-provider', agentOnly: true });
+        if (env.SLACK_BOT_TOKEN) {
+            return env.SLACK_BOT_TOKEN;
+        }
+    }
+    catch {
+        // Bundle missing, store locked, or secrets CLI not available — not fatal.
+    }
+    return undefined;
+}
+/** Build the Slack chat.postMessage payload (exported for tests). */
+export function buildSlackPayload(channel, text, thread) {
+    const payload = { channel, text };
+    if (thread)
+        payload.thread_ts = thread;
+    return payload;
 }
-/** Build the owner-scoped iMessage argv. */
-export function buildRushOwnerMessageArgs(text) {
-    return ['message', 'send', '--text', text];
+async function sendSlack(text, opts) {
+    const channel = 'slack';
+    if (opts.dryRun)
+        return { ok: true, channel, id: opts.target };
+    const token = resolveSlackToken();
+    if (!token) {
+        return {
+            ok: false,
+            channel,
+            id: opts.target,
+            error: 'No SLACK_BOT_TOKEN — set it in env or the webhooks secrets bundle',
+        };
+    }
+    try {
+        const payload = buildSlackPayload(opts.target, text, opts.thread);
+        const res = await fetch('https://slack.com/api/chat.postMessage', {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${token}`,
+                'Content-Type': 'application/json; charset=utf-8',
+            },
+            body: JSON.stringify(payload),
+        });
+        const body = await res.json();
+        if (!body.ok) {
+            return { ok: false, channel, id: opts.target, error: `Slack API: ${body.error ?? 'unknown error'}` };
+        }
+        return { ok: true, channel, id: opts.target };
+    }
+    catch (err) {
+        return { ok: false, channel, id: opts.target, error: err.message };
+    }
 }
-function rushProvider(channel) {
+// ── Unsupported (daemon-era only) ───────────────────────────────────────
+function unsupportedProvider(name) {
     return {
-        name: channel,
-        async send(text, opts) {
-            if (opts.dryRun) {
-                return { ok: true, channel, id: opts.target, attachments: opts.attachments };
-            }
-            // Preflight: rush must be on PATH (mirrors notify.ts's openclaw check).
-            try {
-                await execFileAsync('which', ['rush']);
-            }
-            catch {
-                return { ok: false, channel, id: opts.target, error: 'rush CLI not found on PATH' };
-            }
-            try {
-                if (channel === 'imessage' && opts.ownerScoped) {
-                    if ((opts.attachments?.length ?? 0) > 0) {
-                        return {
-                            ok: false,
-                            channel,
-                            id: opts.target,
-                            error: 'owner-scoped iMessage does not support attachments',
-                        };
-                    }
-                    await execFileAsync('rush', buildRushOwnerMessageArgs(text));
-                    return { ok: true, channel, id: opts.target };
-                }
-                const { stdout } = await execFileAsync('rush', buildRushSendArgs(channel, text, opts));
-                const parsed = JSON.parse(stdout);
-                return {
-                    ok: parsed.ok === true,
-                    channel,
-                    id: opts.target,
-                    attachments: parsed.attachments,
-                    error: parsed.ok === true ? undefined : 'rush send returned ok=false',
-                };
-            }
-            catch (err) {
-                // Daemon down surfaces here as the exec error (ErrDaemonDown), as does a
-                // non-JSON stdout (parse throw). Fail loud — never silently reroute.
-                return { ok: false, channel, id: opts.target, error: err.message };
-            }
+        name,
+        async send(_text, opts) {
+            if (opts.dryRun)
+                return { ok: true, channel: name, id: opts.target };
+            return {
+                ok: false,
+                channel: name,
+                id: opts.target,
+                error: `${name} delivery requires the Rush daemon (removed); use openclaw-telegram for Telegram`,
+            };
         },
     };
 }
-export const rushProviders = RUSH_CHANNELS.map(rushProvider);
+// ── Provider registry ───────────────────────────────────────────────────
+const PROVIDERS = {
+    imessage: { name: 'imessage', send: sendImessage },
+    slack: { name: 'slack', send: sendSlack },
+    telegram: unsupportedProvider('telegram'),
+    discord: unsupportedProvider('discord'),
+};
+export const rushProviders = RUSH_CHANNELS.map((ch) => PROVIDERS[ch]);

package/dist/lib/claude-statusline.d.ts

@@ -30,7 +30,7 @@ interface ClaudeStatusLinePayload {
         };
     };
 }
-export declare function ingestClaudeStatusLineUsage(payload: ClaudeStatusLinePayload, identity: ClaudeHomeIdentity | null): boolean;
+export declare function ingestClaudeStatusLineUsage(payload: ClaudeStatusLinePayload, identity: ClaudeHomeIdentity | null, versionHome?: string | null): boolean;
 /**
  * Where the running Claude keeps the config this render attributes to: the version
  * home when the launch shim set CLAUDE_CONFIG_DIR, otherwise the real HOME — the