command-stream 0.8.2 → 0.9.0

package/js/examples/final-working-examples.mjs

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+
+/**
+ * Final working examples of streaming interfaces for README
+ */
+
+import { $ } from '../src/$.mjs';
+
+console.log('🚀 Final Working Examples - Streaming Interfaces');
+console.log('='.repeat(55));
+
+async function finalWorkingExamples() {
+  try {
+    console.log('\\n📝 EXAMPLE 1: Send data via streams.stdin');
+    console.log('─'.repeat(30));
+
+    // Create a simple echo script that waits for input
+    const echoCmd = $`node -e "process.stdin.pipe(process.stdout)"`;
+    const stdin = await echoCmd.streams.stdin;
+
+    if (stdin) {
+      stdin.write('Hello from stdin!\\n');
+      stdin.write('Multiple lines work!\\n');
+      stdin.end();
+    }
+
+    const result = await echoCmd;
+    console.log('✅ Output:', JSON.stringify(result.stdout));
+
+    console.log('\\n🔧 EXAMPLE 2: Filter data with grep');
+    console.log('─'.repeat(30));
+
+    const grepCmd = $`grep "important"`;
+    const grepStdin = await grepCmd.streams.stdin;
+
+    if (grepStdin) {
+      grepStdin.write('ignore this line\\n');
+      grepStdin.write('important message 1\\n');
+      grepStdin.write('skip this too\\n');
+      grepStdin.write('another important note\\n');
+      grepStdin.end();
+    }
+
+    const grepResult = await grepCmd;
+    console.log('✅ Filtered output:', JSON.stringify(grepResult.stdout));
+
+    console.log('\\n📊 EXAMPLE 3: Sort data via stdin');
+    console.log('─'.repeat(30));
+
+    const sortCmd = $`sort`;
+    const sortStdin = await sortCmd.streams.stdin;
+
+    if (sortStdin) {
+      sortStdin.write('zebra\\n');
+      sortStdin.write('apple\\n');
+      sortStdin.write('banana\\n');
+      sortStdin.write('cherry\\n');
+      sortStdin.end();
+    }
+
+    const sortResult = await sortCmd;
+    console.log('✅ Sorted output:', JSON.stringify(sortResult.stdout));
+
+    console.log('\\n🧮 EXAMPLE 4: Calculator with bc');
+    console.log('─'.repeat(30));
+
+    const calcCmd = $`bc -l`;
+    const calcStdin = await calcCmd.streams.stdin;
+
+    if (calcStdin) {
+      calcStdin.write('scale=2\\n'); // Set decimal precision
+      calcStdin.write('10 / 3\\n'); // Division
+      calcStdin.write('sqrt(16)\\n'); // Square root
+      calcStdin.write('quit\\n'); // Exit
+    }
+
+    const calcResult = await calcCmd;
+    console.log(
+      '✅ Calculation results:',
+      JSON.stringify(calcResult.stdout.trim())
+    );
+
+    console.log('\\n🔄 EXAMPLE 5: Text transformation with tr');
+    console.log('─'.repeat(30));
+
+    const trCmd = $`tr 'a-z' 'A-Z'`; // Convert to uppercase
+    const trStdin = await trCmd.streams.stdin;
+
+    if (trStdin) {
+      trStdin.write('hello world\\n');
+      trStdin.write('this is lowercase text\\n');
+      trStdin.end();
+    }
+
+    const trResult = await trCmd;
+    console.log('✅ Transformed text:', JSON.stringify(trResult.stdout));
+
+    console.log(
+      '\\n⚡ EXAMPLE 6: Process control - kill() for commands that ignore stdin'
+    );
+    console.log('─'.repeat(30));
+
+    const pingCmd = $`ping -c 10 8.8.8.8`; // Long ping
+
+    // Try stdin (will be ignored by ping)
+    setTimeout(async () => {
+      const pingStdin = await pingCmd.streams.stdin;
+      if (pingStdin) {
+        pingStdin.write('q\\n');
+        pingStdin.end();
+        console.log('  📝 Sent "q" to ping (will be ignored)');
+      }
+    }, 500);
+
+    // Use kill() since ping ignores stdin
+    setTimeout(() => {
+      console.log('  🔪 Using kill() method to stop ping...');
+      pingCmd.kill();
+    }, 1500);
+
+    const pingResult = await pingCmd;
+    console.log('✅ Ping stopped with exit code:', pingResult.code);
+    console.log(
+      '✅ Captured',
+      pingResult.stdout.length,
+      'characters of output'
+    );
+
+    console.log('\\n🎯 EXAMPLE 7: Mixed stdout/stderr handling');
+    console.log('─'.repeat(30));
+
+    const mixedCmd = $`sh -c 'echo "stdout message" && echo "stderr message" >&2'`;
+
+    const [stdout, stderr] = await Promise.all([
+      mixedCmd.strings.stdout,
+      mixedCmd.strings.stderr,
+    ]);
+
+    console.log('✅ Stdout:', JSON.stringify(stdout.trim()));
+    console.log('✅ Stderr:', JSON.stringify(stderr.trim()));
+
+    console.log(`\\n${'='.repeat(55)}`);
+    console.log('🎉 ALL STREAMING EXAMPLES COMPLETED SUCCESSFULLY!');
+    console.log('\\n📋 Key Takeaways:');
+    console.log(
+      '  ✅ await cmd.streams.stdin  - Send data to interactive commands'
+    );
+    console.log('  ✅ await cmd.buffers.stdout - Get binary data');
+    console.log('  ✅ await cmd.strings.stderr - Get text data');
+    console.log(
+      '  ✅ cmd.kill()               - Stop processes that ignore stdin'
+    );
+    console.log('  ✅ Works with: grep, sort, bc, tr, node, python, etc.');
+    console.log('  ✅ Network commands (ping) need kill(), not stdin');
+  } catch (error) {
+    console.log('\\n❌ ERROR:', error.message);
+    console.error(error.stack);
+    process.exit(1);
+  }
+}
+
+finalWorkingExamples();

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

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+
+console.log('Testing gh auth status with $.mjs\n');
+
+// Test 1: Basic gh auth status with capture
+console.log('Test 1: Using .run() with capture');
+try {
+  const result = await $`gh auth status`.run({ capture: true, mirror: false });
+  console.log('Exit code:', result.code);
+  console.log('Stdout length:', result.stdout.length);
+  console.log('Stderr length:', result.stderr.length);
+  console.log('Success: gh auth check passed\n');
+} catch (error) {
+  console.log('Error with .run():', error.message);
+  console.log('Exit code:', error.code);
+  console.log('Stdout:', error.stdout);
+  console.log('Stderr:', error.stderr);
+}
+
+// Test 2: Using await directly
+console.log('Test 2: Using await directly');
+try {
+  const result = await $`gh auth status`;
+  console.log('Exit code:', result.code);
+  console.log('Success: gh auth check passed\n');
+} catch (error) {
+  console.log('Error with await:', error.message);
+}
+
+// Test 3: Check with 2>&1 redirection
+console.log('Test 3: Using 2>&1 redirection');
+try {
+  const result = await $`gh auth status 2>&1`.run({
+    capture: true,
+    mirror: false,
+  });
+  console.log('Exit code:', result.code);
+  console.log('Combined output length:', result.stdout.length);
+  console.log('Success: gh auth check passed\n');
+} catch (error) {
+  console.log('Error with redirection:', error.message);
+}
+
+// Test 4: Using streaming
+console.log('Test 4: Using streaming');
+try {
+  const cmd = $`gh auth status`;
+  let outputReceived = false;
+
+  for await (const chunk of cmd.stream()) {
+    outputReceived = true;
+    console.log(
+      `Received ${chunk.type}: ${chunk.data.toString().slice(0, 50)}...`
+    );
+  }
+
+  const result = await cmd;
+  console.log('Exit code:', result.code);
+  console.log('Stream output received:', outputReceived);
+  console.log('Success: gh auth check passed\n');
+} catch (error) {
+  console.log('Error with streaming:', error.message);
+}
+
+// Test 5: Check actual authentication status
+console.log('Test 5: Parse auth status');
+try {
+  const result = await $`gh auth status 2>&1`.run({
+    capture: true,
+    mirror: false,
+  });
+
+  // Check if output contains success indicators
+  const output = result.stdout + result.stderr;
+  const isAuthenticated =
+    output.includes('Logged in to') || output.includes('✓');
+
+  console.log('Is authenticated:', isAuthenticated);
+
+  if (isAuthenticated) {
+    // Try to extract username
+    const usernameMatch = output.match(/account\s+(\S+)/);
+    if (usernameMatch) {
+      console.log('GitHub username:', usernameMatch[1]);
+    }
+  }
+
+  // The command might exit with 0 even when not authenticated (just showing status)
+  // or exit with 1 when not authenticated
+  console.log('Raw exit code:', result.code);
+} catch (error) {
+  console.log('Failed to check auth status:', error.message);
+  console.log('This might mean gh is not authenticated');
+}
+
+console.log('\n--- Summary ---');
+console.log('gh auth status behavior:');
+console.log('- Exit code 0: gh CLI is installed and can show status');
+console.log('- Exit code 1: Usually means not authenticated');
+console.log('- Output goes to stderr by default (not stdout)');
+console.log('- Use 2>&1 to capture the status output');

package/js/examples/gh-delete-hang-test.mjs

@@ -0,0 +1,79 @@
+#!/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 gh gist delete hanging scenario ===\n');
+
+// First create a gist to delete
+const tempFile = path.join(os.tmpdir(), 'delete-hang-test.txt');
+await fs.writeFile(tempFile, 'Test content for deletion\n');
+
+console.log('Creating a gist to test deletion...');
+const createResult =
+  await $`gh gist create ${tempFile} --desc "delete-test" --public=false 2>&1`.run(
+    {
+      capture: true,
+      mirror: false,
+    }
+  );
+
+const lines = createResult.stdout.trim().split('\n');
+const gistUrl = lines.find((line) => line.includes('gist.github.com'));
+if (!gistUrl) {
+  console.error('Failed to create test gist');
+  process.exit(1);
+}
+
+const gistId = gistUrl.split('/').pop();
+console.log('Created gist:', gistId);
+
+console.log('\nNow testing deletion that might hang...');
+console.log('Using the pattern from the original test:\n');
+
+// This is the pattern that was in the original test
+async function deleteGist(gistId) {
+  console.log('🗑️  Deleting the test gist...');
+
+  try {
+    const deleteResult = await $`gh gist delete ${gistId} --yes`.run({
+      capture: true,
+      mirror: false,
+    });
+    console.log('   - Exit code:', deleteResult.code);
+    console.log('   - ✅ Gist deleted successfully');
+    return true;
+  } catch (error) {
+    console.log('   ❌ Failed to delete:', error.message);
+    return false;
+  }
+}
+
+// Call the delete function
+const startTime = Date.now();
+await deleteGist(gistId);
+const deleteTime = Date.now() - startTime;
+console.log(`Delete completed in ${deleteTime}ms`);
+
+// Now try to verify it's gone (this is where it might hang)
+console.log('\n✅ Verifying deletion...');
+const verifyStart = Date.now();
+
+try {
+  console.log('Running gh gist view (this might hang)...');
+  await $`gh gist view ${gistId}`.run({ capture: true, mirror: false });
+  console.log('   ❌ Gist still exists!');
+} catch (error) {
+  console.log('   ✅ Confirmed: gist no longer exists');
+  console.log('   Error code:', error.code);
+}
+
+const verifyTime = Date.now() - verifyStart;
+console.log(`Verification completed in ${verifyTime}ms`);
+
+// Clean up
+await fs.unlink(tempFile).catch(() => {});
+
+console.log('\n=== Test completed without hanging ===');

package/js/examples/gh-gist-creation-test.mjs

@@ -0,0 +1,276 @@
+#!/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 Secret Gist Creation with $.mjs ===\n');
+
+const TEST_GIST_DESC = 'test-gist-from-command-stream';
+const TEST_FILE_CONTENT =
+  '# Test Gist\n\nThis is a test gist created by command-stream $.mjs library.\n';
+
+async function cleanup() {
+  // Clean up any existing test gists
+  console.log('🧹 Cleaning up any existing test gists...');
+  try {
+    const listResult =
+      await $`gh api /gists --jq '.[] | select(.description == "${TEST_GIST_DESC}") | .id'`.run(
+        { capture: true, mirror: false }
+      );
+    const gistIds = listResult.stdout
+      .trim()
+      .split('\n')
+      .filter((id) => id);
+
+    for (const gistId of gistIds) {
+      if (gistId) {
+        console.log(`   Deleting old test gist: ${gistId}`);
+        await $`gh gist delete ${gistId} --yes`.run({
+          capture: true,
+          mirror: false,
+        });
+      }
+    }
+  } catch (error) {
+    console.log('   No existing test gists to clean up');
+  }
+}
+
+async function createGist() {
+  console.log('\n📝 Creating a secret gist...');
+
+  // Create temp file
+  const tempFile = path.join(os.tmpdir(), 'test-gist-content.md');
+  await fs.writeFile(tempFile, TEST_FILE_CONTENT);
+
+  try {
+    // Create secret gist - use 2>&1 to capture all output
+    console.log('   Running: gh gist create with file:', tempFile);
+    const createResult =
+      await $`gh gist create ${tempFile} --desc "${TEST_GIST_DESC}" --public=false 2>&1`.run(
+        {
+          capture: true,
+          mirror: false,
+          timeout: 10000, // 10 second timeout
+        }
+      );
+
+    console.log('   Exit code:', createResult.code);
+    console.log('   Output:', createResult.stdout.trim());
+
+    if (createResult.code !== 0) {
+      throw new Error(`Failed to create gist. Exit code: ${createResult.code}`);
+    }
+
+    // Extract gist ID from URL (last line should be the URL)
+    const outputLines = createResult.stdout.trim().split('\n');
+    const gistUrl =
+      outputLines.find((line) => line.includes('gist.github.com')) ||
+      outputLines[outputLines.length - 1];
+
+    if (!gistUrl || !gistUrl.includes('gist.github.com')) {
+      throw new Error(`Invalid gist URL returned: ${gistUrl}`);
+    }
+
+    const gistId = gistUrl.split('/').pop();
+
+    console.log('   ✅ Gist created with ID:', gistId);
+
+    // Clean up temp file
+    await fs.unlink(tempFile);
+
+    return gistId;
+  } catch (error) {
+    await fs.unlink(tempFile).catch(() => {});
+    throw error;
+  }
+}
+
+async function verifyGistExists(gistId) {
+  console.log('\n🔍 Verifying gist exists...');
+
+  // Method 1: Using gh gist view
+  try {
+    const viewResult = await $`gh gist view ${gistId} --files`.run({
+      capture: true,
+      mirror: false,
+    });
+    console.log('   Method 1 (gh gist view):');
+    console.log('   - Exit code:', viewResult.code);
+    console.log('   - Files found:', viewResult.stdout.trim());
+    console.log('   - ✅ Gist exists and is accessible');
+  } catch (error) {
+    console.log('   ❌ Method 1 failed:', error.message);
+  }
+
+  // Method 2: Using gh api
+  try {
+    const apiResult = await $`gh api /gists/${gistId} --jq '.description'`.run({
+      capture: true,
+      mirror: false,
+    });
+    console.log('   Method 2 (gh api):');
+    console.log('   - Exit code:', apiResult.code);
+    console.log('   - Description:', apiResult.stdout.trim());
+    console.log('   - ✅ Confirmed via API');
+  } catch (error) {
+    console.log('   ❌ Method 2 failed:', error.message);
+  }
+
+  // Method 3: Check if it's secret
+  try {
+    const secretResult = await $`gh api /gists/${gistId} --jq '.public'`.run({
+      capture: true,
+      mirror: false,
+    });
+    const isPublic = secretResult.stdout.trim() === 'true';
+    console.log('   Method 3 (check privacy):');
+    console.log('   - Is public:', isPublic);
+    console.log('   - Is secret:', !isPublic);
+    console.log(
+      '   -',
+      !isPublic ? '✅ Confirmed as secret gist' : '❌ Not a secret gist'
+    );
+  } catch (error) {
+    console.log('   ❌ Method 3 failed:', error.message);
+  }
+}
+
+async function findGistByDescription() {
+  console.log('\n🔎 Finding gist by description...');
+
+  try {
+    // Use jq to filter gists by description
+    const findResult =
+      await $`gh api /gists --jq '.[] | select(.description == "${TEST_GIST_DESC}") | .id + " " + .description' | head -1`.run(
+        { capture: true, mirror: false }
+      );
+
+    if (findResult.stdout.trim()) {
+      const [id, desc] = findResult.stdout.trim().split(' ');
+      console.log('   - Found gist ID:', id);
+      console.log('   - Description:', desc || TEST_GIST_DESC);
+      console.log('   - ✅ Successfully found by description');
+      return id;
+    } else {
+      console.log('   - ❌ No gist found with that description');
+      return null;
+    }
+  } catch (error) {
+    console.log('   ❌ Error finding gist:', error.message);
+    return null;
+  }
+}
+
+async function addFileToGist(gistId) {
+  console.log('\n📎 Adding another file to the gist...');
+
+  const tempFile2 = path.join(os.tmpdir(), 'additional-file.txt');
+  await fs.writeFile(
+    tempFile2,
+    'This is an additional file added to the gist.\n'
+  );
+
+  try {
+    const editResult =
+      await $`gh gist edit ${gistId} ${tempFile2} --filename "added-file.txt"`.run(
+        { capture: true, mirror: false }
+      );
+    console.log('   - Exit code:', editResult.code);
+    console.log('   - ✅ File added successfully');
+
+    // Verify the file was added
+    const filesResult = await $`gh gist view ${gistId} --files`.run({
+      capture: true,
+      mirror: false,
+    });
+    console.log('   - Files in gist:', filesResult.stdout.trim());
+
+    await fs.unlink(tempFile2);
+    return true;
+  } catch (error) {
+    await fs.unlink(tempFile2).catch(() => {});
+    console.log('   ❌ Failed to add file:', error.message);
+    return false;
+  }
+}
+
+async function deleteGist(gistId) {
+  console.log('\n🗑️  Deleting the test gist...');
+
+  try {
+    const deleteResult = await $`gh gist delete ${gistId} --yes`.run({
+      capture: true,
+      mirror: false,
+    });
+    console.log('   - Exit code:', deleteResult.code);
+    console.log('   - ✅ Gist deleted successfully');
+    return true;
+  } catch (error) {
+    console.log('   ❌ Failed to delete:', error.message);
+    return false;
+  }
+}
+
+// Main test flow
+async function runTests() {
+  try {
+    // Check authentication first
+    console.log('🔐 Checking GitHub authentication...');
+    const authResult = await $`gh auth status`.run({
+      capture: true,
+      mirror: false,
+    });
+    if (authResult.code !== 0) {
+      console.error(
+        '❌ Not authenticated to GitHub. Please run: gh auth login'
+      );
+      process.exit(1);
+    }
+    console.log('   ✅ Authenticated\n');
+
+    // Clean up any existing test gists
+    await cleanup();
+
+    // Create a secret gist
+    const gistId = await createGist();
+
+    // Verify it exists
+    await verifyGistExists(gistId);
+
+    // Find it by description
+    const foundId = await findGistByDescription();
+    console.log('   - IDs match:', foundId === gistId ? '✅ Yes' : '❌ No');
+
+    // Add a file to it
+    await addFileToGist(gistId);
+
+    // Delete it
+    await deleteGist(gistId);
+
+    // Verify it's gone
+    console.log('\n✅ Verifying deletion...');
+    try {
+      await $`gh gist view ${gistId}`.run({ capture: true, mirror: false });
+      console.log('   ❌ Gist still exists!');
+    } catch (error) {
+      console.log('   ✅ Confirmed: gist no longer exists');
+    }
+
+    console.log('\n=== Summary ===');
+    console.log(
+      '✅ Successfully created, verified, modified, and deleted a secret gist'
+    );
+    console.log('✅ All operations work correctly with $.mjs');
+    console.log('✅ Exit codes are properly captured');
+    console.log('✅ Output is correctly captured in stdout');
+  } catch (error) {
+    console.error('\n❌ Test failed:', error.message);
+    process.exit(1);
+  }
+}
+
+// Run the tests
+runTests();

package/js/examples/gh-gist-minimal-test.mjs

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+
+import { $ } from '../src/$.mjs';
+import fs from 'fs/promises';
+
+console.log('=== Minimal gh gist create test ===\n');
+
+// Create a test file
+const testFile = '/tmp/test-minimal.txt';
+await fs.writeFile(testFile, 'Test content from minimal test\n');
+
+console.log('Test 1: Direct command execution');
+try {
+  console.log('Running: gh gist create with timeout...');
+  const result =
+    await $`timeout 10 gh gist create ${testFile} --desc "minimal-test" --public=false`.run(
+      {
+        capture: true,
+        mirror: true, // Show output as it happens
+      }
+    );
+
+  console.log('\nResult:');
+  console.log('- Exit code:', result.code);
+  console.log('- Stdout:', result.stdout?.slice(0, 100));
+
+  // Extract gist ID and delete it
+  const gistUrl = result.stdout?.trim();
+  if (gistUrl && gistUrl.includes('gist.github.com')) {
+    const gistId = gistUrl.split('/').pop();
+    console.log('- Gist ID:', gistId);
+
+    // Clean up
+    await $`gh gist delete ${gistId} --yes`.run({
+      capture: true,
+      mirror: false,
+    });
+    console.log('- Cleaned up test gist');
+  }
+} catch (error) {
+  console.log('Error:', error.message);
+  console.log('Exit code:', error.code);
+}
+
+console.log('\n---\n');
+
+console.log('Test 2: Without timeout wrapper');
+try {
+  console.log('Running: gh gist create directly...');
+
+  // Set a timeout option if available
+  const result =
+    await $`gh gist create ${testFile} --desc "minimal-test-2" --public=false`.run(
+      {
+        capture: true,
+        mirror: true,
+        timeout: 10000, // 10 second timeout
+      }
+    );
+
+  console.log('\nResult:');
+  console.log('- Exit code:', result.code);
+  console.log('- Stdout:', result.stdout?.slice(0, 100));
+
+  // Extract gist ID and delete it
+  const gistUrl = result.stdout?.trim();
+  if (gistUrl && gistUrl.includes('gist.github.com')) {
+    const gistId = gistUrl.split('/').pop();
+    console.log('- Gist ID:', gistId);
+
+    // Clean up
+    await $`gh gist delete ${gistId} --yes`.run({
+      capture: true,
+      mirror: false,
+    });
+    console.log('- Cleaned up test gist');
+  }
+} catch (error) {
+  console.log('Error:', error.message);
+  console.log('Exit code:', error.code);
+  if (error.killed) {
+    console.log('Process was killed (timeout?)');
+  }
+}
+
+// Clean up test file
+await fs.unlink(testFile).catch(() => {});
+
+console.log('\n=== Done ===');