Remove piped input support and replace with positional argument handling

Remove piped input detection and TTY handling, replacing it with explicit positional argument support. Users attempting piped input now see a clear error with usage instructions. Variables renamed from `pipedInputPath` to `positionalArgContentPath` to reflect new behavior. Related utility functions, safety checks, and tests removed.

Author: possibilities

src/index.ts

@@ -40,11 +40,11 @@ let tempMcpConfigPath: string | undefined
 let appConfig: AppConfig | undefined
 let yolo: boolean | undefined
 let confirmationPatternTriggers: string[] = []
-let pipedInputPath: string | undefined
+let positionalArgContentPath: string | undefined
 
 const debugLog = util.debuglog('claude-composer')
 
-export { appConfig, pipedInputPath }
+export { appConfig, positionalArgContentPath }
 
 async function initializePatterns(): Promise<boolean> {
   let patternsToUse = patterns
@@ -110,9 +110,9 @@ function cleanup() {
     } catch (e) {}
   }
 
-  if (pipedInputPath && fs.existsSync(pipedInputPath)) {
+  if (positionalArgContentPath && fs.existsSync(positionalArgContentPath)) {
     try {
-      fs.unlinkSync(pipedInputPath)
+      fs.unlinkSync(positionalArgContentPath)
     } catch (e) {}
   }
 
@@ -261,6 +261,47 @@ function handleStdinData(data: Buffer): void {
 }
 
 export async function main() {
+  // Check for piped input and exit immediately
+  if (!process.stdin.isTTY) {
+    console.error(
+      '\x1b[31m╔══════════════════════════════════════════════════════╗\x1b[0m',
+    )
+    console.error(
+      '\x1b[31m║                    PIPED INPUT NOT SUPPORTED         ║\x1b[0m',
+    )
+    console.error(
+      '\x1b[31m╠══════════════════════════════════════════════════════╣\x1b[0m',
+    )
+    console.error(
+      "\x1b[31m║ Claude Composer doesn't support piped input.         ║\x1b[0m",
+    )
+    console.error(
+      '\x1b[31m║                                                      ║\x1b[0m',
+    )
+    console.error(
+      '\x1b[31m║ Instead, pass your content as a positional argument: ║\x1b[0m',
+    )
+    console.error(
+      '\x1b[31m║                                                      ║\x1b[0m',
+    )
+    console.error(
+      '\x1b[31m║   claude "your content here"                         ║\x1b[0m',
+    )
+    console.error(
+      '\x1b[31m║                                                      ║\x1b[0m',
+    )
+    console.error(
+      '\x1b[31m║ Example:                                             ║\x1b[0m',
+    )
+    console.error(
+      '\x1b[31m║   claude "explain this error: ..."                   ║\x1b[0m',
+    )
+    console.error(
+      '\x1b[31m╚══════════════════════════════════════════════════════╝\x1b[0m',
+    )
+    process.exit(1)
+  }
+
   if (process.argv[2] === 'cc-init') {
     const { handleCcInit } = await import('./cli/cc-init.js')
     await handleCcInit(process.argv.slice(3))
@@ -448,10 +489,13 @@ export async function main() {
     // Save the positional argument to a file
     const tmpDir = os.tmpdir()
     const timestamp = new Date().toISOString().replace(/[:.]/g, '-')
-    pipedInputPath = path.join(tmpDir, `claude-composer-piped-${timestamp}.txt`)
+    positionalArgContentPath = path.join(
+      tmpDir,
+      `claude-composer-positional-${timestamp}.txt`,
+    )
 
     // Write the first positional argument to the file
-    fs.writeFileSync(pipedInputPath, childArgs[0])
+    fs.writeFileSync(positionalArgContentPath, childArgs[0])
 
     // Remove the argument from childArgs
     childArgs.splice(0, 1)
@@ -476,11 +520,11 @@ export async function main() {
     process.exit(code)
   })
 
-  // Add app ready pattern if in plan mode, if there's piped input, or if we saved positional args
+  // Add app ready pattern if in plan mode or if we saved positional args
   // IMPORTANT: This must be done AFTER terminal manager is initialized so response queue has targets
-  if (appConfig?.mode === 'plan' || !process.stdin.isTTY || pipedInputPath) {
+  if (appConfig?.mode === 'plan' || positionalArgContentPath) {
     const appStartedPattern = createAppReadyPattern(() => ({
-      pipedInputPath,
+      positionalArgContentPath,
       mode: appConfig?.mode,
     }))
     try {
@@ -491,57 +535,13 @@ export async function main() {
     }
   }
 
-  if (process.stdin.isTTY) {
-    process.stdin.on('data', handleStdinData)
-  } else {
-    const fs = await import('fs')
-    const os = await import('os')
-    const path = await import('path')
-
-    const tmpDir = os.tmpdir()
-    const timestamp = new Date().toISOString().replace(/[:.]/g, '-')
-    pipedInputPath = path.join(tmpDir, `claude-composer-piped-${timestamp}.txt`)
-    const writeStream = fs.createWriteStream(pipedInputPath)
-
-    process.stdin.on('data', chunk => {
-      writeStream.write(chunk)
-    })
-
-    process.stdin.on('end', () => {
-      writeStream.end()
-    })
-
-    process.stdin.resume()
-
-    const tty = await import('tty')
-    if (os.platform() !== 'win32') {
-      try {
-        const ttyFd = fs.openSync('/dev/tty', 'r')
-        const ttyStream = new tty.ReadStream(ttyFd)
-
-        ttyStream.setRawMode(true)
-
-        ttyStream.on('data', handleStdinData)
-        ;(global as any).__ttyStream = ttyStream
+  process.stdin.on('data', handleStdinData)
 
-        process.stdout.on('resize', () => {
-          const newCols = process.stdout.columns || 80
-          const newRows = process.stdout.rows || 30
-          terminalManager.resize(newCols, newRows)
-        })
-      } catch (error) {
-        // Silently fail - don't output to console after child process starts
-      }
-    }
-  }
-
-  if (process.stdin.isTTY) {
-    process.stdout.on('resize', () => {
-      const newCols = process.stdout.columns || 80
-      const newRows = process.stdout.rows || 30
-      terminalManager.resize(newCols, newRows)
-    })
-  }
+  process.stdout.on('resize', () => {
+    const newCols = process.stdout.columns || 80
+    const newRows = process.stdout.rows || 30
+    terminalManager.resize(newCols, newRows)
+  })
 }
 
 main().catch(error => {

src/patterns/registry.ts

@@ -193,33 +193,37 @@ const confirmationPatterns: PatternConfig[] = [
 ]
 
 export function createAppReadyPattern(
-  getAppConfig: () => { pipedInputPath?: string; mode?: string },
+  getAppConfig: () => { positionalArgContentPath?: string; mode?: string },
 ): PatternConfig {
   const getAppReadyResponse = (): string[] | undefined => {
     const config = getAppConfig()
-    const pipedInputPath = config.pipedInputPath
+    const positionalArgContentPath = config.positionalArgContentPath
 
     // If plan mode is enabled, send SHIFT+TAB twice first
     if (config.mode === 'plan') {
-      if (pipedInputPath && fs.existsSync(pipedInputPath)) {
+      if (positionalArgContentPath && fs.existsSync(positionalArgContentPath)) {
         try {
-          const content = fs.readFileSync(pipedInputPath, 'utf8').trimEnd()
+          const content = fs
+            .readFileSync(positionalArgContentPath, 'utf8')
+            .trimEnd()
           return content
             ? ['\x1b[Z', 100, '\x1b[Z', 100, content, 500, '\r']
             : ['\x1b[Z', 100, '\x1b[Z']
         } catch (error) {}
       }
-      // Even without piped content, send SHIFT+TAB in plan mode
+      // Even without positional arg content, send SHIFT+TAB in plan mode
       return ['\x1b[Z', 100, '\x1b[Z']
     }
 
-    // Normal piped input mode (no plan mode)
-    if (!pipedInputPath || !fs.existsSync(pipedInputPath)) {
+    // Normal positional arg injection mode (no plan mode)
+    if (!positionalArgContentPath || !fs.existsSync(positionalArgContentPath)) {
       return
     }
 
     try {
-      const content = fs.readFileSync(pipedInputPath, 'utf8').trimEnd()
+      const content = fs
+        .readFileSync(positionalArgContentPath, 'utf8')
+        .trimEnd()
       return content ? [content, 500, '\r'] : undefined
     } catch (error) {}
   }

src/safety/checker.ts

@@ -5,7 +5,6 @@ import { execSync } from 'child_process'
 import type { AppConfig, PreflightOptions } from '../types/preflight.js'
 import { askYesNo } from '../cli/prompts.js'
 import { log, warn } from '../utils/logging.js'
-import { isPipedInput, exitWithPipedInputError } from '../utils/piped-input.js'
 import { expandPath } from '../utils/file-utils.js'
 
 function isInTrustedRoot(appConfig: AppConfig): boolean {
@@ -64,9 +63,6 @@ export async function checkVersionControl(
 
   if (!fs.existsSync(gitDir)) {
     if (!allowWithoutVersionControl) {
-      if (isPipedInput()) {
-        exitWithPipedInputError('version control check')
-      }
       warn('※ Running in project without version control')
       const proceed = await askYesNo(
         '※ Do you want to continue?',
@@ -97,9 +93,6 @@ export async function checkDirtyDirectory(
 
     if (gitStatus !== '') {
       if (!allowInDirtyDirectory) {
-        if (isPipedInput()) {
-          exitWithPipedInputError('dirty directory check (uncommitted changes)')
-        }
         warn('※ Running in directory with uncommitted changes')
         const proceed = await askYesNo(
           '※ Do you want to continue?',
@@ -188,10 +181,6 @@ export async function handleAutomaticAcceptanceWarning(
     '\x1b[33m╚═════════════════════════════════════════════════════════════════╝\x1b[0m',
   )
 
-  if (isPipedInput()) {
-    exitWithPipedInputError('yolo mode warning')
-  }
-
   const proceed = await askYesNo(
     '※ Do you want to continue with YOLO mode enabled?',
     true,

src/utils/piped-input.ts

@@ -11,8 +11,8 @@ export function shouldAcceptPrompt(
     return true
   }
 
-  // Special case: always accept pipe-on-app-ready
-  if (match.patternId === 'pipe-on-app-ready') {
+  // Special case: always accept inject-positional-arg-on-app-ready
+  if (match.patternId === 'inject-positional-arg-on-app-ready') {
     return true
   }