fix: repair sidebar agent actions

TheStreamCode · TheStreamCode · commit 175f70cb9a60 · 2026-07-18T17:57:34.000+02:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -5,6 +5,15 @@ All notable changes to this project are documented here. The format is based on
 
 ## [Unreleased]
 
+## [1.0.2] - 2026-07-18
+
+### Fixed
+
+- Fixed the grouped sidebar actions so Launch, Favorite, Update, and Setup Guide consistently receive
+  the selected agent instead of the surrounding tree node.
+- Removed launch commands from the virtual Agent Doctor report so command-line credentials cannot be
+  reproduced in its Markdown table.
+
 ## [1.0.1] - 2026-07-18
 
 ### Changed
diff --git a/CITATION.cff b/CITATION.cff
@@ -5,5 +5,5 @@ authors:
   - family-names: Gasperini
     given-names: Michael
 url: "https://github.com/TheStreamCode/super-cli"
-version: "1.0.1"
+version: "1.0.2"
 license: MIT
diff --git a/README.md b/README.md
@@ -66,7 +66,8 @@ defined explicitly for Windows, macOS, and Linux; WSL deliberately selects the L
   **Super CLI: Manage Built-in Agents**. Hiding a favorite safely clears the favorite selection.
 - **Agent Doctor.** Run an explicit, bounded local diagnostic to see detected CLI versions and
   missing or failing version checks. It does not perform network update checks and its report omits
-  environment variables, credentials, `PATH` contents, and captured command output.
+  environment variables, `PATH` contents, launch commands, and raw diagnostic output. The report is
+  a single read-only virtual document that is replaced on every run and is never written to disk.
 - **Agent-specific artwork.** Built-ins use vendor-sourced CLI marks where suitable SVGs are
   available, with a documented compact fallback for Kimi and a ThemeIcon fallback for custom agents.
 - **Built-in presets.** Claude Code, Codex, GitHub Copilot CLI, Cursor, Droid, Grok, Kilo, Kiro,
@@ -220,6 +221,9 @@ This extension does not collect telemetry, analytics, or personal data. It never
 modifies shell profiles; it only runs launch and user-requested update commands in your integrated
 terminal, plus bounded version commands when you explicitly run Agent Doctor.
 
+Keep credentials in each CLI's supported credential store or environment configuration rather than
+embedding them directly in launch, update, or version command strings.
+
 ## Brand assets
 
 The Router S combines the Super CLI initial with two directional command paths. The artwork is kept
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -3,7 +3,7 @@
   "displayName": "Super CLI: Claude Code, Codex & AI Agent Launcher",
   "description": "Launch Claude Code, Codex CLI, Copilot CLI, Google Antigravity, OpenCode, Kiro, OpenClaw and other AI coding agents from one VS Code sidebar.",
   "publisher": "mikesoft",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "repository": {
     "type": "git",
     "url": "https://github.com/TheStreamCode/super-cli.git"
diff --git a/src/agents.ts b/src/agents.ts
@@ -27,6 +27,31 @@ export interface Agent extends Omit<AgentDefinition, 'command' | 'updateCommand'
   versionCommand?: string;
 }
 
+function isAgent(value: unknown): value is Agent {
+  if (!value || typeof value !== 'object') {
+    return false;
+  }
+
+  const candidate = value as Partial<Agent>;
+  return typeof candidate.id === 'string'
+    && typeof candidate.label === 'string'
+    && typeof candidate.command === 'string';
+}
+
+/** Accepts both direct command arguments and agent nodes supplied by VS Code tree item menus. */
+export function resolveCommandAgentArgument(argument: unknown): Agent | undefined {
+  if (isAgent(argument)) {
+    return argument;
+  }
+
+  if (!argument || typeof argument !== 'object') {
+    return undefined;
+  }
+
+  const node = argument as { kind?: unknown; agent?: unknown };
+  return node.kind === 'agent' && isAgent(node.agent) ? node.agent : undefined;
+}
+
 function onAllPlatforms(command: string): Record<CommandPlatform, string> {
   return { windows: command, macos: command, linux: command };
 }
diff --git a/src/doctor.ts b/src/doctor.ts
@@ -167,7 +167,7 @@ export function buildDoctorReport(
   };
   const rows = agents.map((agent) => {
     const result = results.get(agent.id) ?? { status: 'version-unavailable' as const };
-    return `| ${escapeMarkdownCell(agent.label)} | ${labels[result.status]} | ${escapeMarkdownCell(result.version ?? '—')} | ${escapeMarkdownCell(agent.command)} |`;
+    return `| ${escapeMarkdownCell(agent.label)} | ${labels[result.status]} | ${escapeMarkdownCell(result.version ?? '—')} |`;
   });
 
   return [
@@ -178,11 +178,11 @@ export function buildDoctorReport(
     `- Workspace trusted: ${workspaceTrusted ? 'yes' : 'no'}`,
     '- Update availability is not checked over the network.',
     '',
-    '| Agent | Status | Version | Launch command |',
-    '| --- | --- | --- | --- |',
+    '| Agent | Status | Version |',
+    '| --- | --- | --- |',
     ...rows,
     '',
-    'This report intentionally excludes environment variables, credentials, PATH contents, and command output.',
+    'This report excludes environment variables, PATH contents, launch commands, and raw diagnostic output.',
     '',
   ].join('\n');
 }
diff --git a/src/extension.ts b/src/extension.ts
@@ -5,6 +5,7 @@ import {
   type AgentDefinition,
   BUILTIN_AGENTS,
   filterHiddenBuiltins,
+  resolveCommandAgentArgument,
   resolveAgentCommands,
   resolveAgents,
   resolveCommandPlatform,
@@ -328,15 +329,17 @@ export function activate(context: vscode.ExtensionContext): void {
     await runLaunchQuickPick(true);
   });
 
-  const launchAgentCommand = vscode.commands.registerCommand('superCli.launchAgent', async (agent?: Agent) => {
+  const launchAgentCommand = vscode.commands.registerCommand('superCli.launchAgent', async (argument?: unknown) => {
+    const agent = resolveCommandAgentArgument(argument);
     if (!agent) {
       return;
     }
 
     await launchWithStatusGuard(agent);
   });
 
-  const setFavoriteCommand = vscode.commands.registerCommand('superCli.setFavorite', async (agent?: Agent) => {
+  const setFavoriteCommand = vscode.commands.registerCommand('superCli.setFavorite', async (argument?: unknown) => {
+    const agent = resolveCommandAgentArgument(argument);
     if (!agent) {
       return;
     }
@@ -345,15 +348,17 @@ export function activate(context: vscode.ExtensionContext): void {
     void vscode.window.setStatusBarMessage(`${agent.label} is now the favorite agent`, 2500);
   });
 
-  const unsetFavoriteCommand = vscode.commands.registerCommand('superCli.unsetFavorite', async (agent?: Agent) => {
+  const unsetFavoriteCommand = vscode.commands.registerCommand('superCli.unsetFavorite', async (argument?: unknown) => {
+    const agent = resolveCommandAgentArgument(argument);
     if (!agent) {
       return;
     }
 
     await setFavoriteId('');
   });
 
-  const updateAgentCommand = vscode.commands.registerCommand('superCli.updateAgent', async (agent?: Agent) => {
+  const updateAgentCommand = vscode.commands.registerCommand('superCli.updateAgent', async (argument?: unknown) => {
+    const agent = resolveCommandAgentArgument(argument);
     if (!agent) {
       return;
     }
@@ -363,7 +368,8 @@ export function activate(context: vscode.ExtensionContext): void {
 
   const openAgentDocumentationCommand = vscode.commands.registerCommand(
     'superCli.openAgentDocumentation',
-    async (agent?: Agent) => {
+    async (argument?: unknown) => {
+      const agent = resolveCommandAgentArgument(argument);
       if (agent) {
         await openAgentDocumentation(agent);
       }
diff --git a/test/agents.test.js b/test/agents.test.js
@@ -5,6 +5,7 @@ const {
   BUILTIN_AGENTS,
   filterHiddenBuiltins,
   getMissingAgentGuidance,
+  resolveCommandAgentArgument,
   resolveAgentCommands,
   resolveAgents,
   resolveCommandPlatform,
@@ -18,6 +19,16 @@ function resolveBuiltin(id, platform = 'linux') {
   return resolveAgentCommands(definition, platform);
 }
 
+test('resolveCommandAgentArgument accepts direct agents and tree item nodes', () => {
+  const agent = { id: 'example', label: 'Example CLI', command: 'example' };
+
+  assert.equal(resolveCommandAgentArgument(agent), agent);
+  assert.equal(resolveCommandAgentArgument({ kind: 'agent', agent }), agent);
+  assert.equal(resolveCommandAgentArgument({ kind: 'group', agents: [agent] }), undefined);
+  assert.equal(resolveCommandAgentArgument({ kind: 'agent', agent: { id: 'broken' } }), undefined);
+  assert.equal(resolveCommandAgentArgument(undefined), undefined);
+});
+
 test('resolveAgents returns the built-ins when no user agents are configured', () => {
   const agents = resolveAgents(BUILTIN_AGENTS, undefined, true);
   assert.equal(agents.length, BUILTIN_AGENTS.length);
diff --git a/test/doctor.test.js b/test/doctor.test.js
@@ -81,12 +81,16 @@ test('inspectAgents preserves order and limits version checks to three workers',
   assert.ok(maximumActive <= 3);
 });
 
-test('doctor report contains useful state without raw output or environment data', () => {
+test('doctor report contains useful state without commands, raw output, or environment data', () => {
   const results = new Map([['example', { status: 'ready', version: 'example 1.2.3' }]]);
-  const report = buildDoctorReport([agent], results, 'Windows', false, true);
+  const report = buildDoctorReport([
+    { ...agent, command: 'example chat --api-key DOCTOR_SECRET_SENTINEL' },
+  ], results, 'Windows', false, true);
 
   assert.match(report, /Super CLI Agent Doctor/);
   assert.match(report, /Example CLI \| Ready \| example 1\.2\.3/);
   assert.match(report, /Update availability is not checked/);
   assert.doesNotMatch(report, /PATH=/);
+  assert.doesNotMatch(report, /Launch command/);
+  assert.doesNotMatch(report, /DOCTOR_SECRET_SENTINEL/);
 });
diff --git a/test/integration/suite/index.js b/test/integration/suite/index.js
@@ -1,4 +1,6 @@
 const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
 const vscode = require('vscode');
 
 /** Waits for a terminal created by the launcher to appear in the window. */
@@ -27,22 +29,65 @@ async function run() {
   const commands = await vscode.commands.getCommands(true);
   assert.ok(commands.includes('superCli.launch'));
   assert.ok(commands.includes('superCli.launchAgent'));
+  assert.ok(commands.includes('superCli.setFavorite'));
+  assert.ok(commands.includes('superCli.unsetFavorite'));
+  assert.ok(commands.includes('superCli.updateAgent'));
   assert.ok(commands.includes('superCli.openAgentDocumentation'));
   assert.ok(commands.includes('superCli.enableBuiltins'));
   assert.ok(commands.includes('superCli.manageBuiltins'));
   assert.ok(commands.includes('superCli.runDoctor'));
   assert.ok(commands.includes('superCli.openSettings'));
 
-  const beforeCount = vscode.window.terminals.length;
-  await vscode.commands.executeCommand('superCli.launchAgent', {
+  const testAgent = {
     id: 'integration-test',
     label: 'Super CLI Test',
     command: 'node --version',
-  });
+    updateCommand: 'node --version',
+  };
+  const treeNode = { kind: 'agent', agent: testAgent };
+  const configuration = vscode.workspace.getConfiguration('superCli');
+  const originalFavorite = configuration.inspect('favoriteAgent')?.globalValue;
 
-  const terminal = await waitForNewTerminal(beforeCount);
-  assert.match(terminal.name, /^Super CLI Test/);
-  terminal.dispose();
+  try {
+    await configuration.update('favoriteAgent', undefined, vscode.ConfigurationTarget.Global);
+    await vscode.commands.executeCommand('superCli.setFavorite', treeNode);
+    assert.equal(configuration.inspect('favoriteAgent')?.globalValue, testAgent.id);
+
+    await vscode.commands.executeCommand('superCli.unsetFavorite', treeNode);
+    assert.equal(configuration.inspect('favoriteAgent')?.globalValue, undefined);
+
+    const beforeCount = vscode.window.terminals.length;
+    await vscode.commands.executeCommand('superCli.launchAgent', treeNode);
+
+    const terminal = await waitForNewTerminal(beforeCount);
+    assert.match(terminal.name, /^Super CLI Test/);
+    terminal.dispose();
+
+    const beforeUpdateCount = vscode.window.terminals.length;
+    await vscode.commands.executeCommand('superCli.updateAgent', treeNode);
+
+    const updateTerminal = await waitForNewTerminal(beforeUpdateCount);
+    assert.match(updateTerminal.name, /^Update Super CLI Test/);
+    updateTerminal.dispose();
+  } finally {
+    await configuration.update('favoriteAgent', originalFavorite, vscode.ConfigurationTarget.Global);
+  }
+
+  await vscode.commands.executeCommand('superCli.runDoctor');
+  const firstDoctorDocument = vscode.workspace.textDocuments.find(
+    (document) => document.uri.toString() === 'super-cli:/agent-doctor.md',
+  );
+  assert.ok(firstDoctorDocument, 'Expected Agent Doctor to open its virtual report');
+
+  await vscode.commands.executeCommand('superCli.runDoctor');
+  const doctorDocuments = vscode.workspace.textDocuments.filter(
+    (document) => document.uri.toString() === 'super-cli:/agent-doctor.md',
+  );
+  assert.equal(doctorDocuments.length, 1);
+  assert.equal(doctorDocuments[0], firstDoctorDocument);
+  assert.equal((doctorDocuments[0].getText().match(/^# Super CLI Agent Doctor$/gm) ?? []).length, 1);
+  assert.doesNotMatch(doctorDocuments[0].getText(), /Launch command/);
+  assert.equal(fs.existsSync(path.join(extension.extensionPath, 'agent-doctor.md')), false);
 
   await vscode.commands.executeCommand('superCli.openSettings');
 }
