@surf-ai/sdk 0.1.6-beta → 1.0.0-alpha.1

package/dist/server/index.cjs

@@ -5,9 +5,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -30,32 +27,70 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/data/client.ts
-var client_exports = {};
-__export(client_exports, {
-  get: () => get,
-  post: () => post
+// src/server/index.ts
+var server_exports = {};
+__export(server_exports, {
+  createServer: () => createServer,
+  dataApi: () => dataApi
 });
-function env(surfName, legacyName) {
-  return process.env[surfName] || process.env[legacyName];
+module.exports = __toCommonJS(server_exports);
+
+// src/server/runtime.ts
+var import_express = __toESM(require("express"), 1);
+var import_cors = __toESM(require("cors"), 1);
+var import_fs2 = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_croner = require("croner");
+
+// src/core/config.ts
+var DEFAULT_API_BASE_URL = "https://api.ask.surf/gateway/v1";
+function trimTrailingSlashes(value) {
+  return String(value || "").replace(/\/+$/, "");
 }
-function resolveConfig() {
-  const proxyBase = env("SURF_SANDBOX_PROXY_BASE", "DATA_PROXY_BASE");
-  if (proxyBase) {
-    return { baseUrl: proxyBase, headers: {} };
-  }
-  const gatewayUrl = env("SURF_DEPLOYED_GATEWAY_URL", "GATEWAY_URL");
-  const appToken = env("SURF_DEPLOYED_APP_TOKEN", "APP_TOKEN");
-  if (gatewayUrl && appToken) {
-    return {
-      baseUrl: `${gatewayUrl.replace(/\/$/, "")}/gateway/v1`,
-      headers: { Authorization: `Bearer ${appToken}` }
-    };
+function readSurfApiConfig() {
+  return {
+    baseUrl: trimTrailingSlashes(process.env.SURF_API_BASE_URL || DEFAULT_API_BASE_URL),
+    apiKey: process.env.SURF_API_KEY
+  };
+}
+function requireSurfApiConfig() {
+  const config = readSurfApiConfig();
+  if (!config.apiKey) {
+    throw new Error("SURF_API_KEY is required");
   }
-  return { baseUrl: DEFAULT_PUBLIC_URL, headers: {} };
+  return { baseUrl: config.baseUrl, apiKey: config.apiKey };
+}
+function readAdminApiKey() {
+  return process.env.SURF_API_KEY;
+}
+
+// src/db/schema-sync.ts
+var import_fs = __toESM(require("fs"), 1);
+
+// src/core/transport.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function normalizePath(path2) {
-  return String(path2 || "").replace(/^\/+/, "").replace(/^(?:proxy\/)+/, "");
+  return String(path2 || "").replace(/^\/+/, "");
+}
+function buildUrl(path2, params) {
+  const { baseUrl } = requireSurfApiConfig();
+  const url = new URL(`${baseUrl}/${normalizePath(path2)}`);
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      if (value != null) {
+        url.searchParams.set(key, String(value));
+      }
+    }
+  }
+  return url.toString();
+}
+function buildHeaders(extra) {
+  const { apiKey } = requireSurfApiConfig();
+  const headers = new Headers(extra);
+  headers.set("Authorization", `Bearer ${apiKey}`);
+  return headers;
 }
 async function fetchJson(url, init, retries = 1) {
   for (let attempt = 0; attempt <= retries; attempt++) {
@@ -65,80 +100,211 @@ async function fetchJson(url, init, retries = 1) {
       throw new Error(`API error ${res.status}: ${text2.slice(0, 200)}`);
     }
     const text = await res.text();
-    if (text) return JSON.parse(text);
-    if (attempt < retries) await new Promise((r) => setTimeout(r, 1e3));
+    if (text) {
+      return JSON.parse(text);
+    }
+    if (attempt < retries) {
+      await sleep(1e3);
+    }
   }
   throw new Error(`Empty response from ${url}`);
 }
-async function get(path2, params) {
-  const config = resolveConfig();
-  const cleaned = {};
-  if (params) {
-    for (const [k, v] of Object.entries(params)) {
-      if (v != null) cleaned[k] = String(v);
-    }
-  }
-  const qs = Object.keys(cleaned).length ? "?" + new URLSearchParams(cleaned).toString() : "";
-  return fetchJson(`${config.baseUrl}/${normalizePath(path2)}${qs}`, {
-    headers: config.headers
+async function getJson(path2, params) {
+  return fetchJson(buildUrl(path2, params), {
+    headers: buildHeaders()
   });
 }
-async function post(path2, body) {
-  const config = resolveConfig();
-  return fetchJson(`${config.baseUrl}/${normalizePath(path2)}`, {
+async function postJson(path2, body) {
+  return fetchJson(buildUrl(path2), {
     method: "POST",
-    headers: { ...config.headers, "Content-Type": "application/json" },
+    headers: buildHeaders({
+      "Content-Type": "application/json"
+    }),
     body: body ? JSON.stringify(body) : void 0
   });
 }
-var DEFAULT_PUBLIC_URL;
-var init_client = __esm({
-  "src/data/client.ts"() {
-    "use strict";
-    DEFAULT_PUBLIC_URL = "https://api.ask.surf/gateway/v1";
-  }
-});
 
-// src/server/index.ts
-var server_exports = {};
-__export(server_exports, {
-  createServer: () => createServer,
-  dataApi: () => dataApi
-});
-module.exports = __toCommonJS(server_exports);
+// src/data/client.ts
+async function get(path2, params) {
+  return getJson(path2, params);
+}
+async function post(path2, body) {
+  return postJson(path2, body);
+}
+
+// src/db/schema-sync.ts
+var syncing = false;
+async function syncSchema(options) {
+  const { schemaPath, retries = 3, retryDelay = 2e3 } = options;
+  for (let i = 0; i < retries; i++) {
+    try {
+      await doSyncSchema(schemaPath);
+      return;
+    } catch (err) {
+      console.error(`DB schema sync attempt ${i + 1}/${retries} failed: ${err.message}`);
+      if (i < retries - 1) await new Promise((r) => setTimeout(r, retryDelay * (i + 1)));
+    }
+  }
+  console.error("DB schema sync failed after all retries");
+}
+async function doSyncSchema(schemaPath) {
+  if (syncing) return;
+  syncing = true;
+  try {
+    if (!import_fs.default.existsSync(schemaPath)) return;
+    let schema;
+    if (schemaPath.endsWith(".ts")) {
+      try {
+        schema = await import(`${schemaPath}?t=${Date.now()}`);
+      } catch (err) {
+        if (err instanceof SyntaxError) {
+          console.log("DB: schema file has syntax error, waiting for next change...");
+          return;
+        }
+        if (err.message.includes("Cannot find module") || err.message.includes("is not a function")) {
+          return;
+        }
+        throw err;
+      }
+    } else {
+      try {
+        delete require.cache[require.resolve(schemaPath)];
+      } catch {
+      }
+      try {
+        schema = require(schemaPath);
+      } catch (err) {
+        if (err instanceof SyntaxError) {
+          console.log("DB: schema file has syntax error, waiting for next change...");
+          return;
+        }
+        if (err.message.includes("Cannot find module") || err.message.includes("is not a function")) {
+          return;
+        }
+        throw err;
+      }
+    }
+    let getTableConfig;
+    try {
+      getTableConfig = require("drizzle-orm/pg-core").getTableConfig;
+    } catch {
+      return;
+    }
+    const tables = Object.values(schema).filter(
+      (t) => t && typeof t === "object" && /* @__PURE__ */ Symbol.for("drizzle:Name") in t
+    );
+    if (tables.length === 0) return;
+    await post("db/provision", {});
+    const existing = (await get("db/tables")).map((t) => t.name);
+    const missing = tables.filter((t) => !existing.includes(getTableConfig(t).name));
+    if (missing.length > 0) {
+      const { generateDrizzleJson, generateMigration } = require("drizzle-kit/api");
+      const missingSchema = {};
+      for (const t of missing) missingSchema[getTableConfig(t).name] = t;
+      const sqls = await generateMigration(generateDrizzleJson({}), generateDrizzleJson(missingSchema));
+      for (const sql of sqls) {
+        for (let attempt = 0; attempt < 2; attempt++) {
+          try {
+            await post("db/query", { sql, params: [] });
+            console.log(`DB: Executed: ${sql.slice(0, 80)}...`);
+            break;
+          } catch (err) {
+            if (attempt === 0) {
+              console.warn(`DB: Retrying after: ${err.message}`);
+              await new Promise((r) => setTimeout(r, 1500));
+            } else {
+              console.error(`DB: Failed: ${sql.slice(0, 80)}... \u2014 ${err.message}`);
+            }
+          }
+        }
+      }
+    }
+    const existingTables = tables.filter((t) => existing.includes(getTableConfig(t).name));
+    for (const t of existingTables) {
+      const cfg = getTableConfig(t);
+      try {
+        const live = await get("db/table-schema", { table: cfg.name });
+        const liveCols = new Set((live.columns || []).map((c) => c.name));
+        for (const col of cfg.columns) {
+          if (!liveCols.has(col.name)) {
+            const colType = col.getSQLType();
+            const ddl = `ALTER TABLE "${cfg.name}" ADD COLUMN IF NOT EXISTS "${col.name}" ${colType}`;
+            try {
+              await post("db/query", { sql: ddl, params: [] });
+              console.log(`DB: Added column ${col.name} to ${cfg.name}`);
+            } catch (err) {
+              console.warn(`DB: Failed to add column ${col.name} to ${cfg.name}: ${err.message}`);
+            }
+          }
+        }
+      } catch (err) {
+        console.warn(`DB: Column check failed for ${cfg.name}: ${err.message}`);
+      }
+    }
+  } finally {
+    syncing = false;
+  }
+}
+function watchSchema(schemaPath, options) {
+  const { debounceMs = 1e3, retries = 2, retryDelay = 1500 } = options || {};
+  if (!import_fs.default.existsSync(schemaPath)) return () => {
+  };
+  let debounce = null;
+  import_fs.default.watchFile(schemaPath, { interval: 2e3 }, () => {
+    if (debounce) clearTimeout(debounce);
+    debounce = setTimeout(async () => {
+      console.log("DB: schema file changed, re-syncing tables...");
+      try {
+        await syncSchema({ schemaPath, retries, retryDelay });
+        console.log("DB: schema re-sync complete");
+      } catch (err) {
+        console.error(`DB: schema re-sync failed: ${err.message}`);
+      }
+    }, debounceMs);
+  });
+  return () => {
+    import_fs.default.unwatchFile(schemaPath);
+    if (debounce) clearTimeout(debounce);
+  };
+}
 
 // src/server/runtime.ts
-var import_express = __toESM(require("express"), 1);
-var import_cors = __toESM(require("cors"), 1);
-var import_fs = __toESM(require("fs"), 1);
-var import_path = __toESM(require("path"), 1);
-var import_http_proxy_middleware = require("http-proxy-middleware");
-var import_croner = require("croner");
+function requireBearerAuth(req, res, next) {
+  const apiKey = readAdminApiKey();
+  if (!apiKey) {
+    return res.status(503).json({ error: "SURF_API_KEY is not configured" });
+  }
+  if (req.headers.authorization !== `Bearer ${apiKey}`) {
+    return res.status(401).json({ error: "Unauthorized" });
+  }
+  next();
+}
 function createServer(options = {}) {
-  const port = options.port || parseInt(process.env.PORT || "3001", 10);
+  const rawPort = process.env.BACKEND_PORT;
+  const port = options.port ?? (rawPort ? Number.parseInt(rawPort, 10) : void 0);
+  if (!Number.isInteger(port)) {
+    throw new Error("createServer requires a port via options.port or BACKEND_PORT env var");
+  }
   const routesDir = options.routesDir || import_path.default.join(process.cwd(), "routes");
   const cronDir = options.cronDir || process.cwd();
-  const enableProxy = options.proxy !== false;
   const app = (0, import_express.default)();
   app.use((0, import_cors.default)());
-  if (enableProxy) {
-    setupProxy(app, port);
-  }
   app.use(import_express.default.json());
   app.get("/api/health", (_req, res) => {
     res.json({ status: "ok" });
   });
-  if (import_fs.default.existsSync(routesDir)) {
-    for (const file of import_fs.default.readdirSync(routesDir)) {
+  if (import_fs2.default.existsSync(routesDir)) {
+    for (const file of import_fs2.default.readdirSync(routesDir)) {
       if (!file.endsWith(".js") && !file.endsWith(".ts")) continue;
       const name = file.replace(/\.(js|ts)$/, "");
       try {
-        const route = require(import_path.default.join(routesDir, file));
-        const handler = route.default || route;
+        const handler = require(import_path.default.join(routesDir, file));
         if (typeof handler === "function") {
           app.use(`/api/${name}`, handler);
           console.log(`Route registered: /api/${name}`);
+          continue;
         }
+        throw new Error(`Route module must export a handler function via module.exports`);
       } catch (err) {
         console.error(`Failed to load route ${file}: ${err.message}`);
       }
@@ -162,157 +328,15 @@ function createServer(options = {}) {
     }
   };
 }
-function env2(surfName, legacyName) {
-  return process.env[surfName] || process.env[legacyName];
-}
-function setupProxy(app, port) {
-  const gatewayUrl = env2("SURF_DEPLOYED_GATEWAY_URL", "GATEWAY_URL");
-  const appToken = env2("SURF_DEPLOYED_APP_TOKEN", "APP_TOKEN");
-  const proxyBase = env2("SURF_SANDBOX_PROXY_BASE", "DATA_PROXY_BASE");
-  const isDeployed = Boolean(gatewayUrl && appToken);
-  const bufferResponse = (0, import_http_proxy_middleware.responseInterceptor)(async (buf) => buf);
-  if (isDeployed) {
-    app.use("/proxy", (0, import_http_proxy_middleware.createProxyMiddleware)({
-      target: gatewayUrl,
-      changeOrigin: true,
-      selfHandleResponse: true,
-      pathRewrite: (p) => "/gateway/v1" + p,
-      headers: {
-        Authorization: `Bearer ${appToken}`,
-        "Accept-Encoding": "identity"
-      },
-      on: { proxyRes: bufferResponse }
-    }));
-    const loopback = `http://127.0.0.1:${port}/proxy`;
-    process.env.SURF_SANDBOX_PROXY_BASE = loopback;
-    process.env.DATA_PROXY_BASE = loopback;
-  } else if (proxyBase) {
-    const target = proxyBase.replace(/\/proxy$/, "");
-    app.use((0, import_http_proxy_middleware.createProxyMiddleware)({
-      target,
-      changeOrigin: true,
-      pathFilter: "/proxy",
-      on: {
-        proxyReq: (proxyReq, req) => {
-          console.log(`[proxy] >> ${req.method} ${req.originalUrl}`);
-        },
-        proxyRes: (proxyRes, req) => {
-          console.log(`[proxy] << ${proxyRes.statusCode} ${req.method} ${req.originalUrl}`);
-        },
-        error: (err, req, res) => {
-          console.error(`[proxy] !! ${req.method} ${req.originalUrl} error: ${err.message}`);
-          if (!res.headersSent) res.status(502).json({ error: err.message });
-        }
-      }
-    }));
-  }
-}
 var schemaSync = { run: async () => {
 }, watch: () => {
 } };
 function setupSchemaSync(app, schemaDir) {
-  let syncing = false;
   let schemaReady = false;
-  async function doSyncSchema() {
-    if (syncing) return;
-    syncing = true;
-    try {
-      const schemaPath = import_path.default.join(schemaDir, "schema.js");
-      if (!import_fs.default.existsSync(schemaPath)) return;
-      try {
-        delete require.cache[require.resolve(schemaPath)];
-      } catch {
-      }
-      let schema;
-      try {
-        schema = require(schemaPath);
-      } catch (err) {
-        if (err instanceof SyntaxError) {
-          console.log("DB: schema.js has syntax error, waiting for next change...");
-          return;
-        }
-        if (err.message.includes("Cannot find module") || err.message.includes("is not a function")) {
-          return;
-        }
-        throw err;
-      }
-      let getTableConfig;
-      try {
-        getTableConfig = require("drizzle-orm/pg-core").getTableConfig;
-      } catch {
-        return;
-      }
-      const tables = Object.values(schema).filter(
-        (t) => t && typeof t === "object" && /* @__PURE__ */ Symbol.for("drizzle:Name") in t
-      );
-      if (tables.length === 0) return;
-      const { get: dbGet, post: dbPost } = await Promise.resolve().then(() => (init_client(), client_exports));
-      await dbPost("db/provision");
-      const existing = (await dbGet("db/tables")).map((t) => t.name);
-      const missing = tables.filter((t) => !existing.includes(getTableConfig(t).name));
-      if (missing.length > 0) {
-        const { generateDrizzleJson, generateMigration } = require("drizzle-kit/api");
-        const missingSchema = {};
-        for (const t of missing) missingSchema[getTableConfig(t).name] = t;
-        const sqls = await generateMigration(generateDrizzleJson({}), generateDrizzleJson(missingSchema));
-        for (const sql of sqls) {
-          for (let attempt = 0; attempt < 2; attempt++) {
-            try {
-              await dbPost("db/query", { sql, params: [] });
-              console.log(`DB: Executed: ${sql.slice(0, 80)}...`);
-              break;
-            } catch (err) {
-              if (attempt === 0) {
-                console.warn(`DB: Retrying after: ${err.message}`);
-                await new Promise((r) => setTimeout(r, 1500));
-              } else {
-                console.error(`DB: Failed: ${sql.slice(0, 80)}... \u2014 ${err.message}`);
-              }
-            }
-          }
-        }
-      }
-      const existingTables = tables.filter((t) => existing.includes(getTableConfig(t).name));
-      for (const t of existingTables) {
-        const cfg = getTableConfig(t);
-        try {
-          const live = await dbGet("db/table-schema", { table: cfg.name });
-          const liveCols = new Set((live.columns || []).map((c) => c.name));
-          for (const col of cfg.columns) {
-            if (!liveCols.has(col.name)) {
-              const colType = col.getSQLType();
-              const ddl = `ALTER TABLE "${cfg.name}" ADD COLUMN IF NOT EXISTS "${col.name}" ${colType}`;
-              try {
-                await dbPost("db/query", { sql: ddl, params: [] });
-                console.log(`DB: Added column ${col.name} to ${cfg.name}`);
-              } catch (err) {
-                console.warn(`DB: Failed to add column ${col.name} to ${cfg.name}: ${err.message}`);
-              }
-            }
-          }
-        } catch (err) {
-          console.warn(`DB: Column check failed for ${cfg.name}: ${err.message}`);
-        }
-      }
-    } finally {
-      syncing = false;
-    }
-  }
-  async function syncWithRetry(retries = 3, delay = 2e3) {
-    for (let i = 0; i < retries; i++) {
-      try {
-        await doSyncSchema();
-        return;
-      } catch (err) {
-        console.error(`DB schema sync attempt ${i + 1}/${retries} failed: ${err.message}`);
-        if (i < retries - 1) await new Promise((r) => setTimeout(r, delay * (i + 1)));
-      }
-    }
-    console.error("DB schema sync failed after all retries");
-  }
-  app.post("/api/__sync-schema", async (_req, res) => {
+  const schemaPath = import_path.default.join(schemaDir, "schema.js");
+  app.post("/api/__sync-schema", requireBearerAuth, async (_req, res) => {
     try {
-      await syncWithRetry(2, 1500);
+      await syncSchema({ schemaPath, retries: 2, retryDelay: 1500 });
       res.json({ ok: true });
     } catch (err) {
       res.status(500).json({ ok: false, error: err.message });
@@ -324,7 +348,7 @@ function setupSchemaSync(app, schemaDir) {
   });
   schemaSync.run = async () => {
     try {
-      await syncWithRetry();
+      await syncSchema({ schemaPath });
       schemaReady = true;
       console.log("Schema sync complete, API ready");
     } catch {
@@ -333,21 +357,7 @@ function setupSchemaSync(app, schemaDir) {
     }
   };
   schemaSync.watch = () => {
-    const schemaPath = import_path.default.join(schemaDir, "schema.js");
-    if (!import_fs.default.existsSync(schemaPath)) return;
-    let debounce = null;
-    import_fs.default.watchFile(schemaPath, { interval: 2e3 }, () => {
-      if (debounce) clearTimeout(debounce);
-      debounce = setTimeout(async () => {
-        console.log("DB: schema.js changed, re-syncing tables...");
-        try {
-          await syncWithRetry(2, 1500);
-          console.log("DB: schema re-sync complete");
-        } catch (err) {
-          console.error(`DB: schema re-sync failed: ${err.message}`);
-        }
-      }, 1e3);
-    });
+    watchSchema(schemaPath);
   };
 }
 function setupCron(app, cronDir) {
@@ -363,10 +373,10 @@ function setupCron(app, cronDir) {
     }
     cronJobs.clear();
     const cronPath = import_path.default.join(cronDir, "cron.json");
-    if (!import_fs.default.existsSync(cronPath)) return;
+    if (!import_fs2.default.existsSync(cronPath)) return;
     let tasks;
     try {
-      tasks = JSON.parse(import_fs.default.readFileSync(cronPath, "utf-8"));
+      tasks = JSON.parse(import_fs2.default.readFileSync(cronPath, "utf-8"));
     } catch (e) {
       console.error("Failed to parse cron.json:", e.message);
       return;
@@ -414,16 +424,7 @@ function setupCron(app, cronDir) {
       console.log(`Cron registered: [${task.id}] ${task.name} (${task.schedule})`);
     }
   }
-  const envFn = (s, l) => process.env[s] || process.env[l];
-  app.use("/api/cron", (req, res, next) => {
-    const appToken = envFn("SURF_DEPLOYED_APP_TOKEN", "APP_TOKEN");
-    if (!appToken) return next();
-    const auth = req.headers.authorization;
-    if (!auth || auth !== `Bearer ${appToken}`) {
-      return res.status(401).json({ error: "Unauthorized" });
-    }
-    next();
-  });
+  app.use("/api/cron", requireBearerAuth);
   app.get("/api/cron", (_req, res) => {
     res.json(cronTasks.map((t) => {
       const state = cronState.get(t.id) || { lastRunAt: null, lastStatus: null, lastError: null };
@@ -456,7 +457,7 @@ function setupCron(app, cronDir) {
     const cronPath = import_path.default.join(cronDir, "cron.json");
     let tasks = [];
     try {
-      if (import_fs.default.existsSync(cronPath)) tasks = JSON.parse(import_fs.default.readFileSync(cronPath, "utf8"));
+      if (import_fs2.default.existsSync(cronPath)) tasks = JSON.parse(import_fs2.default.readFileSync(cronPath, "utf8"));
     } catch {
       tasks = [];
     }
@@ -465,7 +466,7 @@ function setupCron(app, cronDir) {
     }
     const newTask = { id, name, schedule, handler, enabled, timeout };
     tasks.push(newTask);
-    import_fs.default.writeFileSync(cronPath, JSON.stringify(tasks, null, 2));
+    import_fs2.default.writeFileSync(cronPath, JSON.stringify(tasks, null, 2));
     loadCronJobs();
     res.status(201).json(newTask);
   });
@@ -473,7 +474,7 @@ function setupCron(app, cronDir) {
     const cronPath = import_path.default.join(cronDir, "cron.json");
     let tasks = [];
     try {
-      if (import_fs.default.existsSync(cronPath)) tasks = JSON.parse(import_fs.default.readFileSync(cronPath, "utf8"));
+      if (import_fs2.default.existsSync(cronPath)) tasks = JSON.parse(import_fs2.default.readFileSync(cronPath, "utf8"));
     } catch {
       tasks = [];
     }
@@ -494,7 +495,7 @@ function setupCron(app, cronDir) {
       }
     }
     tasks[idx] = { ...tasks[idx], ...updates, id: req.params.id };
-    import_fs.default.writeFileSync(cronPath, JSON.stringify(tasks, null, 2));
+    import_fs2.default.writeFileSync(cronPath, JSON.stringify(tasks, null, 2));
     loadCronJobs();
     res.json(tasks[idx]);
   });
@@ -502,14 +503,14 @@ function setupCron(app, cronDir) {
     const cronPath = import_path.default.join(cronDir, "cron.json");
     let tasks = [];
     try {
-      if (import_fs.default.existsSync(cronPath)) tasks = JSON.parse(import_fs.default.readFileSync(cronPath, "utf8"));
+      if (import_fs2.default.existsSync(cronPath)) tasks = JSON.parse(import_fs2.default.readFileSync(cronPath, "utf8"));
     } catch {
       tasks = [];
     }
     const idx = tasks.findIndex((t) => t.id === req.params.id);
     if (idx === -1) return res.status(404).json({ error: "Task not found" });
     tasks.splice(idx, 1);
-    import_fs.default.writeFileSync(cronPath, JSON.stringify(tasks, null, 2));
+    import_fs2.default.writeFileSync(cronPath, JSON.stringify(tasks, null, 2));
     cronState.delete(req.params.id);
     loadCronJobs();
     res.json({ ok: true });
@@ -527,11 +528,7 @@ function setupCron(app, cronDir) {
   loadCronJobs();
 }
 
-// src/data/data-api.ts
-init_client();
-
 // src/data/categories/exchange.ts
-init_client();
 var exchange = {
   /** Returns order book bid/ask levels with computed stats. **Included fields:** spread, spread percentage, mid-price, and total bid/ask depth. Use `limit` to control the number of price levels (1–100, default 20). Set `type=swap` to query perpetual contract order books instead of spot. */
   depth: (params) => get("exchange/depth", params),
@@ -550,7 +547,6 @@ var exchange = {
 };
 
 // src/data/categories/fund.ts
-init_client();
 var fund = {
   /** Returns a fund's **profile metadata**. **Included fields:** X accounts, team members, recent research, invested project count. This does NOT return the list of investments — use `/fund/portfolio` for that. **Lookup:** by UUID (`id`) or name (`q`). Returns 404 if not found. */
   detail: (params) => get("fund/detail", params),
@@ -561,7 +557,6 @@ var fund = {
 };
 
 // src/data/categories/kalshi.ts
-init_client();
 var kalshi = {
   /** Returns Kalshi events with nested markets, optionally filtered by `event_ticker`. Each event includes market count and a list of markets. **Data refresh:** ~30 minutes */
   events: (params) => get("prediction-market/kalshi/events", params),
@@ -580,7 +575,6 @@ var kalshi = {
 };
 
 // src/data/categories/market.ts
-init_client();
 var market = {
   /** Returns daily ETF flow history for US spot ETFs. **Included fields:** net flow (USD), token price, per-ticker breakdown. Sorted by date descending. `symbol`: `BTC` or `ETH`. */
   etf: (params) => get("market/etf", params),
@@ -607,7 +601,6 @@ var market = {
 };
 
 // src/data/categories/matching.ts
-init_client();
 var matching = {
   /** Returns daily volume and open interest comparison for a specific matched market pair. Both `polymarket_condition_id` and `kalshi_market_ticker` are required. **Volume units:** Polymarket = USD, Kalshi = contracts. */
   market_daily: (params) => get("prediction-market/matching/daily", params),
@@ -618,7 +611,6 @@ var matching = {
 };
 
 // src/data/categories/news.ts
-init_client();
 var news = {
   /** Returns the full content of a single news article by its ID (returned as `id` in feed and search results). */
   detail: (params) => get("news/detail", params),
@@ -627,7 +619,6 @@ var news = {
 };
 
 // src/data/categories/onchain.ts
-init_client();
 var onchain = {
   /** Returns bridge protocols ranked by total USD volume over a specified time range. */
   bridge_ranking: (params) => get("onchain/bridge/ranking", params),
@@ -646,7 +637,6 @@ var onchain = {
 };
 
 // src/data/categories/polymarket.ts
-init_client();
 var polymarket = {
   /** Returns trade and redemption activity for a Polymarket wallet. **Data refresh:** ~30 minutes */
   activity: (params) => get("prediction-market/polymarket/activity", params),
@@ -669,14 +659,12 @@ var polymarket = {
 };
 
 // src/data/categories/prediction_market.ts
-init_client();
 var prediction_market = {
   /** Returns daily notional volume and open interest aggregated by category across Kalshi and Polymarket. **Filters:** `source` or `category`. **Data refresh:** daily */
   category_metrics: (params) => get("prediction-market/category-metrics", params)
 };
 
 // src/data/categories/project.ts
-init_client();
 var project = {
   /** Returns time-series DeFi metrics for a project. **Available metrics:** `volume`, `fee`, `fees`, `revenue`, `tvl`, `users`. **Lookup:** by UUID (`id`) or name (`q`). Filter by `chain` and date range (`from`/`to`). Returns 404 if the project is not found. **Note:** this endpoint only returns data for DeFi protocol projects (e.g. `aave`, `uniswap`, `lido`, `makerdao`). Use `q` with a DeFi protocol name. */
   defi_metrics: (params) => get("project/defi/metrics", params),
@@ -687,7 +675,6 @@ var project = {
 };
 
 // src/data/categories/search.ts
-init_client();
 var search = {
   /** Searches and filters airdrop opportunities. **Filters:** keyword, status, reward type, task type. Returns paginated results with optional task details. */
   airdrop: (params) => get("search/airdrop", params),
@@ -714,7 +701,6 @@ var search = {
 };
 
 // src/data/categories/social.ts
-init_client();
 var social = {
   /** Returns a **point-in-time snapshot** of social analytics for a project. **Available fields** (via `fields`): `sentiment`, `follower_geo`, `smart_followers`. **Lookup:** by X account ID (`x_id`) or project name (`q`, e.g. `uniswap`, `solana`). The `q` parameter must be a crypto project name, not a personal Twitter handle. Returns 404 if the project has no linked Twitter account. For sentiment **trends over time**, use `/social/mindshare` instead. */
   detail: (params) => get("social/detail", params),
@@ -741,7 +727,6 @@ var social = {
 };
 
 // src/data/categories/token.ts
-init_client();
 var token = {
   /** Returns recent DEX swap events for a token contract address. **Covered DEXes:** `uniswap`, `sushiswap`, `curve`, `balancer`. **Included fields:** trading pair, amounts, USD value, taker address. **Data refresh:** ~24 hours · **Chains:** Ethereum, Base */
   dex_trades: (params) => get("token/dex-trades", params),
@@ -754,7 +739,6 @@ var token = {
 };
 
 // src/data/categories/v2.ts
-init_client();
 var v2 = {
   /** Historical orderbook snapshots for a Kalshi market. Returns yes-side bid/ask levels. Timestamps in milliseconds, prices in cents. Data refresh: ~5 minutes */
   kalshi_orderbooks: (params) => get("gateway/v2/kalshi/orderbooks", params),
@@ -769,7 +753,6 @@ var v2 = {
 };
 
 // src/data/categories/wallet.ts
-init_client();
 var wallet = {
   /** Returns multiple wallet sub-resources in a single request. **Available fields** (via `fields`): `balance`, `tokens`, `labels`, `nft`. **Lookup:** by `address`. Partial failures return available fields with per-field error info. Returns 422 if `fields` is invalid. */
   detail: (params) => get("wallet/detail", params),
@@ -786,7 +769,6 @@ var wallet = {
 };
 
 // src/data/categories/web.ts
-init_client();
 var web = {
   /** Fetches a web page and converts it to clean, LLM-friendly markdown. **Options:** - `target_selector` — extract specific page sections - `remove_selector` — strip unwanted elements Returns 400 if the URL is invalid or unreachable. */
   fetch: (params) => get("web/fetch", params)