feat(relay): add doctor CLI + copy env; ui: scroll no-op indicator

Author: 0xSero

SKILL.MD

@@ -63,6 +63,11 @@ List agents:
 npm run relay -- agents
 ```
 
+Doctor (sanity-check daemon, auth, agent connection, tool forwarding):
+```bash
+npm run relay -- doctor
+```
+
 Get/set default agent:
 ```bash
 npm run relay -- default-agent get

packages/extension/sidepanel/styles/tools.css

@@ -373,3 +373,20 @@
   padding-left: 6px;
   border-left: 1px solid var(--ink-1);
 }
+
+.tool-note {
+  font-family: var(--font-mono);
+  font-size: 10px;
+  letter-spacing: 0.06em;
+  text-transform: uppercase;
+  color: var(--muted-dim);
+  padding: 1px 6px;
+  border-radius: 999px;
+  border: 1px solid var(--ink-1);
+  background: hsla(30, 5%, 100%, 0.02);
+  flex-shrink: 0;
+}
+
+.tool-row.noop {
+  opacity: 0.85;
+}

packages/extension/sidepanel/templates/panels/settings-general.html

@@ -85,6 +85,9 @@ <h3 class="setup-title">Active Profile</h3>
         <button id="saveRelayBtn" class="btn btn-primary" style="width: 100%; margin-top: 4px;">
             Apply Relay Settings
         </button>
+        <button id="copyRelayEnvBtn" class="btn btn-secondary" style="width: 100%; margin-top: 6px;">
+            Copy Relay Env Vars
+        </button>
     </div>
 </details>
 

packages/extension/sidepanel/ui/chat/panel-tools.ts

@@ -169,10 +169,13 @@ const toolIcons: Record<string, string> = {
   entry.endTime = Date.now();
   const isError = result && (result.error || result.success === false);
   const duration = entry.endTime - entry.startTime;
+  const isNoopScroll =
+    entry.fullToolName === 'scroll' && result && result.success === true && result.moved === false;
 
   // Update visual state - subtle, no red/green
   entry.element.classList.remove('running');
   entry.element.classList.add(isError ? 'error' : 'done');
+  entry.element.classList.toggle('noop', isNoopScroll);
 
   // Update duration display
   if (entry.durationEl) {
@@ -183,6 +186,29 @@ const toolIcons: Record<string, string> = {
     entry.statusEl.textContent = isError ? 'ERR' : 'OK';
   }
 
+  // When scroll can't move (common in nested scroll containers), surface it without marking as an error.
+  if (isNoopScroll) {
+    entry.element.title = 'Scroll did not move. The page may use an inner scroll container; pass scroll.selector.';
+    let noteEl = entry.element.querySelector('.tool-note') as HTMLElement | null;
+    if (!noteEl) {
+      noteEl = document.createElement('span');
+      noteEl.className = 'tool-note';
+      noteEl.textContent = 'no-op';
+      // Prefer placing after args, before status.
+      const argsEl = entry.element.querySelector('.tool-args');
+      if (argsEl && argsEl.parentElement) {
+        argsEl.insertAdjacentElement('afterend', noteEl);
+      } else {
+        const statusEl = entry.element.querySelector('.tool-status');
+        if (statusEl && statusEl.parentElement) {
+          statusEl.insertAdjacentElement('beforebegin', noteEl);
+        } else {
+          entry.element.appendChild(noteEl);
+        }
+      }
+    }
+  }
+
   // Store result for potential expansion
   entry.result = result;
 };

packages/extension/sidepanel/ui/core/panel-core.ts

@@ -105,6 +105,43 @@ import { SidePanelUI } from './panel-ui.js';
     } catch {}
   });
 
+  this.elements.copyRelayEnvBtn?.addEventListener('click', async () => {
+    const rawUrl = String(this.elements.relayUrl?.value || '').trim();
+    const token = String(this.elements.relayToken?.value || '').trim();
+    if (!rawUrl) {
+      this.updateStatus('Enter a relay URL first', 'warning');
+      return;
+    }
+    if (!token) {
+      this.updateStatus('Enter a relay token first', 'warning');
+      return;
+    }
+
+    let host = '127.0.0.1';
+    let port = '17373';
+    try {
+      const url = new URL(rawUrl);
+      host = url.hostname || host;
+      port = url.port || port;
+    } catch {
+      const cleaned = rawUrl.replace(/^https?:\/\//, '');
+      const [h, p] = cleaned.split(':');
+      if (h) host = h;
+      if (p) port = p;
+    }
+
+    const text = `export PARCHI_RELAY_TOKEN="${token}"
+export PARCHI_RELAY_HOST="${host}"
+export PARCHI_RELAY_PORT="${port}"`;
+
+    try {
+      await navigator.clipboard.writeText(text);
+      this.updateStatus('Relay env vars copied', 'success');
+    } catch {
+      this.updateStatus('Unable to copy relay env vars', 'error');
+    }
+  });
+
   // Cancel settings
   this.elements.cancelSettingsBtn?.addEventListener('click', () => {
     void this.cancelSettings();

packages/extension/sidepanel/ui/core/panel-elements.ts

@@ -92,6 +92,7 @@ export const getSidePanelElements = (): SidePanelElements => ({
   relayUrl: byId<HTMLInputElement>('relayUrl'),
   relayToken: byId<HTMLInputElement>('relayToken'),
   saveRelayBtn: byId<HTMLButtonElement>('saveRelayBtn'),
+  copyRelayEnvBtn: byId<HTMLButtonElement>('copyRelayEnvBtn'),
   relayConnectedBadge: byId<HTMLElement>('relayConnectedBadge'),
   relayLastErrorText: byId<HTMLElement>('relayLastErrorText'),
 

packages/relay-service/src/cli.ts

@@ -82,6 +82,7 @@ const main = async () => {
     print({
       usage: [
         'parchi-relay rpc <method> [--params=\'{...}\'] [--agentId=...]',
+        'parchi-relay doctor [--agentId=...] [--skipTool=true]',
         'parchi-relay agents',
         'parchi-relay default-agent get|set <agentId>',
         'parchi-relay tools [--agentId=...]',
@@ -102,6 +103,93 @@ const main = async () => {
     return;
   }
 
+  if (cmd === 'doctor') {
+    const agentId = flags.agentId;
+    const skipTool = flags.skipTool === 'true';
+
+    const report: Record<string, any> = {
+      ok: true,
+      target: { host, port },
+      checks: {},
+    };
+
+    const fail = (name: string, err: unknown) => {
+      report.ok = false;
+      report.checks[name] = {
+        ok: false,
+        error: err instanceof Error ? err.message : String(err ?? 'error'),
+      };
+    };
+
+    try {
+      const ping = await fetchRpc({ host, port, token, method: 'relay.ping' });
+      report.checks.ping = { ok: true, result: ping };
+    } catch (err) {
+      fail('ping', err);
+      print(report);
+      process.exit(2);
+    }
+
+    let agents: any[] = [];
+    try {
+      agents = (await fetchRpc({ host, port, token, method: 'agents.list' })) as any[];
+      report.checks.agents = { ok: true, count: Array.isArray(agents) ? agents.length : 0, agents };
+    } catch (err) {
+      fail('agents', err);
+    }
+
+    let resolvedAgentId: string | null = agentId || null;
+    if (!resolvedAgentId) {
+      try {
+        const def = (await fetchRpc({ host, port, token, method: 'agents.default.get' })) as any;
+        resolvedAgentId = typeof def?.agentId === 'string' ? def.agentId : null;
+        report.checks.defaultAgent = { ok: true, agentId: resolvedAgentId };
+      } catch (err) {
+        fail('defaultAgent', err);
+      }
+    } else {
+      report.checks.defaultAgent = { ok: true, agentId: resolvedAgentId, source: 'flag' };
+    }
+
+    const connected = Array.isArray(agents) ? agents.some((a) => a?.agentId === resolvedAgentId) : false;
+    if (resolvedAgentId && !connected) {
+      report.ok = false;
+      report.checks.agentConnected = {
+        ok: false,
+        agentId: resolvedAgentId,
+        hint: 'AgentId not in agents.list. Ensure the extension is loaded from dist/ and Relay is enabled/applied.',
+      };
+    } else {
+      report.checks.agentConnected = { ok: true, agentId: resolvedAgentId };
+    }
+
+    try {
+      const params = resolvedAgentId ? { agentId: resolvedAgentId } : undefined;
+      const tools = await fetchRpc({ host, port, token, method: 'tools.list', params });
+      report.checks.tools = { ok: true, toolCount: Array.isArray(tools) ? tools.length : null, tools };
+    } catch (err) {
+      fail('tools', err);
+    }
+
+    if (!skipTool) {
+      try {
+        const params = resolvedAgentId
+          ? { agentId: resolvedAgentId, tool: 'getTabs', args: {} }
+          : { tool: 'getTabs', args: {} };
+        const result = await fetchRpc({ host, port, token, method: 'tool.call', params });
+        report.checks.forwarding = { ok: true, tool: 'getTabs', result };
+      } catch (err) {
+        fail('forwarding', err);
+      }
+    } else {
+      report.checks.forwarding = { ok: true, skipped: true };
+    }
+
+    print(report);
+    if (!report.ok) process.exit(2);
+    return;
+  }
+
   if (cmd === 'agents') {
     const result = await fetchRpc({ host, port, token, method: 'agents.list' });
     print(result);
@@ -176,4 +264,3 @@ const main = async () => {
 };
 
 await main();
-