charon-hooks 0.1.6 → 0.2.0

package/bin/charon.js

@@ -1,9 +1,11 @@
 #!/usr/bin/env node
 
 import { resolve, dirname } from 'path';
-import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
-import { homedir } from 'os';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, copyFileSync, unlinkSync } from 'fs';
+import { homedir, platform } from 'os';
 import { fileURLToPath } from 'url';
+import { spawn } from 'child_process';
+import YAML from 'yaml';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -18,16 +20,29 @@ Usage:
   charon-hooks [options]
 
 Options:
-  --port <port>    Server port (default: 3000, or PORT env)
-  --help, -h       Show this help
-  --version, -v    Show version
+  --help, -h              Show this help
+  --version, -v           Show version
+  --service <command>     Service management (status|start|stop|install)
+
+Service Commands:
+  --service status        Check if Charon is running
+  --service start         Start Charon in background
+  --service stop          Stop background Charon process
+  --service install       Generate system service files
+
+Promise Commands (for Claude Code integration):
+  --wait <uuid> --trigger <id>    Wait for a promise to be resolved
+  --resolve <uuid> --description <text>    Resolve a pending promise
+
+Configuration:
+  Server port and other settings are configured in config/config.yaml.
+  Copy config/config.yaml.dist to config/config.yaml to customize.
 
 Environment:
-  PORT             Server port
   CHARON_DATA_DIR  Override data directory (default: ~/.charon)
 
 Data Location:
-  If ./config/triggers.yaml exists, uses current directory (dev mode).
+  If ./config/config.yaml exists, uses current directory (dev mode).
   Otherwise, uses ~/.charon/ for configuration and data.
 
 Documentation:
@@ -43,38 +58,446 @@ if (args.includes('--version') || args.includes('-v')) {
   process.exit(0);
 }
 
-// Determine data directory
-const localConfig = resolve(process.cwd(), 'config/triggers.yaml');
+// Determine data directory based on config file presence
+const localConfig = resolve(process.cwd(), 'config/config.yaml');
 const userDataDir = process.env.CHARON_DATA_DIR || resolve(homedir(), '.charon');
 
 let dataDir;
 if (existsSync(localConfig)) {
   dataDir = process.cwd();
-  console.log('[charon] Using local config:', localConfig);
 } else {
   dataDir = userDataDir;
   ensureDataDir(dataDir);
-  console.log('[charon] Using user config:', resolve(dataDir, 'config/triggers.yaml'));
 }
 
 // Set environment for the server
 process.env.CHARON_DATA_DIR = dataDir;
 
-// Parse port
-let port = process.env.PORT || '3000';
-const portIdx = args.indexOf('--port');
-if (portIdx !== -1 && args[portIdx + 1]) {
-  port = args[portIdx + 1];
+// Load configuration
+const config = loadConfig(dataDir);
+const port = config.server?.port || 3000;
+process.env.PORT = String(port);
+
+// PID file location
+const pidFile = resolve(dataDir, 'charon.pid');
+
+// Handle service commands
+const serviceIdx = args.indexOf('--service');
+if (serviceIdx !== -1) {
+  const command = args[serviceIdx + 1];
+  await handleServiceCommand(command, port, pidFile);
+  process.exit(0);
+}
+
+// Handle promise --wait command
+const waitIdx = args.indexOf('--wait');
+if (waitIdx !== -1) {
+  const uuid = args[waitIdx + 1];
+  const triggerIdx = args.indexOf('--trigger');
+  const triggerId = triggerIdx !== -1 ? args[triggerIdx + 1] : 'unknown';
+
+  if (!uuid) {
+    console.error('[charon] --wait requires a UUID');
+    process.exit(1);
+  }
+
+  await handleWaitCommand(uuid, triggerId, port);
+  process.exit(0);
+}
+
+// Handle promise --resolve command
+const resolveIdx = args.indexOf('--resolve');
+if (resolveIdx !== -1) {
+  const uuid = args[resolveIdx + 1];
+  const descIdx = args.indexOf('--description');
+  const description = descIdx !== -1 ? args[descIdx + 1] : '';
+
+  if (!uuid) {
+    console.error('[charon] --resolve requires a UUID');
+    process.exit(1);
+  }
+
+  await handleResolveCommand(uuid, description, port);
+  process.exit(0);
+}
+
+// Check if already running (singleton)
+const isRunning = await isCharonRunning(port);
+if (isRunning) {
+  console.log(`[charon] Already running on port ${port}`);
+  console.log('[charon] Use --service status for details, or --service stop to stop');
+  process.exit(0);
+}
+
+// Show startup info
+if (existsSync(localConfig)) {
+  console.log('[charon] Dev mode: using local config');
+} else {
+  console.log('[charon] Using user config:', resolve(dataDir, 'config'));
 }
-process.env.PORT = port;
+console.log('[charon] Server port:', port);
+
+// Write PID file
+writePidFile(pidFile, process.pid);
+
+// Cleanup PID file on exit
+process.on('exit', () => cleanupPidFile(pidFile));
+process.on('SIGINT', () => { cleanupPidFile(pidFile); process.exit(0); });
+process.on('SIGTERM', () => { cleanupPidFile(pidFile); process.exit(0); });
 
 // Start server
 const serverPath = resolve(__dirname, '..', 'dist', 'server', 'index.js');
 await import(serverPath);
 
+/**
+ * Handle --wait command: blocks until the promise is resolved
+ */
+async function handleWaitCommand(uuid, triggerId, port) {
+  const running = await isCharonRunning(port);
+  if (!running) {
+    console.error('[charon] Charon is not running. Start it with: npx charon-hooks --service start');
+    process.exit(1);
+  }
+
+  try {
+    const controller = new AbortController();
+
+    // Cleanup on process exit
+    const cleanup = () => {
+      controller.abort();
+      process.exit(0);
+    };
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+
+    const response = await fetch(
+      `http://localhost:${port}/api/promise/${uuid}/wait?trigger=${encodeURIComponent(triggerId)}`,
+      { signal: controller.signal }
+    );
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+      console.error(`[charon] Wait failed: ${error.error || response.statusText}`);
+      process.exit(1);
+    }
+
+    const result = await response.json();
+
+    if (result.status === 'resolved') {
+      // Output the description to stdout (for Claude to consume)
+      console.log(result.description);
+    } else {
+      console.error(`[charon] Promise ${result.status}: ${result.error || 'Unknown'}`);
+      process.exit(1);
+    }
+  } catch (err) {
+    if (err.name === 'AbortError') {
+      // Process was killed, exit gracefully
+      process.exit(0);
+    }
+    console.error(`[charon] Wait error: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Handle --resolve command: resolves a pending promise
+ */
+async function handleResolveCommand(uuid, description, port) {
+  const running = await isCharonRunning(port);
+  if (!running) {
+    console.error('[charon] Charon is not running. Start it with: npx charon-hooks --service start');
+    process.exit(1);
+  }
+
+  try {
+    const response = await fetch(`http://localhost:${port}/api/promise/${uuid}/resolve`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ description }),
+    });
+
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+      console.error(`[charon] Resolve failed: ${error.error || response.statusText}`);
+      process.exit(1);
+    }
+
+    const result = await response.json();
+
+    if (result.status === 'resolved') {
+      console.log(`[charon] Resolved promise ${uuid}`);
+    } else if (result.status === 'no_waiter') {
+      // Silently succeed - no one was waiting
+      console.log(`[charon] No waiter for ${uuid} (already resolved or never registered)`);
+    }
+  } catch (err) {
+    console.error(`[charon] Resolve error: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Check if Charon is running on the given port
+ */
+async function isCharonRunning(port) {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 2000);
+
+    const response = await fetch(`http://localhost:${port}/api/triggers`, {
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Handle service management commands
+ */
+async function handleServiceCommand(command, port, pidFile) {
+  switch (command) {
+    case 'status': {
+      const running = await isCharonRunning(port);
+      if (running) {
+        const pid = readPidFile(pidFile);
+        console.log(`[charon] Running on port ${port}${pid ? ` (PID: ${pid})` : ''}`);
+      } else {
+        console.log(`[charon] Not running`);
+      }
+      break;
+    }
+
+    case 'start': {
+      const running = await isCharonRunning(port);
+      if (running) {
+        console.log(`[charon] Already running on port ${port}`);
+        return;
+      }
+
+      console.log('[charon] Starting in background...');
+
+      // Spawn detached process
+      const child = spawn(process.execPath, [resolve(__dirname, 'charon.js')], {
+        detached: true,
+        stdio: 'ignore',
+        cwd: process.cwd(),
+        env: { ...process.env, CHARON_DATA_DIR: dataDir }
+      });
+
+      child.unref();
+
+      // Wait for startup
+      await new Promise(r => setTimeout(r, 1000));
+
+      const nowRunning = await isCharonRunning(port);
+      if (nowRunning) {
+        console.log(`[charon] Started on port ${port} (PID: ${child.pid})`);
+      } else {
+        console.log('[charon] Failed to start. Check logs for errors.');
+        process.exit(1);
+      }
+      break;
+    }
+
+    case 'stop': {
+      const running = await isCharonRunning(port);
+      if (!running) {
+        console.log('[charon] Not running');
+        cleanupPidFile(pidFile);
+        return;
+      }
+
+      const pid = readPidFile(pidFile);
+      if (pid) {
+        try {
+          process.kill(pid, 'SIGTERM');
+          console.log(`[charon] Stopped (PID: ${pid})`);
+          cleanupPidFile(pidFile);
+        } catch (err) {
+          console.log(`[charon] Could not stop process: ${err.message}`);
+          console.log('[charon] Process may have been started by another user or system service');
+        }
+      } else {
+        console.log('[charon] Running but no PID file found');
+        console.log('[charon] Process may have been started by system service or another method');
+      }
+      break;
+    }
+
+    case 'install': {
+      await generateServiceFiles(dataDir, port);
+      break;
+    }
+
+    default:
+      console.log(`[charon] Unknown service command: ${command}`);
+      console.log('[charon] Valid commands: status, start, stop, install');
+      process.exit(1);
+  }
+}
+
+/**
+ * Generate system service files
+ */
+async function generateServiceFiles(dataDir, _port) {
+  const os = platform();
+  const serviceDir = resolve(dataDir, 'service');
+
+  if (!existsSync(serviceDir)) {
+    mkdirSync(serviceDir, { recursive: true });
+  }
+
+  if (os === 'darwin') {
+    // macOS launchd plist
+    const plistPath = resolve(serviceDir, 'com.charon.hooks.plist');
+    const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>com.charon.hooks</string>
+    <key>ProgramArguments</key>
+    <array>
+        <string>${process.execPath}</string>
+        <string>${resolve(__dirname, 'charon.js')}</string>
+    </array>
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>CHARON_DATA_DIR</key>
+        <string>${dataDir}</string>
+    </dict>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <key>StandardOutPath</key>
+    <string>${resolve(dataDir, 'charon.log')}</string>
+    <key>StandardErrorPath</key>
+    <string>${resolve(dataDir, 'charon.error.log')}</string>
+</dict>
+</plist>`;
+
+    writeFileSync(plistPath, plist);
+    console.log(`[charon] Generated launchd plist: ${plistPath}`);
+    console.log('');
+    console.log('To install as a user service:');
+    console.log(`  cp ${plistPath} ~/Library/LaunchAgents/`);
+    console.log('  launchctl load ~/Library/LaunchAgents/com.charon.hooks.plist');
+    console.log('');
+    console.log('To uninstall:');
+    console.log('  launchctl unload ~/Library/LaunchAgents/com.charon.hooks.plist');
+    console.log('  rm ~/Library/LaunchAgents/com.charon.hooks.plist');
+
+  } else if (os === 'linux') {
+    // Linux systemd unit file
+    const unitPath = resolve(serviceDir, 'charon-hooks.service');
+    const unit = `[Unit]
+Description=Charon Hooks - Task triggering service
+After=network.target
+
+[Service]
+Type=simple
+ExecStart=${process.execPath} ${resolve(__dirname, 'charon.js')}
+Environment=CHARON_DATA_DIR=${dataDir}
+Restart=on-failure
+RestartSec=5
+
+[Install]
+WantedBy=default.target
+`;
+
+    writeFileSync(unitPath, unit);
+    console.log(`[charon] Generated systemd unit file: ${unitPath}`);
+    console.log('');
+    console.log('To install as a user service:');
+    console.log('  mkdir -p ~/.config/systemd/user');
+    console.log(`  cp ${unitPath} ~/.config/systemd/user/`);
+    console.log('  systemctl --user daemon-reload');
+    console.log('  systemctl --user enable charon-hooks');
+    console.log('  systemctl --user start charon-hooks');
+    console.log('');
+    console.log('To check status:');
+    console.log('  systemctl --user status charon-hooks');
+    console.log('');
+    console.log('To uninstall:');
+    console.log('  systemctl --user stop charon-hooks');
+    console.log('  systemctl --user disable charon-hooks');
+    console.log('  rm ~/.config/systemd/user/charon-hooks.service');
+
+  } else {
+    console.log(`[charon] Service installation not supported on ${os}`);
+    console.log('[charon] You can start Charon manually with: npx charon-hooks --service start');
+  }
+}
+
+/**
+ * Write PID to file
+ */
+function writePidFile(pidFile, pid) {
+  try {
+    writeFileSync(pidFile, String(pid));
+  } catch {
+    // Ignore write errors (e.g., permission issues)
+  }
+}
+
+/**
+ * Read PID from file
+ */
+function readPidFile(pidFile) {
+  try {
+    if (existsSync(pidFile)) {
+      return parseInt(readFileSync(pidFile, 'utf-8').trim(), 10);
+    }
+  } catch {
+    // Ignore read errors
+  }
+  return null;
+}
+
+/**
+ * Cleanup PID file
+ */
+function cleanupPidFile(pidFile) {
+  try {
+    if (existsSync(pidFile)) {
+      unlinkSync(pidFile);
+    }
+  } catch {
+    // Ignore cleanup errors
+  }
+}
+
+/**
+ * Load configuration from config/config.yaml
+ */
+function loadConfig(dir) {
+  const configPath = resolve(dir, 'config/config.yaml');
+
+  if (!existsSync(configPath)) {
+    return { server: { port: 3000 } };
+  }
+
+  try {
+    const content = readFileSync(configPath, 'utf-8');
+    const parsed = YAML.parse(content);
+    return parsed || { server: { port: 3000 } };
+  } catch (error) {
+    console.error('[charon] Error parsing config.yaml:', error.message);
+    return { server: { port: 3000 } };
+  }
+}
+
+/**
+ * Ensure data directory structure exists with default files
+ */
 function ensureDataDir(dir) {
   if (!existsSync(dir)) {
-    console.log('[charon] Creating data directory:', dir);
     mkdirSync(dir, { recursive: true });
   }
 
@@ -88,16 +511,40 @@ function ensureDataDir(dir) {
     mkdirSync(sanitizersDir, { recursive: true });
   }
 
-  const configFile = resolve(configDir, 'triggers.yaml');
+  // Initialize config.yaml from .dist template
+  const configFile = resolve(configDir, 'config.yaml');
   if (!existsSync(configFile)) {
-    writeFileSync(
-      configFile,
-      `# Charon trigger configuration
+    const distFile = resolve(__dirname, '..', 'config', 'config.yaml.dist');
+    if (existsSync(distFile)) {
+      copyFileSync(distFile, configFile);
+    } else {
+      writeFileSync(
+        configFile,
+        `# Charon configuration
+# See https://github.com/NaxYo/charon for documentation
+
+server:
+  port: 3000
+`
+      );
+    }
+  }
+
+  // Initialize triggers.yaml
+  const triggersFile = resolve(configDir, 'triggers.yaml');
+  if (!existsSync(triggersFile)) {
+    const distTriggersFile = resolve(__dirname, '..', 'config', 'triggers.yaml.dist');
+    if (existsSync(distTriggersFile)) {
+      copyFileSync(distTriggersFile, triggersFile);
+    } else {
+      writeFileSync(
+        triggersFile,
+        `# Charon trigger configuration
 # See https://github.com/NaxYo/charon for documentation
 
 triggers: []
 `
-    );
-    console.log('[charon] Created default config:', configFile);
+      );
+    }
   }
 }

package/config/config.yaml.dist

@@ -0,0 +1,9 @@
+# Charon configuration
+# See https://github.com/NaxYo/charon for documentation
+#
+# Copy this file to config.yaml to customize settings.
+# For production: ~/.charon/config/config.yaml
+# For development: ./config/config.yaml (takes precedence)
+
+server:
+  port: 3000

package/config/triggers.yaml.dist

@@ -0,0 +1,50 @@
+# Tunnel configuration (optional)
+# Exposes webhooks to the internet via ngrok
+# Get your authtoken at: https://dashboard.ngrok.com/get-started/your-authtoken
+tunnel:
+  enabled: false
+  provider: ngrok
+  authtoken: your_ngrok_authtoken_here
+  # Optional: use a static domain (free tier includes 1)
+  # Get one at: https://dashboard.ngrok.com/cloud-edge/domains
+  # domain: your-name.ngrok-free.app
+  # Optional: expose the full UI via tunnel (default: false, only webhooks exposed)
+  # expose_ui: false
+
+triggers:
+  - id: example-webhook
+    name: Example Webhook
+    type: webhook
+    enabled: true
+    template: |
+      Received webhook payload:
+
+      {payload}
+    sanitizer: passthrough
+    egress: console
+
+  - id: example-cron
+    name: Example Cron
+    type: cron
+    schedule: "0 9 * * *"
+    enabled: false
+    template: |
+      Daily scheduled task at {trigger_time}
+    egress: console
+    context:
+      source: scheduler
+
+  # Example: CLI egress with Claude
+  # - id: github-issues
+  #   name: GitHub Issue Handler
+  #   type: webhook
+  #   enabled: true
+  #   template: |
+  #     Fix issue #{issue_number}: {title}
+  #
+  #     {body}
+  #   sanitizer: github-issue
+  #   egress: cli
+  #   context:
+  #     cli_template: "claude \"{description}\""
+  #     working_dir: "/home/dev/{repo}"

package/dist/server/index.js

@@ -1,5 +1,8 @@
 // src/server/app.ts
-import { Hono as Hono7 } from "hono";
+import { Hono as Hono8 } from "hono";
+import { dirname as dirname2, resolve as resolve3 } from "path";
+import { fileURLToPath } from "url";
+import { existsSync as existsSync4 } from "fs";
 
 // src/server/middleware/logger.ts
 import { createMiddleware } from "hono/factory";
@@ -482,7 +485,7 @@ function compose(template, context) {
 function generateTaskId() {
   return "task_" + Math.random().toString(36).slice(2, 10);
 }
-async function processWebhook(db2, trigger, payload, headers) {
+async function processWebhook(db2, trigger, payload, headers, promiseUuid) {
   const run = createRun(db2, {
     trigger_id: trigger.id,
     trigger_type: "webhook",
@@ -496,7 +499,7 @@ async function processWebhook(db2, trigger, payload, headers) {
     data: { payload_size: JSON.stringify(payload).length }
   });
   updateRun(db2, run.id, { status: "processing" });
-  return processPipeline(db2, run.id, trigger, payload, headers);
+  return processPipeline(db2, run.id, trigger, payload, headers, promiseUuid);
 }
 async function processCron(db2, trigger) {
   const run = createRun(db2, {
@@ -517,7 +520,7 @@ async function processCron(db2, trigger) {
   };
   return processPipeline(db2, run.id, trigger, cronContext, {});
 }
-async function processPipeline(db2, runId, trigger, payload, headers) {
+async function processPipeline(db2, runId, trigger, payload, headers, promiseUuid) {
   const startTime = Date.now();
   try {
     let context;
@@ -545,6 +548,9 @@ async function processPipeline(db2, runId, trigger, payload, headers) {
         return { run: getRun(db2, runId), task: null };
       }
       context = { ...trigger.context, ...result };
+      if (promiseUuid) {
+        context.promise_uuid = promiseUuid;
+      }
       updateRun(db2, runId, {
         sanitizer_result: {
           success: true,
@@ -561,6 +567,9 @@ async function processPipeline(db2, runId, trigger, payload, headers) {
       });
     } else {
       context = typeof payload === "object" && payload !== null ? { ...trigger.context, ...payload } : { ...trigger.context, payload };
+      if (promiseUuid) {
+        context.promise_uuid = promiseUuid;
+      }
     }
     const composerStart = Date.now();
     const description = compose(trigger.template, context);
@@ -629,6 +638,15 @@ function initScheduler(db2, triggers) {
     const task = cron.schedule(trigger.schedule, async () => {
       console.log(`[scheduler] Firing trigger: ${trigger.id}`);
       await processCron(db2, trigger);
+      if (trigger.one_off) {
+        console.log(`[scheduler] One-off trigger '${trigger.id}' completed, deleting...`);
+        const job = scheduledJobs.get(trigger.id);
+        if (job) {
+          job.stop();
+          scheduledJobs.delete(trigger.id);
+        }
+        await deleteTrigger(trigger.id);
+      }
     });
     scheduledJobs.set(trigger.id, task);
   }
@@ -736,7 +754,7 @@ async function startTunnel(config, port = 3e3) {
     }
     try {
       await ngrok.disconnect();
-      await new Promise((resolve3) => setTimeout(resolve3, 1e3));
+      await new Promise((resolve4) => setTimeout(resolve4, 1e3));
     } catch {
     }
     listener = null;
@@ -858,6 +876,30 @@ function getTrigger(id) {
   const config = getConfig();
   return config.triggers.find((t) => t.id === id);
 }
+async function deleteTrigger(id, configPath = "config/triggers.yaml") {
+  if (!existsSync2(configPath)) {
+    return false;
+  }
+  const content = readFileSync2(configPath, "utf-8");
+  const result = parseConfig(content);
+  if (!result.success) {
+    console.error(`[config] Cannot delete trigger: invalid config`);
+    return false;
+  }
+  const config = result.data;
+  const triggerIndex = config.triggers.findIndex((t) => t.id === id);
+  if (triggerIndex === -1) {
+    console.warn(`[config] Trigger '${id}' not found for deletion`);
+    return false;
+  }
+  config.triggers.splice(triggerIndex, 1);
+  const yaml = await import("yaml");
+  const newContent = yaml.stringify(config);
+  writeFileSync(configPath, newContent, "utf-8");
+  console.log(`[config] Deleted trigger '${id}'`);
+  cachedConfig = config;
+  return true;
+}
 function startConfigWatcher(configPath = "config/triggers.yaml") {
   if (configWatcher && watchedConfigPath === configPath) {
     return;
@@ -960,7 +1002,7 @@ async function writeTrigger(trigger, configPath = DEFAULT_CONFIG_PATH) {
     return { success: false, error: `Write failed: ${err instanceof Error ? err.message : String(err)}` };
   }
 }
-async function deleteTrigger(id, configPath = DEFAULT_CONFIG_PATH) {
+async function deleteTrigger2(id, configPath = DEFAULT_CONFIG_PATH) {
   try {
     const content = readFileSync3(configPath, "utf-8");
     const config = parseYaml2(content) || {};
@@ -1102,7 +1144,7 @@ async function updateTriggerInternal(id, trigger, configPath) {
     };
   }
   if (idChanged) {
-    const deleteResult = await deleteTrigger(id, configPath);
+    const deleteResult = await deleteTrigger2(id, configPath);
     if (!deleteResult.success) {
       return {
         success: false,
@@ -1136,7 +1178,7 @@ async function deleteTriggerInternal(id, configPath) {
       status: 404
     };
   }
-  const result = await deleteTrigger(id, configPath);
+  const result = await deleteTrigger2(id, configPath);
   if (!result.success) {
     return {
       success: false,
@@ -1479,9 +1521,8 @@ async function ensureConfig2() {
     configLoaded2 = true;
   }
 }
-webhookRoutes.post("/:id", async (c) => {
+async function handleWebhook(c, id, promiseUuid) {
   await ensureConfig2();
-  const id = c.req.param("id");
   const trigger = getTrigger(id);
   if (!trigger) {
     return c.json(
@@ -1507,11 +1548,20 @@ webhookRoutes.post("/:id", async (c) => {
     headers[key] = value;
   });
   const db2 = getDb();
-  const result = await processWebhook(db2, trigger, payload, headers);
+  const result = await processWebhook(db2, trigger, payload, headers, promiseUuid);
   return c.json(
-    { run_id: result.run.id, status: result.run.status },
+    { run_id: result.run.id, status: result.run.status, promise_uuid: promiseUuid || null },
     202
   );
+}
+webhookRoutes.post("/:id", async (c) => {
+  const id = c.req.param("id");
+  return handleWebhook(c, id);
+});
+webhookRoutes.post("/:id/:uuid", async (c) => {
+  const id = c.req.param("id");
+  const uuid = c.req.param("uuid");
+  return handleWebhook(c, id, uuid);
 });
 
 // src/server/routes/task.ts
@@ -1560,6 +1610,80 @@ taskRoutes.post("/complete", async (c) => {
   }
 });
 
+// src/server/routes/promise.ts
+import { Hono as Hono7 } from "hono";
+var promiseRoutes = new Hono7();
+var pendingPromises = /* @__PURE__ */ new Map();
+promiseRoutes.get("/:uuid/wait", async (c) => {
+  const uuid = c.req.param("uuid");
+  const triggerId = c.req.query("trigger") || "unknown";
+  if (pendingPromises.has(uuid)) {
+    return c.json({ error: "Promise already registered" }, 409);
+  }
+  console.log(`[promise] Waiting for ${uuid} (trigger: ${triggerId})`);
+  return new Promise((promiseResolve) => {
+    const cleanup = () => {
+      pendingPromises.delete(uuid);
+    };
+    pendingPromises.set(uuid, {
+      resolve: (description) => {
+        cleanup();
+        console.log(`[promise] Resolved ${uuid}`);
+        promiseResolve(c.json({ status: "resolved", description }));
+      },
+      reject: (error) => {
+        cleanup();
+        console.log(`[promise] Rejected ${uuid}: ${error.message}`);
+        promiseResolve(c.json({ status: "rejected", error: error.message }, 500));
+      },
+      triggerId,
+      createdAt: /* @__PURE__ */ new Date()
+    });
+  });
+});
+promiseRoutes.post("/:uuid/resolve", async (c) => {
+  const uuid = c.req.param("uuid");
+  const body = await c.req.json().catch(() => ({}));
+  const description = body.description || "";
+  const pending = pendingPromises.get(uuid);
+  if (pending) {
+    pending.resolve(description);
+    return c.json({ status: "resolved", uuid });
+  }
+  console.log(`[promise] No waiter for ${uuid}, ignoring resolve`);
+  return c.json({ status: "no_waiter", uuid });
+});
+promiseRoutes.get("/:uuid", (c) => {
+  const uuid = c.req.param("uuid");
+  const pending = pendingPromises.get(uuid);
+  if (pending) {
+    return c.json({
+      uuid,
+      status: "pending",
+      triggerId: pending.triggerId,
+      createdAt: pending.createdAt.toISOString()
+    });
+  }
+  return c.json({ uuid, status: "not_found" }, 404);
+});
+promiseRoutes.get("/", (c) => {
+  const promises = Array.from(pendingPromises.entries()).map(([uuid, p]) => ({
+    uuid,
+    triggerId: p.triggerId,
+    createdAt: p.createdAt.toISOString()
+  }));
+  return c.json({ promises });
+});
+promiseRoutes.delete("/:uuid", (c) => {
+  const uuid = c.req.param("uuid");
+  const pending = pendingPromises.get(uuid);
+  if (pending) {
+    pending.reject(new Error("Cancelled"));
+    return c.json({ status: "cancelled", uuid });
+  }
+  return c.json({ status: "not_found", uuid }, 404);
+});
+
 // src/server/middleware/tunnel-proxy.ts
 var TUNNEL_PATTERNS = [
   ".ngrok-free.app",
@@ -1587,7 +1711,11 @@ async function tunnelProxyMiddleware(c, next) {
 }
 
 // src/server/app.ts
-var app = new Hono7();
+var __dirname = dirname2(fileURLToPath(import.meta.url));
+var prodClientDir = resolve3(__dirname, "../client");
+var devClientDir = resolve3(process.cwd(), "dist/client");
+var clientDir = existsSync4(devClientDir) ? devClientDir : prodClientDir;
+var app = new Hono8();
 app.use("*", quietLogger);
 app.use("*", tunnelProxyMiddleware);
 app.route("/api/triggers", triggersRoutes);
@@ -1596,8 +1724,9 @@ app.route("/api/sanitizers", sanitizersRoutes);
 app.route("/api/tunnel", tunnelRoutes);
 app.route("/api/webhook", webhookRoutes);
 app.route("/api/task", taskRoutes);
-app.use("/*", serveStatic({ root: "./dist/client" }));
-app.get("*", serveStatic({ path: "./dist/client/index.html" }));
+app.route("/api/promise", promiseRoutes);
+app.use("/*", serveStatic({ root: clientDir }));
+app.get("*", serveStatic({ path: resolve3(clientDir, "index.html") }));
 
 // src/server/init.ts
 async function initializeServices() {
@@ -1619,7 +1748,9 @@ await initializeServices();
 if (typeof Bun !== "undefined") {
   const server = Bun.serve({
     fetch: app.fetch,
-    port: PORT
+    port: PORT,
+    // Disable idle timeout to support long-running promise waits
+    idleTimeout: 0
   });
   console.log(`[server] Charon running at http://localhost:${server.port}`);
 } else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "charon-hooks",
-  "version": "0.1.6",
+  "version": "0.2.0",
   "description": "Autonomous task triggering service - webhooks and cron to AI agents",
   "type": "module",
   "bin": {
@@ -8,6 +8,7 @@
   },
   "files": [
     "bin/",
+    "config/*.dist",
     "dist/"
   ],
   "scripts": {