command-stream 0.8.2 → 0.9.0

package/js/examples/gh-hang-exact-original.mjs

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+import { promises as fs } from 'fs';
+import path from 'path';
+import os from 'os';
+
+console.log('=== Testing EXACT original hanging scenario ===\n');
+console.log('Using: --secret flag, no 2>&1, capture: true, mirror: false\n');
+
+const tempFile = path.join(os.tmpdir(), 'original-hang-test.md');
+await fs.writeFile(
+  tempFile,
+  '# Test\nThis tests the exact original scenario\n'
+);
+
+try {
+  console.log('Running command that originally hung...');
+  const startTime = Date.now();
+
+  // EXACT original command that hung
+  const result =
+    await $`gh gist create ${tempFile} --desc "original-hang-test" --secret`.run(
+      {
+        capture: true,
+        mirror: false,
+        // No timeout in original
+      }
+    );
+
+  const duration = Date.now() - startTime;
+
+  console.log(`\n✅ Completed in ${duration}ms`);
+  console.log('Exit code:', result.code);
+  console.log('Stdout:', result.stdout?.trim());
+  console.log('Stderr:', result.stderr?.trim());
+
+  // Cleanup
+  if (result.stdout?.includes('gist.github.com')) {
+    const gistId = result.stdout.trim().split('/').pop();
+    await $`gh gist delete ${gistId} --yes`.run({
+      capture: true,
+      mirror: false,
+    });
+    console.log('Cleaned up gist:', gistId);
+  }
+} catch (error) {
+  console.log('\n❌ FAILED');
+  console.log('Error:', error.message);
+  console.log('This reproduces the original hanging issue!');
+}
+
+await fs.unlink(tempFile).catch(() => {});
+
+console.log('\n=== Testing with variations ===\n');
+
+// Test if --secret vs --public=false makes a difference
+console.log('Test with --public=false instead of --secret:');
+await fs.writeFile(tempFile, 'Test content\n');
+
+try {
+  const result =
+    await $`gh gist create ${tempFile} --desc "public-false-test" --public=false`.run(
+      {
+        capture: true,
+        mirror: false,
+      }
+    );
+
+  console.log('✅ --public=false works');
+
+  if (result.stdout?.includes('gist.github.com')) {
+    const gistId = result.stdout.trim().split('/').pop();
+    await $`gh gist delete ${gistId} --yes`.run({
+      capture: true,
+      mirror: false,
+    });
+  }
+} catch (error) {
+  console.log('❌ --public=false also fails:', error.message);
+}
+
+await fs.unlink(tempFile).catch(() => {});

package/js/examples/gh-hang-reproduction.mjs

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+import { promises as fs } from 'fs';
+import path from 'path';
+import os from 'os';
+
+console.log('=== Reproducing gh gist create hanging issue ===\n');
+
+// Create test file
+const testFile = path.join(os.tmpdir(), 'hang-test.txt');
+await fs.writeFile(testFile, 'Test content\n');
+
+console.log('Test 1: WITHOUT 2>&1 redirection (potential hang)');
+console.log('Running gh gist create WITHOUT stderr redirection...');
+console.log("(This might hang if there's an issue)\n");
+
+try {
+  const startTime = Date.now();
+
+  // This was the problematic case
+  const result =
+    await $`gh gist create ${testFile} --desc "hang-test" --public=false`.run({
+      capture: true,
+      mirror: false, // Not mirroring - just capturing
+      timeout: 5000, // 5 second safety timeout
+    });
+
+  const duration = Date.now() - startTime;
+
+  console.log('✅ Completed in', duration, 'ms');
+  console.log('Exit code:', result.code);
+  console.log('Stdout length:', result.stdout?.length);
+  console.log('Stderr length:', result.stderr?.length);
+  console.log('Stdout content:', result.stdout?.trim());
+  console.log('Stderr content:', result.stderr?.trim());
+
+  // Clean up gist if created
+  if (result.stdout && result.stdout.includes('gist.github.com')) {
+    const gistId = result.stdout.trim().split('/').pop();
+    await $`gh gist delete ${gistId} --yes`.run({
+      capture: true,
+      mirror: false,
+    });
+    console.log('Cleaned up gist:', gistId);
+  }
+} catch (error) {
+  console.log('❌ Failed or timed out');
+  console.log('Error:', error.message);
+  if (error.killed) {
+    console.log('Process was killed (likely timeout)');
+  }
+}
+
+console.log('\n---\n');
+
+console.log('Test 2: WITH 2>&1 redirection (should work)');
+console.log('Running gh gist create WITH stderr redirection...\n');
+
+try {
+  const startTime = Date.now();
+
+  // This is the workaround
+  const result =
+    await $`gh gist create ${testFile} --desc "hang-test-2" --public=false 2>&1`.run(
+      {
+        capture: true,
+        mirror: false,
+        timeout: 5000,
+      }
+    );
+
+  const duration = Date.now() - startTime;
+
+  console.log('✅ Completed in', duration, 'ms');
+  console.log('Exit code:', result.code);
+  console.log('Stdout length:', result.stdout?.length);
+  console.log('Stderr length:', result.stderr?.length);
+  console.log(
+    'Stdout content (first 200 chars):',
+    result.stdout?.slice(0, 200)
+  );
+  console.log('Stderr content:', result.stderr?.trim());
+
+  // Extract URL from output
+  const lines = result.stdout.trim().split('\n');
+  const gistUrl = lines.find((line) => line.includes('gist.github.com'));
+
+  if (gistUrl) {
+    const gistId = gistUrl.split('/').pop();
+    await $`gh gist delete ${gistId} --yes`.run({
+      capture: true,
+      mirror: false,
+    });
+    console.log('Cleaned up gist:', gistId);
+  }
+} catch (error) {
+  console.log('❌ Failed');
+  console.log('Error:', error.message);
+}
+
+console.log('\n---\n');
+
+console.log('Test 3: WITH mirror: true (should also work)');
+console.log('Running gh gist create WITH output mirroring...\n');
+
+try {
+  const startTime = Date.now();
+
+  // Test with mirror enabled
+  const result =
+    await $`gh gist create ${testFile} --desc "hang-test-3" --public=false`.run(
+      {
+        capture: true,
+        mirror: true, // This time we mirror output
+        timeout: 5000,
+      }
+    );
+
+  const duration = Date.now() - startTime;
+
+  console.log('\n✅ Completed in', duration, 'ms');
+  console.log('Exit code:', result.code);
+  console.log('Stdout captured:', result.stdout?.trim());
+
+  // Clean up
+  if (result.stdout && result.stdout.includes('gist.github.com')) {
+    const gistId = result.stdout.trim().split('/').pop();
+    await $`gh gist delete ${gistId} --yes`.run({
+      capture: true,
+      mirror: false,
+    });
+    console.log('Cleaned up gist:', gistId);
+  }
+} catch (error) {
+  console.log('❌ Failed');
+  console.log('Error:', error.message);
+}
+
+// Clean up test file
+await fs.unlink(testFile).catch(() => {});
+
+console.log('\n=== Summary ===');
+console.log('If Test 1 hangs/times out but Tests 2 and 3 work, then:');
+console.log(
+  '- Issue: gh outputs progress to stderr, and $.mjs might not handle it well'
+);
+console.log('- Workaround 1: Use 2>&1 to redirect stderr to stdout');
+console.log(
+  '- Workaround 2: Use mirror: true to display output while capturing'
+);

package/js/examples/gh-hang-test-with-redirect.mjs

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+import { promises as fs } from 'fs';
+
+console.log('Testing gh gist create WITH 2>&1 (should work)');
+console.log('This test will timeout after 10 seconds if it hangs\n');
+
+const testFile = '/tmp/hang-test-with-redirect.txt';
+await fs.writeFile(testFile, 'Test content\n');
+
+try {
+  const startTime = Date.now();
+
+  // WITH 2>&1 - should work
+  const result =
+    await $`gh gist create ${testFile} --desc "test-no-hang" --public=false 2>&1`.run(
+      {
+        capture: true,
+        mirror: false,
+        timeout: 10000,
+      }
+    );
+
+  const duration = Date.now() - startTime;
+  console.log(`✅ SUCCESS - Completed in ${duration}ms`);
+  console.log('Exit code:', result.code);
+  console.log('Output:', result.stdout?.trim());
+
+  // Cleanup
+  const lines = result.stdout?.trim().split('\n') || [];
+  const gistUrl = lines.find((line) => line.includes('gist.github.com'));
+  if (gistUrl) {
+    const gistId = gistUrl.split('/').pop();
+    await $`gh gist delete ${gistId} --yes`.run({
+      capture: true,
+      mirror: false,
+    });
+  }
+} catch (error) {
+  console.log('❌ FAILED');
+  console.log('Error:', error.message);
+}
+
+await fs.unlink(testFile).catch(() => {});

package/js/examples/gh-hang-test-without-redirect.mjs

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+import { promises as fs } from 'fs';
+
+console.log('Testing gh gist create WITHOUT 2>&1 (potential hang)');
+console.log('This test will timeout after 10 seconds if it hangs\n');
+
+const testFile = '/tmp/hang-test-no-redirect.txt';
+await fs.writeFile(testFile, 'Test content\n');
+
+try {
+  const startTime = Date.now();
+
+  // WITHOUT 2>&1 - might hang
+  const result =
+    await $`gh gist create ${testFile} --desc "test-hang" --public=false`.run({
+      capture: true,
+      mirror: false,
+      timeout: 10000,
+    });
+
+  const duration = Date.now() - startTime;
+  console.log(`✅ SUCCESS - Completed in ${duration}ms`);
+  console.log('Exit code:', result.code);
+  console.log('Stdout:', result.stdout?.trim());
+  console.log('Stderr:', result.stderr?.trim());
+
+  // Cleanup
+  if (result.stdout?.includes('gist.github.com')) {
+    const gistId = result.stdout.trim().split('/').pop();
+    await $`gh gist delete ${gistId} --yes`.run({
+      capture: true,
+      mirror: false,
+    });
+  }
+} catch (error) {
+  console.log('❌ FAILED or TIMED OUT');
+  console.log('Error:', error.message);
+  console.log('This confirms the hanging issue!');
+}
+
+await fs.unlink(testFile).catch(() => {});

package/js/examples/gh-minimal-hang-check.mjs

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== Minimal test for hanging ===\n');
+
+// Test 1: Simple command without any options
+console.log('Test 1: Most basic gh command');
+const result1 = await $`gh --version`;
+console.log('✅ Basic command works\n');
+
+// Test 2: Command with capture but no mirror
+console.log('Test 2: With capture: true, mirror: false');
+const result2 = await $`gh --version`.run({ capture: true, mirror: false });
+console.log('Exit code:', result2.code);
+console.log('✅ Capture works\n');
+
+// Test 3: Command that fails
+console.log('Test 3: Command that should fail');
+try {
+  const result3 = await $`gh gist view nonexistent-id`.run({
+    capture: true,
+    mirror: false,
+  });
+  console.log('Exit code:', result3.code);
+  console.log('Stdout:', result3.stdout);
+  console.log('Stderr:', result3.stderr);
+} catch (error) {
+  console.log('Caught error:', error.message);
+  console.log('Exit code:', error.code);
+}
+
+console.log('\n=== All tests completed ===');

package/js/examples/gh-operations-with-cd.mjs

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+
+import { $, shell, enableVirtualCommands } from '../src/$.mjs';
+import { mkdtempSync, rmSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+// Enable virtual commands including cd
+enableVirtualCommands();
+shell.verbose(true);
+
+console.log('=== GitHub CLI Operations with cd Virtual Command Examples ===\n');
+
+async function example1_CheckGHAuth() {
+  console.log('Example 1: Check GitHub CLI Authentication\n');
+
+  try {
+    // Check auth status
+    const authStatus = await $`gh auth status 2>&1 || echo "Not authenticated"`;
+
+    // Try to get current user
+    const user =
+      await $`gh api user --jq .login 2>/dev/null || echo "anonymous"`;
+    console.log(`Current user: ${user.stdout.trim()}`);
+
+    // Check gh version
+    const version = await $`gh --version`;
+    console.log(`GitHub CLI version: ${version.stdout.split('\n')[0]}`);
+
+    console.log('✓ GitHub CLI check completed\n');
+  } catch (error) {
+    console.error('Error:', error.message);
+  }
+}
+
+async function example2_SimulateRepoClone() {
+  console.log('Example 2: Simulate Repository Clone Pattern\n');
+
+  const tempDir = mkdtempSync(join(tmpdir(), 'gh-clone-'));
+  const originalCwd = process.cwd();
+
+  try {
+    // This simulates the pattern from solve.mjs
+    const owner = 'octocat';
+    const repo = 'Hello-World';
+
+    console.log(`Simulating clone of ${owner}/${repo} to ${tempDir}`);
+
+    // Navigate to temp directory
+    await $`cd ${tempDir}`;
+
+    // In real scenario, this would clone the repo
+    // For example purposes, we'll create a mock structure
+    await $`git init`;
+    await $`git config user.email "bot@example.com"`;
+    await $`git config user.name "Bot"`;
+    await $`echo "# ${repo}" > README.md`;
+    await $`git add . && git commit -m "Initial commit"`;
+
+    // Simulate gh commands that would work in a cloned repo
+    console.log('\nSimulating gh pr list (would fail without remote):');
+    await $`gh pr list --limit 1 2>&1 || echo "No remote repository"`;
+
+    // Return to original directory
+    await $`cd ${originalCwd}`;
+
+    console.log('✓ Clone pattern simulation completed\n');
+  } catch (error) {
+    console.error('Error:', error.message);
+  } finally {
+    rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+
+async function example3_WorkflowWithTempDir() {
+  console.log('Example 3: Complete Workflow in Temp Directory\n');
+
+  const tempDir = mkdtempSync(join(tmpdir(), 'workflow-'));
+  const originalCwd = process.cwd();
+
+  try {
+    // Step 1: Setup repository
+    console.log('Step 1: Initialize repository');
+    await $`cd ${tempDir} && git init`;
+    await $`cd ${tempDir} && git config user.email "workflow@example.com"`;
+    await $`cd ${tempDir} && git config user.name "Workflow Bot"`;
+
+    // Step 2: Create initial structure
+    console.log('\nStep 2: Create project structure');
+    await $`cd ${tempDir} && mkdir -p src tests docs`;
+    await $`cd ${tempDir} && echo "# Project" > README.md`;
+    await $`cd ${tempDir} && echo "console.log('Hello');" > src/index.js`;
+    await $`cd ${tempDir} && echo "test('example', () => {});" > tests/test.js`;
+
+    // Step 3: Initial commit
+    console.log('\nStep 3: Create initial commit');
+    await $`cd ${tempDir} && git add .`;
+    await $`cd ${tempDir} && git commit -m "Initial project structure"`;
+
+    // Step 4: Create feature branch
+    console.log('\nStep 4: Create feature branch');
+    const branchName = `feature-${Date.now()}`;
+    await $`cd ${tempDir} && git checkout -b ${branchName}`;
+
+    // Step 5: Make feature changes
+    console.log('\nStep 5: Implement feature');
+    await $`cd ${tempDir} && echo "export const feature = () => 'new feature';" > src/feature.js`;
+    await $`cd ${tempDir} && git add .`;
+    await $`cd ${tempDir} && git commit -m "Add new feature"`;
+
+    // Step 6: Show repository state
+    console.log('\nStep 6: Show repository state');
+    await $`cd ${tempDir} && git log --oneline --graph --all`;
+    await $`cd ${tempDir} && git status`;
+
+    // Return to original directory
+    await $`cd ${originalCwd}`;
+
+    console.log('\n✓ Workflow completed successfully\n');
+  } catch (error) {
+    console.error('Error:', error.message);
+  } finally {
+    rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+
+async function example4_MultipleDirectoryOperations() {
+  console.log('Example 4: Multiple Directory Operations\n');
+
+  const baseDir = mkdtempSync(join(tmpdir(), 'multi-'));
+  const project1 = join(baseDir, 'project1');
+  const project2 = join(baseDir, 'project2');
+  const originalCwd = process.cwd();
+
+  try {
+    // Create project directories
+    await $`mkdir -p ${project1} ${project2}`;
+
+    // Initialize project 1
+    console.log('Setting up project1:');
+    await $`cd ${project1} && git init && echo "Project 1" > README.md`;
+    await $`cd ${project1} && git add . && git config user.email "p1@test.com"`;
+    await $`cd ${project1} && git commit -m "Project 1 init" 2>/dev/null || echo "Commit created"`;
+
+    // Initialize project 2
+    console.log('\nSetting up project2:');
+    await $`cd ${project2} && git init && echo "Project 2" > README.md`;
+    await $`cd ${project2} && git add . && git config user.email "p2@test.com"`;
+    await $`cd ${project2} && git commit -m "Project 2 init" 2>/dev/null || echo "Commit created"`;
+
+    // Show both project states
+    console.log('\nProject 1 status:');
+    await $`cd ${project1} && git log --oneline`;
+
+    console.log('\nProject 2 status:');
+    await $`cd ${project2} && git log --oneline`;
+
+    // Demonstrate that cd doesn't affect parent shell
+    const pwdResult = await $`pwd`;
+    console.log(`\nCurrent directory (unchanged): ${pwdResult.stdout.trim()}`);
+
+    await $`cd ${originalCwd}`;
+
+    console.log('\n✓ Multiple directory operations completed\n');
+  } catch (error) {
+    console.error('Error:', error.message);
+  } finally {
+    rmSync(baseDir, { recursive: true, force: true });
+  }
+}
+
+// Run all examples
+async function runExamples() {
+  try {
+    await example1_CheckGHAuth();
+    await example2_SimulateRepoClone();
+    await example3_WorkflowWithTempDir();
+    await example4_MultipleDirectoryOperations();
+
+    console.log('=== All GitHub CLI Examples Completed ===');
+  } catch (error) {
+    console.error('Failed to run examples:', error);
+    process.exit(1);
+  }
+}
+
+runExamples();

package/js/examples/gh-output-test.mjs

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('=== Testing where gh auth status outputs go ===\n');
+
+// Test 1: Capture stdout and stderr separately
+console.log('Test 1: Capture stdout and stderr separately');
+try {
+  const result = await $`gh auth status`.run({ capture: true, mirror: false });
+  console.log('Exit code:', result.code);
+  console.log(
+    'Stdout content:',
+    result.stdout ? `"${result.stdout.slice(0, 50)}..."` : '(empty)'
+  );
+  console.log('Stdout length:', result.stdout?.length || 0);
+  console.log(
+    'Stderr content:',
+    result.stderr ? `"${result.stderr.slice(0, 50)}..."` : '(empty)'
+  );
+  console.log('Stderr length:', result.stderr?.length || 0);
+
+  // Check where the actual output is
+  if (result.stdout && result.stdout.includes('Logged in')) {
+    console.log('✅ Output is in STDOUT');
+  } else if (result.stderr && result.stderr.includes('Logged in')) {
+    console.log('⚠️ Output is in STDERR (need 2>&1 redirection)');
+  } else {
+    console.log('❌ Output not found in either stdout or stderr');
+  }
+} catch (error) {
+  console.log('Error:', error.message);
+}
+
+console.log('\n---\n');
+
+// Test 2: With 2>&1 redirection
+console.log('Test 2: With 2>&1 redirection to capture all output');
+try {
+  const result = await $`gh auth status 2>&1`.run({
+    capture: true,
+    mirror: false,
+  });
+  console.log('Exit code:', result.code);
+  console.log(
+    'Combined stdout content:',
+    result.stdout ? `"${result.stdout.slice(0, 50)}..."` : '(empty)'
+  );
+  console.log('Combined stdout length:', result.stdout?.length || 0);
+  console.log(
+    'Stderr after redirect:',
+    result.stderr ? `"${result.stderr.slice(0, 50)}..."` : '(empty)'
+  );
+  console.log('Stderr length:', result.stderr?.length || 0);
+
+  if (result.stdout && result.stdout.includes('Logged in')) {
+    console.log('✅ Output captured successfully with 2>&1');
+  }
+} catch (error) {
+  console.log('Error:', error.message);
+}
+
+console.log('\n---\n');
+
+// Test 3: Test if we're authenticated
+console.log('Test 3: Authentication check');
+try {
+  // First try without redirection
+  const result1 = await $`gh auth status`.run({ capture: true, mirror: false });
+  const output1 = (result1.stdout || '') + (result1.stderr || '');
+
+  // Then try with redirection
+  const result2 = await $`gh auth status 2>&1`.run({
+    capture: true,
+    mirror: false,
+  });
+  const output2 = result2.stdout || '';
+
+  // Use whichever has content
+  const output = output1.length > output2.length ? output1 : output2;
+
+  if (output.includes('✓') && output.includes('Logged in to')) {
+    console.log('✅ Authenticated to GitHub');
+    const userMatch = output.match(/account\s+(\S+)/);
+    if (userMatch) {
+      console.log('   User:', userMatch[1]);
+    }
+    const scopeMatch = output.match(/Token scopes:\s*'([^']+)'/);
+    if (scopeMatch) {
+      console.log('   Scopes:', scopeMatch[1]);
+    }
+  } else {
+    console.log('❌ Not authenticated or unable to parse status');
+  }
+} catch (error) {
+  console.log('Error checking auth:', error.message);
+}
+
+console.log('\n=== Summary ===');
+console.log('gh auth status outputs to STDOUT (not STDERR) when successful');
+console.log('Use `.run({ capture: true })` to capture the output');
+console.log('Exit code 0 = authenticated, 1 = not authenticated');

package/js/examples/gh-reproduce-hang.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+import { promises as fs } from 'fs';
+import path from 'path';
+import os from 'os';
+
+console.log('=== Attempting to reproduce the hanging issue ===\n');
+console.log('Using invalid --secret flag without timeout or error handling');
+console.log('This should demonstrate the hanging behavior\n');
+
+const tempFile = path.join(os.tmpdir(), 'hang-reproduce.md');
+await fs.writeFile(tempFile, '# Test Gist\nTrying to reproduce hanging\n');
+
+console.log('Starting command that should hang...');
+console.log('If this hangs, press Ctrl+C to stop\n');
+
+// This is the problematic combination:
+// 1. Invalid --secret flag
+// 2. No timeout
+// 3. No 2>&1 redirect
+// 4. capture: true, mirror: false
+// 5. No error handling to catch the exit code
+
+const startTime = Date.now();
+
+const result =
+  await $`gh gist create ${tempFile} --desc "hang-test" --secret`.run({
+    capture: true,
+    mirror: false,
+    // No timeout - let it hang if it will
+  });
+
+// If we get here, it didn't hang
+const duration = Date.now() - startTime;
+console.log(`\nCompleted in ${duration}ms (did not hang)`);
+console.log('Exit code:', result.code);
+console.log('Stdout:', result.stdout);
+console.log('Stderr:', result.stderr);
+
+await fs.unlink(tempFile).catch(() => {});