@pi-chamber/web 0.2.2 → 0.3.0

package/server/lib/pi/routes.js

@@ -135,6 +135,23 @@ const projectUsage = (raw) => {
   };
 };
 
+const sanitizeNavigation = (value) => {
+  if (!value || typeof value !== 'object' || typeof value.targetEntryId !== 'string' || value.targetEntryId.length === 0) return null;
+  const previousLeafId = value.previousLeafId === null ? null : (typeof value.previousLeafId === 'string' ? value.previousLeafId : null);
+  const newLeafId = value.newLeafId === null ? null : (typeof value.newLeafId === 'string' ? value.newLeafId : null);
+  if (previousLeafId !== null && typeof previousLeafId !== 'string') return null;
+  if (newLeafId !== null && typeof newLeafId !== 'string') return null;
+  const editorText = typeof value.editorText === 'string' ? value.editorText : undefined;
+  // Limit editorText defensively; Pi prompts are bounded and we never persist this.
+  if (editorText !== undefined && editorText.length > 200_000) return null;
+  return {
+    targetEntryId: value.targetEntryId,
+    previousLeafId,
+    newLeafId,
+    ...(editorText !== undefined ? { editorText } : {}),
+  };
+};
+
 const projectSessionDetail = (value) => {
   if (!value || typeof value !== 'object' || !Array.isArray(value.messages) || !Number.isSafeInteger(value.lastSequence)) throw protocolMismatch();
   const messages = value.messages.map((item) => {
@@ -495,7 +512,6 @@ export const registerPiRuntimeRoutes = (app, {
         currentVersion: typeof req.query.currentVersion === 'string' ? req.query.currentVersion : undefined,
         appType: typeof req.query.appType === 'string' ? req.query.appType : undefined,
         platform: typeof req.query.platform === 'string' ? req.query.platform : undefined,
-        reportUsage: req.query.reportUsage === 'true',
       }));
     } catch {
       res.status(503).json({ error: 'Update check unavailable' });
@@ -567,6 +583,16 @@ export const registerPiRuntimeRoutes = (app, {
     }
   });
 
+  app.post('/api/pi/providers/refresh', async (req, res) => {
+    const directory = typeof req.body?.directory === 'string' && req.body.directory.length > 0 ? req.body.directory : undefined;
+    try {
+      const result = await getDaemonRuntime(getPiSessionDaemonRuntime).request('providers.refresh', directory ? { directory } : undefined);
+      res.json(projectProviders(result));
+    } catch (error) {
+      writeDaemonError(res, error);
+    }
+  });
+
   app.get('/api/pi/providers/:providerId/config', async (req, res) => {
     const providerId = req.params.providerId;
     if (typeof providerId !== 'string' || providerId.length === 0) {
@@ -891,7 +917,11 @@ export const registerPiRuntimeRoutes = (app, {
 
   app.post('/api/pi/sessions/:sessionId/navigate', async (req, res) => {
     const result = await requestSessionOperation(req, res, getPiSessionDaemonRuntime, 'sessions.navigate', { messageId: req.body?.messageId });
-    if (result !== undefined) res.json(projectSessionDetail(result));
+    if (result === undefined) return;
+    const detail = projectSessionDetail(result);
+    const navigation = sanitizeNavigation(result.navigation);
+    if (navigation) detail.navigation = navigation;
+    res.json(detail);
   });
 
   for (const [suffix, command] of [['fork', 'sessions.fork'], ['clone', 'sessions.clone']]) {

package/server/lib/pi/session-daemon/DOCUMENTATION.md

@@ -27,7 +27,7 @@ This module is the Pi-owned session-daemon foundation. A detached local daemon p
 - Frames are LF-delimited JSON. They have a 1 MiB maximum buffered size. A malformed, oversized, unauthenticated, or invalid request closes the connection.
 - The private core commands are `runtime.health`, `projects.list/select`, `providers.list/config.get/models.set/status/login/login.respond/login.status/logout`, `settings.get/set`, `resources.list/update/prompts.create/prompts.delete`, and session list/create/open/rename/delete/tree/navigate/fork/clone/prompt/steer/followUp/abort/model/thinking/compact operations. Resource lists use opaque IDs and never disclose server paths. Only top-level Pi prompt templates and applicable AGENTS.md sources are editable; package/path resources and skills are browse-only. Resource writes are rejected while a session streams, use an atomic replace, then recreate the idle runtime. Project trust changes are persisted in Pi trust.json and likewise recreate an idle runtime; extensions remain disabled regardless of trust. Provider login submits API keys only across authenticated private IPC or brokers Pi's OAuth/device/manual-code interaction; public projections contain only opaque login IDs, prompts, URLs/device codes, model catalog/configuration, and stable states, never credentials or write-only headers. `providers.models.set` is rejected while a session streams, atomically persists Pi's `models.json`, then rehydrates the idle runtime so the catalog is authoritative immediately. `providers.list` projects only catalog and authentication-status metadata, including Pi-supported `thinkingLevels` (`null` map entries hidden, `xhigh`/`max` opt-in). Session thinking overrides are clamped to the live model's supported levels. `sessions.list` checks each cwd JSONL header (not the full transcript) so a project with large session logs cannot spend tens of seconds on startup. SDK `SessionManager.list` is not used for that path; `listPiSessionJsonlDirectory` reads a header, a bounded prefix for the first user prompt, and a tail for the latest rename. Concurrent lists of the same directory share one in-flight result. Concurrent `sessions.open` of the same id share one in-flight runtime create; a duplicate that finishes later disposes itself and returns the registered runtime instead of `SESSION_RUNTIME_CONFLICT`. Full-file JSONL validation stays on open of a chosen session. The browser explicitly selects an existing user-chosen project directory before listing it; the daemon's startup cwd is an internal fallback, not a user-visible default project. Unnamed persisted sessions use their first prompt as a readable list title when available. `sessions.open` and `getSession` project the last assistant `provider`/`model`/`thinkingLevel` onto the session record so reopening a chat keeps that cache identity. Session selection validates a persisted JSONL path before Pi opens it; inactive mutations are never directed by a browser-supplied path. `sessions.open` resolves an id by Pi's `timestamp_<id>.jsonl` filename first so a missing deep link 404s without listing or fully reading every transcript in every cwd; SDK list and header scan remain the fallback for non-standard names. Directory-wide JSONL checks on list/create/startup are header-only; full-file validation stays on open of a chosen transcript. Attachment paths originate in the server-local upload map and cross only private IPC into Pi's tool context. Pi may persist or echo those paths in its authoritative JSONL transcript, so every public projection redacts them recursively: session titles/previews, user and assistant text/thinking, tool arguments, errors, snapshots, and live message events never expose the server-local path. The daemon maps Pi message lifecycle, deltas, tools, queue changes, model/thinking, compaction, interruption state, and session title updates (`session.updated` on create-with-title, first-prompt auto-title, and rename) to canonical events. Tool events carry redacted input arguments, cumulative partial-output snapshots, final output, error text, renderer metadata (edit diffs, truncation notes), and start/end timestamps. Persisted `toolResult` entries merge into their assistant `toolCall` parts as output/error/end time so hydrated sessions render complete tool cards; tool-result entries never surface as standalone messages. Assistant message projections and start events carry the owning user-message id so the restored turn renderer can group and display replies; all assistant entries in a tool loop remain attached to the latest user turn. Assistant message projections also pass through Pi's per-turn `Usage` (input, output, cacheRead, cacheWrite, totalTokens, and the same five numeric cost fields). The daemon sanitizes the raw payload through `projectUsage` before publication: every numeric must be finite and non-negative, the whole object is omitted when any field is missing or wrong type, and unknown keys are never copied. The `assistant.message.end` event carries the same sanitized usage so the last turn updates without waiting for a full `getSession` refetch. The public route whitelist re-applies the same sanitizer on each projection so a stale or malformed payload from a different daemon version cannot surface as `NaN` or `Infinity` in the reducer.
 - Each event and reconnect snapshot has a monotonic sequence. A reconnect receives a bounded contiguous replay after its cursor when available, otherwise an authoritative `session.snapshot`; unavailable runtimes are not represented as empty sessions.
-- Prompt, steer, and follow-up requests acknowledge acceptance immediately after Pi accepts the call; the daemon owns the still-running send promise and publishes any asynchronous rejection as `session.error`. A later prompt on the same session invalidates that rejection so it cannot error the new turn. If the rejected send left Pi streaming, the daemon aborts it. Steer/follow-up against an idle session starts a new prompt instead of `SESSION_NOT_RUNNING`. Agent completion is never held behind the 30-second public/private request budgets.
+- Prompt, steer, and follow-up requests acknowledge acceptance immediately after Pi accepts the call; the daemon owns the still-running send promise and publishes any asynchronous rejection as `session.error`. A later prompt on the same session invalidates that rejection so it cannot error the new turn. If the rejected send left Pi streaming, the daemon aborts it. Steer/follow-up against an idle session starts a new prompt instead of `SESSION_NOT_RUNNING`. Agent completion is never held behind the 30-second public/private request budgets. Pi retryable provider failures remain live: an `agent_end` with `willRetry` does not publish terminal `session.error`, and `auto_retry_start` projects Pi's attempt, next-attempt time, and redacted error text through `session.lifecycle: retry`. `agent_settled` remains the authoritative idle boundary after retry success, exhaustion, or cancellation.
 - Registry keys combine the SDK session ID with its cwd. A replacement subscription is rebound to the replacement session so old-session events cannot be published under the new identity. A collision is a visible error; it never replaces or disposes an unrelated runtime.
 - After `agent_settled`, the daemon disposes an idle runtime after five minutes (injectable for tests). Disposal never deletes Pi JSONL; the daemon remembers the selected session file and recreates that runtime on the next private prompt. A new agent start cancels a pending disposal.
 - A startup validation failure writes only a stable failure code to the owner-only non-secret state sidecar. It never records a transcript, session path, or credential. The supervisor surfaces that code as unavailable instead of claiming an empty or idle session.

package/server/lib/pi/session-daemon/runtime-registry.js

@@ -140,6 +140,9 @@ export function createSessionRuntimeRegistry({ onSessionEvent = () => {} } = {})
     register,
     dispose,
     disposeAll,
+    listAll() {
+      return [...recordsByKey.values()].map((record) => record.runtime);
+    },
     get size() {
       return recordsByKey.size;
     },

package/server/lib/pi/session-daemon/session-daemon.js

@@ -631,7 +631,11 @@ export function createSessionDaemon({
   };
 
   const projectMessageEntries = (session, targetDir = activeDirectory || cwd) => {
-    const persisted = session?.sessionManager?.getEntries?.();
+    // Use the active branch, not the full file. `getEntries()` returns every
+    // entry ever written, so a bare `branch()`/`resetLeaf()` would appear to
+    // do nothing. `getBranch()` follows the current leaf and is what
+    // `navigateTree` and `buildSessionContext` use for the model context.
+    const persisted = session?.sessionManager?.getBranch?.() ?? session?.sessionManager?.getEntries?.();
     const entries = liveProjectionEntries(session, Array.isArray(persisted) ? persisted : []);
     if (entries.length === 0) return [];
     const streaming = session?.isStreaming === true;
@@ -820,6 +824,84 @@ export function createSessionDaemon({
     return { providers: [...providers.values()] };
   };
 
+  let refreshProvidersInflight = null;
+  const refreshProviders = async (requestedDirectory) => {
+    if (refreshProvidersInflight) return refreshProvidersInflight;
+    const task = (async () => {
+      const signal = typeof AbortSignal.timeout === 'function' ? AbortSignal.timeout(15_000) : undefined;
+      const runtimes = new Set();
+      for (const services of servicesCache.values()) {
+        const mr = services?.modelRuntime;
+        if (mr) runtimes.add(mr);
+      }
+      if (runtime?.session?.modelRuntime) runtimes.add(runtime.session.modelRuntime);
+      if (runtime?.services?.modelRuntime) runtimes.add(runtime.services.modelRuntime);
+      if (runtimeRegistry?.listAll) {
+        try {
+          for (const tracked of runtimeRegistry.listAll()) {
+            const mr = tracked?.session?.modelRuntime ?? tracked?.services?.modelRuntime;
+            if (mr) runtimes.add(mr);
+          }
+        } catch {}
+      }
+      if (runtimes.size === 0) {
+        const active = await ensureRuntime(requestedDirectory ? await resolveDirectory(requestedDirectory) : undefined);
+        const mr = active?.session?.modelRuntime ?? active?.services?.modelRuntime;
+        if (mr) runtimes.add(mr);
+      }
+      const dummyMap = new Map();
+      for (const mr of runtimes) {
+        try {
+          const providers = typeof mr.getProviders === 'function' ? mr.getProviders() : [];
+          for (const provider of providers) {
+            const auth = mr.getProviderAuthStatus?.(provider.id);
+            if (auth?.configured === true) continue;
+            try {
+              await mr.setRuntimeApiKey(provider.id, 'pichamber-catalog-refresh');
+              let list = dummyMap.get(mr);
+              if (!list) { list = []; dummyMap.set(mr, list); }
+              list.push(provider.id);
+            } catch {}
+          }
+        } catch {}
+      }
+      const errors = new Map();
+      let aborted = false;
+      try {
+        await Promise.all([...runtimes].map(async (mr) => {
+          try {
+            const result = await mr.refresh({ allowNetwork: true, force: true, ...(signal ? { signal } : {}) });
+            if (result?.aborted) aborted = true;
+            if (result?.errors) {
+              for (const [providerId, err] of result.errors) errors.set(providerId, err);
+            }
+          } catch (error) {
+            if (error?.code === 'PI_MODEL_CONFIG_INVALID') throw error;
+            errors.set('_global', error);
+          }
+        }));
+      } finally {
+        for (const [mr, ids] of dummyMap.entries()) {
+          for (const id of ids) {
+            try { await mr.removeRuntimeApiKey(id); } catch {}
+          }
+        }
+      }
+      if (errors.has('_global') && runtimes.size > 0) {
+        const globalError = errors.get('_global');
+        if (globalError?.code === 'PI_MODEL_CONFIG_INVALID') {
+          throw new SessionDaemonProtocolError('PI_MODEL_CONFIG_INVALID', 'Pi models configuration is invalid.');
+        }
+      }
+      const catalog = await listProviders(requestedDirectory);
+      return catalog;
+    })().finally(() => {
+      refreshProvidersInflight = null;
+    });
+    refreshProvidersInflight = task;
+    return task;
+  };
+
   const getProviderConfiguration = async (providerId) => {
     if (typeof providerId !== 'string' || providerId.length === 0 || providerId.length > 256) {
       throw new SessionDaemonProtocolError('INVALID_ARGUMENT', 'The requested provider is invalid.');
@@ -1101,9 +1183,21 @@ export function createSessionDaemon({
     if (!loader || typeof loader.getSkills !== 'function' || typeof loader.getPrompts !== 'function' || typeof loader.getAgentsFiles !== 'function') {
       throw new SessionDaemonProtocolError('DAEMON_REQUEST_FAILED', 'Pi resource discovery is unavailable.');
     }
-    const skills = loader.getSkills().skills.map((skill) => ({
-      id: resourceId('skill', skill.filePath),
-      kind: 'skill', name: skill.name, ...(skill.description ? { description: skill.description } : {}), location: resourceLocation(skill.sourceInfo), editable: false,
+    const skills = await Promise.all(loader.getSkills().skills.map(async (skill) => {
+      let content = '';
+      try {
+        content = await readFile(skill.filePath, 'utf8');
+      } catch {}
+      return {
+        id: resourceId('skill', skill.filePath),
+        kind: 'skill',
+        name: skill.name,
+        ...(skill.description ? { description: skill.description } : {}),
+        location: resourceLocation(skill.sourceInfo),
+        editable: false,
+        ...(content ? { content } : {}),
+        filePath: skill.filePath,
+      };
     }));
     const prompts = loader.getPrompts().prompts.map((prompt) => ({
       id: resourceId('prompt', prompt.filePath),
@@ -1642,11 +1736,19 @@ export function createSessionDaemon({
         const finalMessage = event.messages?.at?.(-1);
         if (finalMessage?.role === 'assistant' && finalMessage.stopReason === 'aborted') {
           publish('session.interrupted', { reason: 'user-abort', streaming: false }, sessionId, directory);
-        } else if (finalMessage?.role === 'assistant' && typeof finalMessage.errorMessage === 'string') {
+        } else if (finalMessage?.role === 'assistant' && typeof finalMessage.errorMessage === 'string' && event.willRetry !== true) {
           publish('session.error', { code: 'ASSISTANT_ERROR', message: redactAttachmentPaths(finalMessage.errorMessage) }, sessionId, directory);
         }
         break;
       }
+      case 'auto_retry_start':
+        publish('session.lifecycle', {
+          state: 'retry',
+          attempt: event.attempt,
+          next: Date.now() + event.delayMs,
+          message: redactAttachmentPaths(event.errorMessage),
+        }, sessionId, directory);
+        break;
       case 'agent_settled':
         publish('session.lifecycle', { state: 'idle' }, sessionId, directory);
         scheduleIdleDisposal(sessionId);
@@ -1684,7 +1786,7 @@ export function createSessionDaemon({
               'projects.list', 'projects.select', 'sessions.list', 'sessions.create', 'sessions.open', 'sessions.rename', 'sessions.delete',
               'sessions.tree', 'sessions.navigate', 'sessions.fork', 'sessions.clone', 'sessions.prompt',
               'sessions.steer', 'sessions.followUp', 'sessions.abort', 'sessions.setModel',
-              'sessions.setThinking', 'sessions.compact', 'providers.list', 'providers.config.get', 'providers.models.set', 'providers.status', 'providers.login',
+              'sessions.setThinking', 'sessions.compact', 'providers.list', 'providers.refresh', 'providers.config.get', 'providers.models.set', 'providers.status', 'providers.login',
               'providers.login.respond', 'providers.login.status', 'providers.logout', 'settings.get', 'settings.set',
               'resources.list', 'resources.update', 'resources.prompts.create', 'resources.prompts.delete',
             ],
@@ -1716,6 +1818,11 @@ export function createSessionDaemon({
         writeFrame(socket, { protocolVersion: PROTOCOL_VERSION, kind: 'response', requestId: message.requestId, result });
         return;
       }
+      case 'providers.refresh': {
+        const result = await refreshProviders(message.payload?.directory);
+        writeFrame(socket, { protocolVersion: PROTOCOL_VERSION, kind: 'response', requestId: message.requestId, result });
+        return;
+      }
       case 'providers.config.get': {
         const result = await getProviderConfiguration(message.payload?.providerId);
         writeFrame(socket, { protocolVersion: PROTOCOL_VERSION, kind: 'response', requestId: message.requestId, result });
@@ -1817,11 +1924,44 @@ export function createSessionDaemon({
       }
       case 'sessions.navigate': {
         const activeRuntime = await activateSession(message.payload?.sessionId, message.payload?.directory || message.payload?.cwd);
-        const messageId = message.payload?.messageId;
+        let messageId = message.payload?.messageId;
         if (typeof messageId !== 'string' || messageId.length === 0) throw new SessionDaemonProtocolError('INVALID_ARGUMENT', 'The requested tree entry is invalid.');
-        const result = await activeRuntime.session.navigateTree(messageId);
-        if (result.cancelled) throw new SessionDaemonProtocolError('SESSION_TREE_NOT_FOUND', 'Pi cancelled tree navigation.');
-        writeFrame(socket, { protocolVersion: PROTOCOL_VERSION, kind: 'response', requestId: message.requestId, result: projectActiveSession(activeRuntime, activeRuntime.cwd) });
+        // UI may pass a part id like "c865141a:text:1" (e.g. from a tool block).
+        // Pi only knows entry ids, so strip the suffix and retry the entry lookup.
+        const tryIds = [messageId];
+        if (messageId.includes(':')) {
+          const entryId = messageId.split(':')[0];
+          if (entryId && entryId !== messageId) tryIds.unshift(entryId);
+        }
+        const previousLeafId = activeRuntime.session.sessionManager?.getLeafId?.() ?? null;
+        let result;
+        let lastError;
+        for (const tryId of tryIds) {
+          try {
+            result = await activeRuntime.session.navigateTree(tryId);
+            messageId = tryId;
+            lastError = undefined;
+            break;
+          } catch (error) {
+            lastError = error;
+            // Only retry on "Entry not found" with a stripped id; otherwise surface immediately.
+            const isEntryNotFound = String(error?.message ?? '').includes('not found');
+            if (!isEntryNotFound || tryId === tryIds[tryIds.length - 1]) {
+              console.error(`[pi:navigate] target=${tryId} leaf=${previousLeafId} branch=${activeRuntime.session.sessionManager?.getBranch?.()?.map((e) => e.id).join(',') ?? 'unknown'} error=${error?.message ?? String(error)}`);
+              throw error;
+            }
+          }
+        }
+        if (lastError) throw lastError;
+        if (result?.cancelled) throw new SessionDaemonProtocolError('SESSION_TREE_NOT_FOUND', 'Pi cancelled tree navigation.');
+        const newLeafId = activeRuntime.session.sessionManager?.getLeafId?.() ?? null;
+        const navigation = {
+          targetEntryId: messageId,
+          previousLeafId: typeof previousLeafId === 'string' ? previousLeafId : null,
+          newLeafId: typeof newLeafId === 'string' ? newLeafId : null,
+          ...(typeof result?.editorText === 'string' && result.editorText.length > 0 ? { editorText: result.editorText } : {}),
+        };
+        writeFrame(socket, { protocolVersion: PROTOCOL_VERSION, kind: 'response', requestId: message.requestId, result: { ...projectActiveSession(activeRuntime, activeRuntime.cwd), navigation } });
         return;
       }
       case 'sessions.fork':

package/server/lib/pi/session-daemon/session-daemon.test.js

@@ -971,6 +971,28 @@ describe('Pi session daemon spike', () => {
     await client.close();
   });
 
+  it('keeps retryable provider failures in retry lifecycle until Pi exhausts retry', async () => {
+    const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-retry-'));
+    const endpoint = testDaemonEndpoint(root);
+    const session = new FakeSession('pi-session-retry');
+    daemon = createSessionDaemon({ endpoint, credential, cwd: root, createRuntime: async () => ({ session, async dispose() {} }) });
+    await daemon.start();
+    const client = connectClient(endpoint);
+    await client.authenticate();
+    await client.request('sessions.create', { cwd: root });
+
+    const retryLifecycle = client.next((frame) => frame.event === 'session.lifecycle' && frame.payload.state === 'retry');
+    const prematureError = client.next((frame) => frame.event === 'session.error');
+    session.emit({ type: 'agent_end', willRetry: true, messages: [{ role: 'assistant', stopReason: 'error', errorMessage: 'Rate limit exceeded' }] });
+    session.emit({ type: 'auto_retry_start', attempt: 1, maxAttempts: 3, delayMs: 2_000, errorMessage: 'Rate limit exceeded' });
+
+    await expect(retryLifecycle).resolves.toMatchObject({
+      payload: { state: 'retry', attempt: 1, message: 'Rate limit exceeded' },
+    });
+    await expect(prematureError).rejects.toThrow(/Timed out/);
+    await client.close();
+  });
+
   it('preserves assistant messageId for tool executions occurring after message_end', async () => {
     const root = await mkdtemp(join(tmpdir(), 'pichamber-pi-daemon-'));
     const endpoint = testDaemonEndpoint(root);

package/server/lib/tunnels/DOCUMENTATION.md

@@ -5,16 +5,15 @@ This module contains the shared tunnel support surface for PiChamber: provider
 capability metadata, tunnel types/normalization helpers, cross-platform
 executable discovery, and dependency install-help metadata.
 
-The actual tunnel start implementations live in
-`packages/web/server/lib/cloudflare-tunnel.js` and
-`packages/web/server/lib/ngrok-tunnel.js`; CLI orchestration lives in
+The tunnel start implementation lives in
+`packages/web/server/lib/cloudflare-tunnel.js`; CLI orchestration lives in
 `packages/web/bin/lib/commands-tunnel.js`.
 
 > Wiring note: the previous service orchestration entrypoint
 > (`tunnels/index.js`, `createTunnelService`) was removed as dead code — no
 > runtime entrypoint registered tunnel routes or started a tunnel service.
 > The remaining files are consumed by the CLI capability surface and by the
-> tunnel provider implementations, not by a tunnel orchestration runtime.
+> Cloudflare tunnel provider implementation, not by a tunnel orchestration runtime.
 
 ## Entrypoints and structure
 - `packages/web/server/lib/tunnels/executable-search.js`: cross-platform executable discovery, including Windows Store app aliases. Consumed by the tunnel providers and `packages/web/server/lib/workspace/host.js`.
@@ -24,10 +23,10 @@ The actual tunnel start implementations live in
 ## Public exports
 - `install-help.js` → `getTunnelDependencyInstallInfo(provider, platform)`
 - `executable-search.js` → `getExecutableSearchDirectories`, `createExecutableSearchEnv`, `findExecutableOnPath`, `resolveExecutableLaunchTarget`
-- `types.js` → `TUNNEL_PROVIDER_CLOUDFLARE`, `TUNNEL_PROVIDER_NGROK`, `TUNNEL_MODE_QUICK`, `TUNNEL_MODE_MANAGED_REMOTE`, `TUNNEL_MODE_MANAGED_LOCAL`, `TUNNEL_INTENT_EPHEMERAL_PUBLIC`, `TUNNEL_INTENT_PERSISTENT_PUBLIC`, `TunnelServiceError`
+- `types.js` → `TUNNEL_PROVIDER_CLOUDFLARE`, `TUNNEL_MODE_QUICK`, `TUNNEL_MODE_MANAGED_REMOTE`, `TUNNEL_MODE_MANAGED_LOCAL`, `TUNNEL_INTENT_EPHEMERAL_PUBLIC`, `TUNNEL_INTENT_PERSISTENT_PUBLIC`, `TunnelServiceError`
 
 ## Consumers
-- `packages/web/bin/lib/cli-tunnel-capabilities.js`: provider capability metadata for CLI tunnel commands.
-- `packages/web/server/lib/cloudflare-tunnel.js` / `packages/web/server/lib/ngrok-tunnel.js`: executable discovery, install-help metadata, and provider constants.
+- `packages/web/bin/lib/cli-tunnel-capabilities.js`: provider capability metadata for CLI tunnel commands (Cloudflare only).
+- `packages/web/server/lib/cloudflare-tunnel.js`: executable discovery, install-help metadata, and provider constants.
 - `packages/web/server/lib/workspace/host.js`: executable discovery.
 

package/server/lib/tunnels/executable-search.test.js

@@ -36,7 +36,7 @@ describe('getExecutableSearchDirectories', () => {
 
 describe('findExecutableOnPath', () => {
   it('finds Windows Store app execution aliases even when PATH omits WindowsApps', () => {
-    const aliasPath = 'C:\\Users\\Ada\\AppData\\Local\\Microsoft\\WindowsApps\\ngrok.exe';
+    const aliasPath = 'C:\\Users\\Ada\\AppData\\Local\\Microsoft\\WindowsApps\\cloudflared.exe';
     const fsLike = {
       statSync: (candidate) => {
         if (candidate === aliasPath) {
@@ -47,7 +47,7 @@ describe('findExecutableOnPath', () => {
       accessSync: () => {},
     };
 
-    const resolved = findExecutableOnPath('ngrok', {
+    const resolved = findExecutableOnPath('cloudflared', {
       platform: 'win32',
       env: {
         PATH: 'C:\\Tools',
@@ -63,7 +63,7 @@ describe('findExecutableOnPath', () => {
 
 describe('resolveExecutableLaunchTarget', () => {
   it('returns a Windows launch target with WindowsApps on PATH when stat lookup fails', () => {
-    const target = resolveExecutableLaunchTarget('ngrok', {
+    const target = resolveExecutableLaunchTarget('cloudflared', {
       platform: 'win32',
       env: {
         PATH: 'C:\\Windows\\System32',
@@ -75,7 +75,7 @@ describe('resolveExecutableLaunchTarget', () => {
       },
     });
 
-    expect(target?.command).toBe('ngrok');
+    expect(target?.command).toBe('cloudflared');
     expect(target?.env.Path).toContain('C:\\Users\\Ada\\AppData\\Local\\Microsoft\\WindowsApps');
   });
 });

package/server/lib/tunnels/install-help.js

@@ -1,6 +1,5 @@
 import {
   TUNNEL_PROVIDER_CLOUDFLARE,
-  TUNNEL_PROVIDER_NGROK,
 } from './types.js';
 
 const PROVIDER_INSTALL_INFO = {
@@ -13,15 +12,6 @@ const PROVIDER_INSTALL_INFO = {
       linux: 'Download cloudflared from https://developers.cloudflare.com/cloudflare-one/networks/connectors/cloudflared/downloads/',
     },
   },
-  [TUNNEL_PROVIDER_NGROK]: {
-    dependency: 'ngrok',
-    installUrl: 'https://ngrok.com/download',
-    commands: {
-      darwin: 'brew install ngrok',
-      win32: 'winget install ngrok -s msstore',
-      linux: 'Download ngrok from https://ngrok.com/download',
-    },
-  },
 };
 
 const normalizeInstallPlatform = (platform) => {

package/server/lib/tunnels/install-help.test.js

@@ -3,7 +3,6 @@ import { describe, expect, it } from 'bun:test';
 import { getTunnelDependencyInstallInfo } from './install-help.js';
 import {
   TUNNEL_PROVIDER_CLOUDFLARE,
-  TUNNEL_PROVIDER_NGROK,
 } from './types.js';
 
 describe('getTunnelDependencyInstallInfo', () => {
@@ -15,14 +14,6 @@ describe('getTunnelDependencyInstallInfo', () => {
     expect(info.message).toContain('Cloudflare.cloudflared');
   });
 
-  it('returns Windows ngrok winget guidance', () => {
-    const info = getTunnelDependencyInstallInfo(TUNNEL_PROVIDER_NGROK, 'win32');
-
-    expect(info.dependency).toBe('ngrok');
-    expect(info.installCommand).toBe('winget install ngrok -s msstore');
-    expect(info.message).toContain('ngrok -s msstore');
-  });
-
   it('keeps macOS Homebrew guidance', () => {
     const info = getTunnelDependencyInstallInfo(TUNNEL_PROVIDER_CLOUDFLARE, 'darwin');
 

package/server/lib/tunnels/types.js

@@ -1,5 +1,4 @@
 export const TUNNEL_PROVIDER_CLOUDFLARE = 'cloudflare';
-export const TUNNEL_PROVIDER_NGROK = 'ngrok';
 
 export const TUNNEL_MODE_QUICK = 'quick';
 export const TUNNEL_MODE_MANAGED_REMOTE = 'managed-remote';