charon-hooks 0.2.0 → 0.2.3

package/README.md

@@ -38,6 +38,18 @@ Because Charon is just a trigger layer, it's completely agnostic:
 - **Swap agents anytime** - Today it's Claude, tomorrow it's GPT or your own thing. Change one line, keep all your triggers.
 - **Mix and match** - Route different events to different agents. Bug reports to Claude, billing issues to a custom script.
 
+## Installation
+
+**Via npx:**
+```bash
+npx charon-hooks
+```
+
+**Via Claude Code Plugin:**
+See [charon-plugin](https://github.com/NaxYo/charon-plugin)
+
+**Advanced options:** See [Installation Guide](docs/INSTALL.md)
+
 ---
 
 ## How It Works
@@ -76,33 +88,16 @@ export default function(payload: any) {
 ## Quick Start
 
 ```bash
-git clone https://github.com/NaxYo/charon
-cd charon
-bun install
-bun dev
+npx charon-hooks
 ```
 
-Open http://localhost:3000 - create your first trigger from the dashboard, or edit `config/triggers.yaml` directly. Both work, pick your style.
-
-See [Trigger Configuration](docs/TRIGGER-CONFIG-UI.md) and [CLI Egress](docs/EGRESS_CLI.md) for the full setup guide.
-
-### Screenshots
+Open http://localhost:3000 - create your first trigger from the dashboard, or edit `~/.charon/config/triggers.yaml` directly.
 
 <p align="center">
   <img src="docs/images/dashboard.png" width="600" alt="Dashboard" />
 </p>
 <p align="center"><em>Dashboard - view triggers and recent runs</em></p>
 
-<p align="center">
-  <img src="docs/images/trigger.png" width="600" alt="Trigger Configuration" />
-</p>
-<p align="center"><em>Trigger configuration - set up webhooks, cron, and egress</em></p>
-
-<p align="center">
-  <img src="docs/images/tunnel.png" width="400" alt="Tunnel Configuration" />
-</p>
-<p align="center"><em>Tunnel configuration - expose webhooks via ngrok</em></p>
-
 ---
 
 ## Features
@@ -133,21 +128,12 @@ No external services required. Single process, single database file, runs anywhe
 
 | Document | Description |
 |----------|-------------|
-| [SPEC.md](docs/SPEC.md) | Design principles and specification |
-| [ARCHITECTURE.md](docs/ARCHITECTURE.md) | System components and data flow |
-| [CONTRACTS.md](docs/CONTRACTS.md) | API contracts and data formats |
-| [EGRESS_CLI.md](docs/EGRESS_CLI.md) | CLI egress handler details |
-| [EGRESS_AUTO_CLAUDE.md](docs/EGRESS_AUTO_CLAUDE.md) | Auto-Claude egress handler |
-| [TUNNEL.md](docs/TUNNEL.md) | ngrok tunnel setup |
-| [UI.md](docs/UI.md) | Dashboard documentation |
-
----
-
-## Why "Charon"?
-
-In Greek mythology, Charon is the ferryman who transports souls across the River Styx.
-
-This Charon ferries events to your agents. It doesn't do the work - it makes sure the right work gets to the right worker.
+| [Installation Guide](docs/INSTALL.md) | Setup and service installation |
+| [Trigger Configuration](docs/TRIGGER-CONFIG-UI.md) | Configure triggers via UI |
+| [CLI Egress](docs/EGRESS_CLI.md) | CLI egress handler details |
+| [Tunnel Setup](docs/TUNNEL.md) | ngrok tunnel configuration |
+| [Architecture](docs/ARCHITECTURE.md) | System design and data flow |
+| [API Contracts](docs/CONTRACTS.md) | API contracts and data formats |
 
 ---
 

package/bin/charon.js

@@ -25,13 +25,13 @@ Options:
   --service <command>     Service management (status|start|stop|install)
 
 Service Commands:
-  --service status        Check if Charon is running
+  --service status        Check status (JSON: running, port, url, webhook_base)
   --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
+  --wait <uuid> --trigger <id>    Wait for webhook (prints URL to stderr)
   --resolve <uuid> --description <text>    Resolve a pending promise
 
 Configuration:
@@ -42,8 +42,8 @@ Environment:
   CHARON_DATA_DIR  Override data directory (default: ~/.charon)
 
 Data Location:
-  If ./config/config.yaml exists, uses current directory (dev mode).
-  Otherwise, uses ~/.charon/ for configuration and data.
+  Configuration and data are stored in ~/.charon/
+  Override with CHARON_DATA_DIR environment variable.
 
 Documentation:
   https://github.com/NaxYo/charon
@@ -58,17 +58,10 @@ if (args.includes('--version') || args.includes('-v')) {
   process.exit(0);
 }
 
-// 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();
-} else {
-  dataDir = userDataDir;
-  ensureDataDir(dataDir);
-}
+// Data directory is always ~/.charon/ (or CHARON_DATA_DIR if set)
+// Dev mode uses `bun dev` directly, not this CLI
+const dataDir = process.env.CHARON_DATA_DIR || resolve(homedir(), '.charon');
+ensureDataDir(dataDir);
 
 // Set environment for the server
 process.env.CHARON_DATA_DIR = dataDir;
@@ -130,11 +123,7 @@ if (isRunning) {
 }
 
 // Show startup info
-if (existsSync(localConfig)) {
-  console.log('[charon] Dev mode: using local config');
-} else {
-  console.log('[charon] Using user config:', resolve(dataDir, 'config'));
-}
+console.log('[charon] Data dir:', dataDir);
 console.log('[charon] Server port:', port);
 
 // Write PID file
@@ -149,6 +138,24 @@ process.on('SIGTERM', () => { cleanupPidFile(pidFile); process.exit(0); });
 const serverPath = resolve(__dirname, '..', 'dist', 'server', 'index.js');
 await import(serverPath);
 
+/**
+ * Get the base URL for webhooks (tunnel URL if active, otherwise localhost)
+ */
+async function getWebhookBaseUrl(port) {
+  try {
+    const response = await fetch(`http://localhost:${port}/api/tunnel`);
+    if (response.ok) {
+      const tunnel = await response.json();
+      if (tunnel.connected && tunnel.url) {
+        return tunnel.url;
+      }
+    }
+  } catch {
+    // Tunnel API not available or error, fall back to localhost
+  }
+  return `http://localhost:${port}`;
+}
+
 /**
  * Handle --wait command: blocks until the promise is resolved
  */
@@ -159,6 +166,12 @@ async function handleWaitCommand(uuid, triggerId, port) {
     process.exit(1);
   }
 
+  // Get webhook URL and output to stderr (so stdout stays clean for resolved description)
+  const baseUrl = await getWebhookBaseUrl(port);
+  const webhookUrl = `${baseUrl}/api/webhook/${triggerId}/${uuid}`;
+  console.error(`[charon] Webhook URL: ${webhookUrl}`);
+  console.error(`[charon] Waiting for webhook...`);
+
   try {
     const controller = new AbortController();
 
@@ -265,9 +278,23 @@ async function handleServiceCommand(command, port, pidFile) {
       const running = await isCharonRunning(port);
       if (running) {
         const pid = readPidFile(pidFile);
-        console.log(`[charon] Running on port ${port}${pid ? ` (PID: ${pid})` : ''}`);
+        const baseUrl = await getWebhookBaseUrl(port);
+        // Output JSON for machine-readable status
+        console.log(JSON.stringify({
+          running: true,
+          port,
+          pid: pid || null,
+          url: baseUrl,
+          webhook_base: `${baseUrl}/api/webhook`
+        }));
       } else {
-        console.log(`[charon] Not running`);
+        console.log(JSON.stringify({
+          running: false,
+          port,
+          pid: null,
+          url: null,
+          webhook_base: null
+        }));
       }
       break;
     }

package/dist/server/index.js

@@ -1,8 +1,8 @@
 // src/server/app.ts
 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";
+import { dirname as dirname3, resolve as resolve4 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { existsSync as existsSync5 } from "fs";
 
 // src/server/middleware/logger.ts
 import { createMiddleware } from "hono/factory";
@@ -106,8 +106,8 @@ function serveStatic({ root, path: fallbackPath }) {
 import { Hono } from "hono";
 
 // src/lib/config/loader.ts
-import { readFileSync as readFileSync2, writeFileSync, mkdirSync, watch, existsSync as existsSync2 } from "fs";
-import { dirname } from "path";
+import { readFileSync as readFileSync2, writeFileSync, mkdirSync as mkdirSync2, watch, existsSync as existsSync3 } from "fs";
+import { dirname as dirname2 } from "path";
 
 // src/lib/config/schema.ts
 import { z } from "zod";
@@ -258,8 +258,8 @@ function initSchema(db2) {
 var db = null;
 function getDb() {
   if (!db) {
-    const dbPath = process.env.CHARON_DB || "charon.db";
-    db = createDatabase(dbPath);
+    const dbPath2 = process.env.CHARON_DB || "charon.db";
+    db = createDatabase(dbPath2);
     initSchema(db);
   }
   return db;
@@ -422,16 +422,88 @@ function listEvents(db2, filter) {
 }
 
 // src/lib/pipeline/sanitizer.ts
-import { resolve as resolve2 } from "path";
+import { resolve as resolve3 } from "path";
 import { pathToFileURL } from "url";
+
+// src/lib/data-dir.ts
+import { existsSync as existsSync2, mkdirSync, copyFileSync, readdirSync } from "fs";
+import { resolve as resolve2, dirname } from "path";
+import { homedir } from "os";
+import { fileURLToPath } from "url";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var isDevMode = process.env.CHARON_DEV === "1";
+var dataDir = isDevMode ? process.cwd() : process.env.CHARON_DATA_DIR || resolve2(homedir(), ".charon");
+var configDir = resolve2(dataDir, "config");
+var triggersPath = resolve2(configDir, "triggers.yaml");
+var configPath = resolve2(configDir, "config.yaml");
+var sanitizersDir = resolve2(dataDir, "sanitizers");
+var dbPath = process.env.CHARON_DB || resolve2(dataDir, "charon.db");
+function getBundledDir() {
+  if (isDevMode) {
+    return process.cwd();
+  }
+  return resolve2(__dirname, "../..");
+}
+function initializeDataDir() {
+  if (isDevMode) {
+    console.log("[data-dir] Dev mode: using", dataDir);
+    return;
+  }
+  console.log("[data-dir] Prod mode: using", dataDir);
+  if (!existsSync2(dataDir)) {
+    mkdirSync(dataDir, { recursive: true });
+  }
+  if (!existsSync2(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+  if (!existsSync2(sanitizersDir)) {
+    mkdirSync(sanitizersDir, { recursive: true });
+  }
+  const bundledDir = getBundledDir();
+  copyDefaultFile(
+    resolve2(bundledDir, "config/config.yaml.dist"),
+    resolve2(configDir, "config.yaml")
+  );
+  copyDefaultFile(
+    resolve2(bundledDir, "config/triggers.yaml.dist"),
+    resolve2(configDir, "triggers.yaml")
+  );
+  const bundledSanitizersDir = resolve2(bundledDir, "sanitizers");
+  if (existsSync2(bundledSanitizersDir)) {
+    const existingSanitizers = existsSync2(sanitizersDir) ? readdirSync(sanitizersDir).filter((f) => f.endsWith(".ts")) : [];
+    if (existingSanitizers.length === 0) {
+      const defaultSanitizers = readdirSync(bundledSanitizersDir).filter(
+        (f) => f.endsWith(".ts")
+      );
+      for (const file of defaultSanitizers) {
+        copyDefaultFile(
+          resolve2(bundledSanitizersDir, file),
+          resolve2(sanitizersDir, file)
+        );
+      }
+      if (defaultSanitizers.length > 0) {
+        console.log(
+          `[data-dir] Installed ${defaultSanitizers.length} default sanitizer(s)`
+        );
+      }
+    }
+  }
+}
+function copyDefaultFile(src, dest) {
+  if (!existsSync2(dest) && existsSync2(src)) {
+    copyFileSync(src, dest);
+    console.log(`[data-dir] Created ${dest}`);
+  }
+}
+
+// src/lib/pipeline/sanitizer.ts
 var sanitizerCache = /* @__PURE__ */ new Map();
-var SANITIZERS_DIR = process.env.CHARON_SANITIZERS_DIR || "sanitizers";
 async function loadSanitizer(name) {
   if (sanitizerCache.has(name)) {
     return sanitizerCache.get(name);
   }
   try {
-    const sanitizerPath = resolve2(SANITIZERS_DIR, `${name}.ts`);
+    const sanitizerPath = resolve3(sanitizersDir, `${name}.ts`);
     const sanitizerUrl = pathToFileURL(sanitizerPath).href;
     const mod = await import(sanitizerUrl);
     const fn = mod.default;
@@ -754,7 +826,7 @@ async function startTunnel(config, port = 3e3) {
     }
     try {
       await ngrok.disconnect();
-      await new Promise((resolve4) => setTimeout(resolve4, 1e3));
+      await new Promise((resolve5) => setTimeout(resolve5, 1e3));
     } catch {
     }
     listener = null;
@@ -837,9 +909,9 @@ var DEFAULT_CONFIG = `# Charon trigger configuration
 
 triggers: []
 `;
-async function loadConfig(path = "config/triggers.yaml") {
-  if (!existsSync2(path)) {
-    mkdirSync(dirname(path), { recursive: true });
+async function loadConfig(path = triggersPath) {
+  if (!existsSync3(path)) {
+    mkdirSync2(dirname2(path), { recursive: true });
     writeFileSync(path, DEFAULT_CONFIG, "utf-8");
     console.log(`[config] Created default config at ${path}`);
   }
@@ -851,8 +923,8 @@ async function loadConfig(path = "config/triggers.yaml") {
   cachedConfig = result.data;
   return result.data;
 }
-async function initializeApp(configPath = "config/triggers.yaml") {
-  const config = await loadConfig(configPath);
+async function initializeApp(configPath2 = triggersPath) {
+  const config = await loadConfig(configPath2);
   const db2 = getDb();
   initScheduler(db2, config.triggers);
   if (config.tunnel) {
@@ -860,7 +932,7 @@ async function initializeApp(configPath = "config/triggers.yaml") {
   } else {
     await stopTunnel();
   }
-  startConfigWatcher(configPath);
+  startConfigWatcher(configPath2);
   return {
     config,
     tunnel: getTunnelStatus()
@@ -876,11 +948,11 @@ 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)) {
+async function deleteTrigger(id, configPath2 = triggersPath) {
+  if (!existsSync3(configPath2)) {
     return false;
   }
-  const content = readFileSync2(configPath, "utf-8");
+  const content = readFileSync2(configPath2, "utf-8");
   const result = parseConfig(content);
   if (!result.success) {
     console.error(`[config] Cannot delete trigger: invalid config`);
@@ -895,22 +967,22 @@ async function deleteTrigger(id, configPath = "config/triggers.yaml") {
   config.triggers.splice(triggerIndex, 1);
   const yaml = await import("yaml");
   const newContent = yaml.stringify(config);
-  writeFileSync(configPath, newContent, "utf-8");
+  writeFileSync(configPath2, newContent, "utf-8");
   console.log(`[config] Deleted trigger '${id}'`);
   cachedConfig = config;
   return true;
 }
-function startConfigWatcher(configPath = "config/triggers.yaml") {
-  if (configWatcher && watchedConfigPath === configPath) {
+function startConfigWatcher(configPath2 = triggersPath) {
+  if (configWatcher && watchedConfigPath === configPath2) {
     return;
   }
   stopConfigWatcher();
-  if (!existsSync2(configPath)) {
-    console.warn(`[config] Config file not found: ${configPath}, skipping watcher`);
+  if (!existsSync3(configPath2)) {
+    console.warn(`[config] Config file not found: ${configPath2}, skipping watcher`);
     return;
   }
-  watchedConfigPath = configPath;
-  configWatcher = watch(configPath, (eventType) => {
+  watchedConfigPath = configPath2;
+  configWatcher = watch(configPath2, (eventType) => {
     if (eventType === "change") {
       if (reloadTimeout) {
         clearTimeout(reloadTimeout);
@@ -918,7 +990,7 @@ function startConfigWatcher(configPath = "config/triggers.yaml") {
       reloadTimeout = setTimeout(async () => {
         console.log("[config] File changed, reloading...");
         try {
-          await reloadConfig(configPath);
+          await reloadConfig(configPath2);
           console.log("[config] Reload complete");
         } catch (err) {
           console.error("[config] Reload failed:", err instanceof Error ? err.message : err);
@@ -926,7 +998,7 @@ function startConfigWatcher(configPath = "config/triggers.yaml") {
       }, 300);
     }
   });
-  console.log(`[config] Watching ${configPath} for changes`);
+  console.log(`[config] Watching ${configPath2} for changes`);
 }
 function stopConfigWatcher() {
   if (reloadTimeout) {
@@ -940,8 +1012,8 @@ function stopConfigWatcher() {
     console.log("[config] Stopped watching config file");
   }
 }
-async function reloadConfig(configPath) {
-  const config = await loadConfig(configPath);
+async function reloadConfig(configPath2) {
+  const config = await loadConfig(configPath2);
   const db2 = getDb();
   initScheduler(db2, config.triggers);
   if (config.tunnel) {
@@ -955,14 +1027,14 @@ async function reloadConfig(configPath) {
 import { readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
 import { parse as parseYaml2, stringify as stringifyYaml } from "yaml";
 var DEFAULT_CONFIG_PATH = "config/triggers.yaml";
-async function writeTrigger(trigger, configPath = DEFAULT_CONFIG_PATH) {
+async function writeTrigger(trigger, configPath2 = DEFAULT_CONFIG_PATH) {
   const validation = validateTrigger(trigger);
   if (!validation.success) {
     const messages = validation.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ");
     return { success: false, error: `Validation failed: ${messages}` };
   }
   try {
-    const content = readFileSync3(configPath, "utf-8");
+    const content = readFileSync3(configPath2, "utf-8");
     const config = parseYaml2(content) || {};
     if (!config.triggers) {
       config.triggers = [];
@@ -996,15 +1068,15 @@ async function writeTrigger(trigger, configPath = DEFAULT_CONFIG_PATH) {
       defaultStringType: "PLAIN",
       defaultKeyType: "PLAIN"
     });
-    writeFileSync2(configPath, yamlOutput);
+    writeFileSync2(configPath2, yamlOutput);
     return { success: true };
   } catch (err) {
     return { success: false, error: `Write failed: ${err instanceof Error ? err.message : String(err)}` };
   }
 }
-async function deleteTrigger2(id, configPath = DEFAULT_CONFIG_PATH) {
+async function deleteTrigger2(id, configPath2 = DEFAULT_CONFIG_PATH) {
   try {
-    const content = readFileSync3(configPath, "utf-8");
+    const content = readFileSync3(configPath2, "utf-8");
     const config = parseYaml2(content) || {};
     if (!config.triggers || !Array.isArray(config.triggers)) {
       return { success: false, error: `Trigger '${id}' not found` };
@@ -1019,15 +1091,15 @@ async function deleteTrigger2(id, configPath = DEFAULT_CONFIG_PATH) {
       defaultStringType: "PLAIN",
       defaultKeyType: "PLAIN"
     });
-    writeFileSync2(configPath, yamlOutput);
+    writeFileSync2(configPath2, yamlOutput);
     return { success: true };
   } catch (err) {
     return { success: false, error: `Delete failed: ${err instanceof Error ? err.message : String(err)}` };
   }
 }
-async function listTriggerIds(configPath = DEFAULT_CONFIG_PATH) {
+async function listTriggerIds(configPath2 = DEFAULT_CONFIG_PATH) {
   try {
-    const content = readFileSync3(configPath, "utf-8");
+    const content = readFileSync3(configPath2, "utf-8");
     const config = parseYaml2(content) || {};
     if (!config.triggers || !Array.isArray(config.triggers)) {
       return [];
@@ -1037,9 +1109,9 @@ async function listTriggerIds(configPath = DEFAULT_CONFIG_PATH) {
     return [];
   }
 }
-async function writeTunnelConfig(tunnel, configPath = DEFAULT_CONFIG_PATH) {
+async function writeTunnelConfig(tunnel, configPath2 = DEFAULT_CONFIG_PATH) {
   try {
-    const content = readFileSync3(configPath, "utf-8");
+    const content = readFileSync3(configPath2, "utf-8");
     const config = parseYaml2(content) || {};
     const tunnelObj = {
       enabled: tunnel.enabled,
@@ -1058,15 +1130,15 @@ async function writeTunnelConfig(tunnel, configPath = DEFAULT_CONFIG_PATH) {
       defaultStringType: "PLAIN",
       defaultKeyType: "PLAIN"
     });
-    writeFileSync2(configPath, yamlOutput);
+    writeFileSync2(configPath2, yamlOutput);
     return { success: true };
   } catch (err) {
     return { success: false, error: `Write failed: ${err instanceof Error ? err.message : String(err)}` };
   }
 }
-async function getTunnelConfig(configPath = DEFAULT_CONFIG_PATH) {
+async function getTunnelConfig(configPath2 = DEFAULT_CONFIG_PATH) {
   try {
-    const content = readFileSync3(configPath, "utf-8");
+    const content = readFileSync3(configPath2, "utf-8");
     const config = parseYaml2(content) || {};
     if (!config.tunnel) {
       return null;
@@ -1085,7 +1157,7 @@ async function getTunnelConfig(configPath = DEFAULT_CONFIG_PATH) {
 
 // src/server/routes/triggers.ts
 var triggersRoutes = new Hono();
-async function createTriggerInternal(trigger, configPath) {
+async function createTriggerInternal(trigger, configPath2) {
   const validation = validateTrigger(trigger);
   if (!validation.success) {
     return {
@@ -1095,7 +1167,7 @@ async function createTriggerInternal(trigger, configPath) {
       status: 400
     };
   }
-  const existingIds = await listTriggerIds(configPath);
+  const existingIds = await listTriggerIds(configPath2);
   if (existingIds.includes(trigger.id)) {
     return {
       success: false,
@@ -1103,7 +1175,7 @@ async function createTriggerInternal(trigger, configPath) {
       status: 409
     };
   }
-  const result = await writeTrigger(trigger, configPath);
+  const result = await writeTrigger(trigger, configPath2);
   if (!result.success) {
     return {
       success: false,
@@ -1117,7 +1189,7 @@ async function createTriggerInternal(trigger, configPath) {
     status: 201
   };
 }
-async function updateTriggerInternal(id, trigger, configPath) {
+async function updateTriggerInternal(id, trigger, configPath2) {
   const validation = validateTrigger(trigger);
   if (!validation.success) {
     return {
@@ -1127,7 +1199,7 @@ async function updateTriggerInternal(id, trigger, configPath) {
       status: 400
     };
   }
-  const existingIds = await listTriggerIds(configPath);
+  const existingIds = await listTriggerIds(configPath2);
   if (!existingIds.includes(id)) {
     return {
       success: false,
@@ -1144,7 +1216,7 @@ async function updateTriggerInternal(id, trigger, configPath) {
     };
   }
   if (idChanged) {
-    const deleteResult = await deleteTrigger2(id, configPath);
+    const deleteResult = await deleteTrigger2(id, configPath2);
     if (!deleteResult.success) {
       return {
         success: false,
@@ -1153,7 +1225,7 @@ async function updateTriggerInternal(id, trigger, configPath) {
       };
     }
   }
-  const result = await writeTrigger(trigger, configPath);
+  const result = await writeTrigger(trigger, configPath2);
   if (!result.success) {
     return {
       success: false,
@@ -1169,8 +1241,8 @@ async function updateTriggerInternal(id, trigger, configPath) {
     status: 200
   };
 }
-async function deleteTriggerInternal(id, configPath) {
-  const existingIds = await listTriggerIds(configPath);
+async function deleteTriggerInternal(id, configPath2) {
+  const existingIds = await listTriggerIds(configPath2);
   if (!existingIds.includes(id)) {
     return {
       success: false,
@@ -1178,7 +1250,7 @@ async function deleteTriggerInternal(id, configPath) {
       status: 404
     };
   }
-  const result = await deleteTrigger2(id, configPath);
+  const result = await deleteTrigger2(id, configPath2);
   if (!result.success) {
     return {
       success: false,
@@ -1199,9 +1271,9 @@ async function ensureConfig() {
     configLoaded = true;
   }
 }
-async function testTriggerInternal(id, payload, configPath) {
-  if (configPath) {
-    await loadConfig(configPath);
+async function testTriggerInternal(id, payload, configPath2) {
+  if (configPath2) {
+    await loadConfig(configPath2);
   } else {
     await ensureConfig();
   }
@@ -1360,10 +1432,9 @@ runsRoutes.get("/:id", async (c) => {
 
 // src/server/routes/sanitizers.ts
 import { Hono as Hono3 } from "hono";
-import { readdirSync, existsSync as existsSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2 } from "fs";
+import { readdirSync as readdirSync2, existsSync as existsSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
 import { join as join2 } from "path";
 var sanitizersRoutes = new Hono3();
-var DEFAULT_SANITIZERS_DIR = process.env.CHARON_SANITIZERS_DIR || "sanitizers";
 var BOILERPLATE = `/**
  * Sanitizer function for processing webhook payloads.
  *
@@ -1383,17 +1454,17 @@ export default sanitize;
 function sanitizeName(name) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-");
 }
-function listSanitizersInternal(sanitizersDir = DEFAULT_SANITIZERS_DIR) {
-  if (!existsSync3(sanitizersDir)) {
+function listSanitizersInternal(dir = sanitizersDir) {
+  if (!existsSync4(dir)) {
     return [];
   }
-  const files = readdirSync(sanitizersDir);
+  const files = readdirSync2(dir);
   return files.filter((f) => f.endsWith(".ts")).map((f) => ({
     name: f.replace(".ts", ""),
-    path: join2(sanitizersDir, f)
+    path: join2(dir, f)
   }));
 }
-function createSanitizerInternal(rawName, sanitizersDir = DEFAULT_SANITIZERS_DIR) {
+function createSanitizerInternal(rawName, dir = sanitizersDir) {
   if (!rawName || typeof rawName !== "string") {
     return { success: false, error: "Name is required", status: 400 };
   }
@@ -1401,12 +1472,12 @@ function createSanitizerInternal(rawName, sanitizersDir = DEFAULT_SANITIZERS_DIR
   if (!name) {
     return { success: false, error: "Invalid name", status: 400 };
   }
-  const filePath = join2(sanitizersDir, `${name}.ts`);
-  if (existsSync3(filePath)) {
+  const filePath = join2(dir, `${name}.ts`);
+  if (existsSync4(filePath)) {
     return { success: false, error: `Sanitizer '${name}' already exists`, status: 409 };
   }
-  if (!existsSync3(sanitizersDir)) {
-    mkdirSync2(sanitizersDir, { recursive: true });
+  if (!existsSync4(dir)) {
+    mkdirSync3(dir, { recursive: true });
   }
   writeFileSync3(filePath, BOILERPLATE);
   return { success: true, name, path: filePath, status: 201 };
@@ -1711,10 +1782,10 @@ async function tunnelProxyMiddleware(c, next) {
 }
 
 // src/server/app.ts
-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 __dirname2 = dirname3(fileURLToPath2(import.meta.url));
+var prodClientDir = resolve4(__dirname2, "../client");
+var devClientDir = resolve4(process.cwd(), "dist/client");
+var clientDir = existsSync5(devClientDir) ? devClientDir : prodClientDir;
 var app = new Hono8();
 app.use("*", quietLogger);
 app.use("*", tunnelProxyMiddleware);
@@ -1726,11 +1797,12 @@ app.route("/api/webhook", webhookRoutes);
 app.route("/api/task", taskRoutes);
 app.route("/api/promise", promiseRoutes);
 app.use("/*", serveStatic({ root: clientDir }));
-app.get("*", serveStatic({ path: resolve3(clientDir, "index.html") }));
+app.get("*", serveStatic({ path: resolve4(clientDir, "index.html") }));
 
 // src/server/init.ts
 async function initializeServices() {
   try {
+    initializeDataDir();
     const { config, tunnel } = await initializeApp();
     console.log(`[init] Loaded ${config.triggers.length} triggers`);
     if (tunnel.connected) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "charon-hooks",
-  "version": "0.2.0",
+  "version": "0.2.3",
   "description": "Autonomous task triggering service - webhooks and cron to AI agents",
   "type": "module",
   "bin": {
@@ -12,17 +12,17 @@
     "dist/"
   ],
   "scripts": {
-    "dev": "bun run dev:server",
-    "dev:server": "bun --watch src/server/index.ts",
+    "dev": "CHARON_DEV=1 bun run dev:server",
+    "dev:server": "CHARON_DEV=1 bun --watch src/server/index.ts",
     "dev:client": "vite",
-    "dev:all": "bun run build:client && bun run dev:server",
+    "dev:all": "bun run build:client && CHARON_DEV=1 bun run dev:server",
     "build": "bun run build:client && bun run build:server",
     "build:client": "vite build",
     "build:server": "tsup",
     "start": "node dist/server/index.js",
     "lint": "eslint",
-    "test": "CHARON_DB=:memory: bun test",
-    "test:watch": "CHARON_DB=:memory: bun test --watch"
+    "test": "CHARON_DEV=1 CHARON_DB=:memory: bun test --max-concurrency=1",
+    "test:watch": "CHARON_DEV=1 CHARON_DB=:memory: bun test --watch --max-concurrency=1"
   },
   "dependencies": {
     "@hono/node-server": "^1.19.8",