@cosmovex/agentpager 0.1.0 → 0.1.1

package/README.md

@@ -4,7 +4,7 @@ A pager for your AI coding agents. Approve what they want to do, reply, and hear
 on your phone, with the [AgentPager Android app](https://play.google.com/store/apps/details?id=com.cosmovex.mdpilot).
 
 ```bash
-npx agentpager
+npx @cosmovex/agentpager
 ```
 
 A QR code appears. Scan it in the app. Your sessions show up in a few seconds.
@@ -80,7 +80,7 @@ folder names only, so the picker can list your projects without sending any of t
 ## Keep it running
 
 ```bash
-npm install -g agentpager
+npm install -g @cosmovex/agentpager
 agentpager service install     # starts at login: macOS LaunchAgent, systemd user unit, Windows task
 agentpager service uninstall
 ```

package/dist/agents/acp.js

@@ -261,6 +261,17 @@ export class AcpAgent {
             clientCapabilities: { fs: { readTextFile: false, writeTextFile: false } },
         });
         let sessionId;
+        /** The agent's own model state, when it publishes one. Null means: this agent has no models API. */
+        let newModels = null;
+        const reportModels = () => {
+            const rows = newModels?.availableModels ?? [];
+            const items = rows
+                .filter((m) => m && typeof m.modelId === 'string')
+                .map((m) => ({ id: m.modelId, name: m.name || m.modelId, description: m.description ?? undefined }));
+            if (!items.length)
+                return;
+            sink.models({ items, current: newModels?.currentModelId ?? null, canSet: true });
+        };
         const canLoad = init?.agentCapabilities?.loadSession === true;
         if (id && canLoad) {
             await conn.loadSession({ sessionId: id, cwd: cwd ?? process.cwd(), mcpServers: [] });
@@ -270,7 +281,12 @@ export class AcpAgent {
             const created = await conn.newSession({ cwd: cwd ?? process.cwd(), mcpServers: [] });
             sessionId = created.sessionId;
             sink.identified(sessionId);
+            // ACP carries the model state on the session it just made, when the agent supports it at all
+            // (it is an unstable part of the protocol, so most do not). Unlike Codex there IS a verifiable
+            // setter here — session/set_model — so where the agent offers the state, the phone may choose.
+            newModels = created?.models ?? null;
         }
+        reportModels();
         proc.on('exit', () => {
             flush();
             sink.error(`${this.name} stopped on this computer.`);
@@ -300,6 +316,13 @@ export class AcpAgent {
                     sink.error(x.message, x.code);
                 });
             },
+            setModel: async (id) => {
+                await conn.setSessionModel({ sessionId, modelId: id });
+                // Believe the agent, not the tap: re-publish from our own state only after it accepted.
+                if (newModels)
+                    newModels.currentModelId = id;
+                reportModels();
+            },
             interrupt: async () => {
                 await conn.cancel({ sessionId }).catch(() => { });
             },

package/dist/agents/claude.js

@@ -138,6 +138,35 @@ export class ClaudeAgent {
         let lastText = '';
         /** What the deltas have already sent for the message currently being written. */
         let streamed = '';
+        /** The model in use, from the init message and from a switch the CLI accepted. */
+        let current = null;
+        // A resumed session's model, read from its own transcript.
+        //
+        // The SDK emits `system`/`init` — the one message that states the model — only when the first
+        // turn starts. So a session you opened and have not typed into yet would show no model at all,
+        // which is exactly the complaint this feature answers. Every assistant message in the transcript
+        // records the model that produced it, so the last one is what this session last ran on: a fact,
+        // not a guess, and init overwrites it the moment the real thing arrives.
+        if (id) {
+            void (async () => {
+                try {
+                    const messages = await getSessionMessages(id);
+                    for (let i = messages.length - 1; i >= 0; i--) {
+                        const model = messages[i]?.message?.model;
+                        if (typeof model === 'string' && model) {
+                            if (!current)
+                                current = model; // never clobber an init that already landed
+                            break;
+                        }
+                    }
+                    if (current)
+                        await reportModels();
+                }
+                catch {
+                    /* no transcript, or an unreadable one: the model simply shows up after the first turn */
+                }
+            })();
+        }
         const q = query({
             prompt: prompts,
             options: {
@@ -193,6 +222,12 @@ export class ClaudeAgent {
                     const msg = m;
                     if (msg.type === 'system' && msg.subtype === 'init' && msg.session_id) {
                         sink.identified(msg.session_id);
+                        // The only message that states which model this session is on. The initialize RESPONSE
+                        // lists the available models but not the chosen one, so this is the source of truth.
+                        if (typeof msg.model === 'string' && msg.model) {
+                            current = msg.model;
+                            void reportModels();
+                        }
                     }
                     else if (msg.type === 'system' && msg.subtype === 'session_state_changed') {
                         sink.state(msg.state === 'requires_action' ? 'needs_you' : msg.state === 'running' ? 'running' : 'idle');
@@ -242,14 +277,19 @@ export class ClaudeAgent {
                         // The one number people are desperate for. "I used up Max 5 in 1 hour of working,
                         // before I could work 8 hours" — the agent knew all along; nothing told the phone.
                         const rl = msg.rate_limits;
-                        if (msg.rate_limits_available && rl) {
-                            const win = (w) => (w ? { used: w.utilization ?? null, resetsAt: w.resets_at ?? null } : null);
-                            sink.limits({
-                                plan: msg.subscription_type ?? null,
-                                fiveHour: win(rl.five_hour),
-                                sevenDay: win(rl.seven_day),
-                            });
-                        }
+                        // Report the PLAN on every result, even when there are no rate-limit windows to report.
+                        //
+                        // This used to be inside `if (rate_limits_available)`, which made an API key — the one
+                        // case where dollars are real money — indistinguishable from "this session has not said
+                        // anything yet". The phone then fell back to showing a dollar estimate, and a $200/month
+                        // Max subscriber was told "$2092.12 of your $20.00 limit" in red. A plan of null now
+                        // positively means an API key, and no message at all means we do not know yet.
+                        const win = (w) => (w ? { used: w.utilization ?? null, resetsAt: w.resets_at ?? null } : null);
+                        sink.limits({
+                            plan: msg.subscription_type ?? null,
+                            fiveHour: msg.rate_limits_available && rl ? win(rl.five_hour) : null,
+                            sevenDay: msg.rate_limits_available && rl ? win(rl.seven_day) : null,
+                        });
                         const ok = msg.subtype === 'success' && !msg.is_error;
                         sink.done(ok, clip(String(msg.result ?? lastText ?? ''), 1200));
                     }
@@ -262,11 +302,61 @@ export class ClaudeAgent {
                 }
             }
         })();
+        /**
+         * Ask Claude Code what it can run, and report it.
+         *
+         * The list comes from the SDK every time rather than from anything we keep: model names change
+         * under us, and offering a model this account cannot run is worse than offering none. Failure is
+         * silent on purpose — not knowing the model must never stop a session from starting.
+         */
+        async function reportModels() {
+            try {
+                const models = await q.supportedModels();
+                if (!models?.length)
+                    return;
+                sink.models({
+                    items: models.map((m) => ({ id: m.value, name: m.displayName, description: m.description })),
+                    // Match the alias row's resolved id too: a session pinned to 'claude-sonnet-5' has to light
+                    // up the 'sonnet' row that covers it, or the picker shows nothing selected at all.
+                    current: current ? (models.find((m) => m.value === current || m.resolvedModel === current)?.value ?? current) : null,
+                    canSet: true,
+                });
+            }
+            catch {
+                /* an older CLI without supportedModels: no picker, everything else unaffected */
+            }
+        }
+        if (!id) {
+            // A session that has just been created has no pinned model, so the row the CLI itself labels
+            // `default` IS what it will run — a fact about a new session, not a guess. Without this the
+            // model bar stays empty until the first turn, which is the same "no model anywhere" the
+            // feature exists to fix.
+            void (async () => {
+                try {
+                    const models = await q.supportedModels();
+                    if (models?.some((m) => m.value === 'default') && !current) {
+                        current = 'default';
+                        await reportModels();
+                    }
+                }
+                catch {
+                    /* older CLI: the model appears after the first turn instead */
+                }
+            })();
+        }
         return {
             send: (text) => {
                 sink.state('running');
                 prompts.push(text);
             },
+            setModel: async (id) => {
+                // A control request the CLI resolves is its acceptance — it rejects a model the account
+                // cannot run, which is the difference from Codex, where the equivalent call returns {} for
+                // a bogus name and for `banana: 1` alike and is therefore not offered at all.
+                await q.setModel(id);
+                current = id;
+                await reportModels();
+            },
             interrupt: async () => {
                 await q.interrupt();
             },

package/dist/agents/codex.js

@@ -149,6 +149,26 @@ export class CodexAgent {
         this.lastRoute = created;
         if (!id)
             sink.identified(threadId);
+        // Which model this thread runs. Reported, never offered as a choice: `model/list` is real and
+        // honest, but the only way to change it — thread/settings/update — answers {} to a model that
+        // does not exist AND to `banana: 1`, and nothing Codex reports afterwards names a model. A
+        // switch that cannot be verified must not be presented as one, so canSet is false and the phone
+        // shows the model as a fact rather than a control. (Probed against codex-cli 0.138.0.)
+        void (async () => {
+            try {
+                const list = await rpc.request('model/list', {});
+                const rows = list?.data ?? [];
+                const items = rows
+                    .filter((m) => m && !m.hidden && typeof m.id === 'string')
+                    .map((m) => ({ id: m.id, name: m.displayName || m.id, description: m.description }));
+                if (!items.length)
+                    return;
+                sink.models({ items, current: items.length === 1 ? items[0].id : null, canSet: false });
+            }
+            catch {
+                /* an older codex without model/list: no model shown, nothing else affected */
+            }
+        })();
         return {
             send: (text) => {
                 sink.state('running');

package/dist/cli.js

@@ -93,6 +93,31 @@ async function serve(state, keepAwake) {
         hub.attach(c);
         c.start();
     }
+    // `agentpager pair` (a SEPARATE process, e.g. re-pairing after a reinstall while this one keeps
+    // running) writes the new device straight to disk. Without this, that pairing succeeds — the phone
+    // gets its "ok" — and then never connects, because this process's channel list was built once at
+    // startup and nothing ever told it a new device exists. The phone just sits on "Connecting…"
+    // forever with no way to know a restart was the missing step. Poll instead of a restart: cheap,
+    // and it means pairing a second (or reinstalled) phone never requires touching this window.
+    setInterval(() => {
+        let onDisk;
+        try {
+            onDisk = loadState();
+        }
+        catch {
+            return; // mid-write on another process; try again next tick
+        }
+        const known = new Set(state.devices.map((d) => d.id));
+        for (const d of onDisk.devices) {
+            if (known.has(d.id))
+                continue;
+            state.devices.push(d);
+            const c = new Channel(d, persist, (msg, ch) => hub.handle(msg, ch));
+            hub.attach(c);
+            c.start();
+            log(`paired while running: ${d.name}`);
+        }
+    }, 5000);
     const stopControl = serveControl((req) => hub.job(req));
     // Detect the ACP agents in the background and announce them as they appear.
     void (async () => {

package/dist/guard/limits.js

@@ -43,14 +43,23 @@ export function read() {
     }
 }
 export const fresh = (s, now = Date.now()) => !!s && now - s.at <= MAX_AGE_MS;
-/** The window closest to running out, as a percentage, or null when we cannot say. */
+/**
+ * The window closest to running out, as a percentage, or null when we cannot say.
+ *
+ * 🧨 This used to multiply by 100, on the assumption that `utilization` was a 0..1 fraction. It is
+ * not — the SDK says 0-100, and the phone has always read it that way (a 77 shows as "23% of your
+ * plan left"). So a real reading of 45 became 4500, and ANY planCapPercent denied every tool call
+ * the moment one usage reading existed: the feature built for "claude has usage limit, it is not in
+ * dollars" would have bricked the agent instead of capping it. The unit tests missed it because they
+ * fed fractions and asserted the product — they agreed with the bug rather than with the provider.
+ */
 export function worstUsedPct(s, now = Date.now()) {
     if (!fresh(s, now))
         return null;
     const vals = [s.fiveHour?.used, s.sevenDay?.used].filter((v) => typeof v === 'number');
     if (!vals.length)
         return null;
-    return Math.round(Math.max(...vals) * 100);
+    return Math.round(Math.max(...vals));
 }
 /** Which window is the one running out, for a message that tells you something you can act on. */
 export function worstWindow(s, now = Date.now()) {

package/dist/hub.js

@@ -71,6 +71,8 @@ export class Hub {
                     return;
                 case 'new':
                     return await this.startNew(msg.agent, msg.cwd, from, msg.ref);
+                case 'set_model':
+                    return await this.setModel(msg, from);
                 case 'rules_get':
                     return from.send(this.rulesReply());
                 case 'rules_set':
@@ -500,6 +502,12 @@ export class Hub {
                 // and it is a tiny message.
                 this.broadcast({ type: 'limits', sid: live.sid, plan: l.plan, fiveHour: l.fiveHour, sevenDay: l.sevenDay });
             },
+            models: (m) => {
+                // Not onlyActive: this is small, it changes rarely, and it is the first thing the session
+                // header shows when the app comes back — a phone that reopens to "model: —" looks broken.
+                live.models = m;
+                this.broadcast({ type: 'models', sid: live.sid, items: m.items.slice(0, 40), current: m.current, canSet: m.canSet });
+            },
             commands: (items) => {
                 this.flush(live);
                 this.broadcast({ type: 'commands', sid: live.sid, items: items.slice(0, 120) }, true);
@@ -542,6 +550,31 @@ export class Hub {
             },
         };
     }
+    /**
+     * Change a live session's model, then say what is actually in use.
+     *
+     * The reply is always a fresh `models` read back from the agent rather than an echo of what was
+     * asked for: a switch that silently did not take must show as the old model, or the phone reports
+     * a change that never happened — and the model is the one setting that decides how fast the plan
+     * window empties.
+     */
+    async setModel(msg, from) {
+        const live = this.live.get(msg.sid);
+        if (!live?.session?.setModel) {
+            return from.send({ type: 'error', sid: msg.sid, code: 'model', message: 'This agent cannot change model from the phone.' });
+        }
+        try {
+            await live.session.setModel(msg.model);
+            this.log(`model → ${msg.model}`);
+        }
+        catch (e) {
+            from.send({ type: 'error', sid: msg.sid, code: 'model', message: `Could not switch model: ${String(e?.message ?? e)}` });
+            // Fall through: re-report anyway, so the phone snaps back to the model still in use.
+        }
+        if (live.models) {
+            this.broadcast({ type: 'models', sid: live.sid, items: live.models.items.slice(0, 40), current: live.models.current, canSet: live.models.canSet });
+        }
+    }
     drop(live) {
         if (Hub.busy(live.state))
             this.awake.release();

package/dist/risk.js

@@ -26,20 +26,60 @@ export function classify(tool, input) {
         return 'danger';
     return 'shell';
 }
-/** One short line a person can read at a glance (or hear): never a whole file. */
+/**
+ * One short line a person can read at a glance (or hear): never a whole file.
+ *
+ * The summary carries the *point* of the call, not its syntax. This used to say "Run a command" for
+ * every single Bash approval — so a page at a red light read "Run a command" over a line of shell,
+ * and deciding meant parsing the shell yourself. Sumanth: "claude asked for approval for execution
+ * but it should tell context of what the command does".
+ *
+ * The context was already in the payload: Claude Code's Bash tool takes a `description` written by
+ * the model in plain English for exactly this reader ("Discard all local changes and match remote
+ * main"), and we were dropping it on the floor. Prefer it, always — the command still travels as
+ * the detail for anyone who wants to read it.
+ */
 export function describe(tool, input) {
     const clip = (s, n) => (s.length > n ? `${s.slice(0, n - 1)}…` : s);
     const path = String(input.file_path ?? input.path ?? input.notebook_path ?? '');
+    /** The agent's own one-line account of what it is about to do, if it wrote one. */
+    const said = () => {
+        for (const key of ['description', 'reason', 'explanation', 'justification']) {
+            const v = input[key];
+            if (typeof v !== 'string')
+                continue;
+            // One line only: a paragraph is not a summary, and the card has a detail pane for the rest.
+            const line = v.replace(/\s+/g, ' ').trim();
+            if (line.length > 2)
+                return clip(line, 140);
+        }
+        return null;
+    };
     switch (tool) {
         case 'Bash':
         case 'shell':
-            return { summary: 'Run a command', detail: clip(String(input.command ?? ''), 2000) };
+            return { summary: said() ?? 'Run a command', detail: clip(String(input.command ?? ''), 2000) };
         case 'Edit':
         case 'MultiEdit':
-        case 'edit':
-            return { summary: `Edit ${basename(path) || 'files'}`, detail: clip(String(input.detail ?? '') || path, 2000) };
-        case 'Write':
-            return { summary: `Write ${basename(path)}`, detail: clip(path, 2000) };
+        case 'edit': {
+            const file = basename(path) || 'files';
+            return {
+                summary: said() ?? `Edit ${file}`,
+                // What the edit actually changes, not just which file it lands in. Approving a change you
+                // cannot see is a tap, not a decision.
+                detail: clip(String(input.detail ?? '') || diffOf(input) || path, 2000),
+            };
+        }
+        case 'Write': {
+            const file = basename(path);
+            const body = String(input.content ?? '');
+            return {
+                summary: said() ?? `Write ${file}`,
+                // The path alone was the whole detail here, so the card named a file and showed nothing of
+                // what was going into it.
+                detail: clip(body ? `${path}\n\n${body}` : path, 2000),
+            };
+        }
         case 'WebFetch':
             return { summary: 'Fetch a web page', detail: clip(String(input.url ?? ''), 500) };
         default:
@@ -76,3 +116,12 @@ export function readable(input) {
         .join('\n');
 }
 const basename = (p) => p.split(/[\\/]/).filter(Boolean).pop() ?? '';
+/** An Edit's before/after, short enough to read on a phone. */
+function diffOf(input) {
+    const before = typeof input.old_string === 'string' ? input.old_string : '';
+    const after = typeof input.new_string === 'string' ? input.new_string : '';
+    if (!before && !after)
+        return '';
+    const side = (s) => (s.length > 400 ? `${s.slice(0, 399)}…` : s);
+    return `- ${side(before)}\n+ ${side(after)}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmovex/agentpager",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Pager for your AI coding agents \u2014 approve, reply and hear results on your phone. End-to-end encrypted.",
   "main": "dist/cli.js",
   "scripts": {