charon-hooks 0.2.3 → 0.2.4

package/dist/server/index.js

@@ -2,7 +2,7 @@
 import { Hono as Hono8 } from "hono";
 import { dirname as dirname3, resolve as resolve4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 
 // src/server/middleware/logger.ts
 import { createMiddleware } from "hono/factory";
@@ -106,7 +106,7 @@ function serveStatic({ root, path: fallbackPath }) {
 import { Hono } from "hono";
 
 // src/lib/config/loader.ts
-import { readFileSync as readFileSync2, writeFileSync, mkdirSync as mkdirSync2, watch, existsSync as existsSync3 } from "fs";
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync3, watch, existsSync as existsSync5 } from "fs";
 import { dirname as dirname2 } from "path";
 
 // src/lib/config/schema.ts
@@ -158,9 +158,9 @@ function parseConfig(yamlContent) {
 var createDatabase;
 var isBun = typeof globalThis.Bun !== "undefined";
 if (isBun) {
-  const { Database } = await import("bun:sqlite");
+  const { Database: Database2 } = await import("bun:sqlite");
   createDatabase = (path) => {
-    const db2 = new Database(path);
+    const db2 = new Database2(path);
     return {
       exec: (sql) => db2.run(sql),
       prepare: (sql) => {
@@ -424,6 +424,7 @@ function listEvents(db2, filter) {
 // src/lib/pipeline/sanitizer.ts
 import { resolve as resolve3 } from "path";
 import { pathToFileURL } from "url";
+import { createJiti } from "jiti";
 
 // src/lib/data-dir.ts
 import { existsSync as existsSync2, mkdirSync, copyFileSync, readdirSync } from "fs";
@@ -498,20 +499,28 @@ function copyDefaultFile(src, dest) {
 
 // src/lib/pipeline/sanitizer.ts
 var sanitizerCache = /* @__PURE__ */ new Map();
+var jiti = createJiti(import.meta.url);
 async function loadSanitizer(name) {
   if (sanitizerCache.has(name)) {
     return sanitizerCache.get(name);
   }
+  const sanitizerPath = resolve3(sanitizersDir, `${name}.ts`);
   try {
-    const sanitizerPath = resolve3(sanitizersDir, `${name}.ts`);
     const sanitizerUrl = pathToFileURL(sanitizerPath).href;
     const mod = await import(sanitizerUrl);
     const fn = mod.default;
     sanitizerCache.set(name, fn);
     return fn;
   } catch {
-    sanitizerCache.set(name, null);
-    return null;
+    try {
+      const mod = await jiti.import(sanitizerPath);
+      const fn = mod.default;
+      sanitizerCache.set(name, fn);
+      return fn;
+    } catch {
+      sanitizerCache.set(name, null);
+      return null;
+    }
   }
 }
 async function executeSanitizer(sanitizer, payload, headers, trigger) {
@@ -522,25 +531,108 @@ async function executeSanitizer(sanitizer, payload, headers, trigger) {
   return result;
 }
 
-// src/lib/egress/loader.ts
-var egressCache = /* @__PURE__ */ new Map();
-async function loadEgress(name) {
-  if (egressCache.has(name)) {
-    return egressCache.get(name);
+// src/egress/console.ts
+var consoleEgress = (task) => {
+  if (isDevMode) {
+    console.log("[egress:console]", JSON.stringify(task, null, 2));
   }
-  try {
-    const mod = await import(`@/egress/${name}`);
-    const fn = mod.default;
-    egressCache.set(name, fn);
-    return fn;
-  } catch {
-    egressCache.set(name, null);
-    return null;
+};
+var console_default = consoleEgress;
+
+// src/egress/cli.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync } from "fs";
+import { join as join2 } from "path";
+function ensureMcpConfig() {
+  const mcpDir = join2(process.cwd(), "mcp");
+  const mcpConfigPath = join2(mcpDir, "charon-mcp.json");
+  const finishTaskPath = join2(mcpDir, "finish-task.ts");
+  if (!existsSync3(mcpConfigPath)) {
+    if (!existsSync3(mcpDir)) {
+      mkdirSync2(mcpDir, { recursive: true });
+    }
+    const config = {
+      mcpServers: {
+        "finish-task": {
+          type: "stdio",
+          command: "bun",
+          args: [finishTaskPath],
+          env: {
+            CHARON_API_URL: process.env.CHARON_API_URL || "http://localhost:3000"
+          }
+        }
+      }
+    };
+    writeFileSync(mcpConfigPath, JSON.stringify(config, null, 2) + "\n");
+    console.log("[egress:cli] Created MCP config:", mcpConfigPath);
   }
+  return mcpConfigPath;
 }
-async function executeEgress(egress, task, trigger) {
-  await egress(task, trigger);
+function shellEscape(str) {
+  return str.replace(/'/g, "'\\''").replace(/\n/g, "\\n");
+}
+function composeCommand(template, context) {
+  return template.replace(/\{(\w+)\}/g, (match, key) => {
+    if (key in context) {
+      const value = context[key];
+      const str = typeof value === "object" ? JSON.stringify(value) : String(value);
+      return shellEscape(str);
+    }
+    return match;
+  });
+}
+function composeWorkingDir(workingDir, context) {
+  if (!workingDir) return void 0;
+  return composeCommand(workingDir, context);
 }
+var cliEgress = (task, trigger) => {
+  const cliTemplate = trigger.context?.cli_template;
+  if (!cliTemplate || typeof cliTemplate !== "string") {
+    console.error("[egress:cli] Missing cli_template in trigger context");
+    return;
+  }
+  const mcpConfig = cliTemplate.includes("{mcp_config}") ? ensureMcpConfig() : void 0;
+  const context = {
+    ...trigger.context,
+    ...task.task.context,
+    description: task.task.description,
+    trigger_id: task.trigger_id,
+    run_id: task.run_id,
+    ...mcpConfig && { mcp_config: mcpConfig }
+  };
+  const command = composeCommand(cliTemplate, context);
+  const workingDir = composeWorkingDir(
+    trigger.context?.working_dir,
+    context
+  );
+  console.log("[egress:cli] Executing:", command);
+  if (workingDir) {
+    console.log("[egress:cli] Working directory:", workingDir);
+  }
+  const child = spawn(command, [], {
+    shell: true,
+    cwd: workingDir,
+    detached: true,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  child.stdout?.on("data", (data) => {
+    console.log("[egress:cli] stdout:", data.toString().trim());
+  });
+  child.stderr?.on("data", (data) => {
+    console.error("[egress:cli] stderr:", data.toString().trim());
+  });
+  child.on("error", (err) => {
+    console.error("[egress:cli] spawn error:", err.message);
+  });
+  child.on("exit", (code, signal) => {
+    if (code !== 0) {
+      console.error("[egress:cli] exited with code:", code, "signal:", signal);
+    }
+  });
+  child.unref();
+  console.log("[egress:cli] Spawned process PID:", child.pid);
+};
+var cli_default = cliEgress;
 
 // src/lib/pipeline/composer.ts
 function compose(template, context) {
@@ -553,6 +645,352 @@ function compose(template, context) {
   });
 }
 
+// src/egress/kanban.ts
+import Database from "better-sqlite3";
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+function uuidToBlob(uuid) {
+  const hex = uuid.replace(/-/g, "");
+  const bytes = new Uint8Array(16);
+  for (let i = 0; i < 16; i++) {
+    bytes[i] = parseInt(hex.substr(i * 2, 2), 16);
+  }
+  return bytes;
+}
+function blobToUUID(blob) {
+  const hex = Array.from(blob).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return hex.slice(0, 8) + "-" + hex.slice(8, 12) + "-" + hex.slice(12, 16) + "-" + hex.slice(16, 20) + "-" + hex.slice(20);
+}
+function lookupRepoForProject(projectId) {
+  let db2 = null;
+  try {
+    const dbPath2 = join3(homedir2(), ".local/share/vibe-kanban/db.sqlite");
+    db2 = new Database(dbPath2, { readonly: true, timeout: 5e3 });
+    const projectBlob = uuidToBlob(projectId);
+    const result = db2.prepare("SELECT repo_id FROM project_repos WHERE project_id = ? LIMIT 1").get(projectBlob);
+    if (result?.repo_id) {
+      return blobToUUID(new Uint8Array(result.repo_id));
+    }
+    return null;
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("locked")) {
+      console.error(
+        "[egress:kanban] Vibe Kanban database is locked. Please provide repo_id in config or try again later."
+      );
+    } else {
+      console.error("[egress:kanban] Failed to lookup repo:", error);
+    }
+    return null;
+  } finally {
+    db2?.close();
+  }
+}
+function extractTitle(description) {
+  const firstLine = description.split("\n")[0].trim();
+  return firstLine.length > 200 ? firstLine.slice(0, 197) + "..." : firstLine;
+}
+function composeTitle(template, context, fallbackDescription) {
+  const composed = compose(template, context);
+  const title = composed.length > 200 ? composed.slice(0, 197) + "..." : composed;
+  if (!title.trim() || title.includes("{")) {
+    return extractTitle(fallbackDescription);
+  }
+  return title;
+}
+async function startTaskAttempt(apiUrl, taskId, repoId, executor, variant, baseBranch) {
+  try {
+    const response = await fetch(`${apiUrl}/api/task-attempts`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        task_id: taskId,
+        executor_profile_id: {
+          executor,
+          variant
+        },
+        repos: [
+          {
+            repo_id: repoId,
+            base_branch: baseBranch,
+            target_branch: baseBranch
+          }
+        ]
+      })
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error(
+        "[egress:kanban] Failed to start task:",
+        response.status,
+        response.statusText,
+        errorText
+      );
+      return false;
+    }
+    const result = await response.json();
+    if (!result.success) {
+      console.error("[egress:kanban] Start task error:", result.message);
+      return false;
+    }
+    console.log("[egress:kanban] Task started successfully");
+    console.log("[egress:kanban] Attempt ID:", result.data?.id);
+    console.log("[egress:kanban] Branch:", result.data?.branch);
+    return true;
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error("[egress:kanban] Failed to start task:", error.message);
+    } else {
+      console.error("[egress:kanban] Failed to start task:", error);
+    }
+    return false;
+  }
+}
+var kanbanEgress = async (task, trigger) => {
+  const apiUrl = trigger.context?.api_url;
+  const projectId = trigger.context?.project_id;
+  const titleTemplate = trigger.context?.title_template;
+  const autoStart = trigger.context?.auto_start === true;
+  const repoId = trigger.context?.repo_id;
+  const executor = trigger.context?.executor || "CLAUDE_CODE";
+  const variant = trigger.context?.variant || "DEFAULT";
+  const baseBranch = trigger.context?.base_branch || "main";
+  if (!apiUrl || typeof apiUrl !== "string") {
+    console.error("[egress:kanban] Missing required config: api_url");
+    return;
+  }
+  if (!projectId || typeof projectId !== "string") {
+    console.error("[egress:kanban] Missing required config: project_id");
+    return;
+  }
+  let resolvedRepoId = repoId;
+  if (autoStart && !resolvedRepoId) {
+    console.log("[egress:kanban] No repo_id provided, looking up from Vibe Kanban database...");
+    resolvedRepoId = lookupRepoForProject(projectId) ?? void 0;
+    if (resolvedRepoId) {
+      console.log("[egress:kanban] Found repo_id:", resolvedRepoId);
+    } else {
+      console.error(
+        "[egress:kanban] Could not find repo for project. Either provide repo_id in config or ensure the project has a linked repository in Vibe Kanban."
+      );
+      return;
+    }
+  }
+  const taskContext = task.task.context || {};
+  const title = titleTemplate ? composeTitle(titleTemplate, taskContext, task.task.description) : extractTitle(task.task.description);
+  const description = task.task.description;
+  console.log("[egress:kanban] Creating task:", title);
+  console.log("[egress:kanban] Project ID:", projectId);
+  console.log("[egress:kanban] API URL:", apiUrl);
+  if (autoStart) {
+    console.log("[egress:kanban] Auto-start enabled with executor:", executor);
+  }
+  try {
+    const response = await fetch(`${apiUrl}/api/tasks`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        project_id: projectId,
+        title,
+        description
+      })
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error(
+        "[egress:kanban] API error:",
+        response.status,
+        response.statusText,
+        errorText
+      );
+      return;
+    }
+    const result = await response.json();
+    if (!result.success || !result.data) {
+      console.error("[egress:kanban] API returned error:", result.message);
+      return;
+    }
+    const taskId = result.data.id;
+    console.log("[egress:kanban] Task created successfully:", taskId);
+    console.log("[egress:kanban] Task status:", result.data.status);
+    if (autoStart && resolvedRepoId) {
+      console.log("[egress:kanban] Starting task with", executor, variant);
+      await startTaskAttempt(apiUrl, taskId, resolvedRepoId, executor, variant, baseBranch);
+    }
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error("[egress:kanban] Connection failed:", error.message);
+    } else {
+      console.error("[egress:kanban] Connection failed:", error);
+    }
+  }
+};
+var kanban_default = kanbanEgress;
+
+// src/egress/auto-claude.ts
+import { spawn as spawn2, spawnSync } from "child_process";
+import { existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir3 } from "os";
+var DEB_BACKEND_PATH = "/opt/Auto-Claude/resources/backend";
+var DEB_PYTHON_PATH = "/opt/Auto-Claude/resources/python/bin/python3";
+var DEB_SITE_PACKAGES = "/opt/Auto-Claude/resources/python-site-packages";
+function parseSpecId(output) {
+  const patterns = [
+    /Created spec:\s*(\d{3}[\w-]*)/i,
+    /Spec\s+(\d{3}[\w-]*)/i,
+    /specs\/(\d{3}[\w-]*)/,
+    /(\d{3}-[\w-]+)/
+  ];
+  for (const pattern of patterns) {
+    const match = output.match(pattern);
+    if (match) {
+      return match[1];
+    }
+  }
+  return null;
+}
+function resolvePath(path) {
+  return path.replace(/^~/, homedir3());
+}
+var autoClaudeEgress = async (task, trigger) => {
+  const ctx = trigger.context || {};
+  const projectDir = ctx.project_dir;
+  if (!projectDir) {
+    console.error("[egress:auto-claude] Missing project_dir in trigger context");
+    console.error("[egress:auto-claude] This is the directory where Auto-Claude will create specs");
+    return;
+  }
+  const resolvedProjectDir = resolvePath(projectDir);
+  if (!existsSync4(resolvedProjectDir)) {
+    console.error("[egress:auto-claude] Project directory does not exist:", resolvedProjectDir);
+    return;
+  }
+  const backendPath = resolvePath(ctx.backend_path || DEB_BACKEND_PATH);
+  const specRunnerPath = join4(backendPath, "runners", "spec_runner.py");
+  const runPath = join4(backendPath, "run.py");
+  if (!existsSync4(specRunnerPath)) {
+    console.error("[egress:auto-claude] spec_runner.py not found at:", specRunnerPath);
+    console.error("[egress:auto-claude] Backend path:", backendPath);
+    return;
+  }
+  const pythonPath = resolvePath(ctx.python_path || DEB_PYTHON_PATH);
+  if (!existsSync4(pythonPath)) {
+    console.error("[egress:auto-claude] Python not found at:", pythonPath);
+    return;
+  }
+  const complexity = ctx.complexity;
+  const autoRun = ctx.auto_run !== false;
+  const maxIterations = ctx.max_iterations;
+  const skipQa = ctx.skip_qa === true;
+  const autoApprove = ctx.auto_approve !== false;
+  const description = task.task.description;
+  console.log("[egress:auto-claude] Creating spec for task:", description.substring(0, 100) + "...");
+  console.log("[egress:auto-claude] Project directory:", resolvedProjectDir);
+  console.log("[egress:auto-claude] Backend path:", backendPath);
+  const specArgs = [
+    specRunnerPath,
+    "--task",
+    description,
+    "--project-dir",
+    resolvedProjectDir
+  ];
+  if (complexity) {
+    specArgs.push("--complexity", complexity);
+  }
+  if (autoApprove) {
+    specArgs.push("--auto-approve");
+  }
+  if (!autoRun) {
+    specArgs.push("--no-build");
+  }
+  console.log("[egress:auto-claude] Running:", pythonPath, specArgs.join(" "));
+  const env = {
+    ...process.env,
+    PYTHONPATH: DEB_SITE_PACKAGES
+  };
+  const specResult = spawnSync(pythonPath, specArgs, {
+    cwd: backendPath,
+    encoding: "utf-8",
+    timeout: 12e4,
+    // 2 minutes for spec creation
+    env
+  });
+  if (specResult.error) {
+    console.error("[egress:auto-claude] Failed to create spec:", specResult.error.message);
+    return;
+  }
+  const specOutput = (specResult.stdout || "") + (specResult.stderr || "");
+  console.log("[egress:auto-claude] spec_runner.py output:", specOutput);
+  if (specResult.status !== 0) {
+    console.error("[egress:auto-claude] spec_runner.py failed with status:", specResult.status);
+    return;
+  }
+  const specId = parseSpecId(specOutput);
+  if (specId) {
+    console.log("[egress:auto-claude] Created spec:", specId);
+  } else {
+    console.log("[egress:auto-claude] Spec created (could not parse ID from output)");
+  }
+  if (!autoRun) {
+    console.log("[egress:auto-claude] auto_run is disabled, spec created but not started");
+  } else if (specId && existsSync4(runPath)) {
+    if (maxIterations || skipQa) {
+      const runArgs = [
+        runPath,
+        "--spec",
+        specId,
+        "--project-dir",
+        resolvedProjectDir,
+        "--auto-continue"
+      ];
+      if (maxIterations) {
+        runArgs.push("--max-iterations", String(maxIterations));
+      }
+      if (skipQa) {
+        runArgs.push("--skip-qa");
+      }
+      console.log("[egress:auto-claude] Running spec with options:", pythonPath, runArgs.join(" "));
+      const runChild = spawn2(pythonPath, runArgs, {
+        cwd: backendPath,
+        detached: true,
+        stdio: ["ignore", "pipe", "pipe"],
+        env
+      });
+      runChild.stdout?.on("data", (data) => {
+        console.log("[egress:auto-claude] run.py stdout:", data.toString().trim());
+      });
+      runChild.stderr?.on("data", (data) => {
+        console.error("[egress:auto-claude] run.py stderr:", data.toString().trim());
+      });
+      runChild.on("error", (err) => {
+        console.error("[egress:auto-claude] run.py spawn error:", err.message);
+      });
+      runChild.unref();
+      console.log("[egress:auto-claude] Spawned run.py PID:", runChild.pid);
+    }
+  }
+  console.log("[egress:auto-claude] Task queued successfully");
+};
+var auto_claude_default = autoClaudeEgress;
+
+// src/lib/egress/loader.ts
+var egressRegistry = {
+  console: console_default,
+  cli: cli_default,
+  kanban: kanban_default,
+  "auto-claude": auto_claude_default
+};
+async function loadEgress(name) {
+  return egressRegistry[name] || null;
+}
+async function executeEgress(egress, task, trigger) {
+  await egress(task, trigger);
+}
+
 // src/lib/pipeline/processor.ts
 function generateTaskId() {
   return "task_" + Math.random().toString(36).slice(2, 10);
@@ -910,9 +1348,9 @@ var DEFAULT_CONFIG = `# Charon trigger configuration
 triggers: []
 `;
 async function loadConfig(path = triggersPath) {
-  if (!existsSync3(path)) {
-    mkdirSync2(dirname2(path), { recursive: true });
-    writeFileSync(path, DEFAULT_CONFIG, "utf-8");
+  if (!existsSync5(path)) {
+    mkdirSync3(dirname2(path), { recursive: true });
+    writeFileSync2(path, DEFAULT_CONFIG, "utf-8");
     console.log(`[config] Created default config at ${path}`);
   }
   const content = readFileSync2(path, "utf-8");
@@ -949,7 +1387,7 @@ function getTrigger(id) {
   return config.triggers.find((t) => t.id === id);
 }
 async function deleteTrigger(id, configPath2 = triggersPath) {
-  if (!existsSync3(configPath2)) {
+  if (!existsSync5(configPath2)) {
     return false;
   }
   const content = readFileSync2(configPath2, "utf-8");
@@ -967,7 +1405,7 @@ async function deleteTrigger(id, configPath2 = triggersPath) {
   config.triggers.splice(triggerIndex, 1);
   const yaml = await import("yaml");
   const newContent = yaml.stringify(config);
-  writeFileSync(configPath2, newContent, "utf-8");
+  writeFileSync2(configPath2, newContent, "utf-8");
   console.log(`[config] Deleted trigger '${id}'`);
   cachedConfig = config;
   return true;
@@ -977,7 +1415,7 @@ function startConfigWatcher(configPath2 = triggersPath) {
     return;
   }
   stopConfigWatcher();
-  if (!existsSync3(configPath2)) {
+  if (!existsSync5(configPath2)) {
     console.warn(`[config] Config file not found: ${configPath2}, skipping watcher`);
     return;
   }
@@ -1024,7 +1462,7 @@ async function reloadConfig(configPath2) {
 }
 
 // src/lib/config/writer.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
 import { parse as parseYaml2, stringify as stringifyYaml } from "yaml";
 var DEFAULT_CONFIG_PATH = "config/triggers.yaml";
 async function writeTrigger(trigger, configPath2 = DEFAULT_CONFIG_PATH) {
@@ -1068,7 +1506,7 @@ async function writeTrigger(trigger, configPath2 = DEFAULT_CONFIG_PATH) {
       defaultStringType: "PLAIN",
       defaultKeyType: "PLAIN"
     });
-    writeFileSync2(configPath2, yamlOutput);
+    writeFileSync3(configPath2, yamlOutput);
     return { success: true };
   } catch (err) {
     return { success: false, error: `Write failed: ${err instanceof Error ? err.message : String(err)}` };
@@ -1091,7 +1529,7 @@ async function deleteTrigger2(id, configPath2 = DEFAULT_CONFIG_PATH) {
       defaultStringType: "PLAIN",
       defaultKeyType: "PLAIN"
     });
-    writeFileSync2(configPath2, yamlOutput);
+    writeFileSync3(configPath2, yamlOutput);
     return { success: true };
   } catch (err) {
     return { success: false, error: `Delete failed: ${err instanceof Error ? err.message : String(err)}` };
@@ -1130,7 +1568,7 @@ async function writeTunnelConfig(tunnel, configPath2 = DEFAULT_CONFIG_PATH) {
       defaultStringType: "PLAIN",
       defaultKeyType: "PLAIN"
     });
-    writeFileSync2(configPath2, yamlOutput);
+    writeFileSync3(configPath2, yamlOutput);
     return { success: true };
   } catch (err) {
     return { success: false, error: `Write failed: ${err instanceof Error ? err.message : String(err)}` };
@@ -1432,8 +1870,8 @@ runsRoutes.get("/:id", async (c) => {
 
 // src/server/routes/sanitizers.ts
 import { Hono as Hono3 } from "hono";
-import { readdirSync as readdirSync2, existsSync as existsSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
-import { join as join2 } from "path";
+import { readdirSync as readdirSync2, existsSync as existsSync6, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "fs";
+import { join as join5 } from "path";
 var sanitizersRoutes = new Hono3();
 var BOILERPLATE = `/**
  * Sanitizer function for processing webhook payloads.
@@ -1455,13 +1893,13 @@ function sanitizeName(name) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-+/g, "-");
 }
 function listSanitizersInternal(dir = sanitizersDir) {
-  if (!existsSync4(dir)) {
+  if (!existsSync6(dir)) {
     return [];
   }
   const files = readdirSync2(dir);
   return files.filter((f) => f.endsWith(".ts")).map((f) => ({
     name: f.replace(".ts", ""),
-    path: join2(dir, f)
+    path: join5(dir, f)
   }));
 }
 function createSanitizerInternal(rawName, dir = sanitizersDir) {
@@ -1472,14 +1910,14 @@ function createSanitizerInternal(rawName, dir = sanitizersDir) {
   if (!name) {
     return { success: false, error: "Invalid name", status: 400 };
   }
-  const filePath = join2(dir, `${name}.ts`);
-  if (existsSync4(filePath)) {
+  const filePath = join5(dir, `${name}.ts`);
+  if (existsSync6(filePath)) {
     return { success: false, error: `Sanitizer '${name}' already exists`, status: 409 };
   }
-  if (!existsSync4(dir)) {
-    mkdirSync3(dir, { recursive: true });
+  if (!existsSync6(dir)) {
+    mkdirSync4(dir, { recursive: true });
   }
-  writeFileSync3(filePath, BOILERPLATE);
+  writeFileSync4(filePath, BOILERPLATE);
   return { success: true, name, path: filePath, status: 201 };
 }
 sanitizersRoutes.get("/", async (c) => {
@@ -1785,7 +2223,7 @@ async function tunnelProxyMiddleware(c, next) {
 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 clientDir = existsSync7(devClientDir) ? devClientDir : prodClientDir;
 var app = new Hono8();
 app.use("*", quietLogger);
 app.use("*", tunnelProxyMiddleware);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "charon-hooks",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "Autonomous task triggering service - webhooks and cron to AI agents",
   "type": "module",
   "bin": {
@@ -36,6 +36,7 @@
     "clsx": "^2.1.1",
     "date-fns": "^4.1.0",
     "hono": "^4.7.0",
+    "jiti": "^2.6.1",
     "lucide-react": "^0.562.0",
     "node-cron": "^4.2.1",
     "radix-ui": "^1.4.3",