@moxxy/plugin-channel-web 0.28.1 → 0.29.0

package/src/channel.test.ts

@@ -1,6 +1,7 @@
 import { afterEach, describe, expect, it } from 'vitest';
 import { WebSocket } from 'ws';
 import type { ClientSession, MoxxyEvent } from '@moxxy/sdk';
+import { assertDefined } from '@moxxy/sdk';
 import {
   freeTcpPortIfMoxxy,
   WebChannel,
@@ -188,7 +189,8 @@ describe('WebChannel', () => {
     });
     handle = await channel.start({ session: fakeSession().session });
     expect(published).not.toBeNull();
-    expect(published!.url).toBe('https://abc.trycloudflare.com/?t=tkn');
+    assertDefined(published, 'a surface was published');
+    expect(published.url).toBe('https://abc.trycloudflare.com/?t=tkn');
   });
 
   it('co-attached to a real Session publishes a localhost URL by default (the TUI case)', async () => {
@@ -206,8 +208,9 @@ describe('WebChannel', () => {
     });
     handle = await channel.start({ session: session as never });
     expect(published).not.toBeNull();
+    assertDefined(published, 'a surface was published');
     // A real, tokenized URL present_view can hand back — never null/rendered:false.
-    expect(published!.url).toMatch(/^http:\/\/127\.0\.0\.1:\d+\/\?t=tkn$/);
+    expect(published.url).toMatch(/^http:\/\/127\.0\.0\.1:\d+\/\?t=tkn$/);
   });
 
   it('falls back to the local URL when the tunnel provider fails', async () => {
@@ -227,8 +230,9 @@ describe('WebChannel', () => {
     });
     handle = await channel.start({ session: fakeSession().session });
     expect(published).not.toBeNull();
-    expect(published!.url).toContain('http://127.0.0.1:');
-    expect(published!.url).toContain('?t=tkn');
+    assertDefined(published, 'a surface was published');
+    expect(published.url).toContain('http://127.0.0.1:');
+    expect(published.url).toContain('?t=tkn');
   });
 
   it('opens a WS handshake under the relay base path (proxy /web)', async () => {

package/src/channel.ts

@@ -122,9 +122,10 @@ export async function freeTcpPortIfMoxxy(
   );
   const foreign = holders.filter((h) => !looksLikeMoxxy(h.command));
   if (foreign.length > 0) {
-    logger?.warn?.(`port ${port} is held by non-moxxy process(es); not killing them`, {
-      holders: foreign.map((h) => `${h.pid}: ${h.command || '<unknown command>'}`),
-    });
+    if (logger?.warn)
+      logger.warn(`port ${port} is held by non-moxxy process(es); not killing them`, {
+        holders: foreign.map((h) => `${h.pid}: ${h.command || '<unknown command>'}`),
+      });
     return false;
   }
   // Re-verify identity immediately before each signal. Between the `ps`
@@ -139,7 +140,7 @@ export async function freeTcpPortIfMoxxy(
     try {
       // Log the exact command we judged moxxy-owned before signalling, so a
       // mis-fire on a substring-collision process is auditable after the fact.
-      logger?.warn?.('freeing port: SIGTERM to apparent stale moxxy process', { pid, command });
+      if (logger?.warn) logger.warn('freeing port: SIGTERM to apparent stale moxxy process', { pid, command });
       deps.kill(pid, 'SIGTERM');
       attempted = true;
     } catch {
@@ -158,7 +159,7 @@ export async function freeTcpPortIfMoxxy(
     const command = await deps.pidCommand(pid);
     if (!looksLikeMoxxy(command)) continue;
     try {
-      logger?.warn?.('freeing port: SIGKILL to apparent stale moxxy process', { pid, command });
+      if (logger?.warn) logger.warn('freeing port: SIGKILL to apparent stale moxxy process', { pid, command });
       deps.kill(pid, 'SIGKILL');
     } catch {
       /* dead */
@@ -328,7 +329,10 @@ export class WebChannel implements Channel<WebStartOpts> {
     wss.on('connection', (ws) => this.onConnection(ws));
     // Never leave an EventEmitter 'error' unhandled — it would throw at the
     // process level. Forwarded server errors after bind are log-and-survive.
-    wss.on('error', (err) => this.logger?.warn?.('web socket server error', { err: String(err) }));
+    wss.on('error', (err) => {
+      const logger = this.logger;
+      if (logger?.warn) logger.warn('web socket server error', { err: String(err) });
+    });
 
     await this.openTunnel();
     this.publishSurface?.({ url: this.shareUrl, nextViewId: () => `v_srv_${++this.viewSeq}` });
@@ -358,7 +362,8 @@ export class WebChannel implements Channel<WebStartOpts> {
           server.off('error', onError);
           const addr = server.address();
           if (addr && typeof addr === 'object') this.port = (addr as AddressInfo).port;
-          this.logger?.info?.('web channel listening', { url: this.url });
+          const logger = this.logger;
+          if (logger?.info) logger.info('web channel listening', { url: this.url });
           resolve();
         };
         server.once('error', onError);
@@ -376,9 +381,11 @@ export class WebChannel implements Channel<WebStartOpts> {
     const requested = this.port;
     const freed = await freeTcpPortIfMoxxy(requested, this.logger).catch(() => false);
     if (freed) {
-      this.logger?.warn?.(
-        `web channel port ${requested} was held by a stale moxxy process; freed it, retrying`,
-      );
+      const logger = this.logger;
+      if (logger?.warn)
+        logger.warn(
+          `web channel port ${requested} was held by a stale moxxy process; freed it, retrying`,
+        );
       try {
         await tryListen();
         return;
@@ -392,10 +399,12 @@ export class WebChannel implements Channel<WebStartOpts> {
     // this.url / shareUrl / the tunnel all carry it automatically.
     this.port = 0;
     await tryListen();
-    this.logger?.warn?.(
-      `web channel port ${requested} was in use by another process; bound ephemeral port ${this.port} instead`,
-      { requestedPort: requested, boundPort: this.port, url: this.url },
-    );
+    const logger = this.logger;
+    if (logger?.warn)
+      logger.warn(
+        `web channel port ${requested} was in use by another process; bound ephemeral port ${this.port} instead`,
+        { requestedPort: requested, boundPort: this.port, url: this.url },
+      );
   }
 
   /**
@@ -422,9 +431,11 @@ export class WebChannel implements Channel<WebStartOpts> {
       this.tunnel = await provider.open({ port: this.port, host: this.host, label: 'web' });
       this.tunnelBase = this.tunnel.url;
       this.basePath = basePathFromUrl(this.tunnel.url);
-      this.logger?.info?.('web surface tunnel open', { provider: provider.name, url: this.shareUrl });
+      const logger = this.logger;
+      if (logger?.info) logger.info('web surface tunnel open', { provider: provider.name, url: this.shareUrl });
     } catch (err) {
-      this.logger?.warn?.('web surface tunnel failed; using local URL', { provider: provider.name, err: String(err) });
+      const logger = this.logger;
+      if (logger?.warn) logger.warn('web surface tunnel failed; using local URL', { provider: provider.name, err: String(err) });
     }
   }
 
@@ -622,10 +633,12 @@ export class WebChannel implements Channel<WebStartOpts> {
     const now = Date.now();
     if (now - this.lastDropWarnAt < DROP_WARN_INTERVAL_MS) return;
     this.lastDropWarnAt = now;
-    this.logger?.warn?.('web channel dropped invalid client frame(s)', {
-      reason,
-      droppedTotal: this.droppedFrames,
-    });
+    const logger = this.logger;
+    if (logger?.warn)
+      logger.warn('web channel dropped invalid client frame(s)', {
+        reason,
+        droppedTotal: this.droppedFrames,
+      });
   }
 
   private async drive(prompt: string): Promise<void> {

package/src/discovery.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it, vi } from 'vitest';
 import type { ServiceRegistry } from '@moxxy/sdk';
+import { assertDefined } from '@moxxy/sdk';
 import { webChannelPlugin } from './index.js';
 
 /**
@@ -32,7 +33,11 @@ describe('webChannelPlugin (discovery-loadable)', () => {
       }
     });
     const services = { get, register: () => {}, require: () => undefined, has: () => true } as unknown as ServiceRegistry;
-    webChannelPlugin.hooks!.onInit!({ services } as never);
+    const hooks = webChannelPlugin.hooks;
+    assertDefined(hooks, 'plugin defines hooks');
+    const onInit = hooks.onInit;
+    assertDefined(onInit, 'hooks define onInit');
+    onInit({ services } as never);
     expect(get).toHaveBeenCalledWith('tunnelProviders');
     expect(get).toHaveBeenCalledWith('viewSurface');
     expect(get).toHaveBeenCalledWith('webControls');

package/src/frontend/chat.tsx

@@ -51,7 +51,7 @@ export function ChatPanel(props: {
   useEffect(() => {
     const opener = typeof document !== 'undefined' ? (document.activeElement as HTMLElement | null) : null;
     inputRef.current?.focus();
-    return () => opener?.focus?.();
+    return () => opener?.focus();
   }, []);
 
   const onKeyDown = useCallback(
@@ -64,9 +64,9 @@ export function ChatPanel(props: {
       if (e.key !== 'Tab') return;
       // Trap Tab within the panel so focus never escapes to the obscured view.
       const focusables = focusableWithin(panelRef.current);
-      if (focusables.length === 0) return;
-      const first = focusables[0]!;
-      const last = focusables[focusables.length - 1]!;
+      const first = focusables[0];
+      const last = focusables[focusables.length - 1];
+      if (!first || !last) return;
       const active = document.activeElement;
       if (e.shiftKey && active === first) {
         e.preventDefault();

package/src/frontend/render-diff.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, it } from 'vitest';
 import { createElement } from 'react';
 import { renderToStaticMarkup } from 'react-dom/server';
 import type { FileDiffDisplay } from '@moxxy/sdk';
+import { assertDefined } from '@moxxy/sdk';
 import { FileDiffView } from './render-diff.js';
 
 const render = (display: FileDiffDisplay): string => renderToStaticMarkup(createElement(FileDiffView, { display }));
@@ -58,10 +59,12 @@ describe('FileDiffView', () => {
   });
 
   it('inserts a ⋯ gap row between non-contiguous hunks', () => {
+    const hunk = baseDisplay.hunks[0];
+    assertDefined(hunk, 'baseDisplay has a hunk');
     const twoHunks: FileDiffDisplay = {
       ...baseDisplay,
       hunks: [
-        baseDisplay.hunks[0]!,
+        hunk,
         { oldStart: 40, oldLines: 1, newStart: 41, newLines: 1, lines: [{ kind: 'context', text: 'far away', oldNo: 40, newNo: 41 }] },
       ],
     };

package/src/frontend/render.tsx

@@ -110,6 +110,7 @@ export function renderNode(node: ViewNode, h: RenderHandlers, key?: number): Rea
     case 'link': {
       // A `to` link navigates client-side; otherwise it is an external anchor.
       if (node.nav) {
+        const nav = node.nav;
         return (
           <a
             className="v-link"
@@ -117,7 +118,7 @@ export function renderNode(node: ViewNode, h: RenderHandlers, key?: number): Rea
             key={key}
             onClick={(e) => {
               e.preventDefault();
-              h.navigate(node.nav!);
+              h.navigate(nav);
             }}
           >
             {kids}
@@ -223,7 +224,10 @@ function gatherFormValues(form: HTMLFormElement | null): Record<string, string>
 function pick(values: Record<string, string>, fields: ReadonlyArray<string>): Record<string, string> {
   if (fields.length === 0) return values;
   const out: Record<string, string> = {};
-  for (const f of fields) if (f in values) out[f] = values[f]!;
+  for (const f of fields) {
+    const v = values[f];
+    if (v !== undefined) out[f] = v;
+  }
   return out;
 }
 

package/src/frontend/view-store.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import type { ViewDoc } from '@moxxy/sdk';
+import { assertDefined } from '@moxxy/sdk';
 import { applyView, canGoBack, currentEntry, goBack, initialNav, navigateTo } from './view-store.js';
 
 const doc = (tag = 'view'): ViewDoc => ({ root: { kind: 'element', tag, props: {}, children: [] } });
@@ -48,7 +49,8 @@ describe('view-store', () => {
     s = applyView(s, frame('v2', 'results'));
     const back = navigateTo(s, 'search');
     expect(back).not.toBeNull();
-    expect(currentEntry(back!)?.key).toBe('search');
+    assertDefined(back, 'navigateTo returned a cached view');
+    expect(currentEntry(back)?.key).toBe('search');
     expect(navigateTo(s, 'detail')).toBeNull(); // not cached → caller asks the agent
   });
 

package/src/frontend/view-store.ts

@@ -78,7 +78,8 @@ function prune(state: NavState): NavState {
   const order = [...state.order];
   // Walk oldest→newest, dropping evictable (non-history) keys until within cap.
   for (let i = 0; i < order.length && order.length > MAX_CACHED_VIEWS; ) {
-    const key = order[i]!;
+    const key = order[i];
+    if (key === undefined) break;
     if (live.has(key)) {
       i += 1; // pinned by history — skip, keep it
       continue;

package/src/index.ts

@@ -97,7 +97,8 @@ export function buildWebChannelPlugin(opts: BuildWebChannelOptions = {}): Plugin
             }
             tunnels.setActive(name);
             await writeTunnelSetting(name, opts.settingsFile);
-            const url = (await opts.getControls?.()?.retunnel()) ?? null;
+            const controls = opts.getControls?.();
+            const url = (await controls?.retunnel()) ?? null;
             return { ok: true, active: name, ...(url ? { url } : { note: 'applies when the web surface (re)starts' }) };
           },
         }),
@@ -166,7 +167,10 @@ export const webChannelPlugin: Plugin = (() => {
 
   const tunnels: TunnelControls = {
     list: () => tp?.list().map((p) => p.name) ?? [],
-    active: () => tp?.getActive()?.name ?? null,
+    active: () => {
+      const activeTunnel = tp?.getActive();
+      return activeTunnel?.name ?? null;
+    },
     setActive: (n) => {
       tp?.setActive(n);
     },

package/src/projector.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import type { MoxxyEvent } from '@moxxy/sdk';
+import { assertDefined } from '@moxxy/sdk';
 import { EventProjector } from './projector.js';
 
 // Minimal event factory — only the fields the projector reads.
@@ -15,7 +16,8 @@ describe('EventProjector', () => {
     expect(p.project(ev({ type: 'tool_call_requested', callId: 'c1', name: 'present_view', input: { fallbackText: 'fb' } }))).toEqual([]);
     const frames = p.project(ev({ type: 'tool_result', callId: 'c1', ok: true, output: { ast: sampleDoc } }));
     expect(frames).toHaveLength(1);
-    const f = frames[0]!;
+    const f = frames[0];
+    assertDefined(f, 'projector emitted a view frame');
     expect(f.kind).toBe('view');
     if (f.kind !== 'view') return;
     expect(f.doc).toEqual(sampleDoc);
@@ -26,9 +28,13 @@ describe('EventProjector', () => {
   it('sets `replaces` to the prior view id on the second view', () => {
     const p = new EventProjector();
     p.project(ev({ type: 'tool_call_requested', callId: 'c1', name: 'present_view', input: {} }));
-    const first = p.project(ev({ type: 'tool_result', callId: 'c1', ok: true, output: { ast: sampleDoc } }))[0]!;
+    const firstFrames = p.project(ev({ type: 'tool_result', callId: 'c1', ok: true, output: { ast: sampleDoc } }));
+    const first = firstFrames[0];
+    assertDefined(first, 'projector emitted a view frame');
     p.project(ev({ type: 'tool_call_requested', callId: 'c2', name: 'present_view', input: {} }));
-    const second = p.project(ev({ type: 'tool_result', callId: 'c2', ok: true, output: { ast: sampleDoc } }))[0]!;
+    const secondFrames = p.project(ev({ type: 'tool_result', callId: 'c2', ok: true, output: { ast: sampleDoc } }));
+    const second = secondFrames[0];
+    assertDefined(second, 'projector emitted a view frame');
     if (first.kind !== 'view' || second.kind !== 'view') throw new Error('expected views');
     expect(second.replaces).toBe(first.viewId);
     expect(second.viewId).not.toBe(first.viewId);
@@ -38,14 +44,18 @@ describe('EventProjector', () => {
     const p = new EventProjector();
     p.project(ev({ type: 'tool_call_requested', callId: 'c1', name: 'present_view', input: {} }));
     const namedDoc = { root: { kind: 'element', tag: 'view', props: { name: 'search' }, children: [] } };
-    const f = p.project(ev({ type: 'tool_result', callId: 'c1', ok: true, output: { ast: namedDoc } }))[0]!;
+    const namedFrames = p.project(ev({ type: 'tool_result', callId: 'c1', ok: true, output: { ast: namedDoc } }));
+    const f = namedFrames[0];
+    assertDefined(f, 'projector emitted a view frame');
     expect(f.kind === 'view' && f.name).toBe('search');
   });
 
   it('omits name when the view has none', () => {
     const p = new EventProjector();
     p.project(ev({ type: 'tool_call_requested', callId: 'c1', name: 'present_view', input: {} }));
-    const f = p.project(ev({ type: 'tool_result', callId: 'c1', ok: true, output: { ast: sampleDoc } }))[0]!;
+    const frames = p.project(ev({ type: 'tool_result', callId: 'c1', ok: true, output: { ast: sampleDoc } }));
+    const f = frames[0];
+    assertDefined(f, 'projector emitted a view frame');
     expect(f.kind === 'view' && f.name).toBeUndefined();
   });
 
@@ -142,9 +152,13 @@ describe('EventProjector', () => {
   it('handles two present_view calls in one turn, each replacing the last', () => {
     const p = new EventProjector();
     p.project(ev({ type: 'tool_call_requested', callId: 'a', name: 'present_view', input: {} }));
-    const first = p.project(ev({ type: 'tool_result', callId: 'a', ok: true, output: { ast: sampleDoc } }))[0]!;
+    const firstFrames = p.project(ev({ type: 'tool_result', callId: 'a', ok: true, output: { ast: sampleDoc } }));
+    const first = firstFrames[0];
+    assertDefined(first, 'projector emitted a view frame');
     p.project(ev({ type: 'tool_call_requested', callId: 'b', name: 'present_view', input: {} }));
-    const second = p.project(ev({ type: 'tool_result', callId: 'b', ok: true, output: { ast: sampleDoc } }))[0]!;
+    const secondFrames = p.project(ev({ type: 'tool_result', callId: 'b', ok: true, output: { ast: sampleDoc } }));
+    const second = secondFrames[0];
+    assertDefined(second, 'projector emitted a view frame');
     if (first.kind !== 'view' || second.kind !== 'view') throw new Error('views');
     expect(second.replaces).toBe(first.viewId);
   });
@@ -167,6 +181,8 @@ describe('EventProjector', () => {
     p.project(ev({ type: 'tool_call_requested', callId: 'live', name: 'present_view', input: {} }));
     const frames = p.project(ev({ type: 'tool_result', callId: 'live', ok: true, output: { ast: sampleDoc } }));
     expect(frames).toHaveLength(1);
-    expect(frames[0]!.kind).toBe('view');
+    const frame = frames[0];
+    assertDefined(frame, 'projector emitted a view frame');
+    expect(frame.kind).toBe('view');
   });
 });

package/src/tunnel-tools.test.ts

@@ -94,7 +94,10 @@ describe('web_set_tunnel', () => {
 });
 
 describe('onInit applies the persisted / default tunnel', () => {
-  const fireInit = (hooks: LifecycleHooks | undefined) => (hooks?.onInit as (() => void) | undefined)?.();
+  const fireInit = (hooks: LifecycleHooks | undefined) => {
+    const onInit = hooks?.onInit as (() => void) | undefined;
+    onInit?.();
+  };
 
   it('applies a persisted setting on boot', async () => {
     await writeTunnelSetting('proxy', file);