runsignal 0.1.4 → 0.1.6

package/README.md

@@ -16,22 +16,31 @@ npx runsignal --help
 
 ## Commands
 
-- `runsignal login`
+- `runsignal login`
 - `runsignal init`
-- `runsignal wrap -- <command>`
+- `runsignal setup`
+- `runsignal wrap -- <command>`
 - `runsignal send --message "..."`
 - `runsignal status <eventId>`
 - `runsignal logout`
-- `runsignal hooks install --shell powershell`
-- `runsignal hooks doctor --shell powershell`
-- `runsignal hooks uninstall --shell powershell`
+- `runsignal hooks install`
+- `runsignal hooks doctor`
+- `runsignal hooks uninstall`
 
 ## Quickstart
 
+Canonical zero-friction onboarding:
+
+```bash
+npx --yes runsignal@latest setup
+```
+
+Equivalent manual flow:
+
 ```bash
-npx runsignal@latest login
-npx runsignal@latest init
-npx runsignal@latest wrap -- claude "refactor auth flow"
+npx --yes runsignal@latest login
+npx --yes runsignal@latest init
+npx --yes runsignal@latest hooks install
 ```
 
 ## Environment
@@ -43,12 +52,19 @@ npx runsignal@latest wrap -- claude "refactor auth flow"
 To keep using `claude ...` / `codex ...` normally while routing through RunSignal:
 
 ```bash
-runsignal hooks install --shell powershell
+runsignal hooks install
 ```
 
 Then restart terminal and verify:
 
 ```bash
-runsignal hooks doctor --shell powershell
+runsignal hooks doctor
+```
+
+After that, use your CLI agents normally:
+
+```bash
+claude
+codex
 ```
 

package/bin/runsignal.js

@@ -3,6 +3,7 @@
 import {Command} from 'commander';
 import {spawn, execSync} from 'node:child_process';
 import {promises as fs} from 'node:fs';
+import {existsSync} from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import {
@@ -122,38 +123,44 @@ function buildHookBlock(shellKind) {
     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
+  $candidates = @(Get-Command $Name -CommandType Application -ErrorAction SilentlyContinue)
+  if (-not $candidates -or $candidates.Count -eq 0) { return $null }
+  $preferred = $candidates | Where-Object { $_.Source -match '\\.exe$' } | Select-Object -First 1
+  if ($preferred) { return $preferred.Source }
+  $launcher = $candidates | Where-Object { $_.Source -match '\\.(cmd|bat)$' } | Select-Object -First 1
+  if ($launcher) { return $launcher.Source }
+  $secondary = $candidates | Where-Object { $_.Source -match '\\.[A-Za-z0-9]+$' } | Select-Object -First 1
+  if ($secondary) { return $secondary.Source }
+  return $candidates[0].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 }
+  if (-not $native) {
+    $userHome = [Environment]::GetFolderPath("UserProfile")
+    $fallback = Join-Path $userHome ".local\\bin\\claude.exe"
+    if (Test-Path $fallback) { $native = $fallback }
+  }
+  if (-not $native) { Write-Error "RunSignal hook: native claude executable not found. Add your native installer path to PATH (example: %USERPROFILE%\\.local\\bin)."; 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}
@@ -162,41 +169,46 @@ ${HOOK_END}
 
   return `${HOOK_START}
 runsignal_resolve_native() {
-  type -P "$1" 2>/dev/null
+  local name
+  name="$1"
+  if type -P "$name" >/dev/null 2>&1; then
+    type -P "$name"
+    return 0
+  fi
+  if [ -x "$HOME/.local/bin/$name" ]; then
+    printf '%s\n' "$HOME/.local/bin/$name"
+    return 0
+  fi
+  return 1
 }
 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}
@@ -320,6 +332,21 @@ async function runHooksDoctor(options) {
   }
 }
 
+async function areHooksInstalled(shellOption) {
+  const targets = resolveHookTargets(shellOption);
+  if (!targets.length) {
+    throw new Error('hooks_shell_not_supported');
+  }
+  for (const target of targets) {
+    const existing = await readTextFile(target.path);
+    const hasHooks = existing.includes(HOOK_START) && existing.includes(HOOK_END);
+    if (!hasHooks) {
+      return false;
+    }
+  }
+  return true;
+}
+
 function getMachineName() {
   return process.env.COMPUTERNAME || os.hostname() || 'machine';
 }
@@ -405,6 +432,35 @@ function quoteForShell(arg) {
   return `"${escaped}"`;
 }
 
+function stripWrappingQuotes(value) {
+  const raw = String(value || '').trim();
+  if ((raw.startsWith('"') && raw.endsWith('"')) || (raw.startsWith("'") && raw.endsWith("'"))) {
+    return raw.slice(1, -1);
+  }
+  return raw;
+}
+
+function isWindowsScriptLauncher(filePath) {
+  if (process.platform !== 'win32') return false;
+  const ext = path.extname(String(filePath || '')).toLowerCase();
+  return ext === '.cmd' || ext === '.bat' || ext === '.ps1';
+}
+
+function normalizeWindowsExecutablePath(filePath) {
+  const raw = String(filePath || '');
+  if (process.platform !== 'win32') return raw;
+  if (!raw) return raw;
+  const ext = path.extname(raw).toLowerCase();
+  if (ext) return raw;
+  const exe = `${raw}.exe`;
+  if (existsSync(exe)) return exe;
+  const cmd = `${raw}.cmd`;
+  if (existsSync(cmd)) return cmd;
+  const bat = `${raw}.bat`;
+  if (existsSync(bat)) return bat;
+  return raw;
+}
+
 async function runLogin(options) {
   const config = await readConfig();
   const baseUrl = String(options.appUrl || config.app_url || DEFAULT_APP_URL).replace(/\/$/, '');
@@ -563,13 +619,71 @@ async function runWrap(commandParts) {
     commandParts.length === 1
       ? String(commandParts[0])
       : commandParts.map((part) => quoteForShell(part)).join(' ');
+  const singleCommand = String(commandParts[0] || '');
+  const singleExecutable = normalizeWindowsExecutablePath(stripWrappingQuotes(singleCommand));
   const interactivePassthrough =
-    commandParts.length === 1 && !/[\s"'`]/.test(String(commandParts[0]));
-  const child = spawn(commandString, {
-    stdio: interactivePassthrough ? 'inherit' : ['inherit', 'pipe', 'pipe'],
-    shell: true,
-    env: process.env
-  });
+    commandParts.length === 1 && (existsSync(singleExecutable) || !/\s/.test(singleExecutable));
+  const child = interactivePassthrough
+    ? isWindowsScriptLauncher(singleExecutable)
+      ? spawn(singleExecutable, [], {
+          stdio: 'inherit',
+          shell: true,
+          env: process.env
+        })
+      : spawn(singleExecutable, [], {
+          stdio: 'inherit',
+          shell: false,
+          env: process.env
+        })
+    : spawn(commandString, {
+        stdio: ['inherit', 'pipe', 'pipe'],
+        shell: true,
+        env: process.env
+      });
+
+  let heartbeatInterval = null;
+  if (interactivePassthrough) {
+    const startedAt = Date.now();
+    try {
+      await sendEvent({
+        apiFetch,
+        baseUrl,
+        machineApiKey,
+        event: {
+          message: `Session started: ${singleExecutable}`,
+          event_type: 'session_started',
+          repo,
+          branch,
+          severity: 'info',
+          context,
+          agent: agentLabel
+        }
+      });
+    } catch {
+      // non-blocking
+    }
+
+    heartbeatInterval = setInterval(() => {
+      const elapsedMin = Math.max(1, Math.floor((Date.now() - startedAt) / 60_000));
+      sendEvent({
+        apiFetch,
+        baseUrl,
+        machineApiKey,
+        event: {
+          message: `Session running (${elapsedMin} min): ${singleExecutable}`,
+          event_type: 'session_running',
+          repo,
+          branch,
+          severity: 'info',
+          context,
+          agent: agentLabel
+        }
+      }).catch(() => {
+        // non-blocking
+      });
+    }, 120_000);
+    heartbeatInterval.unref?.();
+  }
 
   let sawApproval = false;
   let sawQuestion = false;
@@ -669,8 +783,12 @@ async function runWrap(commandParts) {
   }
 
   const exitCode = await new Promise((resolve) => {
+    child.on('error', () => resolve(1));
     child.on('close', (code) => resolve(code ?? 1));
   });
+  if (heartbeatInterval) {
+    clearInterval(heartbeatInterval);
+  }
   await Promise.allSettled(Array.from(pendingTasks));
 
   const completionMessage =
@@ -744,7 +862,9 @@ function normalizeEventType(value) {
     raw === 'task_completed' ||
     raw === 'error' ||
     raw === 'quota_warning' ||
-    raw === 'question'
+    raw === 'question' ||
+    raw === 'session_started' ||
+    raw === 'session_running'
   ) {
     return raw;
   }
@@ -857,9 +977,78 @@ async function runLogout() {
   console.log('Logged out.');
 }
 
+async function runSetup(options) {
+  const shell = String(options.shell || 'auto');
+  let config = await readConfig();
+  const baseUrl = String(options.appUrl || config.app_url || DEFAULT_APP_URL).replace(/\/$/, '');
+
+  if (config.app_url !== baseUrl) {
+    await writeConfig(mergeConfig(config, {app_url: baseUrl}));
+    config = await readConfig();
+  }
+
+  const summary = {
+    login: 'skipped',
+    init: 'skipped',
+    hooks: 'skipped'
+  };
+
+  if (!config.access_token) {
+    await runLogin({appUrl: baseUrl});
+    summary.login = 'ok';
+    config = await readConfig();
+  }
+
+  if (!config.machine_api_key) {
+    await runInit({
+      appUrl: baseUrl,
+      machineName: options.machineName,
+      provider: options.provider,
+      botToken: options.botToken,
+      chatId: options.chatId,
+      webhookUrl: options.webhookUrl
+    });
+    summary.init = 'ok';
+  }
+
+  const hooksInstalled = await areHooksInstalled(shell);
+  if (!hooksInstalled) {
+    await runHooksInstall({shell});
+    summary.hooks = 'ok';
+  }
+
+  console.log(
+    JSON.stringify(
+      {
+        setup: 'ok',
+        login: summary.login,
+        init: summary.init,
+        hooks: summary.hooks,
+        next: 'Open a new terminal, then run claude or codex normally.'
+      },
+      null,
+      2
+    )
+  );
+}
+
 const program = new Command();
 
-program.name('runsignal').description('RunSignal CLI').version('0.1.4');
+program.name('runsignal').description('RunSignal CLI').version('0.1.6');
+
+program
+  .command('setup')
+  .description('Zero-friction onboarding: login + init + hooks install')
+  .option('--app-url <url>', 'RunSignal app base URL')
+  .option('--shell <shell>', 'auto|powershell|bash|zsh|all', 'auto')
+  .option('--provider <provider>', 'telegram or slack (optional)')
+  .option('--machine-name <name>', 'Machine name override')
+  .option('--bot-token <token>', 'Telegram bot token')
+  .option('--chat-id <id>', 'Telegram chat id')
+  .option('--webhook-url <url>', 'Slack webhook URL')
+  .action(async (options) => {
+    await runSetup(options);
+  });
 
 program
   .command('login')

package/package.json

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