runsignal 0.1.2 → 0.1.4

package/README.md

@@ -19,9 +19,12 @@ npx runsignal --help
 - `runsignal login`
 - `runsignal init`
 - `runsignal wrap -- <command>`
-- `runsignal send --message "..."`
-- `runsignal status <eventId>`
-- `runsignal logout`
+- `runsignal send --message "..."`
+- `runsignal status <eventId>`
+- `runsignal logout`
+- `runsignal hooks install --shell powershell`
+- `runsignal hooks doctor --shell powershell`
+- `runsignal hooks uninstall --shell powershell`
 
 ## Quickstart
 
@@ -34,4 +37,18 @@ npx runsignal@latest wrap -- claude "refactor auth flow"
 ## Environment
 
 - `RUNSIGNAL_APP_URL` to override app URL (default: `https://runsignal.dev`)
+
+## Automatic Wrapping
+
+To keep using `claude ...` / `codex ...` normally while routing through RunSignal:
+
+```bash
+runsignal hooks install --shell powershell
+```
+
+Then restart terminal and verify:
+
+```bash
+runsignal hooks doctor --shell powershell
+```
 

package/bin/runsignal.js

@@ -40,6 +40,8 @@ function toUserMessage(errorCode) {
   if (code.includes('message_required')) return 'Message is required. Use --message "..."';
   if (code.includes('event_id_required')) return 'Event id is required. Usage: runsignal status <eventId>';
   if (code.includes('init_failed')) return 'Initialization failed. Check token/provider config and try again.';
+  if (code.includes('hooks_shell_not_supported'))
+    return 'Hooks shell not supported. Use --shell powershell|bash|zsh|all.';
   return code || 'Unknown error';
 }
 
@@ -98,6 +100,226 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+const HOOK_START = '# >>> RunSignal hooks start >>>';
+const HOOK_END = '# <<< RunSignal hooks end <<<';
+
+function stripHookBlock(content) {
+  const start = content.indexOf(HOOK_START);
+  const end = content.indexOf(HOOK_END);
+  if (start === -1 || end === -1 || end < start) {
+    return content;
+  }
+  const before = content.slice(0, start).trimEnd();
+  const after = content.slice(end + HOOK_END.length).trimStart();
+  if (!before && !after) return '';
+  if (!before) return `${after}\n`;
+  if (!after) return `${before}\n`;
+  return `${before}\n\n${after}\n`;
+}
+
+function buildHookBlock(shellKind) {
+  if (shellKind === 'powershell') {
+    return `${HOOK_START}
+function RunSignal-Resolve-NativeCommand {
+  param([string]$Name)
+  $cmd = Get-Command $Name -CommandType Application -ErrorAction SilentlyContinue | Select-Object -First 1
+  if (-not $cmd) { return $null }
+  return $cmd.Source
+}
+function claude {
+  $native = RunSignal-Resolve-NativeCommand "claude"
+  if (-not $native) { Write-Error "RunSignal hook: native claude executable not found."; return }
+  if ($args.Count -eq 0) { & $native; return }
+  runsignal wrap -- $native @args
+}
+function codex {
+  $native = RunSignal-Resolve-NativeCommand "codex"
+  if (-not $native) { Write-Error "RunSignal hook: native codex executable not found."; return }
+  if ($args.Count -eq 0) { & $native; return }
+  runsignal wrap -- $native @args
+}
+function cursor {
+  $native = RunSignal-Resolve-NativeCommand "cursor"
+  if (-not $native) { Write-Error "RunSignal hook: native cursor executable not found."; return }
+  if ($args.Count -eq 0) { & $native; return }
+  runsignal wrap -- $native @args
+}
+function gemini {
+  $native = RunSignal-Resolve-NativeCommand "gemini"
+  if (-not $native) { Write-Error "RunSignal hook: native gemini executable not found."; return }
+  if ($args.Count -eq 0) { & $native; return }
+  runsignal wrap -- $native @args
+}
+function aider {
+  $native = RunSignal-Resolve-NativeCommand "aider"
+  if (-not $native) { Write-Error "RunSignal hook: native aider executable not found."; return }
+  if ($args.Count -eq 0) { & $native; return }
+  runsignal wrap -- $native @args
+}
+${HOOK_END}
+`;
+  }
+
+  return `${HOOK_START}
+runsignal_resolve_native() {
+  type -P "$1" 2>/dev/null
+}
+claude() {
+  local native
+  native="$(runsignal_resolve_native claude)"
+  if [ -z "$native" ]; then echo "RunSignal hook: native claude executable not found." >&2; return 127; fi
+  if [ "$#" -eq 0 ]; then "$native"; return $?; fi
+  runsignal wrap -- "$native" "$@"
+}
+codex() {
+  local native
+  native="$(runsignal_resolve_native codex)"
+  if [ -z "$native" ]; then echo "RunSignal hook: native codex executable not found." >&2; return 127; fi
+  if [ "$#" -eq 0 ]; then "$native"; return $?; fi
+  runsignal wrap -- "$native" "$@"
+}
+cursor() {
+  local native
+  native="$(runsignal_resolve_native cursor)"
+  if [ -z "$native" ]; then echo "RunSignal hook: native cursor executable not found." >&2; return 127; fi
+  if [ "$#" -eq 0 ]; then "$native"; return $?; fi
+  runsignal wrap -- "$native" "$@"
+}
+gemini() {
+  local native
+  native="$(runsignal_resolve_native gemini)"
+  if [ -z "$native" ]; then echo "RunSignal hook: native gemini executable not found." >&2; return 127; fi
+  if [ "$#" -eq 0 ]; then "$native"; return $?; fi
+  runsignal wrap -- "$native" "$@"
+}
+aider() {
+  local native
+  native="$(runsignal_resolve_native aider)"
+  if [ -z "$native" ]; then echo "RunSignal hook: native aider executable not found." >&2; return 127; fi
+  if [ "$#" -eq 0 ]; then "$native"; return $?; fi
+  runsignal wrap -- "$native" "$@"
+}
+${HOOK_END}
+`;
+}
+
+function resolveHookTargets(shellOption) {
+  const shell = String(shellOption || 'auto').toLowerCase();
+  const home = os.homedir();
+
+  if (process.platform === 'win32') {
+    const powershellTargets = [
+      {
+        path: path.join(home, 'Documents', 'PowerShell', 'Microsoft.PowerShell_profile.ps1'),
+        kind: 'powershell'
+      },
+      {
+        path: path.join(home, 'Documents', 'WindowsPowerShell', 'Microsoft.PowerShell_profile.ps1'),
+        kind: 'powershell'
+      }
+    ];
+    if (shell === 'auto' || shell === 'powershell' || shell === 'all') {
+      return powershellTargets;
+    }
+    return [];
+  }
+
+  if (shell === 'zsh') return [{path: path.join(home, '.zshrc'), kind: 'posix'}];
+  if (shell === 'bash') return [{path: path.join(home, '.bashrc'), kind: 'posix'}];
+  if (shell === 'all') {
+    return [
+      {path: path.join(home, '.bashrc'), kind: 'posix'},
+      {path: path.join(home, '.zshrc'), kind: 'posix'}
+    ];
+  }
+  if (shell === 'auto') {
+    const shellEnv = String(process.env.SHELL || '').toLowerCase();
+    if (shellEnv.includes('zsh')) return [{path: path.join(home, '.zshrc'), kind: 'posix'}];
+    return [{path: path.join(home, '.bashrc'), kind: 'posix'}];
+  }
+
+  return [];
+}
+
+async function readTextFile(filePath) {
+  try {
+    return await fs.readFile(filePath, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+async function runHooksInstall(options) {
+  const targets = resolveHookTargets(options.shell);
+  if (!targets.length) {
+    throw new Error('hooks_shell_not_supported');
+  }
+
+  for (const target of targets) {
+    const existing = await readTextFile(target.path);
+    const cleaned = stripHookBlock(existing).trimEnd();
+    const block = buildHookBlock(target.kind);
+    const next = cleaned ? `${cleaned}\n\n${block}` : block;
+    await fs.mkdir(path.dirname(target.path), {recursive: true});
+    await fs.writeFile(target.path, next, 'utf8');
+    console.log(`Hooks installed: ${target.path}`);
+  }
+
+  console.log('Restart your terminal to apply hooks.');
+}
+
+async function runHooksUninstall(options) {
+  const targets = resolveHookTargets(options.shell);
+  if (!targets.length) {
+    throw new Error('hooks_shell_not_supported');
+  }
+
+  for (const target of targets) {
+    const existing = await readTextFile(target.path);
+    if (!existing) {
+      console.log(`Hooks not present: ${target.path}`);
+      continue;
+    }
+    const next = stripHookBlock(existing);
+    if (next === existing) {
+      console.log(`Hooks not present: ${target.path}`);
+      continue;
+    }
+    await fs.writeFile(target.path, next, 'utf8');
+    console.log(`Hooks removed: ${target.path}`);
+  }
+}
+
+async function runHooksDoctor(options) {
+  const targets = resolveHookTargets(options.shell);
+  if (!targets.length) {
+    throw new Error('hooks_shell_not_supported');
+  }
+
+  let healthy = true;
+  for (const target of targets) {
+    const existing = await readTextFile(target.path);
+    const hasHooks = existing.includes(HOOK_START) && existing.includes(HOOK_END);
+    if (!hasHooks) {
+      healthy = false;
+    }
+    console.log(
+      JSON.stringify(
+        {
+          path: target.path,
+          installed: hasHooks
+        },
+        null,
+        2
+      )
+    );
+  }
+
+  if (!healthy) {
+    process.exitCode = 1;
+  }
+}
+
 function getMachineName() {
   return process.env.COMPUTERNAME || os.hostname() || 'machine';
 }
@@ -171,6 +393,18 @@ function extractInterestingLine(chunk) {
   return null;
 }
 
+function quoteForShell(arg) {
+  const value = String(arg ?? '');
+  if (value.length === 0) {
+    return '""';
+  }
+  if (!/[\s"]/g.test(value)) {
+    return value;
+  }
+  const escaped = value.replace(/(["\\$`])/g, '\\$1');
+  return `"${escaped}"`;
+}
+
 async function runLogin(options) {
   const config = await readConfig();
   const baseUrl = String(options.appUrl || config.app_url || DEFAULT_APP_URL).replace(/\/$/, '');
@@ -325,9 +559,14 @@ async function runWrap(commandParts) {
     agent_label: agentLabel
   };
 
-  const commandString = commandParts.join(' ');
+  const commandString =
+    commandParts.length === 1
+      ? String(commandParts[0])
+      : commandParts.map((part) => quoteForShell(part)).join(' ');
+  const interactivePassthrough =
+    commandParts.length === 1 && !/[\s"'`]/.test(String(commandParts[0]));
   const child = spawn(commandString, {
-    stdio: ['inherit', 'pipe', 'pipe'],
+    stdio: interactivePassthrough ? 'inherit' : ['inherit', 'pipe', 'pipe'],
     shell: true,
     env: process.env
   });
@@ -335,6 +574,12 @@ async function runWrap(commandParts) {
   let sawApproval = false;
   let sawQuestion = false;
   let lastInterestingLine = '';
+  const pendingTasks = new Set();
+
+  const queueTask = (promise) => {
+    pendingTasks.add(promise);
+    promise.finally(() => pendingTasks.delete(promise));
+  };
 
   const handleChunk = async (chunkRaw) => {
     const chunk = chunkRaw.toString('utf8');
@@ -412,18 +657,21 @@ async function runWrap(commandParts) {
     }
   };
 
-  child.stdout.on('data', (chunk) => {
-    process.stdout.write(chunk);
-    void handleChunk(chunk);
-  });
-  child.stderr.on('data', (chunk) => {
-    process.stderr.write(chunk);
-    void handleChunk(chunk);
-  });
+  if (!interactivePassthrough) {
+    child.stdout.on('data', (chunk) => {
+      process.stdout.write(chunk);
+      queueTask(handleChunk(chunk));
+    });
+    child.stderr.on('data', (chunk) => {
+      process.stderr.write(chunk);
+      queueTask(handleChunk(chunk));
+    });
+  }
 
   const exitCode = await new Promise((resolve) => {
     child.on('close', (code) => resolve(code ?? 1));
   });
+  await Promise.allSettled(Array.from(pendingTasks));
 
   const completionMessage =
     exitCode === 0
@@ -449,7 +697,9 @@ async function runWrap(commandParts) {
     // no-op
   }
 
-  process.exit(exitCode);
+  // Avoid hard process exit on Windows: let Node close handles cleanly.
+  process.exitCode = exitCode;
+  return;
 }
 
 async function runTest() {
@@ -609,7 +859,7 @@ async function runLogout() {
 
 const program = new Command();
 
-program.name('runsignal').description('RunSignal CLI').version('0.1.2');
+program.name('runsignal').description('RunSignal CLI').version('0.1.4');
 
 program
   .command('login')
@@ -666,6 +916,29 @@ program.command('logout').action(async () => {
   await runLogout();
 });
 
+const hooks = program.command('hooks').description('Manage shell hooks for automatic wrapping');
+
+hooks
+  .command('install')
+  .option('--shell <shell>', 'auto|powershell|bash|zsh|all', 'auto')
+  .action(async (options) => {
+    await runHooksInstall(options);
+  });
+
+hooks
+  .command('uninstall')
+  .option('--shell <shell>', 'auto|powershell|bash|zsh|all', 'auto')
+  .action(async (options) => {
+    await runHooksUninstall(options);
+  });
+
+hooks
+  .command('doctor')
+  .option('--shell <shell>', 'auto|powershell|bash|zsh|all', 'auto')
+  .action(async (options) => {
+    await runHooksDoctor(options);
+  });
+
 program.parseAsync(process.argv).catch((error) => {
   const message = error instanceof Error ? error.message : String(error);
   console.error(`RunSignal error: ${toUserMessage(message)}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "runsignal",
-   "version": "0.1.2",
+   "version": "0.1.4",
   "description": "RunSignal CLI for wrapping AI agent runs and handling approvals",
   "type": "module",
   "license": "MIT",