@veolab/discoverylab 0.1.0

package/dist/index.js

@@ -0,0 +1,869 @@
+#!/usr/bin/env node
+import {
+  analyzeTools,
+  canvasTools,
+  captureTools,
+  exportTools,
+  integrationTools,
+  projectTools,
+  taskHubTools,
+  testingTools,
+  uiTools
+} from "./chunk-SSRXIO2V.js";
+import "./chunk-W3WJGYR6.js";
+import {
+  setupTools
+} from "./chunk-7IDQLLBW.js";
+import {
+  mcpServer
+} from "./chunk-QJXXHOV7.js";
+import {
+  startServer,
+  stopServer
+} from "./chunk-PBHUHSC3.js";
+import "./chunk-MN6LCZHZ.js";
+import {
+  closeDatabase,
+  exportDestinations,
+  exportRules,
+  frames,
+  getDatabase,
+  projectExports,
+  projects,
+  settings
+} from "./chunk-VY3BLXBW.js";
+import "./chunk-MLKGABMK.js";
+
+// src/core/protocol/types.ts
+function isWSRequest(msg) {
+  return typeof msg === "object" && msg !== null && msg.type === "req" && typeof msg.id === "string" && typeof msg.method === "string";
+}
+function isWSResponse(msg) {
+  return typeof msg === "object" && msg !== null && msg.type === "res" && typeof msg.id === "string" && typeof msg.ok === "boolean";
+}
+function isWSEvent(msg) {
+  return typeof msg === "object" && msg !== null && msg.type === "event" && typeof msg.event === "string";
+}
+function isWSMessage(msg) {
+  return isWSRequest(msg) || isWSResponse(msg) || isWSEvent(msg);
+}
+
+// src/core/protocol/validator.ts
+var schemas = {
+  request: {
+    type: "object",
+    required: ["type", "id", "method"],
+    properties: {
+      type: { const: "req" },
+      id: { type: "string" },
+      method: { type: "string" },
+      params: { type: "object" }
+    },
+    additionalProperties: false
+  },
+  response: {
+    type: "object",
+    required: ["type", "id", "ok"],
+    properties: {
+      type: { const: "res" },
+      id: { type: "string" },
+      ok: { type: "boolean" },
+      payload: {},
+      error: { type: "string" }
+    },
+    additionalProperties: false
+  },
+  event: {
+    type: "object",
+    required: ["type", "event", "payload"],
+    properties: {
+      type: { const: "event" },
+      event: { type: "string" },
+      payload: {},
+      seq: { type: "number" },
+      timestamp: { type: "number" }
+    },
+    additionalProperties: false
+  },
+  // Method-specific param schemas
+  methods: {
+    "ping": {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    },
+    "recorder.start": {
+      type: "object",
+      required: ["name", "url"],
+      properties: {
+        name: { type: "string" },
+        url: { type: "string" },
+        resolution: {
+          type: "object",
+          properties: {
+            width: { type: "number" },
+            height: { type: "number" }
+          }
+        }
+      },
+      additionalProperties: false
+    },
+    "recorder.stop": {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    },
+    "recorder.status": {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    },
+    "liveStream.start": {
+      type: "object",
+      required: ["platform"],
+      properties: {
+        platform: { enum: ["ios", "android"] },
+        deviceId: { type: "string" },
+        interactive: { type: "boolean" }
+      },
+      additionalProperties: false
+    },
+    "liveStream.stop": {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    },
+    "liveStream.tap": {
+      type: "object",
+      required: ["x", "y"],
+      properties: {
+        x: { type: "number" },
+        y: { type: "number" }
+      },
+      additionalProperties: false
+    },
+    "project.list": {
+      type: "object",
+      properties: {},
+      additionalProperties: false
+    },
+    "project.get": {
+      type: "object",
+      required: ["id"],
+      properties: {
+        id: { type: "string" }
+      },
+      additionalProperties: false
+    },
+    "project.create": {
+      type: "object",
+      required: ["name"],
+      properties: {
+        name: { type: "string" },
+        packageName: { type: "string" }
+      },
+      additionalProperties: false
+    },
+    "project.delete": {
+      type: "object",
+      required: ["id"],
+      properties: {
+        id: { type: "string" }
+      },
+      additionalProperties: false
+    }
+  }
+};
+function validateSchema(data, schema, path = "") {
+  const errors = [];
+  if (schema.const !== void 0) {
+    if (data !== schema.const) {
+      errors.push({
+        path: path || "root",
+        message: `Expected constant value`,
+        expected: String(schema.const),
+        received: String(data)
+      });
+    }
+    return errors;
+  }
+  if (schema.enum !== void 0) {
+    if (!schema.enum.includes(data)) {
+      errors.push({
+        path: path || "root",
+        message: `Value must be one of: ${schema.enum.join(", ")}`,
+        received: String(data)
+      });
+    }
+    return errors;
+  }
+  if (schema.type === "object") {
+    if (typeof data !== "object" || data === null || Array.isArray(data)) {
+      errors.push({
+        path: path || "root",
+        message: "Expected object",
+        expected: "object",
+        received: typeof data
+      });
+      return errors;
+    }
+    const obj = data;
+    if (schema.required) {
+      for (const key of schema.required) {
+        if (!(key in obj)) {
+          errors.push({
+            path: `${path}.${key}`,
+            message: `Missing required property: ${key}`
+          });
+        }
+      }
+    }
+    if (schema.properties) {
+      for (const [key, propSchema] of Object.entries(schema.properties)) {
+        if (key in obj) {
+          const propErrors = validateSchema(obj[key], propSchema, `${path}.${key}`);
+          errors.push(...propErrors);
+        }
+      }
+    }
+    if (schema.additionalProperties === false && schema.properties) {
+      for (const key of Object.keys(obj)) {
+        if (!(key in schema.properties)) {
+          errors.push({
+            path: `${path}.${key}`,
+            message: `Unexpected property: ${key}`
+          });
+        }
+      }
+    }
+  } else if (schema.type === "string") {
+    if (typeof data !== "string") {
+      errors.push({
+        path: path || "root",
+        message: "Expected string",
+        expected: "string",
+        received: typeof data
+      });
+    }
+  } else if (schema.type === "number") {
+    if (typeof data !== "number") {
+      errors.push({
+        path: path || "root",
+        message: "Expected number",
+        expected: "number",
+        received: typeof data
+      });
+    }
+  } else if (schema.type === "boolean") {
+    if (typeof data !== "boolean") {
+      errors.push({
+        path: path || "root",
+        message: "Expected boolean",
+        expected: "boolean",
+        received: typeof data
+      });
+    }
+  }
+  return errors;
+}
+function validateRequest(msg) {
+  const errors = validateSchema(msg, schemas.request);
+  return { valid: errors.length === 0, errors };
+}
+function validateMethodParams(method, params) {
+  const schema = schemas.methods[method];
+  if (!schema) {
+    return {
+      valid: false,
+      errors: [{ path: "method", message: `Unknown method: ${method}` }]
+    };
+  }
+  const errors = validateSchema(params ?? {}, schema);
+  return { valid: errors.length === 0, errors };
+}
+function validateResponse(msg) {
+  const errors = validateSchema(msg, schemas.response);
+  return { valid: errors.length === 0, errors };
+}
+function validateEvent(msg) {
+  const errors = validateSchema(msg, schemas.event);
+  return { valid: errors.length === 0, errors };
+}
+function formatValidationErrors(errors) {
+  return errors.map((e) => {
+    let msg = `${e.path}: ${e.message}`;
+    if (e.expected) msg += ` (expected: ${e.expected})`;
+    if (e.received) msg += ` (received: ${e.received})`;
+    return msg;
+  }).join("\n");
+}
+var availableMethods = [
+  "ping",
+  "recorder.start",
+  "recorder.stop",
+  "recorder.status",
+  "liveStream.start",
+  "liveStream.stop",
+  "liveStream.tap",
+  "project.list",
+  "project.get",
+  "project.create",
+  "project.delete"
+];
+var availableEvents = [
+  "action",
+  "screenshot",
+  "status",
+  "stopped",
+  "session",
+  "liveFrame",
+  "error",
+  "connected"
+];
+
+// src/core/protocol/index.ts
+import { randomUUID } from "crypto";
+function createRequest(method, params) {
+  return {
+    type: "req",
+    id: randomUUID(),
+    method,
+    params
+  };
+}
+function createResponse(id, ok, payloadOrError) {
+  if (ok) {
+    return {
+      type: "res",
+      id,
+      ok: true,
+      payload: payloadOrError
+    };
+  } else {
+    return {
+      type: "res",
+      id,
+      ok: false,
+      error: payloadOrError
+    };
+  }
+}
+function createEvent(event, payload, seq) {
+  return {
+    type: "event",
+    event,
+    payload,
+    seq,
+    timestamp: Date.now()
+  };
+}
+var eventSequence = 0;
+function nextEventSeq() {
+  return ++eventSequence;
+}
+function resetEventSeq() {
+  eventSequence = 0;
+}
+
+// src/core/skills/parser.ts
+import { readFile } from "fs/promises";
+function parseSimpleYaml(yaml) {
+  const result = {};
+  const lines = yaml.split("\n");
+  const stack = [{ obj: result, indent: -1 }];
+  for (const line of lines) {
+    if (!line.trim() || line.trim().startsWith("#")) continue;
+    const match = line.match(/^(\s*)([^:]+):\s*(.*)$/);
+    if (!match) continue;
+    const [, spaces, key, rawValue] = match;
+    const indent = spaces.length;
+    const trimmedKey = key.trim();
+    const value = rawValue.trim();
+    while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
+      stack.pop();
+    }
+    const current = stack[stack.length - 1].obj;
+    if (value === "") {
+      const nested = {};
+      current[trimmedKey] = nested;
+      stack.push({ obj: nested, indent });
+    } else if (value.startsWith("[") && value.endsWith("]")) {
+      const arrayContent = value.slice(1, -1);
+      current[trimmedKey] = arrayContent.split(",").map((s) => s.trim()).filter((s) => s.length > 0).map((s) => parseYamlValue(s));
+    } else {
+      current[trimmedKey] = parseYamlValue(value);
+    }
+  }
+  return result;
+}
+function parseYamlValue(value) {
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (value === "null" || value === "~") return null;
+  const num = Number(value);
+  if (!isNaN(num) && value !== "") return num;
+  return value;
+}
+var FRONTMATTER_REGEX = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
+function parseSkillMd(fileContent, filePath) {
+  const match = fileContent.match(FRONTMATTER_REGEX);
+  if (!match) {
+    throw new Error(`Invalid SKILL.md format: missing YAML frontmatter in ${filePath}`);
+  }
+  const [, yamlContent, markdownContent] = match;
+  let metadata;
+  try {
+    const parsed = parseSimpleYaml(yamlContent);
+    metadata = parsed;
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : "Unknown error";
+    throw new Error(`Failed to parse YAML frontmatter in ${filePath}: ${msg}`);
+  }
+  if (!metadata.name) {
+    throw new Error(`Missing required field 'name' in ${filePath}`);
+  }
+  if (!metadata.description) {
+    throw new Error(`Missing required field 'description' in ${filePath}`);
+  }
+  if (metadata.requires) {
+    if (metadata.requires.bins && !Array.isArray(metadata.requires.bins)) {
+      metadata.requires.bins = [metadata.requires.bins];
+    }
+    if (metadata.requires.env && !Array.isArray(metadata.requires.env)) {
+      metadata.requires.env = [metadata.requires.env];
+    }
+    if (metadata.requires.packages && !Array.isArray(metadata.requires.packages)) {
+      metadata.requires.packages = [metadata.requires.packages];
+    }
+  }
+  if (metadata.os && !Array.isArray(metadata.os)) {
+    metadata.os = [metadata.os];
+  }
+  if (metadata.tools && !Array.isArray(metadata.tools)) {
+    metadata.tools = [metadata.tools];
+  }
+  if (metadata.tags && !Array.isArray(metadata.tags)) {
+    metadata.tags = [metadata.tags];
+  }
+  return {
+    metadata,
+    content: markdownContent.trim()
+  };
+}
+async function readSkillMd(filePath) {
+  const content = await readFile(filePath, "utf-8");
+  return parseSkillMd(content, filePath);
+}
+function generateSkillMd(metadata, content) {
+  const yaml = generateYamlFrontmatter(metadata);
+  return `---
+${yaml}---
+
+${content}`;
+}
+function generateYamlFrontmatter(metadata) {
+  const lines = [];
+  lines.push(`name: ${metadata.name}`);
+  lines.push(`description: "${metadata.description}"`);
+  if (metadata.emoji) {
+    lines.push(`emoji: "${metadata.emoji}"`);
+  }
+  if (metadata.version) {
+    lines.push(`version: "${metadata.version}"`);
+  }
+  if (metadata.author) {
+    lines.push(`author: "${metadata.author}"`);
+  }
+  if (metadata.category) {
+    lines.push(`category: ${metadata.category}`);
+  }
+  if (metadata.requires) {
+    lines.push("requires:");
+    if (metadata.requires.bins?.length) {
+      lines.push(`  bins: [${metadata.requires.bins.join(", ")}]`);
+    }
+    if (metadata.requires.env?.length) {
+      lines.push(`  env: [${metadata.requires.env.join(", ")}]`);
+    }
+    if (metadata.requires.packages?.length) {
+      lines.push(`  packages: [${metadata.requires.packages.join(", ")}]`);
+    }
+  }
+  if (metadata.os?.length) {
+    lines.push(`os: [${metadata.os.join(", ")}]`);
+  }
+  if (metadata.always) {
+    lines.push("always: true");
+  }
+  if (metadata.install) {
+    lines.push("install:");
+    if (metadata.install.brew) {
+      lines.push(`  brew: ${metadata.install.brew}`);
+    }
+    if (metadata.install.apt) {
+      lines.push(`  apt: ${metadata.install.apt}`);
+    }
+    if (metadata.install.npm) {
+      lines.push(`  npm: ${metadata.install.npm}`);
+    }
+    if (metadata.install.manual) {
+      lines.push(`  manual: "${metadata.install.manual}"`);
+    }
+  }
+  if (metadata.tools?.length) {
+    lines.push(`tools: [${metadata.tools.join(", ")}]`);
+  }
+  if (metadata.tags?.length) {
+    lines.push(`tags: [${metadata.tags.join(", ")}]`);
+  }
+  return lines.join("\n") + "\n";
+}
+
+// src/core/skills/gating.ts
+import { execSync } from "child_process";
+import { platform } from "os";
+function checkBinary(name) {
+  try {
+    const cmd = platform() === "win32" ? `where ${name}` : `which ${name}`;
+    execSync(cmd, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function checkBinaries(bins) {
+  return bins.filter((bin) => !checkBinary(bin));
+}
+function checkEnvVar(name) {
+  const value = process.env[name];
+  return value !== void 0 && value !== "";
+}
+function checkEnvVars(envs) {
+  return envs.filter((env) => !checkEnvVar(env));
+}
+function getCurrentOS() {
+  const os = platform();
+  if (os === "darwin" || os === "linux" || os === "win32") {
+    return os;
+  }
+  return "linux";
+}
+function checkOS(supportedOS) {
+  const currentOS = getCurrentOS();
+  return supportedOS.includes(currentOS);
+}
+function checkSkillRequirements(metadata) {
+  if (metadata.always) {
+    return {
+      satisfied: true,
+      missingBins: [],
+      missingEnv: [],
+      osUnsupported: false,
+      summary: "Skill is always available"
+    };
+  }
+  const missingBins = metadata.requires?.bins ? checkBinaries(metadata.requires.bins) : [];
+  const missingEnv = metadata.requires?.env ? checkEnvVars(metadata.requires.env) : [];
+  const osUnsupported = metadata.os ? !checkOS(metadata.os) : false;
+  const satisfied = missingBins.length === 0 && missingEnv.length === 0 && !osUnsupported;
+  const reasons = [];
+  if (missingBins.length > 0) {
+    reasons.push(`Missing binaries: ${missingBins.join(", ")}`);
+  }
+  if (missingEnv.length > 0) {
+    reasons.push(`Missing env vars: ${missingEnv.join(", ")}`);
+  }
+  if (osUnsupported) {
+    const currentOS = getCurrentOS();
+    reasons.push(`OS '${currentOS}' not supported (requires: ${metadata.os?.join(", ")})`);
+  }
+  const summary = satisfied ? "All requirements satisfied" : reasons.join("; ");
+  return {
+    satisfied,
+    missingBins,
+    missingEnv,
+    osUnsupported,
+    summary
+  };
+}
+function getInstallInstructions(metadata, result) {
+  const instructions = [];
+  if (result.missingBins.length > 0 && metadata.install) {
+    const os = getCurrentOS();
+    if (os === "darwin" && metadata.install.brew) {
+      instructions.push(`brew install ${metadata.install.brew}`);
+    } else if (os === "linux" && metadata.install.apt) {
+      instructions.push(`apt install ${metadata.install.apt}`);
+    } else if (metadata.install.npm) {
+      instructions.push(`npm install -g ${metadata.install.npm}`);
+    } else if (metadata.install.manual) {
+      instructions.push(metadata.install.manual);
+    }
+  }
+  if (result.missingEnv.length > 0) {
+    for (const env of result.missingEnv) {
+      instructions.push(`Set environment variable: export ${env}=<value>`);
+    }
+  }
+  return instructions;
+}
+
+// src/core/skills/loader.ts
+import { readdir, access } from "fs/promises";
+import { join, dirname } from "path";
+import { homedir } from "os";
+import { fileURLToPath } from "url";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var BUNDLED_SKILLS_DIR = join(__dirname, "../../mcp/tools");
+var USER_SKILLS_DIR = join(homedir(), ".discoverylab", "skills");
+var WORKSPACE_SKILLS_DIR = join(process.cwd(), ".discoverylab", "skills");
+async function pathExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function findSkillFiles(baseDir) {
+  const skillFiles = [];
+  if (!await pathExists(baseDir)) {
+    return skillFiles;
+  }
+  try {
+    const entries = await readdir(baseDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const skillPath = join(baseDir, entry.name, "SKILL.md");
+        if (await pathExists(skillPath)) {
+          skillFiles.push(skillPath);
+        }
+      }
+    }
+  } catch {
+  }
+  return skillFiles;
+}
+async function discoverSkillFiles() {
+  const [bundled, user, workspace] = await Promise.all([
+    findSkillFiles(BUNDLED_SKILLS_DIR),
+    findSkillFiles(USER_SKILLS_DIR),
+    findSkillFiles(WORKSPACE_SKILLS_DIR)
+  ]);
+  return { bundled, user, workspace };
+}
+async function loadSkill(skillPath) {
+  const { metadata, content } = await readSkillMd(skillPath);
+  const gatingResult = checkSkillRequirements(metadata);
+  const skill = {
+    metadata,
+    content,
+    path: skillPath,
+    available: gatingResult.satisfied
+  };
+  if (!gatingResult.satisfied) {
+    skill.unavailableReasons = [];
+    if (gatingResult.missingBins.length > 0) {
+      skill.unavailableReasons.push(`Missing binaries: ${gatingResult.missingBins.join(", ")}`);
+    }
+    if (gatingResult.missingEnv.length > 0) {
+      skill.unavailableReasons.push(`Missing env vars: ${gatingResult.missingEnv.join(", ")}`);
+    }
+    if (gatingResult.osUnsupported) {
+      skill.unavailableReasons.push(gatingResult.summary);
+    }
+    const instructions = getInstallInstructions(metadata, gatingResult);
+    if (instructions.length > 0) {
+      skill.unavailableReasons.push(`Install: ${instructions.join(" && ")}`);
+    }
+  }
+  return skill;
+}
+async function loadSkills() {
+  const result = {
+    loaded: [],
+    failed: [],
+    unavailable: []
+  };
+  const { bundled, user, workspace } = await discoverSkillFiles();
+  const allPaths = [...bundled, ...user, ...workspace];
+  const skillsByName = /* @__PURE__ */ new Map();
+  for (const path of allPaths) {
+    try {
+      const skill = await loadSkill(path);
+      skillsByName.set(skill.metadata.name, skill);
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : "Unknown error";
+      result.failed.push({ path, error: msg });
+    }
+  }
+  for (const skill of skillsByName.values()) {
+    if (skill.available) {
+      result.loaded.push(skill);
+    } else {
+      result.unavailable.push(skill);
+    }
+  }
+  return result;
+}
+function createSkillRegistry() {
+  const skills = /* @__PURE__ */ new Map();
+  return {
+    skills,
+    getAvailable() {
+      return Array.from(skills.values()).filter((s) => s.available);
+    },
+    get(name) {
+      return skills.get(name);
+    },
+    isAvailable(name) {
+      const skill = skills.get(name);
+      return skill?.available ?? false;
+    },
+    async reload() {
+      skills.clear();
+      const result = await loadSkills();
+      for (const skill of [...result.loaded, ...result.unavailable]) {
+        skills.set(skill.metadata.name, skill);
+      }
+      return result;
+    }
+  };
+}
+var globalRegistry = null;
+async function getSkillRegistry() {
+  if (!globalRegistry) {
+    globalRegistry = createSkillRegistry();
+    await globalRegistry.reload();
+  }
+  return globalRegistry;
+}
+async function reloadSkillRegistry() {
+  if (!globalRegistry) {
+    globalRegistry = createSkillRegistry();
+  }
+  return globalRegistry.reload();
+}
+function formatSkillInfo(skill) {
+  const lines = [];
+  const statusIcon = skill.available ? "\u2713" : "\u2717";
+  const emoji = skill.metadata.emoji || "\u{1F4E6}";
+  lines.push(`${emoji} ${skill.metadata.name} [${statusIcon}]`);
+  lines.push(`   ${skill.metadata.description}`);
+  if (skill.metadata.version) {
+    lines.push(`   Version: ${skill.metadata.version}`);
+  }
+  if (skill.metadata.requires) {
+    if (skill.metadata.requires.bins?.length) {
+      lines.push(`   Requires: ${skill.metadata.requires.bins.join(", ")}`);
+    }
+    if (skill.metadata.requires.env?.length) {
+      lines.push(`   Env vars: ${skill.metadata.requires.env.join(", ")}`);
+    }
+  }
+  if (!skill.available && skill.unavailableReasons?.length) {
+    lines.push(`   \u26A0 ${skill.unavailableReasons.join("\n   \u26A0 ")}`);
+  }
+  return lines.join("\n");
+}
+function formatSkillList(skills) {
+  if (skills.length === 0) {
+    return "No skills found";
+  }
+  const available = skills.filter((s) => s.available);
+  const unavailable = skills.filter((s) => !s.available);
+  const lines = [];
+  if (available.length > 0) {
+    lines.push("Available Skills:");
+    for (const skill of available) {
+      const emoji = skill.metadata.emoji || "\u{1F4E6}";
+      lines.push(`  ${emoji} ${skill.metadata.name} - ${skill.metadata.description}`);
+    }
+  }
+  if (unavailable.length > 0) {
+    if (lines.length > 0) lines.push("");
+    lines.push("Unavailable Skills (missing dependencies):");
+    for (const skill of unavailable) {
+      const emoji = skill.metadata.emoji || "\u{1F4E6}";
+      lines.push(`  ${emoji} ${skill.metadata.name} - ${skill.metadata.description}`);
+      if (skill.unavailableReasons?.length) {
+        lines.push(`     \u26A0 ${skill.unavailableReasons[0]}`);
+      }
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/index.ts
+async function main() {
+  try {
+    getDatabase();
+    mcpServer.registerTools([
+      ...uiTools,
+      ...projectTools,
+      ...setupTools,
+      ...captureTools,
+      ...analyzeTools,
+      ...canvasTools,
+      ...exportTools,
+      ...testingTools,
+      ...integrationTools,
+      ...taskHubTools
+    ]);
+    await mcpServer.runStdio();
+  } catch (error) {
+    console.error("Failed to start MCP server:", error);
+    process.exit(1);
+  }
+}
+main();
+export {
+  availableEvents,
+  availableMethods,
+  checkBinaries,
+  checkBinary,
+  checkEnvVar,
+  checkEnvVars,
+  checkOS,
+  checkSkillRequirements,
+  closeDatabase,
+  createEvent,
+  createRequest,
+  createResponse,
+  createSkillRegistry,
+  exportDestinations,
+  exportRules,
+  formatSkillInfo,
+  formatSkillList,
+  formatValidationErrors,
+  frames,
+  generateSkillMd,
+  getCurrentOS,
+  getDatabase,
+  getInstallInstructions,
+  getSkillRegistry,
+  isWSEvent,
+  isWSMessage,
+  isWSRequest,
+  isWSResponse,
+  loadSkills,
+  mcpServer,
+  nextEventSeq,
+  parseSkillMd,
+  projectExports,
+  projects,
+  readSkillMd,
+  reloadSkillRegistry,
+  resetEventSeq,
+  schemas,
+  settings,
+  startServer,
+  stopServer,
+  validateEvent,
+  validateMethodParams,
+  validateRequest,
+  validateResponse
+};