@hasna/connectors 1.1.18 → 1.2.0

package/bin/mcp.js

@@ -26,6 +26,7 @@ var __export = (target, all) => {
       set: (newValue) => all[name] = () => newValue
     });
 };
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
 // node_modules/ajv/dist/compile/codegen/code.js
 var require_code = __commonJS((exports) => {
@@ -6499,6 +6500,629 @@ var require_dist = __commonJS((exports, module) => {
   exports.default = formatsPlugin;
 });
 
+// src/db/database.ts
+var exports_database = {};
+__export(exports_database, {
+  shortUuid: () => shortUuid,
+  now: () => now,
+  getDatabase: () => getDatabase,
+  closeDatabase: () => closeDatabase
+});
+import { Database } from "bun:sqlite";
+import { join as join6 } from "path";
+import { homedir as homedir4 } from "os";
+import { mkdirSync as mkdirSync4 } from "fs";
+function getDatabase(path) {
+  if (_db)
+    return _db;
+  const dbPath = path ?? DB_PATH;
+  mkdirSync4(join6(dbPath, ".."), { recursive: true });
+  _db = new Database(dbPath);
+  _db.run("PRAGMA journal_mode = WAL");
+  migrate(_db);
+  return _db;
+}
+function closeDatabase() {
+  _db?.close();
+  _db = null;
+}
+function now() {
+  return new Date().toISOString();
+}
+function shortUuid() {
+  return crypto.randomUUID().slice(0, 8);
+}
+function migrate(db) {
+  db.run(`
+    CREATE TABLE IF NOT EXISTS agents (
+      id TEXT PRIMARY KEY,
+      name TEXT UNIQUE NOT NULL,
+      session_id TEXT,
+      role TEXT NOT NULL DEFAULT 'agent',
+      last_seen_at TEXT NOT NULL,
+      created_at TEXT NOT NULL
+    )
+  `);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS resource_locks (
+      id TEXT PRIMARY KEY,
+      resource_type TEXT NOT NULL CHECK(resource_type IN ('connector', 'agent', 'profile', 'token')),
+      resource_id TEXT NOT NULL,
+      agent_id TEXT NOT NULL,
+      lock_type TEXT NOT NULL DEFAULT 'exclusive' CHECK(lock_type IN ('advisory', 'exclusive')),
+      locked_at TEXT NOT NULL DEFAULT (datetime('now')),
+      expires_at TEXT NOT NULL
+    )
+  `);
+  db.run(`
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_resource_locks_exclusive
+      ON resource_locks(resource_type, resource_id)
+      WHERE lock_type = 'exclusive'
+  `);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_resource_locks_agent ON resource_locks(agent_id)`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_resource_locks_expires ON resource_locks(expires_at)`);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS connector_rate_usage (
+      agent_id TEXT NOT NULL,
+      connector TEXT NOT NULL,
+      window_start TEXT NOT NULL,
+      call_count INTEGER NOT NULL DEFAULT 0,
+      PRIMARY KEY (agent_id, connector, window_start)
+    )
+  `);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_rate_usage_window ON connector_rate_usage(connector, window_start)`);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS connector_jobs (
+      id TEXT PRIMARY KEY,
+      name TEXT UNIQUE NOT NULL,
+      connector TEXT NOT NULL,
+      command TEXT NOT NULL,
+      args TEXT NOT NULL DEFAULT '[]',
+      cron TEXT NOT NULL,
+      enabled INTEGER NOT NULL DEFAULT 1,
+      strip INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL,
+      last_run_at TEXT
+    )
+  `);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_jobs_enabled ON connector_jobs(enabled)`);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS connector_job_runs (
+      id TEXT PRIMARY KEY,
+      job_id TEXT NOT NULL REFERENCES connector_jobs(id) ON DELETE CASCADE,
+      started_at TEXT NOT NULL,
+      finished_at TEXT,
+      exit_code INTEGER,
+      raw_output TEXT,
+      stripped_output TEXT
+    )
+  `);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_job_runs_job ON connector_job_runs(job_id, started_at DESC)`);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS connector_workflows (
+      id TEXT PRIMARY KEY,
+      name TEXT UNIQUE NOT NULL,
+      steps TEXT NOT NULL DEFAULT '[]',
+      enabled INTEGER NOT NULL DEFAULT 1,
+      created_at TEXT NOT NULL
+    )
+  `);
+}
+var DB_DIR, DB_PATH, _db = null;
+var init_database = __esm(() => {
+  DB_DIR = join6(homedir4(), ".connectors");
+  DB_PATH = join6(DB_DIR, "connectors.db");
+});
+
+// src/lib/llm.ts
+var exports_llm = {};
+__export(exports_llm, {
+  setLlmStrip: () => setLlmStrip,
+  saveLlmConfig: () => saveLlmConfig,
+  maskKey: () => maskKey,
+  isStripEnabled: () => isStripEnabled,
+  getLlmConfig: () => getLlmConfig,
+  PROVIDER_DEFAULTS: () => PROVIDER_DEFAULTS,
+  LLMClient: () => LLMClient
+});
+import { existsSync as existsSync6, readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync5 } from "fs";
+import { join as join7 } from "path";
+import { homedir as homedir5 } from "os";
+function getLlmConfigPath() {
+  return join7(homedir5(), ".connectors", "llm.json");
+}
+function getLlmConfig() {
+  const path = getLlmConfigPath();
+  if (!existsSync6(path))
+    return null;
+  try {
+    return JSON.parse(readFileSync4(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveLlmConfig(config2) {
+  const dir = join7(homedir5(), ".connectors");
+  mkdirSync5(dir, { recursive: true });
+  writeFileSync3(getLlmConfigPath(), JSON.stringify(config2, null, 2));
+}
+function setLlmStrip(enabled) {
+  const config2 = getLlmConfig();
+  if (!config2)
+    throw new Error("No LLM config found. Run: connectors llm set --provider <provider> --key <key>");
+  saveLlmConfig({ ...config2, strip: enabled });
+}
+function isStripEnabled() {
+  return getLlmConfig()?.strip === true;
+}
+function maskKey(key) {
+  if (key.length <= 8)
+    return "***";
+  return key.slice(0, 8) + "***";
+}
+
+class LLMClient {
+  config;
+  constructor(config2) {
+    this.config = config2;
+  }
+  static fromConfig() {
+    const config2 = getLlmConfig();
+    if (!config2)
+      return null;
+    return new LLMClient(config2);
+  }
+  async complete(prompt, content) {
+    const start = Date.now();
+    const { provider, model, api_key } = this.config;
+    if (provider === "anthropic") {
+      return this._anthropicComplete(prompt, content, start);
+    }
+    const baseUrl = PROVIDER_BASE_URLS[provider];
+    const response = await fetch(`${baseUrl}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${api_key}`
+      },
+      body: JSON.stringify({
+        model,
+        messages: [
+          { role: "system", content: prompt },
+          { role: "user", content }
+        ],
+        temperature: 0,
+        max_tokens: 4096
+      })
+    });
+    if (!response.ok) {
+      const error2 = await response.text();
+      throw new Error(`LLM request failed (${provider} ${response.status}): ${error2}`);
+    }
+    const data = await response.json();
+    return {
+      content: data.choices[0].message.content,
+      provider,
+      model,
+      latency_ms: Date.now() - start
+    };
+  }
+  async _anthropicComplete(prompt, content, start) {
+    const { model, api_key } = this.config;
+    const response = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": api_key,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify({
+        model,
+        system: prompt,
+        messages: [{ role: "user", content }],
+        max_tokens: 4096
+      })
+    });
+    if (!response.ok) {
+      const error2 = await response.text();
+      throw new Error(`LLM request failed (anthropic ${response.status}): ${error2}`);
+    }
+    const data = await response.json();
+    return {
+      content: data.content[0].text,
+      provider: "anthropic",
+      model,
+      latency_ms: Date.now() - start
+    };
+  }
+}
+var PROVIDER_BASE_URLS, PROVIDER_DEFAULTS;
+var init_llm = __esm(() => {
+  PROVIDER_BASE_URLS = {
+    cerebras: "https://api.cerebras.ai/v1",
+    groq: "https://api.groq.com/openai/v1",
+    openai: "https://api.openai.com/v1"
+  };
+  PROVIDER_DEFAULTS = {
+    cerebras: { model: "qwen-3-32b" },
+    groq: { model: "llama-3.3-70b-versatile" },
+    openai: { model: "gpt-4o-mini" },
+    anthropic: { model: "claude-haiku-4-5-20251001" }
+  };
+});
+
+// src/lib/strip.ts
+async function maybeStrip(output, _type = "json") {
+  const config2 = getLlmConfig();
+  if (!config2?.strip)
+    return output;
+  if (!output || output.trim().length === 0)
+    return output;
+  const client = LLMClient.fromConfig();
+  if (!client)
+    return output;
+  try {
+    const result = await client.complete(STRIP_PROMPT, output);
+    return result.content.trim();
+  } catch {
+    return output;
+  }
+}
+var STRIP_PROMPT = `You are a data extraction assistant. Your job is to take raw API output and return ONLY the essential, structured data.
+
+Rules:
+- Return valid JSON only (no markdown, no explanation)
+- Remove pagination metadata, rate limit headers, empty fields, null values
+- Keep all meaningful data fields
+- If the input is already minimal, return it unchanged
+- If input is not JSON, extract key facts as a JSON object
+- Never truncate actual data values`;
+var init_strip = __esm(() => {
+  init_llm();
+});
+
+// src/db/jobs.ts
+var exports_jobs = {};
+__export(exports_jobs, {
+  updateJob: () => updateJob,
+  touchJobLastRun: () => touchJobLastRun,
+  listJobs: () => listJobs,
+  listJobRuns: () => listJobRuns,
+  listEnabledJobs: () => listEnabledJobs,
+  getLatestRun: () => getLatestRun,
+  getJobByName: () => getJobByName,
+  getJob: () => getJob,
+  finishJobRun: () => finishJobRun,
+  deleteJob: () => deleteJob,
+  createJobRun: () => createJobRun,
+  createJob: () => createJob
+});
+function rowToJob(row) {
+  return {
+    ...row,
+    args: JSON.parse(row.args || "[]"),
+    enabled: row.enabled === 1,
+    strip: row.strip === 1
+  };
+}
+function createJob(input, db) {
+  const d = db ?? getDatabase();
+  const id = shortUuid();
+  const ts = now();
+  d.run("INSERT INTO connector_jobs (id, name, connector, command, args, cron, enabled, strip, created_at) VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?)", [id, input.name, input.connector, input.command, JSON.stringify(input.args ?? []), input.cron, input.strip ? 1 : 0, ts]);
+  return getJob(id, d);
+}
+function getJob(id, db) {
+  const d = db ?? getDatabase();
+  const row = d.query("SELECT * FROM connector_jobs WHERE id = ?").get(id);
+  return row ? rowToJob(row) : null;
+}
+function getJobByName(name, db) {
+  const d = db ?? getDatabase();
+  const row = d.query("SELECT * FROM connector_jobs WHERE name = ?").get(name);
+  return row ? rowToJob(row) : null;
+}
+function listJobs(db) {
+  const d = db ?? getDatabase();
+  return d.query("SELECT * FROM connector_jobs ORDER BY name").all().map(rowToJob);
+}
+function listEnabledJobs(db) {
+  const d = db ?? getDatabase();
+  return d.query("SELECT * FROM connector_jobs WHERE enabled = 1").all().map(rowToJob);
+}
+function updateJob(id, input, db) {
+  const d = db ?? getDatabase();
+  const sets = [];
+  const params = [];
+  if (input.name !== undefined) {
+    sets.push("name = ?");
+    params.push(input.name);
+  }
+  if (input.connector !== undefined) {
+    sets.push("connector = ?");
+    params.push(input.connector);
+  }
+  if (input.command !== undefined) {
+    sets.push("command = ?");
+    params.push(input.command);
+  }
+  if (input.args !== undefined) {
+    sets.push("args = ?");
+    params.push(JSON.stringify(input.args));
+  }
+  if (input.cron !== undefined) {
+    sets.push("cron = ?");
+    params.push(input.cron);
+  }
+  if (input.enabled !== undefined) {
+    sets.push("enabled = ?");
+    params.push(input.enabled ? 1 : 0);
+  }
+  if (input.strip !== undefined) {
+    sets.push("strip = ?");
+    params.push(input.strip ? 1 : 0);
+  }
+  if (sets.length === 0)
+    return getJob(id, d);
+  params.push(id);
+  d.run(`UPDATE connector_jobs SET ${sets.join(", ")} WHERE id = ?`, params);
+  return getJob(id, d);
+}
+function deleteJob(id, db) {
+  const d = db ?? getDatabase();
+  return d.run("DELETE FROM connector_jobs WHERE id = ?", [id]).changes > 0;
+}
+function touchJobLastRun(id, db) {
+  const d = db ?? getDatabase();
+  d.run("UPDATE connector_jobs SET last_run_at = ? WHERE id = ?", [now(), id]);
+}
+function createJobRun(jobId, db) {
+  const d = db ?? getDatabase();
+  const id = shortUuid();
+  const ts = now();
+  d.run("INSERT INTO connector_job_runs (id, job_id, started_at) VALUES (?, ?, ?)", [id, jobId, ts]);
+  return { id, job_id: jobId, started_at: ts, finished_at: null, exit_code: null, raw_output: null, stripped_output: null };
+}
+function finishJobRun(id, result, db) {
+  const d = db ?? getDatabase();
+  d.run("UPDATE connector_job_runs SET finished_at = ?, exit_code = ?, raw_output = ?, stripped_output = ? WHERE id = ?", [now(), result.exit_code, result.raw_output, result.stripped_output ?? null, id]);
+}
+function getLatestRun(jobId, db) {
+  const d = db ?? getDatabase();
+  return d.query("SELECT * FROM connector_job_runs WHERE job_id = ? ORDER BY started_at DESC LIMIT 1").get(jobId);
+}
+function listJobRuns(jobId, limit = 20, db) {
+  const d = db ?? getDatabase();
+  return d.query("SELECT * FROM connector_job_runs WHERE job_id = ? ORDER BY started_at DESC LIMIT ?").all(jobId, limit);
+}
+var init_jobs = __esm(() => {
+  init_database();
+});
+
+// src/lib/scheduler.ts
+var exports_scheduler = {};
+__export(exports_scheduler, {
+  triggerJob: () => triggerJob,
+  stopScheduler: () => stopScheduler,
+  startScheduler: () => startScheduler
+});
+import { spawn as spawn2 } from "child_process";
+function cronMatches(cron, d) {
+  const parts = cron.trim().split(/\s+/);
+  if (parts.length !== 5)
+    return false;
+  const [min, hour, dom, mon, dow] = parts;
+  function matches(field, value, min_v, max_v) {
+    if (field === "*")
+      return true;
+    if (field.startsWith("*/")) {
+      const step = parseInt(field.slice(2));
+      return value % step === 0;
+    }
+    if (field.includes("-")) {
+      const [a, b] = field.split("-").map(Number);
+      return value >= a && value <= b;
+    }
+    if (field.includes(",")) {
+      return field.split(",").map(Number).includes(value);
+    }
+    return parseInt(field) === value;
+  }
+  return matches(min, d.getMinutes(), 0, 59) && matches(hour, d.getHours(), 0, 23) && matches(dom, d.getDate(), 1, 31) && matches(mon, d.getMonth() + 1, 1, 12) && matches(dow, d.getDay(), 0, 6);
+}
+async function runConnectorCommand2(connector, command, args) {
+  return new Promise((resolve) => {
+    const cmdArgs = [connector, command, ...args, "--format", "json"];
+    const proc = spawn2("connectors", ["run", ...cmdArgs], { shell: false });
+    let output = "";
+    proc.stdout.on("data", (d) => {
+      output += d.toString();
+    });
+    proc.stderr.on("data", (d) => {
+      output += d.toString();
+    });
+    proc.on("close", (code) => resolve({ exitCode: code ?? 1, output }));
+    proc.on("error", () => resolve({ exitCode: 1, output: `Failed to spawn connectors run` }));
+    setTimeout(() => {
+      proc.kill();
+      resolve({ exitCode: 124, output: output + `
+[timeout]` });
+    }, 60000);
+  });
+}
+async function executeJob(job, db) {
+  const run = createJobRun(job.id, db);
+  try {
+    const { exitCode, output } = await runConnectorCommand2(job.connector, job.command, job.args);
+    const stripped = job.strip ? await maybeStrip(output) : undefined;
+    finishJobRun(run.id, { exit_code: exitCode, raw_output: output, stripped_output: stripped }, db);
+    touchJobLastRun(job.id, db);
+  } catch (e) {
+    finishJobRun(run.id, { exit_code: 1, raw_output: String(e) }, db);
+  }
+}
+function startScheduler(db) {
+  if (_interval)
+    return;
+  _interval = setInterval(async () => {
+    const now3 = new Date;
+    const currentMinute = now3.getMinutes() + now3.getHours() * 60;
+    if (currentMinute === _lastCheckedMinute)
+      return;
+    _lastCheckedMinute = currentMinute;
+    const jobs = listEnabledJobs(db);
+    for (const job of jobs) {
+      if (cronMatches(job.cron, now3)) {
+        executeJob(job, db).catch(() => {});
+      }
+    }
+  }, 30000);
+}
+function stopScheduler() {
+  if (_interval) {
+    clearInterval(_interval);
+    _interval = null;
+    _lastCheckedMinute = -1;
+  }
+}
+async function triggerJob(job, db) {
+  const run = createJobRun(job.id, db);
+  const { exitCode, output } = await runConnectorCommand2(job.connector, job.command, job.args);
+  const stripped = job.strip ? await maybeStrip(output) : undefined;
+  finishJobRun(run.id, { exit_code: exitCode, raw_output: output, stripped_output: stripped }, db);
+  touchJobLastRun(job.id, db);
+  return { run_id: run.id, exit_code: exitCode, output: stripped ?? output };
+}
+var _interval = null, _lastCheckedMinute = -1;
+var init_scheduler = __esm(() => {
+  init_jobs();
+  init_strip();
+});
+
+// src/db/workflows.ts
+var exports_workflows = {};
+__export(exports_workflows, {
+  updateWorkflow: () => updateWorkflow,
+  listWorkflows: () => listWorkflows,
+  getWorkflowByName: () => getWorkflowByName,
+  getWorkflow: () => getWorkflow,
+  deleteWorkflow: () => deleteWorkflow,
+  createWorkflow: () => createWorkflow
+});
+function rowToWorkflow(row) {
+  return {
+    ...row,
+    steps: JSON.parse(row.steps || "[]"),
+    enabled: row.enabled === 1
+  };
+}
+function createWorkflow(input, db) {
+  const d = db ?? getDatabase();
+  const id = shortUuid();
+  d.run("INSERT INTO connector_workflows (id, name, steps, enabled, created_at) VALUES (?, ?, ?, 1, ?)", [id, input.name, JSON.stringify(input.steps), now()]);
+  return getWorkflow(id, d);
+}
+function getWorkflow(id, db) {
+  const d = db ?? getDatabase();
+  const row = d.query("SELECT * FROM connector_workflows WHERE id = ?").get(id);
+  return row ? rowToWorkflow(row) : null;
+}
+function getWorkflowByName(name, db) {
+  const d = db ?? getDatabase();
+  const row = d.query("SELECT * FROM connector_workflows WHERE name = ?").get(name);
+  return row ? rowToWorkflow(row) : null;
+}
+function listWorkflows(db) {
+  const d = db ?? getDatabase();
+  return d.query("SELECT * FROM connector_workflows ORDER BY name").all().map(rowToWorkflow);
+}
+function updateWorkflow(id, input, db) {
+  const d = db ?? getDatabase();
+  const sets = [];
+  const params = [];
+  if (input.name !== undefined) {
+    sets.push("name = ?");
+    params.push(input.name);
+  }
+  if (input.steps !== undefined) {
+    sets.push("steps = ?");
+    params.push(JSON.stringify(input.steps));
+  }
+  if (input.enabled !== undefined) {
+    sets.push("enabled = ?");
+    params.push(input.enabled ? 1 : 0);
+  }
+  if (sets.length === 0)
+    return getWorkflow(id, d);
+  params.push(id);
+  d.run(`UPDATE connector_workflows SET ${sets.join(", ")} WHERE id = ?`, params);
+  return getWorkflow(id, d);
+}
+function deleteWorkflow(id, db) {
+  const d = db ?? getDatabase();
+  return d.run("DELETE FROM connector_workflows WHERE id = ?", [id]).changes > 0;
+}
+var init_workflows = __esm(() => {
+  init_database();
+});
+
+// src/lib/workflow-runner.ts
+var exports_workflow_runner = {};
+__export(exports_workflow_runner, {
+  runWorkflow: () => runWorkflow
+});
+import { spawn as spawn3 } from "child_process";
+async function runStep(step, previousOutput) {
+  return new Promise((resolve) => {
+    const args = [...step.args ?? []];
+    if (previousOutput && previousOutput.trim()) {
+      args.push("--input", previousOutput.trim().slice(0, 4096));
+    }
+    const cmdArgs = ["run", step.connector, step.command, ...args, "--format", "json"];
+    const proc = spawn3("connectors", cmdArgs, { shell: false });
+    let output = "";
+    proc.stdout.on("data", (d) => {
+      output += d.toString();
+    });
+    proc.stderr.on("data", (d) => {
+      output += d.toString();
+    });
+    proc.on("close", (code) => resolve({ exitCode: code ?? 1, output }));
+    proc.on("error", () => resolve({ exitCode: 1, output: "Failed to spawn connectors" }));
+    setTimeout(() => {
+      proc.kill();
+      resolve({ exitCode: 124, output: output + `
+[timeout]` });
+    }, 60000);
+  });
+}
+async function runWorkflow(workflow) {
+  const results = [];
+  let previousOutput;
+  let success = true;
+  for (let i = 0;i < workflow.steps.length; i++) {
+    const step = workflow.steps[i];
+    const { exitCode, output } = await runStep(step, previousOutput);
+    const stripped = await maybeStrip(output);
+    results.push({ step: i + 1, connector: step.connector, command: step.command, exit_code: exitCode, output: stripped });
+    if (exitCode !== 0) {
+      success = false;
+      break;
+    }
+    previousOutput = stripped;
+  }
+  return {
+    workflow_id: workflow.id,
+    workflow_name: workflow.name,
+    steps: results,
+    success,
+    final_output: results[results.length - 1]?.output ?? ""
+  };
+}
+var init_workflow_runner = __esm(() => {
+  init_strip();
+});
+
 // node_modules/zod/v3/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -25975,61 +26599,10 @@ async function getConnectorCommandHelp(name, command) {
   return result.stdout || result.stderr;
 }
 
-// src/db/database.ts
-import { Database } from "bun:sqlite";
-import { join as join6 } from "path";
-import { homedir as homedir4 } from "os";
-import { mkdirSync as mkdirSync4 } from "fs";
-var DB_DIR = join6(homedir4(), ".connectors");
-var DB_PATH = join6(DB_DIR, "connectors.db");
-var _db = null;
-function getDatabase(path) {
-  if (_db)
-    return _db;
-  const dbPath = path ?? DB_PATH;
-  mkdirSync4(join6(dbPath, ".."), { recursive: true });
-  _db = new Database(dbPath);
-  _db.run("PRAGMA journal_mode = WAL");
-  migrate(_db);
-  return _db;
-}
-function now() {
-  return new Date().toISOString();
-}
-function migrate(db) {
-  db.run(`
-    CREATE TABLE IF NOT EXISTS agents (
-      id TEXT PRIMARY KEY,
-      name TEXT UNIQUE NOT NULL,
-      session_id TEXT,
-      role TEXT NOT NULL DEFAULT 'agent',
-      last_seen_at TEXT NOT NULL,
-      created_at TEXT NOT NULL
-    )
-  `);
-  db.run(`
-    CREATE TABLE IF NOT EXISTS resource_locks (
-      id TEXT PRIMARY KEY,
-      resource_type TEXT NOT NULL CHECK(resource_type IN ('connector', 'agent', 'profile', 'token')),
-      resource_id TEXT NOT NULL,
-      agent_id TEXT NOT NULL,
-      lock_type TEXT NOT NULL DEFAULT 'exclusive' CHECK(lock_type IN ('advisory', 'exclusive')),
-      locked_at TEXT NOT NULL DEFAULT (datetime('now')),
-      expires_at TEXT NOT NULL
-    )
-  `);
-  db.run(`
-    CREATE UNIQUE INDEX IF NOT EXISTS idx_resource_locks_exclusive
-      ON resource_locks(resource_type, resource_id)
-      WHERE lock_type = 'exclusive'
-  `);
-  db.run(`CREATE INDEX IF NOT EXISTS idx_resource_locks_agent ON resource_locks(agent_id)`);
-  db.run(`CREATE INDEX IF NOT EXISTS idx_resource_locks_expires ON resource_locks(expires_at)`);
-}
-
 // src/db/agents.ts
+init_database();
 var AGENT_ACTIVE_WINDOW_MS = 30 * 60 * 1000;
-function shortUuid() {
+function shortUuid2() {
   return crypto.randomUUID().slice(0, 8);
 }
 function isAgentConflict(result) {
@@ -26066,7 +26639,7 @@ function registerAgent(input, db) {
     d.run(`UPDATE agents SET ${updates.join(", ")} WHERE id = ?`, params);
     return getAgent(existing.id, d);
   }
-  const id = shortUuid();
+  const id = shortUuid2();
   const ts = now();
   d.run(`INSERT INTO agents (id, name, session_id, role, last_seen_at, created_at)
      VALUES (?, ?, ?, ?, ?, ?)`, [id, normalizedName, input.session_id ?? null, input.role ?? "agent", ts, ts]);
@@ -26086,6 +26659,7 @@ function listAgents(db) {
 }
 
 // src/db/rate.ts
+init_database();
 var AGENT_ACTIVE_WINDOW_MS2 = 30 * 60 * 1000;
 var WINDOW_SECONDS = 60;
 function ensureRateTable(db) {
@@ -26153,6 +26727,9 @@ function checkRateBudget(agentId, connector, connectorLimit, consume = true, db)
 function getRateBudget(agentId, connector, connectorLimit, db) {
   return checkRateBudget(agentId, connector, connectorLimit, false, db);
 }
+
+// src/mcp/index.ts
+init_strip();
 // package.json
 var package_default = {
   name: "@hasna/connectors",
@@ -26243,6 +26820,9 @@ var package_default = {
 
 // src/mcp/index.ts
 loadConnectorVersions();
+async function stripped(text) {
+  return { content: [{ type: "text", text: await maybeStrip(text) }] };
+}
 var server = new McpServer({
   name: "connectors",
   version: package_default.version
@@ -26253,20 +26833,7 @@ server.registerTool("search_connectors", {
   inputSchema: { query: exports_external.string() }
 }, async ({ query }) => {
   const results = searchConnectors(query);
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(results.map((c) => ({
-          name: c.name,
-          displayName: c.displayName,
-          version: c.version,
-          category: c.category,
-          description: c.description
-        })), null, 2)
-      }
-    ]
-  };
+  return stripped(JSON.stringify(results.map((c) => ({ name: c.name, displayName: c.displayName, version: c.version, category: c.category, description: c.description })), null, 2));
 });
 server.registerTool("list_connectors", {
   title: "List Connectors",
@@ -26299,9 +26866,7 @@ server.registerTool("list_connectors", {
     category: c.category,
     description: c.description
   }));
-  return {
-    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
-  };
+  return stripped(JSON.stringify(data, null, 2));
 });
 server.registerTool("connector_docs", {
   title: "Connector Documentation",
@@ -26730,6 +27295,71 @@ server.registerTool("describe_tools", {
 `);
   return { content: [{ type: "text", text: result }] };
 });
+server.registerTool("list_jobs", { title: "List Jobs", description: "List scheduled connector jobs.", inputSchema: {} }, async () => {
+  const { listJobs: listJobs2 } = await Promise.resolve().then(() => (init_jobs(), exports_jobs));
+  const { getDatabase: getDatabase2 } = await Promise.resolve().then(() => (init_database(), exports_database));
+  return stripped(JSON.stringify(listJobs2(getDatabase2()), null, 2));
+});
+server.registerTool("get_latest_job_run", { title: "Get Latest Job Run", description: "Get the most recent run output for a job.", inputSchema: { name: exports_external.string() } }, async ({ name }) => {
+  const { getJobByName: getJobByName2, getLatestRun: getLatestRun2 } = await Promise.resolve().then(() => (init_jobs(), exports_jobs));
+  const { getDatabase: getDatabase2 } = await Promise.resolve().then(() => (init_database(), exports_database));
+  const db = getDatabase2();
+  const job = getJobByName2(name, db);
+  if (!job)
+    return { content: [{ type: "text", text: JSON.stringify({ error: `Job "${name}" not found` }) }], isError: true };
+  const run = getLatestRun2(job.id, db);
+  return stripped(JSON.stringify(run ?? { message: "No runs yet" }, null, 2));
+});
+server.registerTool("run_job", { title: "Run Job", description: "Manually trigger a scheduled job.", inputSchema: { name: exports_external.string() } }, async ({ name }) => {
+  const { getJobByName: getJobByName2 } = await Promise.resolve().then(() => (init_jobs(), exports_jobs));
+  const { getDatabase: getDatabase2 } = await Promise.resolve().then(() => (init_database(), exports_database));
+  const { triggerJob: triggerJob2 } = await Promise.resolve().then(() => (init_scheduler(), exports_scheduler));
+  const db = getDatabase2();
+  const job = getJobByName2(name, db);
+  if (!job)
+    return { content: [{ type: "text", text: JSON.stringify({ error: `Job "${name}" not found` }) }], isError: true };
+  const result = await triggerJob2(job, db);
+  return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+});
+server.registerTool("list_workflows", { title: "List Workflows", description: "List connector workflows.", inputSchema: {} }, async () => {
+  const { listWorkflows: listWorkflows2 } = await Promise.resolve().then(() => (init_workflows(), exports_workflows));
+  const { getDatabase: getDatabase2 } = await Promise.resolve().then(() => (init_database(), exports_database));
+  return stripped(JSON.stringify(listWorkflows2(getDatabase2()), null, 2));
+});
+server.registerTool("run_workflow", { title: "Run Workflow", description: "Execute a connector workflow pipeline.", inputSchema: { name: exports_external.string() } }, async ({ name }) => {
+  const { getWorkflowByName: getWorkflowByName2 } = await Promise.resolve().then(() => (init_workflows(), exports_workflows));
+  const { getDatabase: getDatabase2 } = await Promise.resolve().then(() => (init_database(), exports_database));
+  const { runWorkflow: runWorkflow2 } = await Promise.resolve().then(() => (init_workflow_runner(), exports_workflow_runner));
+  const wf = getWorkflowByName2(name, getDatabase2());
+  if (!wf)
+    return { content: [{ type: "text", text: JSON.stringify({ error: `Workflow "${name}" not found` }) }], isError: true };
+  const result = await runWorkflow2(wf);
+  return stripped(JSON.stringify(result, null, 2));
+});
+server.registerTool("get_llm_config", {
+  title: "Get LLM Config",
+  description: "Get current LLM provider config and strip status.",
+  inputSchema: {}
+}, async () => {
+  const { getLlmConfig: getConfig, maskKey: mask } = await Promise.resolve().then(() => (init_llm(), exports_llm));
+  const config2 = getConfig();
+  if (!config2)
+    return { content: [{ type: "text", text: JSON.stringify({ configured: false }) }] };
+  return { content: [{ type: "text", text: JSON.stringify({ configured: true, provider: config2.provider, model: config2.model, key: mask(config2.api_key), strip: config2.strip }) }] };
+});
+server.registerTool("set_llm_strip", {
+  title: "Set LLM Strip",
+  description: "Enable or disable global output stripping.",
+  inputSchema: { enabled: exports_external.boolean() }
+}, async ({ enabled }) => {
+  const { setLlmStrip: setLlmStrip2 } = await Promise.resolve().then(() => (init_llm(), exports_llm));
+  try {
+    setLlmStrip2(enabled);
+    return { content: [{ type: "text", text: JSON.stringify({ success: true, strip: enabled }) }] };
+  } catch (e) {
+    return { content: [{ type: "text", text: JSON.stringify({ success: false, error: e instanceof Error ? e.message : String(e) }) }], isError: true };
+  }
+});
 server.registerTool("register_agent", {
   title: "Register Agent",
   description: "Register or heartbeat an agent. Returns agent or conflict error.",