charon-hooks 0.2.0 → 0.2.1

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,92 @@ 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 cwd = process.cwd();
+var userDataDir = process.env.CHARON_DATA_DIR || resolve2(homedir(), ".charon");
+var isDevMode = existsSync2(resolve2(cwd, "sanitizers")) || existsSync2(resolve2(cwd, "src/lib/data-dir.ts"));
+var dataDir = isDevMode ? process.cwd() : userDataDir;
+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() {
+  const devPath = resolve2(process.cwd());
+  const prodPath = resolve2(__dirname, "../..");
+  if (existsSync2(resolve2(devPath, "src/lib/data-dir.ts"))) {
+    return devPath;
+  }
+  return prodPath;
+}
+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 +830,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 +913,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 +927,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 +936,7 @@ async function initializeApp(configPath = "config/triggers.yaml") {
   } else {
     await stopTunnel();
   }
-  startConfigWatcher(configPath);
+  startConfigWatcher(configPath2);
   return {
     config,
     tunnel: getTunnelStatus()
@@ -876,11 +952,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 +971,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 +994,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 +1002,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 +1016,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 +1031,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 +1072,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 +1095,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 +1113,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 +1134,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 +1161,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 +1171,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 +1179,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 +1193,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 +1203,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 +1220,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 +1229,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 +1245,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 +1254,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 +1275,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 +1436,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 +1458,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 +1476,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 +1786,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 +1801,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.1",
   "description": "Autonomous task triggering service - webhooks and cron to AI agents",
   "type": "module",
   "bin": {