@prohost/cli 0.14.0 → 0.16.0

package/dist/codehost/history.js

@@ -0,0 +1,98 @@
+/**
+ * A viewer's local scroll-back (CONTRACTS-R2 R1): the pane's history as text, so the viewer
+ * scrolls it on its own screen instead of driving tmux copy mode over the network (one wheel
+ * step per round trip, and copy mode is the PANE's: one viewer's scroll froze everyone's view).
+ *
+ * - client → server: `{"type":"history","id":<string>,"lines":<int, capped 10000>}`;
+ * - server → that client only: `{"type":"history","id","text","cols","rows"}`, the history and
+ *   visible screen as `tmux capture-pane -p -e -J -S -<lines>` prints them (SGR colours kept,
+ *   wrapped lines joined), or `{"type":"history","id","error":"<code>"}`.
+ *
+ * Answered only to a viewer that said `hello` (an older page never sees one), and bounded: a
+ * frame never exceeds {@link HISTORY_MAX_FRAME_BYTES}; the oldest lines go first.
+ */
+import { windowTarget } from './tmux.js';
+/** Most lines a viewer may ask for. */
+export const HISTORY_MAX_LINES = 10_000;
+/** Lines asked for when a request names none (or an unusable number). */
+export const HISTORY_DEFAULT_LINES = 2_000;
+/**
+ * Largest answer, as sent (JSON): the relay carries it over Redis and the cloud pipe's upstream
+ * socket takes at most 1 MiB, so this stays well under both.
+ */
+export const HISTORY_MAX_FRAME_BYTES = 768 * 1024;
+/** A request id: what the viewer matches its answer by. */
+export const HISTORY_ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
+/** `lines` as asked, within 1..{@link HISTORY_MAX_LINES}. */
+export function clampHistoryLines(raw) {
+    const n = typeof raw === 'number' && Number.isFinite(raw) ? Math.trunc(raw) : Number.NaN;
+    if (!Number.isFinite(n) || n < 1)
+        return HISTORY_DEFAULT_LINES;
+    return Math.min(n, HISTORY_MAX_LINES);
+}
+/** A `history` request frame's fields, or `null` when it can't be answered (no usable id). */
+export function parseHistoryRequest(frame) {
+    if (frame.type !== 'history' || typeof frame.id !== 'string' || !HISTORY_ID_PATTERN.test(frame.id))
+        return null;
+    return { type: 'history', id: frame.id, lines: clampHistoryLines(frame.lines) };
+}
+/**
+ * `-p` print, `-e` keep the SGR escapes (colours, bold), `-J` join wrapped lines (the viewer
+ * wraps them at its own width), `-S -<lines>` from that far back in the history to the screen's end.
+ */
+export function captureHistoryArgs(name, lines) {
+    return ['capture-pane', '-p', '-e', '-J', '-S', `-${clampHistoryLines(lines)}`, '-t', windowTarget(name)];
+}
+/** The pane's size, and whether a program (vim, less) holds its alternate screen: `<cols> <rows> <0|1>`. */
+export function paneGeometryArgs(name) {
+    return ['display-message', '-p', '-t', windowTarget(name), '#{pane_width} #{pane_height} #{alternate_on}'];
+}
+export function parsePaneGeometry(stdout) {
+    const match = /^(\d+) (\d+) ([01])$/.exec(stdout.trim());
+    if (!match)
+        return null;
+    const cols = Number(match[1]);
+    const rows = Number(match[2]);
+    if (cols < 1 || rows < 1)
+        return null;
+    return { cols, rows, alternate: match[3] === '1' };
+}
+const frameBytes = (frame) => Buffer.byteLength(JSON.stringify(frame), 'utf8');
+/**
+ * The answer to request `id`, at most `maxBytes` as JSON: whole lines are dropped from the top
+ * (the oldest) until it fits. tmux ends its capture with a newline, which is not a line.
+ */
+export function historyFrame(id, result, maxBytes = HISTORY_MAX_FRAME_BYTES) {
+    if (!result.ok)
+        return { type: 'history', id, error: result.error };
+    let lines = result.text.replace(/\r/g, '').replace(/\n$/, '').split('\n');
+    const build = () => ({ type: 'history', id, text: lines.join('\n'), cols: result.cols, rows: result.rows });
+    let frame = build();
+    let size = frameBytes(frame);
+    while (size > maxBytes && lines.length > 1) {
+        // Proportionally, with a margin, so a big history takes a few passes rather than thousands.
+        const keep = Math.max(1, Math.min(lines.length - 1, Math.floor((lines.length * maxBytes) / size) - 1));
+        lines = lines.slice(lines.length - keep);
+        frame = build();
+        size = frameBytes(frame);
+    }
+    if (size > maxBytes)
+        return { type: 'history', id, error: 'capture_failed' };
+    return frame;
+}
+/**
+ * Read `lines` of window `name`'s history. A pane in the alternate screen (a full-screen program)
+ * has no scroll-back to show: the viewer falls back to sending it the wheel.
+ */
+export async function readHistory(tmux, name, lines) {
+    const geometryRead = await tmux(paneGeometryArgs(name));
+    const geometry = geometryRead.ok ? parsePaneGeometry(geometryRead.stdout ?? '') : null;
+    if (!geometry)
+        return { ok: false, error: 'capture_failed' };
+    if (geometry.alternate)
+        return { ok: false, error: 'alternate_screen' };
+    const capture = await tmux(captureHistoryArgs(name, lines));
+    if (!capture.ok)
+        return { ok: false, error: 'capture_failed' };
+    return { ok: true, text: capture.stdout ?? '', cols: geometry.cols, rows: geometry.rows };
+}

package/dist/codehost/hooks.d.ts

@@ -73,8 +73,14 @@ export declare function hookShimPath(env?: NodeJS.ProcessEnv): string;
 export declare function claudeSettingsPath(env?: NodeJS.ProcessEnv): string;
 /** The shim script: env-guarded, then the current CLI's `hook` command. */
 export declare function hookShimScript(nodePath: string, cliEntrypoint: string): string;
-/** The `--settings` document Claude Code is launched with: hooks only. */
-export declare function claudeHookSettings(shimPath: string, invocationProtocol?: boolean): Record<string, unknown>;
+/**
+ * The `--settings` document Claude Code is launched with: hooks only, and, for a window started
+ * without permission prompts (`skipsPermissions`), the owner's acceptance of Claude Code's one-time
+ * bypass-mode warning: `skipDangerousModePermissionPrompt` ("whether the user has accepted the
+ * bypass permissions mode dialog", Claude Code's settings schema; read from `--settings` too). Only
+ * that window's document carries it: every other window launches without bypass mode, as before.
+ */
+export declare function claudeHookSettings(shimPath: string, invocationProtocol?: boolean, skipsPermissions?: boolean): Record<string, unknown>;
 /** Codex `-c notify=[...]` value (TOML array), naming the shim. */
 export declare function codexNotifyOverride(shimPath: string): string;
 /** Write the shim and Claude settings. Called on every daemon start. */
@@ -82,6 +88,8 @@ export declare function installHookFiles(nodePath: string, cliEntrypoint: string
     shim: string;
     claudeSettings: string;
     claudeInvocationSettings: string;
+    claudeSkipSettings: string;
+    claudeInvocationSkipSettings: string;
 };
 /** Last non-empty line, clipped — the inbox row's preview. */
 export declare function previewOf(text: string): string | undefined;

package/dist/codehost/hooks.js

@@ -123,8 +123,14 @@ export function hookShimScript(nodePath, cliEntrypoint) {
         '',
     ].join('\n');
 }
-/** The `--settings` document Claude Code is launched with: hooks only. */
-export function claudeHookSettings(shimPath, invocationProtocol = false) {
+/**
+ * The `--settings` document Claude Code is launched with: hooks only, and, for a window started
+ * without permission prompts (`skipsPermissions`), the owner's acceptance of Claude Code's one-time
+ * bypass-mode warning: `skipDangerousModePermissionPrompt` ("whether the user has accepted the
+ * bypass permissions mode dialog", Claude Code's settings schema; read from `--settings` too). Only
+ * that window's document carries it: every other window launches without bypass mode, as before.
+ */
+export function claudeHookSettings(shimPath, invocationProtocol = false, skipsPermissions = false) {
     const hooks = {};
     for (const name of CLAUDE_HOOK_EVENTS) {
         // The PermissionRequest hook waits for a decision from ProhostAI (`--wait`), within its own
@@ -154,7 +160,7 @@ export function claudeHookSettings(shimPath, invocationProtocol = false) {
         hooks.PostToolUse = [{ hooks: [{
                         type: 'command', command: `${shellQuote(shimPath, 'darwin')} claude PostToolUse`, timeout: 10,
                     }] }];
-    return { hooks };
+    return skipsPermissions ? { hooks, skipDangerousModePermissionPrompt: true } : { hooks };
 }
 /** Codex `-c notify=[...]` value (TOML array), naming the shim. */
 export function codexNotifyOverride(shimPath) {
@@ -173,7 +179,12 @@ export function installHookFiles(nodePath, cliEntrypoint, env = process.env) {
     writePrivateJson(claudeSettings, claudeHookSettings(shim));
     const claudeInvocationSettings = path.join(codeHostDir(env), 'claude-invocation-settings.json');
     writePrivateJson(claudeInvocationSettings, claudeHookSettings(shim, true));
-    return { shim, claudeSettings, claudeInvocationSettings };
+    // The same two for a window started without permission prompts (`agentCommandLine`).
+    const claudeSkipSettings = path.join(codeHostDir(env), 'claude-settings-skip-permissions.json');
+    writePrivateJson(claudeSkipSettings, claudeHookSettings(shim, false, true));
+    const claudeInvocationSkipSettings = path.join(codeHostDir(env), 'claude-invocation-settings-skip-permissions.json');
+    writePrivateJson(claudeInvocationSkipSettings, claudeHookSettings(shim, true, true));
+    return { shim, claudeSettings, claudeInvocationSettings, claudeSkipSettings, claudeInvocationSkipSettings };
 }
 // ── Parsing what the agents hand their hooks ───────────────────────────────
 function asObject(value) {

package/dist/codehost/host.d.ts

@@ -45,6 +45,13 @@ export declare const HOST_INSTANCE_CAPABILITY_PREFIX = "host_instance_";
  * sends a folder start only to a socket that declared it.
  */
 export declare const CODE_THREAD_FOLDERS_CAPABILITY = "code_thread_folders";
+/**
+ * Declared beside {@link REMOTE_TERMINAL_CAPABILITY} (only while remote control is on) by a host
+ * that reads `skipPermissions` in `code_thread.start_requested`: Claude Code and Codex then start
+ * without permission prompts (`agentCommandLine`); with remote control off they always ask. The
+ * server records a thread as skipping only for a socket that declared it.
+ */
+export declare const CODE_THREAD_SKIP_PERMISSIONS_CAPABILITY = "code_thread_skip_permissions";
 /** `code_thread.start_requested` data (camelCase per the contract), or `null`. */
 export declare function parseStartRequest(data: Record<string, unknown>): StartRequest | null;
 /** `code_thread.input_requested` data, or `null`. */
@@ -86,6 +93,18 @@ export interface CodeHostLike {
      * (`agents.ts`), re-checked on every status frame: what the server offers for this Mac.
      */
     agentCapabilities?(): string[];
+    /** Terminal sessions open on this machine now (`prohost host` counts them against capacity). */
+    liveTerminals?(): Array<{
+        terminalId: string;
+        codeThreadId: string;
+        agent: string;
+    }>;
+    /**
+     * Report a start as failed without starting anything (the computer is
+     * paused), the way a failed start is reported: the thread never waits in
+     * `starting`. Resolves whether the report landed.
+     */
+    failStart?(data: Record<string, unknown>, reason: string): Promise<boolean>;
 }
 /** `code_thread.approval_decided` data, or `null`. */
 export declare function parseApprovalDecision(data: Record<string, unknown>): ApprovalRequest | null;
@@ -131,6 +150,13 @@ export interface CodeHostOptions {
     onCodeHostChanged?: () => void;
     /** The selected account's environment (see `CodeTerminalsOptions.accountEnv`). */
     accountEnv?: (agent: CodeAgent) => AccountEnvResult;
+    /** See `CodeHostRelayOptions.fallbackApiKey`. */
+    fallbackApiKey?: string;
+    /**
+     * The computer is paused (`prohost host pause`): no new viewer may dial in.
+     * Terminals already open, replies and approvals carry on.
+     */
+    paused?: () => boolean;
     tmux?: TmuxRunner;
     spawnPty?: () => PtySpawn | undefined;
     events?: CodeThreadEventSink;
@@ -183,6 +209,11 @@ export declare class CodeHost implements CodeHostLike {
     constructor(options: CodeHostOptions);
     settings(): CodeHostSettings;
     remoteTerminalAllowed(): boolean;
+    liveTerminals(): Array<{
+        terminalId: string;
+        codeThreadId: string;
+        agent: string;
+    }>;
     instanceCapability(): string;
     /**
      * Only the agents a start would accept: installed here, and runnable on this harness's login
@@ -265,6 +296,7 @@ export declare class CodeHost implements CodeHostLike {
      * Throws {@link UnreportedOutcomeError} when the outcome never reached the
      * server, so the harness asks for the delivery again rather than ack it.
      */
+    failStart(data: Record<string, unknown>, reason: string): Promise<boolean>;
     handleStart(data: Record<string, unknown>): Promise<boolean>;
     handleInput(data: Record<string, unknown>, deliveryId?: string): Promise<boolean>;
     handleApproval(data: Record<string, unknown>, deliveryId?: string): Promise<boolean>;

package/dist/codehost/host.js

@@ -24,7 +24,7 @@ import { LocalTerminalServer } from './local_server.js';
 import { loadNodePty } from './pty.js';
 import { CodeHostRelay } from './relay.js';
 import { codeHostDir, codeHostInstanceId, ensurePrivateDir, loadSettings } from './settings.js';
-import { CodeTerminals, execTmux } from './terminals.js';
+import { CodeTerminals, execTmux, isDefinitive } from './terminals.js';
 import { APPROVAL_DECISIONS, isValidId, socketNameFor, TMUX_CONF } from './tmux.js';
 export const EVENT_CODE_THREAD_START_REQUESTED = 'code_thread.start_requested';
 export const EVENT_CODE_THREAD_INPUT_REQUESTED = 'code_thread.input_requested';
@@ -56,6 +56,13 @@ export const HOST_INSTANCE_CAPABILITY_PREFIX = 'host_instance_';
  * sends a folder start only to a socket that declared it.
  */
 export const CODE_THREAD_FOLDERS_CAPABILITY = 'code_thread_folders';
+/**
+ * Declared beside {@link REMOTE_TERMINAL_CAPABILITY} (only while remote control is on) by a host
+ * that reads `skipPermissions` in `code_thread.start_requested`: Claude Code and Codex then start
+ * without permission prompts (`agentCommandLine`); with remote control off they always ask. The
+ * server records a thread as skipping only for a socket that declared it.
+ */
+export const CODE_THREAD_SKIP_PERMISSIONS_CAPABILITY = 'code_thread_skip_permissions';
 function text(value) {
     return typeof value === 'string' ? value : undefined;
 }
@@ -78,6 +85,8 @@ export function parseStartRequest(data) {
         branch: text(data.branch) || undefined,
         agent,
         ...(folder ? { folder, separateCopy: data.separateCopy === true } : {}),
+        // Only an explicit `true` skips the prompts: a server before the choice sends nothing.
+        ...(data.skipPermissions === true ? { skipPermissions: true } : {}),
     };
 }
 /** `code_thread.input_requested` data, or `null`. */
@@ -180,6 +189,7 @@ export class CodeHost {
             checkouts: this.checkouts,
             events: this.events,
             hookFiles: { claudeSettings: hookFiles.claudeSettings, claudeInvocationSettings: hookFiles.claudeInvocationSettings,
+                claudeSkipSettings: hookFiles.claudeSkipSettings, claudeInvocationSkipSettings: hookFiles.claudeInvocationSkipSettings,
                 hookShim: hookFiles.shim, codexNotify: codexNotifyOverride(hookFiles.shim) },
             accountEnv: options.accountEnv,
             agentInstalled: (agent) => resolvesOnPath(AGENT_BINARIES[agent], this.env),
@@ -194,6 +204,11 @@ export class CodeHost {
     remoteTerminalAllowed() {
         return this.settings().allowRemoteTerminal;
     }
+    liveTerminals() {
+        return this.terminals
+            .list()
+            .map((record) => ({ terminalId: record.terminalId, codeThreadId: record.codeThreadId, agent: record.agent }));
+    }
     instanceCapability() {
         return `${HOST_INSTANCE_CAPABILITY_PREFIX}${this.instanceId}`;
     }
@@ -233,6 +248,8 @@ export class CodeHost {
             this.relay = new CodeHostRelay({
                 baseUrl: this.options.baseUrl,
                 apiKey: this.options.apiKey,
+                ...(this.options.fallbackApiKey ? { fallbackApiKey: this.options.fallbackApiKey } : {}),
+                ...(this.options.paused ? { dialsPaused: this.options.paused } : {}),
                 machineId: this.options.machineId,
                 instanceId: this.instanceId,
                 machine: this.options.machine,
@@ -517,6 +534,14 @@ export class CodeHost {
      * Throws {@link UnreportedOutcomeError} when the outcome never reached the
      * server, so the harness asks for the delivery again rather than ack it.
      */
+    async failStart(data, reason) {
+        const request = parseStartRequest(data);
+        if (!request)
+            return true;
+        const status = await this.events.post(request.codeThreadId, event('failed', { reason }, Date.now()));
+        // Retryable answers (401 while the token renews, 408, 429, 5xx) leave the delivery to be retried.
+        return isDefinitive(status);
+    }
     async handleStart(data) {
         const request = parseStartRequest(data);
         if (!request)

package/dist/codehost/host_stats.d.ts

@@ -6,8 +6,10 @@
  * number comes from a stock tool or Node's `os` module; anything that can't be
  * read is `null`, never 0. macOS sources: `vm_stat` (memory in use),
  * `sysctl kern.memorystatus_vm_pressure_level` (pressure), `pmset -g batt`
- * (battery), `sysctl machdep.cpu.brand_string` (spec). Elsewhere only the
- * `os`-module numbers are reported.
+ * (battery), `sysctl machdep.cpu.brand_string` (spec). Linux: `/proc/meminfo`
+ * (memory in use), `/proc/pressure/memory` (pressure, PSI), and
+ * `/sys/class/power_supply` (battery). Windows: `typeperf` performance counters
+ * (memory in use, commit charge → pressure) and PowerShell's `Win32_Battery`.
  */
 import os from 'node:os';
 export type MemoryPressure = 'normal' | 'elevated' | 'critical';
@@ -31,6 +33,47 @@ export declare function parsePmset(text: string): {
     batteryPct: number | null;
     onBattery: boolean | null;
 };
+/**
+ * Linux PSI (`/proc/pressure/memory`): the share of the last 10 s some / all
+ * runnable tasks stalled on memory. `full` stalls mean the machine is
+ * thrashing; sustained `some` stalls mean reclaim is getting in the way.
+ */
+export declare function pressureFromPsi(text: string): MemoryPressure | null;
+/** Bytes in use per `/proc/meminfo`: MemTotal − MemAvailable (what `free` calls used). */
+export declare function usedFromMeminfo(text: string): number | undefined;
+/** `/sys/class/power_supply/BAT*`: its `capacity` and `status`, and whether any AC supply is online. */
+export declare function linuxBattery(supplies: Array<{
+    name: string;
+    type?: string;
+    capacity?: string;
+    status?: string;
+    online?: string;
+}>): {
+    batteryPct: number | null;
+    onBattery: boolean | null;
+};
+/**
+ * One `typeperf -sc 1` sample of `\Memory\Available MBytes` and
+ * `\Memory\% Committed Bytes In Use`: the last CSV row, quoted values.
+ */
+export declare function parseTypeperf(text: string): {
+    availableMb?: number;
+    committedPct?: number;
+};
+/**
+ * Windows has no single pressure level, so it is read from what the memory
+ * manager is short of: physical memory left, and the commit charge against
+ * its limit (past which allocations fail outright).
+ */
+export declare function windowsPressure(sample: {
+    availableMb?: number;
+    committedPct?: number;
+}, totalBytes: number | undefined): MemoryPressure | null;
+/** PowerShell `Win32_Battery` as `<BatteryStatus>,<EstimatedChargeRemaining>`; 1 = discharging. */
+export declare function parseWindowsBattery(text: string): {
+    batteryPct: number | null;
+    onBattery: boolean | null;
+};
 /** e.g. `Apple M3 Max · 64 GB`. */
 export declare function specFrom(brand: string | undefined, totalBytes: number | undefined): string | null;
 interface CpuSample {
@@ -51,6 +94,10 @@ export interface HostStatsSamplerOptions {
         busy: number;
         total: number;
     } | undefined;
+    /** Reads a small system file (`/proc`, `/sys`); `undefined` when it can't. */
+    readFile?: (file: string) => string | undefined;
+    /** Lists a directory (`/sys/class/power_supply`); empty when it can't. */
+    listDir?: (dir: string) => string[];
 }
 /** Samples on demand. Keeps the previous CPU sample so each call reports the interval since the last. */
 export declare class HostStatsSampler {

package/dist/codehost/host_stats.js

@@ -6,11 +6,15 @@
  * number comes from a stock tool or Node's `os` module; anything that can't be
  * read is `null`, never 0. macOS sources: `vm_stat` (memory in use),
  * `sysctl kern.memorystatus_vm_pressure_level` (pressure), `pmset -g batt`
- * (battery), `sysctl machdep.cpu.brand_string` (spec). Elsewhere only the
- * `os`-module numbers are reported.
+ * (battery), `sysctl machdep.cpu.brand_string` (spec). Linux: `/proc/meminfo`
+ * (memory in use), `/proc/pressure/memory` (pressure, PSI), and
+ * `/sys/class/power_supply` (battery). Windows: `typeperf` performance counters
+ * (memory in use, commit charge → pressure) and PowerShell's `Win32_Battery`.
  */
 import { execFile } from 'node:child_process';
+import { readdirSync, readFileSync } from 'node:fs';
 import os from 'node:os';
+import path from 'node:path';
 const GB = 1024 ** 3;
 const round1 = (value) => Math.round(value * 10) / 10;
 /** Bytes in use per `vm_stat`: active + wired + compressed (what Activity Monitor calls used). */
@@ -49,6 +53,96 @@ export function parsePmset(text) {
         onBattery: source === undefined ? null : source === 'Battery Power',
     };
 }
+/**
+ * Linux PSI (`/proc/pressure/memory`): the share of the last 10 s some / all
+ * runnable tasks stalled on memory. `full` stalls mean the machine is
+ * thrashing; sustained `some` stalls mean reclaim is getting in the way.
+ */
+export function pressureFromPsi(text) {
+    const avg10 = (kind) => {
+        const match = new RegExp(`^${kind}\\s.*?avg10=([0-9.]+)`, 'm').exec(text);
+        return match ? Number.parseFloat(match[1]) : undefined;
+    };
+    const some = avg10('some');
+    const full = avg10('full');
+    if (some === undefined && full === undefined)
+        return null;
+    if ((full ?? 0) >= 10 || (some ?? 0) >= 50)
+        return 'critical';
+    if ((full ?? 0) >= 2 || (some ?? 0) >= 10)
+        return 'elevated';
+    return 'normal';
+}
+/** Bytes in use per `/proc/meminfo`: MemTotal − MemAvailable (what `free` calls used). */
+export function usedFromMeminfo(text) {
+    const kb = (label) => {
+        const match = new RegExp(`^${label}:\\s+(\\d+) kB`, 'm').exec(text);
+        return match ? Number.parseInt(match[1], 10) * 1024 : undefined;
+    };
+    const total = kb('MemTotal');
+    const available = kb('MemAvailable');
+    return total !== undefined && available !== undefined ? Math.max(0, total - available) : undefined;
+}
+/** `/sys/class/power_supply/BAT*`: its `capacity` and `status`, and whether any AC supply is online. */
+export function linuxBattery(supplies) {
+    const battery = supplies.find((s) => (s.type ?? '').trim() === 'Battery' || /^BAT/i.test(s.name));
+    if (!battery)
+        return { batteryPct: null, onBattery: null };
+    const pct = Number.parseInt((battery.capacity ?? '').trim(), 10);
+    const acOnline = supplies.some((s) => (s.type ?? '').trim() === 'Mains' && (s.online ?? '').trim() === '1');
+    const status = (battery.status ?? '').trim();
+    return {
+        batteryPct: Number.isFinite(pct) ? Math.min(100, Math.max(0, pct)) : null,
+        onBattery: status ? status === 'Discharging' && !acOnline : null,
+    };
+}
+/**
+ * One `typeperf -sc 1` sample of `\Memory\Available MBytes` and
+ * `\Memory\% Committed Bytes In Use`: the last CSV row, quoted values.
+ */
+export function parseTypeperf(text) {
+    const rows = text
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.startsWith('"'));
+    if (rows.length < 2)
+        return {};
+    const cells = (row) => row.split('","').map((cell) => cell.replace(/^"|"$/g, ''));
+    const header = cells(rows[0]);
+    const values = cells(rows[rows.length - 1]);
+    const read = (needle) => {
+        const index = header.findIndex((name) => name.toLowerCase().includes(needle));
+        const value = index >= 0 ? Number.parseFloat(values[index] ?? '') : Number.NaN;
+        return Number.isFinite(value) ? value : undefined;
+    };
+    return { availableMb: read('available mbytes'), committedPct: read('% committed bytes in use') };
+}
+/**
+ * Windows has no single pressure level, so it is read from what the memory
+ * manager is short of: physical memory left, and the commit charge against
+ * its limit (past which allocations fail outright).
+ */
+export function windowsPressure(sample, totalBytes) {
+    const { availableMb, committedPct } = sample;
+    if (availableMb === undefined && committedPct === undefined)
+        return null;
+    const availablePct = availableMb !== undefined && totalBytes ? (availableMb * 1024 * 1024 * 100) / totalBytes : undefined;
+    if ((availablePct !== undefined && availablePct < 5) || (committedPct ?? 0) >= 95)
+        return 'critical';
+    if ((availablePct !== undefined && availablePct < 12) || (committedPct ?? 0) >= 85)
+        return 'elevated';
+    return 'normal';
+}
+/** PowerShell `Win32_Battery` as `<BatteryStatus>,<EstimatedChargeRemaining>`; 1 = discharging. */
+export function parseWindowsBattery(text) {
+    const match = /(\d+)\s*,\s*(\d+)/.exec(text.trim());
+    if (!match)
+        return { batteryPct: null, onBattery: null };
+    return {
+        batteryPct: Math.min(100, Number.parseInt(match[2], 10)),
+        onBattery: Number.parseInt(match[1], 10) === 1,
+    };
+}
 /** e.g. `Apple M3 Max · 64 GB`. */
 export function specFrom(brand, totalBytes) {
     const parts = [brand?.trim(), totalBytes ? `${Math.round(totalBytes / GB)} GB` : undefined].filter(Boolean);
@@ -76,6 +170,25 @@ const defaultRun = (file, args) => new Promise((resolve) => {
         resolve(error ? undefined : String(stdout));
     });
 });
+const defaultReadFile = (file) => {
+    try {
+        return readFileSync(file, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+};
+const defaultListDir = (dir) => {
+    try {
+        return readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+};
+const POWER_SUPPLY_DIR = '/sys/class/power_supply';
+const TYPEPERF_COUNTERS = ['\\Memory\\Available MBytes', '\\Memory\\% Committed Bytes In Use'];
+const WINDOWS_BATTERY_SCRIPT = 'Get-CimInstance Win32_Battery | Select-Object -First 1 | ForEach-Object { "$($_.BatteryStatus),$($_.EstimatedChargeRemaining)" }';
 /** Samples on demand. Keeps the previous CPU sample so each call reports the interval since the last. */
 export class HostStatsSampler {
     options;
@@ -135,6 +248,44 @@ export class HostStatsSampler {
                 this.spec = specFrom(brand || undefined, total);
             }
         }
+        else if (this.platform === 'linux') {
+            const read = this.options.readFile ?? defaultReadFile;
+            const meminfo = read('/proc/meminfo');
+            used = meminfo ? usedFromMeminfo(meminfo) : undefined;
+            if (used === undefined) {
+                const free = safe(this.freemem);
+                used = total !== undefined && free !== undefined ? total - free : undefined;
+            }
+            const psi = read('/proc/pressure/memory');
+            memoryPressure = psi ? pressureFromPsi(psi) : null;
+            const list = this.options.listDir ?? defaultListDir;
+            battery = linuxBattery(list(POWER_SUPPLY_DIR).map((name) => {
+                const field = (key) => read(path.join(POWER_SUPPLY_DIR, name, key));
+                return { name, type: field('type'), capacity: field('capacity'), status: field('status'), online: field('online') };
+            }));
+            if (this.spec === undefined)
+                this.spec = specFrom(safe(() => os.cpus()[0]?.model), total);
+        }
+        else if (this.platform === 'win32') {
+            const [counters, power] = await Promise.all([
+                this.run('typeperf', [...TYPEPERF_COUNTERS, '-sc', '1']),
+                this.run('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', WINDOWS_BATTERY_SCRIPT]),
+            ]);
+            const sample = counters ? parseTypeperf(counters) : {};
+            used =
+                sample.availableMb !== undefined && total !== undefined
+                    ? Math.max(0, total - sample.availableMb * 1024 * 1024)
+                    : undefined;
+            if (used === undefined) {
+                const free = safe(this.freemem);
+                used = total !== undefined && free !== undefined ? total - free : undefined;
+            }
+            memoryPressure = windowsPressure(sample, total);
+            if (power)
+                battery = parseWindowsBattery(power);
+            if (this.spec === undefined)
+                this.spec = specFrom(safe(() => os.cpus()[0]?.model), total);
+        }
         else {
             const free = safe(this.freemem);
             used = total !== undefined && free !== undefined ? total - free : undefined;

package/dist/codehost/relay.d.ts

@@ -53,7 +53,12 @@ export interface DialFrame {
 }
 /** A `dial` frame, or `null` when it is not one this host can act on. */
 export declare function parseDial(frame: Record<string, unknown>): DialFrame | null;
-/** Pipe one terminal stream over one open socket until either side ends. */
+/**
+ * Pipe one terminal stream over one open socket until either side ends.
+ *
+ * Text controls in: `resize`, `input`, `hello`, `claim`, `history` (answered with the pane's
+ * scroll-back, only once the viewer said hello: an older page never sees one), `ping`.
+ */
 export declare function pipeStream(ws: WebSocket, stream: TerminalStream, onClosed: (reason: string) => void): void;
 /** Whose pairing this is, as the relay's `auth_ok` names it. */
 export interface PairingIdentity {
@@ -86,6 +91,14 @@ export declare function parseViewerVerdict(frame: Record<string, unknown>): View
 export interface CodeHostRelayOptions {
     baseUrl: string;
     apiKey: string;
+    /**
+     * A second credential for a relay that refuses `apiKey`: `prohost host`
+     * authenticates as the computer, and falls back to the adopted agent
+     * pairing's key on a server that doesn't take computer keys here yet.
+     */
+    fallbackApiKey?: string;
+    /** No new viewer dials in while this says so (the computer is paused); open streams carry on. */
+    dialsPaused?: () => boolean;
     machineId: string;
     /**
      * This home's CLI instance (see `codeHostInstanceId`): its presence and control
@@ -130,6 +143,8 @@ export declare class CodeHostRelay {
     /** Bumped by {@link dropStreams}: a dial begun before a drop never opens. */
     private generation;
     private refused;
+    /** Authenticating with {@link CodeHostRelayOptions.fallbackApiKey} after `apiKey` was refused. */
+    private usingFallback;
     private readonly log;
     private readonly Ctor;
     private readonly setTimer;