runsignal 0.1.1 → 0.1.3

package/LICENSE

@@ -1,22 +1,22 @@
-MIT License
-
-Copyright (c) 2026 RunSignal
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
+MIT License
+
+Copyright (c) 2026 RunSignal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -1,37 +1,54 @@
-# RunSignal CLI
-
-RunSignal CLI lets you initialize a machine, wrap agent commands, and inspect event decisions.
-
-## Install
+# RunSignal CLI
+
+RunSignal CLI lets you initialize a machine, wrap agent commands, and inspect event decisions.
+
+## Install
+
+```bash
+npm i -g runsignal
+```
+
+Or run directly:
+
+```bash
+npx runsignal --help
+```
+
+## Commands
+
+- `runsignal login`
+- `runsignal init`
+- `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`
+
+## Quickstart
 
 ```bash
-npm i -g runsignal
+npx runsignal@latest login
+npx runsignal@latest init
+npx runsignal@latest wrap -- claude "refactor auth flow"
 ```
 
-Or run directly:
-
-```bash
-npx runsignal --help
-```
+## Environment
 
-## Commands
+- `RUNSIGNAL_APP_URL` to override app URL (default: `https://runsignal.dev`)
 
-- `runsignal login`
-- `runsignal init --provider telegram|slack`
-- `runsignal wrap -- <command>`
-- `runsignal send --message "..."`
-- `runsignal status <eventId>`
-- `runsignal logout`
+## Automatic Wrapping
 
-## Quickstart
+To keep using `claude ...` / `codex ...` normally while routing through RunSignal:
 
 ```bash
-runsignal login
-runsignal init --provider telegram
-runsignal wrap -- claude "refactor auth flow"
+runsignal hooks install --shell powershell
 ```
 
-## Environment
-
-- `RUNSIGNAL_APP_URL` to override app URL (default: `http://localhost:3000`)
+Then restart terminal and verify:
 
+```bash
+runsignal hooks doctor --shell powershell
+```
+

package/bin/runsignal.js

@@ -5,8 +5,6 @@ import {spawn, execSync} from 'node:child_process';
 import {promises as fs} from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import readline from 'node:readline/promises';
-import {stdin as input, stdout as output} from 'node:process';
 import {
   getEventAnswer,
   getEventDecision,
@@ -15,7 +13,7 @@ import {
   sendEvent
 } from '../src/api-client.js';
 
-const DEFAULT_APP_URL = process.env.RUNSIGNAL_APP_URL || 'http://localhost:3000';
+const DEFAULT_APP_URL = process.env.RUNSIGNAL_APP_URL || 'https://runsignal.dev';
 const CONFIG_DIR = path.join(os.homedir(), '.runsignal');
 const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json');
 
@@ -42,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';
 }
 
@@ -100,13 +100,159 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-async function prompt(question) {
-  const rl = readline.createInterface({input, output});
+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 claude { runsignal wrap -- claude @args }
+function codex { runsignal wrap -- codex @args }
+function cursor { runsignal wrap -- cursor @args }
+function gemini { runsignal wrap -- gemini @args }
+function aider { runsignal wrap -- aider @args }
+${HOOK_END}
+`;
+  }
+
+  return `${HOOK_START}
+claude() { runsignal wrap -- claude "$@"; }
+codex() { runsignal wrap -- codex "$@"; }
+cursor() { runsignal wrap -- cursor "$@"; }
+gemini() { runsignal wrap -- gemini "$@"; }
+aider() { runsignal wrap -- aider "$@"; }
+${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 {
-    const value = await rl.question(question);
-    return value.trim();
-  } finally {
-    rl.close();
+    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;
   }
 }
 
@@ -183,6 +329,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(/\/$/, '');
@@ -239,10 +397,20 @@ async function runInit(options) {
     throw new Error('not_logged_in');
   }
 
+  const hasSlackWebhook = typeof options.webhookUrl === 'string' && options.webhookUrl.length > 0;
+  const hasTelegramConfig =
+    typeof options.botToken === 'string' ||
+    typeof options.chatId === 'string' ||
+    typeof config.provider === 'string';
   let provider = String(options.provider || '').toLowerCase();
   if (provider !== 'telegram' && provider !== 'slack') {
-    const answer = await prompt('Provider (telegram/slack): ');
-    provider = answer.toLowerCase();
+    if (hasSlackWebhook) {
+      provider = 'slack';
+    } else if (hasTelegramConfig) {
+      provider = 'telegram';
+    } else {
+      provider = 'telegram';
+    }
   }
 
   if (provider !== 'telegram' && provider !== 'slack') {
@@ -253,21 +421,25 @@ async function runInit(options) {
   const providerConfig = {};
 
   if (provider === 'telegram') {
-    const botToken = String(options.botToken || (await prompt('Telegram bot token: ')));
-    const chatId = String(options.chatId || (await prompt('Telegram chat id: ')));
-    if (!botToken || !chatId) {
+    const botToken = String(options.botToken || '').trim();
+    const chatId = String(options.chatId || '').trim();
+    if ((botToken && !chatId) || (!botToken && chatId)) {
       throw new Error('telegram_config_invalid');
     }
-    providerConfig.bot_token = botToken;
-    providerConfig.chat_id = chatId;
+    if (botToken && chatId) {
+      providerConfig.bot_token = botToken;
+      providerConfig.chat_id = chatId;
+    }
   }
 
   if (provider === 'slack') {
-    const webhookUrl = String(options.webhookUrl || (await prompt('Slack webhook URL: ')));
-    if (!webhookUrl.startsWith('https://')) {
-      throw new Error('slack_webhook_invalid');
+    const webhookUrl = String(options.webhookUrl || '').trim();
+    if (webhookUrl) {
+      if (!webhookUrl.startsWith('https://')) {
+        throw new Error('slack_webhook_invalid');
+      }
+      providerConfig.webhook_url = webhookUrl;
     }
-    providerConfig.webhook_url = webhookUrl;
   }
 
   const register = await apiFetch(baseUrl, '/api/cli/machines/register', {
@@ -323,9 +495,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
   });
@@ -333,6 +510,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');
@@ -410,18 +593,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
@@ -447,7 +633,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() {
@@ -607,7 +795,7 @@ async function runLogout() {
 
 const program = new Command();
 
-program.name('runsignal').description('RunSignal CLI').version('0.1.0');
+program.name('runsignal').description('RunSignal CLI').version('0.1.3');
 
 program
   .command('login')
@@ -618,7 +806,7 @@ program
 
 program
   .command('init')
-  .option('--provider <provider>', 'telegram or slack')
+  .option('--provider <provider>', 'telegram or slack (optional)')
   .option('--app-url <url>', 'RunSignal app base URL')
   .option('--machine-name <name>', 'Machine name override')
   .option('--bot-token <token>', 'Telegram bot token')
@@ -664,6 +852,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,48 +1,48 @@
-{
-  "name": "runsignal",
-   "version": "0.1.1",
-  "description": "RunSignal CLI for wrapping AI agent runs and handling approvals",
-  "type": "module",
-  "license": "MIT",
-  "homepage": "https://runsignal.dev",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/gdamien33/runsignal.git",
-    "directory": "apps/cli"
-  },
-  "bugs": {
-    "url": "https://github.com/gdamien33/runsignal/issues"
-  },
-  "keywords": [
-    "runsignal",
-    "cli",
-    "ai",
-    "agent",
-    "devtools",
-    "monitoring"
-  ],
-  "engines": {
-    "node": ">=18.18.0"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "files": [
-    "bin",
-    "src",
-    "README.md",
-    "LICENSE"
-  ],
-  "bin": {
-    "runsignal": "bin/runsignal.js"
-  },
-  "scripts": {
-    "start": "node bin/runsignal.js --help",
-    "test:smoke": "node test/e2e-smoke.mjs",
-    "pack:check": "npm pack --dry-run",
-    "prepublishOnly": "npm run test:smoke"
-  },
-  "dependencies": {
-    "commander": "^14.0.1"
-  }
-}
+{
+  "name": "runsignal",
+   "version": "0.1.3",
+  "description": "RunSignal CLI for wrapping AI agent runs and handling approvals",
+  "type": "module",
+  "license": "MIT",
+  "homepage": "https://runsignal.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gdamien33/runsignal.git",
+    "directory": "apps/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/gdamien33/runsignal/issues"
+  },
+  "keywords": [
+    "runsignal",
+    "cli",
+    "ai",
+    "agent",
+    "devtools",
+    "monitoring"
+  ],
+  "engines": {
+    "node": ">=18.18.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "bin": {
+    "runsignal": "bin/runsignal.js"
+  },
+  "scripts": {
+    "start": "node bin/runsignal.js --help",
+    "test:smoke": "node test/e2e-smoke.mjs",
+    "pack:check": "npm pack --dry-run",
+    "prepublishOnly": "npm run test:smoke"
+  },
+  "dependencies": {
+    "commander": "^14.0.1"
+  }
+}

package/src/api-client.js

@@ -1,107 +1,107 @@
-function normalizeEventResponse(payload) {
-  if (!payload || typeof payload !== 'object') return { eventId: null, decision: 'pending' };
-
-  if (payload.data && typeof payload.data === 'object') {
-    return {
-      eventId: payload.data.event_id || null,
-      decision: payload.data.decision || 'pending'
-    };
-  }
-
-  return {
-    eventId: payload.event_id || null,
-    decision: payload.decision || 'pending'
-  };
-}
-
-export async function sendEvent({ apiFetch, baseUrl, machineApiKey, event }) {
-  const { ok, status, payload } = await apiFetch(baseUrl, '/api/events', {
-    method: 'POST',
-    headers: { authorization: `Bearer ${machineApiKey}` },
-    body: JSON.stringify(event)
-  });
-
-  if (!ok) {
-    const errorMessage = payload?.error?.message || payload?.error || `http_${status}`;
-    throw new Error(`send_event_failed:${errorMessage}`);
-  }
-
-  return normalizeEventResponse(payload);
-}
-
-export async function getEventDecision({ apiFetch, baseUrl, machineApiKey, eventId }) {
-  const response = await apiFetch(
-    baseUrl,
-    `/api/cli/events/${encodeURIComponent(eventId)}/decision`,
-    {
-      method: 'GET',
-      headers: { authorization: `Bearer ${machineApiKey}` }
-    }
-  );
-
-  if (!response.ok) {
-    throw new Error(`status_failed:${response.payload?.error || response.status}`);
-  }
-
-  return response.payload?.decision || 'pending';
-}
-
-export async function getEventAnswer({ apiFetch, baseUrl, machineApiKey, eventId }) {
-  const response = await apiFetch(
-    baseUrl,
-    `/api/cli/events/${encodeURIComponent(eventId)}/answer`,
-    {
-      method: 'GET',
-      headers: { authorization: `Bearer ${machineApiKey}` }
-    }
-  );
-
-  if (!response.ok) {
-    return null;
-  }
-  return response.payload?.answer ?? null;
-}
-
-export async function pollDecision({
-  apiFetch,
-  baseUrl,
-  machineApiKey,
-  eventId,
-  sleep,
-  timeoutMs = 5 * 60 * 1000
-}) {
-  const startedAt = Date.now();
-  while (Date.now() - startedAt < timeoutMs) {
-    const decision = await getEventDecision({ apiFetch, baseUrl, machineApiKey, eventId }).catch(
-      () => 'pending'
-    );
-    if (decision !== 'pending') {
-      return decision;
-    }
-    await sleep(2000);
-  }
-
-  return 'pending';
-}
-
-export async function pollAnswer({
-  apiFetch,
-  baseUrl,
-  machineApiKey,
-  eventId,
-  sleep,
-  timeoutMs = 5 * 60 * 1000
-}) {
-  const startedAt = Date.now();
-  while (Date.now() - startedAt < timeoutMs) {
-    const answer = await getEventAnswer({ apiFetch, baseUrl, machineApiKey, eventId }).catch(
-      () => null
-    );
-    if (typeof answer === 'string' && answer.trim()) {
-      return answer.trim();
-    }
-    await sleep(2000);
-  }
-
-  return null;
-}
+function normalizeEventResponse(payload) {
+  if (!payload || typeof payload !== 'object') return { eventId: null, decision: 'pending' };
+
+  if (payload.data && typeof payload.data === 'object') {
+    return {
+      eventId: payload.data.event_id || null,
+      decision: payload.data.decision || 'pending'
+    };
+  }
+
+  return {
+    eventId: payload.event_id || null,
+    decision: payload.decision || 'pending'
+  };
+}
+
+export async function sendEvent({ apiFetch, baseUrl, machineApiKey, event }) {
+  const { ok, status, payload } = await apiFetch(baseUrl, '/api/events', {
+    method: 'POST',
+    headers: { authorization: `Bearer ${machineApiKey}` },
+    body: JSON.stringify(event)
+  });
+
+  if (!ok) {
+    const errorMessage = payload?.error?.message || payload?.error || `http_${status}`;
+    throw new Error(`send_event_failed:${errorMessage}`);
+  }
+
+  return normalizeEventResponse(payload);
+}
+
+export async function getEventDecision({ apiFetch, baseUrl, machineApiKey, eventId }) {
+  const response = await apiFetch(
+    baseUrl,
+    `/api/cli/events/${encodeURIComponent(eventId)}/decision`,
+    {
+      method: 'GET',
+      headers: { authorization: `Bearer ${machineApiKey}` }
+    }
+  );
+
+  if (!response.ok) {
+    throw new Error(`status_failed:${response.payload?.error || response.status}`);
+  }
+
+  return response.payload?.decision || 'pending';
+}
+
+export async function getEventAnswer({ apiFetch, baseUrl, machineApiKey, eventId }) {
+  const response = await apiFetch(
+    baseUrl,
+    `/api/cli/events/${encodeURIComponent(eventId)}/answer`,
+    {
+      method: 'GET',
+      headers: { authorization: `Bearer ${machineApiKey}` }
+    }
+  );
+
+  if (!response.ok) {
+    return null;
+  }
+  return response.payload?.answer ?? null;
+}
+
+export async function pollDecision({
+  apiFetch,
+  baseUrl,
+  machineApiKey,
+  eventId,
+  sleep,
+  timeoutMs = 5 * 60 * 1000
+}) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    const decision = await getEventDecision({ apiFetch, baseUrl, machineApiKey, eventId }).catch(
+      () => 'pending'
+    );
+    if (decision !== 'pending') {
+      return decision;
+    }
+    await sleep(2000);
+  }
+
+  return 'pending';
+}
+
+export async function pollAnswer({
+  apiFetch,
+  baseUrl,
+  machineApiKey,
+  eventId,
+  sleep,
+  timeoutMs = 5 * 60 * 1000
+}) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    const answer = await getEventAnswer({ apiFetch, baseUrl, machineApiKey, eventId }).catch(
+      () => null
+    );
+    if (typeof answer === 'string' && answer.trim()) {
+      return answer.trim();
+    }
+    await sleep(2000);
+  }
+
+  return null;
+}