fix(tui): eliminate freezes from network fetches and stdin contention (#67)

* feat(marketplace): add offline option to resolvePluginSpec

Allows callers to resolve plugin specs without triggering network
fetches. When offline=true, URL-sourced plugins resolve only if
already cached locally.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* fix(status): use offline resolution to avoid network fetches

Status checks now resolve marketplace plugins locally without
triggering git pull. This eliminates the primary cause of TUI
freezes — repeated network subprocess spawns during status views.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* fix(cli): await runWizard to ensure proper terminal cleanup

Missing await caused the wizard promise to run detached, preventing
proper stdin/stdout cleanup on exit.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* fix(core): add stdin ignore to all subprocess calls

Prevents child git/gh processes from inheriting the TUI's raw-mode
stdin. On Windows, Git Credential Manager could deadlock trying to
read from stdin owned by @clack/prompts. This is the root cause of
TUI freezes on Windows.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

* perf(tui): cache workspace status to avoid duplicate resolution

Status results are now cached in the TUI session cache, avoiding
redundant getWorkspaceStatus calls when viewing status or managing
plugins multiple times without changes.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

Author: christso

src/cli/index.ts

@@ -32,7 +32,7 @@ if (agentHelp) {
 } else if (finalArgs.length === 0 && process.stdout.isTTY && !json) {
   // Interactive wizard when no args and running in a terminal
   const { runWizard } = await import('./tui/wizard.js');
-  runWizard();
+  await runWizard();
 } else {
   run(app, finalArgs);
 }

src/cli/tui/actions/plugins.ts

@@ -167,7 +167,11 @@ export async function runInstallPlugin(context: TuiContext, cache?: TuiCache): P
  */
 export async function runManagePlugins(context: TuiContext, cache?: TuiCache): Promise<void> {
   try {
-    const status = await getWorkspaceStatus(context.workspacePath ?? undefined);
+    let status = cache?.getStatus();
+    if (!status) {
+      status = await getWorkspaceStatus(context.workspacePath ?? undefined);
+      cache?.setStatus(status);
+    }
 
     if (!status.success || status.plugins.length === 0) {
       p.note('No plugins installed in this workspace.', 'Plugins');

src/cli/tui/actions/status.ts

@@ -1,14 +1,19 @@
 import * as p from '@clack/prompts';
 import { getWorkspaceStatus } from '../../../core/status.js';
 import type { TuiContext } from '../context.js';
+import type { TuiCache } from '../cache.js';
 
 /**
  * Display workspace and plugin status.
  * Shows plugin availability and configured clients.
  */
-export async function runStatus(context: TuiContext): Promise<void> {
+export async function runStatus(context: TuiContext, cache?: TuiCache): Promise<void> {
   try {
-    const status = await getWorkspaceStatus(context.workspacePath ?? undefined);
+    let status = cache?.getStatus();
+    if (!status) {
+      status = await getWorkspaceStatus(context.workspacePath ?? undefined);
+      cache?.setStatus(status);
+    }
 
     if (!status.success) {
       p.note(status.error ?? 'Unknown error', 'Status Error');

src/cli/tui/cache.ts

@@ -1,4 +1,5 @@
 import type { MarketplaceEntry, MarketplacePluginsResult } from '../../core/marketplace.js';
+import type { WorkspaceStatusResult } from '../../core/status.js';
 import type { TuiContext } from './context.js';
 
 /**
@@ -10,6 +11,7 @@ export class TuiCache {
   private marketplaces: MarketplaceEntry[] | undefined;
   private context: TuiContext | undefined;
   private marketplacePlugins: Map<string, MarketplacePluginsResult> = new Map();
+  private status: WorkspaceStatusResult | undefined;
 
   /** Get cached marketplace list (undefined if not cached) */
   getMarketplaces(): MarketplaceEntry[] | undefined {
@@ -46,10 +48,21 @@ export class TuiCache {
     this.marketplacePlugins.set(name, result);
   }
 
+  /** Get cached workspace status (undefined if not cached) */
+  getStatus(): WorkspaceStatusResult | undefined {
+    return this.status;
+  }
+
+  /** Store workspace status in cache */
+  setStatus(status: WorkspaceStatusResult): void {
+    this.status = status;
+  }
+
   /** Clear all cached data. Call after any write operation. */
   invalidate(): void {
     this.marketplaces = undefined;
     this.context = undefined;
     this.marketplacePlugins.clear();
+    this.status = undefined;
   }
 }

src/cli/tui/wizard.ts

@@ -120,7 +120,7 @@ export async function runWizard(): Promise<void> {
         cache.invalidate();
         break;
       case 'status':
-        await runStatus(context);
+        await runStatus(context, cache);
         break;
       case 'install':
         await runInstallPlugin(context, cache);

src/core/marketplace.ts

@@ -8,6 +8,7 @@ import {
 } from '../utils/marketplace-manifest-parser.js';
 import { fetchPlugin } from './plugin.js';
 import type { FetchResult } from './plugin.js';
+import { parseGitHubUrl, getPluginCachePath } from '../utils/plugin-path.js';
 
 /**
  * Source types for marketplaces
@@ -220,7 +221,7 @@ export async function addMarketplace(
     } else {
       // Check if gh CLI is available
       try {
-        await execa('gh', ['--version']);
+        await execa('gh', ['--version'], { stdin: 'ignore' });
       } catch {
         return {
           success: false,
@@ -236,7 +237,7 @@ export async function addMarketplace(
 
       // Clone repository
       try {
-        await execa('gh', ['repo', 'clone', parsed.location, marketplacePath]);
+        await execa('gh', ['repo', 'clone', parsed.location, marketplacePath], { stdin: 'ignore' });
       } catch (error) {
         const msg = error instanceof Error ? error.message : String(error);
         if (msg.toLowerCase().includes('not found') || msg.includes('404')) {
@@ -418,7 +419,7 @@ export async function updateMarketplace(
         const { stdout } = await execa(
           'git',
           ['symbolic-ref', 'refs/remotes/origin/HEAD', '--short'],
-          { cwd: marketplace.path },
+          { cwd: marketplace.path, stdin: 'ignore' },
         );
         // stdout is like "origin/main" - strip remote prefix to get local branch name
         const ref = stdout.trim();
@@ -431,7 +432,7 @@ export async function updateMarketplace(
           const { stdout } = await execa(
             'git',
             ['remote', 'show', 'origin'],
-            { cwd: marketplace.path },
+            { cwd: marketplace.path, stdin: 'ignore' },
           );
           const match = stdout.match(/HEAD branch:\s*(\S+)/);
           if (match?.[1]) {
@@ -443,8 +444,9 @@ export async function updateMarketplace(
       }
       await execa('git', ['checkout', defaultBranch], {
         cwd: marketplace.path,
+        stdin: 'ignore',
       });
-      await execa('git', ['pull'], { cwd: marketplace.path });
+      await execa('git', ['pull'], { cwd: marketplace.path, stdin: 'ignore' });
 
       // Update lastUpdated in registry
       marketplace.lastUpdated = new Date().toISOString();
@@ -642,6 +644,7 @@ export async function resolvePluginSpec(
     subpath?: string;
     marketplaceNameOverride?: string;
     marketplacePathOverride?: string;
+    offline?: boolean;
     fetchFn?: (url: string) => Promise<FetchResult>;
   } = {},
 ): Promise<{ path: string; marketplace: string; plugin: string } | null> {
@@ -681,6 +684,21 @@ export async function resolvePluginSpec(
           };
         }
       } else {
+        if (options.offline) {
+          // Offline mode: check if plugin is already cached, don't fetch
+          const parsedUrl = parseGitHubUrl(pluginEntry.source.url);
+          if (parsedUrl) {
+            const cachePath = getPluginCachePath(parsedUrl.owner, parsedUrl.repo);
+            if (existsSync(cachePath)) {
+              return {
+                path: cachePath,
+                marketplace: marketplaceName,
+                plugin: parsed.plugin,
+              };
+            }
+          }
+          return null;
+        }
         // URL source - fetch/clone the plugin
         const fetchFn = options.fetchFn ?? fetchPlugin;
         const fetchResult = await fetchFn(pluginEntry.source.url);
@@ -732,6 +750,7 @@ export interface ResolvePluginSpecResult {
  */
 export async function resolvePluginSpecWithAutoRegister(
   spec: string,
+  options: { offline?: boolean } = {},
 ): Promise<ResolvePluginSpecResult> {
   // Parse plugin@marketplace using the parser
   const parsed = parsePluginSpec(spec);
@@ -778,6 +797,7 @@ export async function resolvePluginSpecWithAutoRegister(
   const resolved = await resolvePluginSpec(spec, {
     ...(subpath && { subpath }),
     marketplaceNameOverride: marketplace.name,
+    ...(options.offline != null && { offline: options.offline }),
   });
   if (!resolved) {
     return {

src/core/plugin.ts

@@ -95,7 +95,7 @@ export async function fetchPlugin(
 
   // Check if gh CLI is available
   try {
-    await execaFn('gh', ['--version']);
+    await execaFn('gh', ['--version'], { stdin: 'ignore' });
   } catch {
     return {
       success: false,
@@ -120,7 +120,7 @@ export async function fetchPlugin(
   try {
     if (isCached) {
       // Default: pull latest changes
-      await execaFn('git', ['pull'], { cwd: cachePath });
+      await execaFn('git', ['pull'], { cwd: cachePath, stdin: 'ignore' });
 
       return {
         success: true,
@@ -135,9 +135,9 @@ export async function fetchPlugin(
 
     // Clone repository with specific branch if provided
     if (branch) {
-      await execaFn('gh', ['repo', 'clone', `${owner}/${repo}`, cachePath, '--', '--branch', branch]);
+      await execaFn('gh', ['repo', 'clone', `${owner}/${repo}`, cachePath, '--', '--branch', branch], { stdin: 'ignore' });
     } else {
-      await execaFn('gh', ['repo', 'clone', `${owner}/${repo}`, cachePath]);
+      await execaFn('gh', ['repo', 'clone', `${owner}/${repo}`, cachePath], { stdin: 'ignore' });
     }
 
     return {
@@ -281,7 +281,7 @@ export async function updateCachedPlugins(
 
   for (const plugin of toUpdate) {
     try {
-      await execa('git', ['pull'], { cwd: plugin.path });
+      await execa('git', ['pull'], { cwd: plugin.path, stdin: 'ignore' });
       results.push({ name: plugin.name, success: true });
     } catch (error) {
       results.push({

src/core/status.ts

@@ -147,7 +147,7 @@ async function getUserPluginStatuses(): Promise<PluginStatus[]> {
  * Get status of a plugin@marketplace spec
  */
 async function getMarketplacePluginStatus(spec: string): Promise<PluginStatus> {
-  const resolved = await resolvePluginSpecWithAutoRegister(spec);
+  const resolved = await resolvePluginSpecWithAutoRegister(spec, { offline: true });
 
   return {
     source: spec,

tests/unit/core/marketplace.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
-import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { mkdirSync, mkdtempSync, writeFileSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 import {
@@ -326,3 +326,81 @@ describe('getMarketplacePluginsFromManifest', () => {
     expect(result.warnings).toEqual([]);
   });
 });
+
+describe('resolvePluginSpec offline mode', () => {
+  it('does not call fetchFn when offline is true', async () => {
+    const testDir = mkdtempSync(join(tmpdir(), 'mp-offline-'));
+    const manifestDir = join(testDir, '.claude-plugin');
+    mkdirSync(manifestDir, { recursive: true });
+
+    const manifest = {
+      name: 'test-marketplace',
+      plugins: [
+        {
+          name: 'remote-plugin',
+          description: 'A remote plugin',
+          source: { source: 'url', url: 'https://github.com/owner/repo' },
+        },
+      ],
+    };
+
+    writeFileSync(
+      join(manifestDir, 'marketplace.json'),
+      JSON.stringify(manifest),
+    );
+
+    let fetchCalled = false;
+    const result = await resolvePluginSpec('remote-plugin@test-marketplace', {
+      marketplacePathOverride: testDir,
+      offline: true,
+      fetchFn: async () => {
+        fetchCalled = true;
+        return { success: true, action: 'fetched' as const, cachePath: '/fake' };
+      },
+    });
+
+    expect(fetchCalled).toBe(false);
+    expect(result).toBeNull();
+
+    rmSync(testDir, { recursive: true, force: true });
+  });
+
+  it('returns cached path when offline and plugin is already cached', async () => {
+    const testDir = mkdtempSync(join(tmpdir(), 'mp-offline-cached-'));
+    const manifestDir = join(testDir, '.claude-plugin');
+    mkdirSync(manifestDir, { recursive: true });
+
+    // Create a fake cache directory that matches what getPluginCachePath returns
+    const { getPluginCachePath: getCachePath } = await import('../../../src/utils/plugin-path.js');
+    const cachePath = getCachePath('someowner', 'somerepo');
+    mkdirSync(cachePath, { recursive: true });
+
+    const manifest = {
+      name: 'test-marketplace',
+      plugins: [
+        {
+          name: 'cached-plugin',
+          description: 'A cached remote plugin',
+          source: { source: 'url', url: 'https://github.com/someowner/somerepo' },
+        },
+      ],
+    };
+
+    writeFileSync(
+      join(manifestDir, 'marketplace.json'),
+      JSON.stringify(manifest),
+    );
+
+    const result = await resolvePluginSpec('cached-plugin@test-marketplace', {
+      marketplacePathOverride: testDir,
+      offline: true,
+    });
+
+    expect(result).not.toBeNull();
+    expect(result!.path).toBe(cachePath);
+
+    // Cleanup
+    rmSync(cachePath, { recursive: true, force: true });
+    rmSync(testDir, { recursive: true, force: true });
+  });
+});