runsignal 0.0.1 → 0.1.0

package/LICENSE

@@ -0,0 +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.
+

package/README.md

@@ -0,0 +1,37 @@
+# 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 --provider telegram|slack`
+- `runsignal wrap -- <command>`
+- `runsignal send --message "..."`
+- `runsignal status <eventId>`
+- `runsignal logout`
+
+## Quickstart
+
+```bash
+runsignal login
+runsignal init --provider telegram
+runsignal wrap -- claude "refactor auth flow"
+```
+
+## Environment
+
+- `RUNSIGNAL_APP_URL` to override app URL (default: `http://localhost:3000`)
+

package/bin/runsignal.js

@@ -1,3 +1,671 @@
-#!/usr/bin/env node
-
-console.log("RunSignal CLI ready");
+#!/usr/bin/env node
+
+import {Command} from 'commander';
+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,
+  pollAnswer,
+  pollDecision,
+  sendEvent
+} from '../src/api-client.js';
+
+const DEFAULT_APP_URL = process.env.RUNSIGNAL_APP_URL || 'http://localhost:3000';
+const CONFIG_DIR = path.join(os.homedir(), '.runsignal');
+const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json');
+
+function toUserMessage(errorCode) {
+  const code = String(errorCode || '');
+  if (code.includes('not_logged_in')) return 'You are not logged in. Run: runsignal login';
+  if (code.includes('machine_not_initialized')) return 'Machine is not initialized. Run: runsignal init';
+  if (code.includes('missing_wrapped_command')) return 'Missing wrapped command. Usage: runsignal wrap -- <command>';
+  if (code.includes('provider_invalid')) return 'Invalid provider. Use telegram or slack.';
+  if (code.includes('telegram_config_invalid'))
+    return 'Telegram config invalid. bot_token and chat_id are required.';
+  if (code.includes('slack_webhook_invalid')) return 'Slack webhook URL is invalid.';
+  if (code.includes('slack_config_invalid'))
+    return 'Slack config invalid. Use webhook_url or bot_token + channel_id.';
+  if (code.includes('login_timeout')) return 'Login timed out. Retry runsignal login and validate quickly.';
+  if (code.includes('login_poll_failed'))
+    return 'Login polling failed. Check APP URL and server availability.';
+  if (code.includes('send_event_failed'))
+    return 'Event send failed. Check machine key, network and server logs.';
+  if (code.includes('status_failed')) return 'Status check failed. Verify event id and machine ownership.';
+  if (code.includes('event_type_invalid'))
+    return 'Invalid event type. Use approval_required, task_completed, error, quota_warning, question.';
+  if (code.includes('severity_invalid')) return 'Invalid severity. Use info, warning, or critical.';
+  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.';
+  return code || 'Unknown error';
+}
+
+async function ensureConfigDir() {
+  await fs.mkdir(CONFIG_DIR, {recursive: true});
+}
+
+async function readConfig() {
+  try {
+    const raw = await fs.readFile(CONFIG_PATH, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+
+async function writeConfig(config) {
+  await ensureConfigDir();
+  const raw = `${JSON.stringify(config, null, 2)}\n`;
+  await fs.writeFile(CONFIG_PATH, raw, {encoding: 'utf8'});
+
+  if (process.platform !== 'win32') {
+    try {
+      await fs.chmod(CONFIG_PATH, 0o600);
+    } catch {
+      // noop
+    }
+  }
+}
+
+function mergeConfig(base, patch) {
+  return {...base, ...patch};
+}
+
+async function apiFetch(baseUrl, route, options = {}) {
+  const response = await fetch(`${baseUrl}${route}`, {
+    ...options,
+    headers: {
+      'content-type': 'application/json',
+      ...(options.headers || {})
+    }
+  });
+
+  const text = await response.text();
+  let payload = null;
+  try {
+    payload = text ? JSON.parse(text) : null;
+  } catch {
+    payload = null;
+  }
+
+  return {ok: response.ok, status: response.status, payload};
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function prompt(question) {
+  const rl = readline.createInterface({input, output});
+  try {
+    const value = await rl.question(question);
+    return value.trim();
+  } finally {
+    rl.close();
+  }
+}
+
+function getMachineName() {
+  return process.env.COMPUTERNAME || os.hostname() || 'machine';
+}
+
+function getPlatformLabel() {
+  return `${process.platform}-${process.arch}`;
+}
+
+function getRepoFromGit() {
+  try {
+    const remote = execSync('git config --get remote.origin.url', {
+      stdio: ['ignore', 'pipe', 'ignore']
+    })
+      .toString('utf8')
+      .trim();
+
+    if (!remote) {
+      return path.basename(process.cwd());
+    }
+
+    const normalized = remote.replace(/\.git$/i, '');
+    const slashParts = normalized.split('/');
+    const lastSlash = slashParts[slashParts.length - 1];
+
+    if (lastSlash.includes(':')) {
+      return lastSlash.split(':').pop() || path.basename(process.cwd());
+    }
+
+    return lastSlash || path.basename(process.cwd());
+  } catch {
+    return path.basename(process.cwd());
+  }
+}
+
+function getBranchFromGit() {
+  try {
+    return execSync('git rev-parse --abbrev-ref HEAD', {stdio: ['ignore', 'pipe', 'ignore']})
+      .toString('utf8')
+      .trim();
+  } catch {
+    return '';
+  }
+}
+
+function inferAgentLabel(commandParts) {
+  const first = (commandParts[0] || '').toLowerCase();
+  if (first.includes('claude')) return 'claude-code';
+  if (first.includes('codex')) return 'codex';
+  if (first.includes('cursor')) return 'cursor-cli';
+  if (first.includes('gemini')) return 'gemini-cli';
+  if (first.includes('aider')) return 'aider';
+  return first || 'manual-cli';
+}
+
+function extractInterestingLine(chunk) {
+  const lines = chunk
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+
+  for (const line of lines) {
+    if (/approve|approval|confirm|allow/i.test(line)) {
+      return {kind: 'approval_required', line};
+    }
+
+    if (/\?$/.test(line) || /choose|select|which option|reply/i.test(line)) {
+      return {kind: 'question', line};
+    }
+  }
+
+  return null;
+}
+
+async function runLogin(options) {
+  const config = await readConfig();
+  const baseUrl = String(options.appUrl || config.app_url || DEFAULT_APP_URL).replace(/\/$/, '');
+
+  const start = await apiFetch(baseUrl, '/api/cli/device/start', {method: 'POST', body: '{}'});
+  if (!start.ok) {
+    throw new Error('login_start_failed');
+  }
+
+  const deviceCode = start.payload?.device_code;
+  const userCode = start.payload?.user_code;
+  const verificationUrl = start.payload?.verification_url;
+  const interval = Number(start.payload?.interval || 4);
+
+  if (!deviceCode || !userCode || !verificationUrl) {
+    throw new Error('login_payload_invalid');
+  }
+
+  console.log(`Open ${verificationUrl} and enter code: ${userCode}`);
+
+  let accessToken = null;
+  const deadline = Date.now() + 10 * 60 * 1000;
+  while (Date.now() < deadline) {
+    await sleep(interval * 1000);
+    const poll = await apiFetch(baseUrl, '/api/cli/device/poll', {
+      method: 'POST',
+      body: JSON.stringify({device_code: deviceCode})
+    });
+
+    if (poll.ok && poll.payload?.access_token) {
+      accessToken = poll.payload.access_token;
+      break;
+    }
+
+    if (poll.status !== 428) {
+      throw new Error('login_poll_failed');
+    }
+  }
+
+  if (!accessToken) {
+    throw new Error('login_timeout');
+  }
+
+  await writeConfig(mergeConfig(config, {app_url: baseUrl, access_token: accessToken}));
+  console.log('Login completed.');
+}
+
+async function runInit(options) {
+  const config = await readConfig();
+  const baseUrl = String(config.app_url || options.appUrl || DEFAULT_APP_URL).replace(/\/$/, '');
+  const accessToken = config.access_token;
+
+  if (!accessToken) {
+    throw new Error('not_logged_in');
+  }
+
+  let provider = String(options.provider || '').toLowerCase();
+  if (provider !== 'telegram' && provider !== 'slack') {
+    const answer = await prompt('Provider (telegram/slack): ');
+    provider = answer.toLowerCase();
+  }
+
+  if (provider !== 'telegram' && provider !== 'slack') {
+    throw new Error('provider_invalid');
+  }
+
+  const machineName = String(options.machineName || getMachineName());
+  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) {
+      throw new Error('telegram_config_invalid');
+    }
+    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');
+    }
+    providerConfig.webhook_url = webhookUrl;
+  }
+
+  const register = await apiFetch(baseUrl, '/api/cli/machines/register', {
+    method: 'POST',
+    headers: {authorization: `Bearer ${accessToken}`},
+    body: JSON.stringify({
+      machine_name: machineName,
+      platform: getPlatformLabel(),
+      provider,
+      provider_config: providerConfig
+    })
+  });
+
+  if (!register.ok) {
+    throw new Error(`init_failed:${register.payload?.error || register.status}`);
+  }
+
+  await writeConfig(
+    mergeConfig(config, {
+      app_url: baseUrl,
+      machine_name: machineName,
+      machine_id: register.payload.machine_id,
+      machine_api_key: register.payload.machine_api_key,
+      provider,
+      provider_config: providerConfig
+    })
+  );
+
+  console.log(`Machine initialized: ${register.payload.machine_id}`);
+}
+
+async function runWrap(commandParts) {
+  if (!commandParts.length) {
+    throw new Error('missing_wrapped_command');
+  }
+
+  const config = await readConfig();
+  const baseUrl = String(config.app_url || DEFAULT_APP_URL).replace(/\/$/, '');
+  const machineApiKey = config.machine_api_key;
+  if (!machineApiKey) {
+    throw new Error('machine_not_initialized');
+  }
+
+  const repo = getRepoFromGit();
+  const branch = getBranchFromGit();
+  const machineName = config.machine_name || getMachineName();
+  const agentLabel = inferAgentLabel(commandParts);
+
+  const context = {
+    cwd_name: path.basename(process.cwd()),
+    git_repo: repo,
+    machine_name: machineName,
+    agent_label: agentLabel
+  };
+
+  const commandString = commandParts.join(' ');
+  const child = spawn(commandString, {
+    stdio: ['inherit', 'pipe', 'pipe'],
+    shell: true,
+    env: process.env
+  });
+
+  let sawApproval = false;
+  let sawQuestion = false;
+  let lastInterestingLine = '';
+
+  const handleChunk = async (chunkRaw) => {
+    const chunk = chunkRaw.toString('utf8');
+    const interesting = extractInterestingLine(chunk);
+    if (!interesting) return;
+
+    lastInterestingLine = interesting.line;
+
+    if (interesting.kind === 'approval_required' && !sawApproval) {
+      sawApproval = true;
+      try {
+        const event = await sendEvent({
+          apiFetch,
+          baseUrl,
+          machineApiKey,
+          event: {
+            message: interesting.line.slice(0, 500),
+            event_type: 'approval_required',
+            repo,
+            branch,
+            severity: 'critical',
+            context,
+            agent: agentLabel
+          }
+        });
+        if (event.eventId) {
+          const decision = await pollDecision({
+            apiFetch,
+            baseUrl,
+            machineApiKey,
+            eventId: event.eventId,
+            sleep
+          });
+          console.log(`\n[RunSignal] decision: ${decision}`);
+        }
+      } catch {
+        // keep wrapped command running
+      }
+    }
+
+    if (interesting.kind === 'question' && !sawQuestion) {
+      sawQuestion = true;
+      try {
+        const event = await sendEvent({
+          apiFetch,
+          baseUrl,
+          machineApiKey,
+          event: {
+            message: interesting.line.slice(0, 500),
+            event_type: 'question',
+            repo,
+            branch,
+            severity: 'warning',
+            question: interesting.line.slice(0, 500),
+            options: ['A', 'B', 'C', 'D'],
+            context,
+            agent: agentLabel
+          }
+        });
+        if (event.eventId) {
+          const answer = await pollAnswer({
+            apiFetch,
+            baseUrl,
+            machineApiKey,
+            eventId: event.eventId,
+            sleep
+          });
+          if (answer) {
+            console.log(`\n[RunSignal] reply: ${answer}`);
+          }
+        }
+      } catch {
+        // keep wrapped command running
+      }
+    }
+  };
+
+  child.stdout.on('data', (chunk) => {
+    process.stdout.write(chunk);
+    void handleChunk(chunk);
+  });
+  child.stderr.on('data', (chunk) => {
+    process.stderr.write(chunk);
+    void handleChunk(chunk);
+  });
+
+  const exitCode = await new Promise((resolve) => {
+    child.on('close', (code) => resolve(code ?? 1));
+  });
+
+  const completionMessage =
+    exitCode === 0
+      ? `Wrapped command completed: ${commandParts.join(' ')}`
+      : `Wrapped command failed (code ${exitCode}): ${lastInterestingLine || commandParts.join(' ')}`;
+
+  try {
+    await sendEvent({
+      apiFetch,
+      baseUrl,
+      machineApiKey,
+      event: {
+        message: completionMessage.slice(0, 1000),
+        event_type: exitCode === 0 ? 'task_completed' : 'error',
+        repo,
+        branch,
+        severity: exitCode === 0 ? 'info' : 'critical',
+        context,
+        agent: agentLabel
+      }
+    });
+  } catch {
+    // no-op
+  }
+
+  process.exit(exitCode);
+}
+
+async function runTest() {
+  const config = await readConfig();
+  const baseUrl = String(config.app_url || DEFAULT_APP_URL).replace(/\/$/, '');
+  const machineApiKey = config.machine_api_key;
+
+  if (!machineApiKey) {
+    throw new Error('machine_not_initialized');
+  }
+
+  const repo = getRepoFromGit();
+  const branch = getBranchFromGit();
+
+  const result = await sendEvent({
+    apiFetch,
+    baseUrl,
+    machineApiKey,
+    event: {
+      message: 'RunSignal test event',
+      event_type: 'quota_warning',
+      repo,
+      branch,
+      severity: 'warning',
+      context: {
+        cwd_name: path.basename(process.cwd()),
+        git_repo: repo,
+        machine_name: config.machine_name || getMachineName(),
+        agent_label: 'runsignal-test'
+      },
+      agent: 'runsignal-test'
+    }
+  });
+
+  console.log(`Test event sent: ${result.eventId || 'unknown'}`);
+}
+
+function normalizeEventType(value) {
+  const raw = String(value || '').trim().toLowerCase();
+  if (
+    raw === 'approval_required' ||
+    raw === 'task_completed' ||
+    raw === 'error' ||
+    raw === 'quota_warning' ||
+    raw === 'question'
+  ) {
+    return raw;
+  }
+  throw new Error('event_type_invalid');
+}
+
+function defaultSeverityForType(type) {
+  if (type === 'error' || type === 'approval_required') return 'critical';
+  if (type === 'quota_warning' || type === 'question') return 'warning';
+  return 'info';
+}
+
+function normalizeSeverity(value, fallback) {
+  const raw = String(value || fallback || '').trim().toLowerCase();
+  if (raw === 'info' || raw === 'warning' || raw === 'critical') {
+    return raw;
+  }
+  throw new Error('severity_invalid');
+}
+
+async function runSend(options) {
+  const config = await readConfig();
+  const baseUrl = String(config.app_url || options.appUrl || DEFAULT_APP_URL).replace(/\/$/, '');
+  const machineApiKey = config.machine_api_key;
+  if (!machineApiKey) {
+    throw new Error('machine_not_initialized');
+  }
+
+  const eventType = normalizeEventType(options.type || 'task_completed');
+  const severity = normalizeSeverity(options.severity, defaultSeverityForType(eventType));
+  const message = String(options.message || '').trim();
+  if (!message) {
+    throw new Error('message_required');
+  }
+
+  const repo = options.repo ? String(options.repo).trim() : getRepoFromGit();
+  const branch = options.branch ? String(options.branch).trim() : getBranchFromGit();
+  const agent = options.agent ? String(options.agent).trim() : 'manual-cli';
+
+  const result = await sendEvent({
+    apiFetch,
+    baseUrl,
+    machineApiKey,
+    event: {
+      message: message.slice(0, 2000),
+      event_type: eventType,
+      repo,
+      branch,
+      severity,
+      context: {
+        cwd_name: path.basename(process.cwd()),
+        git_repo: repo,
+        machine_name: config.machine_name || getMachineName(),
+        agent_label: agent
+      },
+      agent
+    }
+  });
+
+  console.log(
+    JSON.stringify(
+      {
+        event_id: result.eventId,
+        decision: result.decision
+      },
+      null,
+      2
+    )
+  );
+}
+
+async function runStatus(eventId, options) {
+  const config = await readConfig();
+  const baseUrl = String(config.app_url || options.appUrl || DEFAULT_APP_URL).replace(/\/$/, '');
+  const machineApiKey = config.machine_api_key;
+  if (!machineApiKey) {
+    throw new Error('machine_not_initialized');
+  }
+
+  const id = String(eventId || '').trim();
+  if (!id) {
+    throw new Error('event_id_required');
+  }
+
+  const decision = await getEventDecision({apiFetch, baseUrl, machineApiKey, eventId: id});
+  const answer = await getEventAnswer({apiFetch, baseUrl, machineApiKey, eventId: id});
+
+  console.log(
+    JSON.stringify(
+      {
+        event_id: id,
+        decision,
+        answer
+      },
+      null,
+      2
+    )
+  );
+}
+
+async function runLogout() {
+  const config = await readConfig();
+  const next = {...config};
+  delete next.access_token;
+  delete next.machine_id;
+  delete next.machine_api_key;
+  delete next.provider;
+  delete next.provider_config;
+  await writeConfig(next);
+  console.log('Logged out.');
+}
+
+const program = new Command();
+
+program.name('runsignal').description('RunSignal CLI').version('0.1.0');
+
+program
+  .command('login')
+  .option('--app-url <url>', 'RunSignal app base URL')
+  .action(async (options) => {
+    await runLogin(options);
+  });
+
+program
+  .command('init')
+  .option('--provider <provider>', 'telegram or slack')
+  .option('--app-url <url>', 'RunSignal app base URL')
+  .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 runInit(options);
+  });
+
+program
+  .command('wrap')
+  .argument('<command...>', 'Command to wrap and monitor')
+  .action(async (commandParts) => {
+    await runWrap(commandParts);
+  });
+
+program.command('test').action(async () => {
+  await runTest();
+});
+
+program
+  .command('send')
+  .requiredOption('--message <message>', 'Event message')
+  .option('--type <type>', 'Event type', 'task_completed')
+  .option('--severity <severity>', 'info|warning|critical')
+  .option('--repo <repo>', 'Repository name override')
+  .option('--branch <branch>', 'Git branch override')
+  .option('--agent <agent>', 'Agent label override')
+  .option('--app-url <url>', 'RunSignal app base URL')
+  .action(async (options) => {
+    await runSend(options);
+  });
+
+program
+  .command('status')
+  .argument('<eventId>', 'Event identifier')
+  .option('--app-url <url>', 'RunSignal app base URL')
+  .action(async (eventId, options) => {
+    await runStatus(eventId, options);
+  });
+
+program.command('logout').action(async () => {
+  await runLogout();
+});
+
+program.parseAsync(process.argv).catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`RunSignal error: ${toUserMessage(message)}`);
+  process.exit(1);
+});

package/package.json

@@ -1,10 +1,48 @@
 {
   "name": "runsignal",
-  "version": "0.0.1",
-  "description": "RunSignal CLI agent",
+  "version": "0.1.0",
+  "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"
   },
-  "type": "module",
-  "license": "MIT"
+  "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

@@ -0,0 +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;
+}