@veolab/discoverylab 1.2.0 → 1.2.2

package/dist/chunk-G524UVBK.js

@@ -0,0 +1,334 @@
+import {
+  DATA_DIR,
+  DB_PATH
+} from "./chunk-TJ3H23LL.js";
+import {
+  createJsonResult,
+  createTextResult
+} from "./chunk-XKX6NBHF.js";
+
+// src/mcp/tools/setup.ts
+import { z } from "zod";
+import { execSync } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { createRequire } from "module";
+import { platform, homedir } from "os";
+var requireFromHere = createRequire(import.meta.url);
+var dependencies = [
+  {
+    name: "FFmpeg",
+    command: "ffmpeg -version",
+    versionPattern: /ffmpeg version (\d+\.\d+(?:\.\d+)?)/,
+    required: true,
+    description: "Video processing and export",
+    installHint: "brew install ffmpeg (macOS) or apt install ffmpeg (Linux)"
+  },
+  {
+    name: "Maestro CLI",
+    command: "",
+    // Special handling - check multiple paths
+    versionPattern: /(\d+\.\d+\.\d+)/,
+    required: false,
+    description: "Mobile app testing automation",
+    installHint: 'curl -Ls "https://get.maestro.mobile.dev" | bash'
+  },
+  {
+    name: "Playwright",
+    command: "",
+    // Special handling - avoid npx auto-install false positives
+    versionPattern: /(\d+\.\d+\.\d+)/,
+    required: false,
+    description: "Web app testing and browser automation",
+    installHint: "npm install -g playwright"
+  },
+  {
+    name: "Xcode CLI Tools",
+    command: "xcode-select -p",
+    versionPattern: /.*/,
+    required: false,
+    description: "iOS Simulator access (macOS only)",
+    installHint: "xcode-select --install"
+  },
+  {
+    name: "ADB",
+    command: "adb version",
+    versionPattern: /Android Debug Bridge version (\d+\.\d+\.\d+)/,
+    required: false,
+    description: "Android Emulator access",
+    installHint: "Install Android Studio or: brew install android-platform-tools"
+  }
+];
+function checkDependency(dep) {
+  if (dep.name === "Maestro CLI") {
+    return checkMaestro(dep);
+  }
+  if (dep.name === "Playwright") {
+    return checkPlaywright(dep);
+  }
+  try {
+    const output = execSync(dep.command, { encoding: "utf-8", timeout: 5e3 }).trim();
+    const match = output.match(dep.versionPattern);
+    return {
+      installed: true,
+      version: match ? match[1] || "installed" : "installed"
+    };
+  } catch (error) {
+    return {
+      installed: false,
+      version: null,
+      error: error instanceof Error ? error.message : "Command failed"
+    };
+  }
+}
+function checkPlaywright(dep) {
+  try {
+    const pkgPath = requireFromHere.resolve("playwright/package.json");
+    const raw = readFileSync(pkgPath, "utf-8");
+    const pkg = JSON.parse(raw);
+    return {
+      installed: true,
+      version: typeof pkg.version === "string" && pkg.version.trim() ? pkg.version.trim() : "installed"
+    };
+  } catch (error) {
+    return {
+      installed: false,
+      version: null,
+      error: error instanceof Error ? error.message : "Playwright package not found"
+    };
+  }
+}
+function checkMaestro(dep) {
+  const homeDir = homedir();
+  const maestroPaths = [
+    `${homeDir}/.maestro/bin/maestro`,
+    "/usr/local/bin/maestro",
+    "/opt/homebrew/bin/maestro"
+  ];
+  try {
+    const output = execSync("maestro --version 2>/dev/null || maestro version 2>/dev/null", {
+      encoding: "utf-8",
+      timeout: 5e3,
+      shell: "/bin/bash"
+    }).trim();
+    const match = output.match(dep.versionPattern);
+    return {
+      installed: true,
+      version: match ? match[1] : "installed"
+    };
+  } catch {
+  }
+  for (const maestroPath of maestroPaths) {
+    if (existsSync(maestroPath)) {
+      try {
+        const output = execSync(`"${maestroPath}" --version 2>/dev/null || "${maestroPath}" version 2>/dev/null`, {
+          encoding: "utf-8",
+          timeout: 5e3,
+          shell: "/bin/bash"
+        }).trim();
+        const match = output.match(dep.versionPattern);
+        return {
+          installed: true,
+          version: match ? match[1] : "installed"
+        };
+      } catch {
+        return {
+          installed: true,
+          version: "installed"
+        };
+      }
+    }
+  }
+  return {
+    installed: false,
+    version: null,
+    error: "Maestro not found in PATH or common installation directories"
+  };
+}
+var setupStatusTool = {
+  name: "dlab.setup.status",
+  description: "Check the status of DiscoveryLab setup and all dependencies.",
+  inputSchema: z.object({}),
+  handler: async () => {
+    const results = [];
+    let allRequiredInstalled = true;
+    for (const dep of dependencies) {
+      if (dep.name === "Xcode CLI Tools" && platform() !== "darwin") {
+        continue;
+      }
+      const status = checkDependency(dep);
+      results.push({
+        name: dep.name,
+        installed: status.installed,
+        version: status.version,
+        required: dep.required,
+        description: dep.description,
+        installHint: status.installed ? null : dep.installHint
+      });
+      if (dep.required && !status.installed) {
+        allRequiredInstalled = false;
+      }
+    }
+    const dataReady = existsSync(DATA_DIR);
+    const dbReady = existsSync(DB_PATH);
+    return createJsonResult({
+      ready: allRequiredInstalled && dataReady,
+      platform: platform(),
+      dataDirectory: {
+        path: DATA_DIR,
+        exists: dataReady
+      },
+      database: {
+        path: DB_PATH,
+        exists: dbReady
+      },
+      dependencies: results,
+      summary: {
+        total: results.length,
+        installed: results.filter((r) => r.installed).length,
+        missing: results.filter((r) => !r.installed).length,
+        requiredMissing: results.filter((r) => r.required && !r.installed).map((r) => r.name)
+      }
+    });
+  }
+};
+var setupCheckTool = {
+  name: "dlab.setup.check",
+  description: "Quick check if a specific tool is installed.",
+  inputSchema: z.object({
+    tool: z.enum(["ffmpeg", "maestro", "playwright", "xcode", "adb"]).describe("Tool to check")
+  }),
+  handler: async (params) => {
+    const toolMap = {
+      ffmpeg: dependencies[0],
+      maestro: dependencies[1],
+      playwright: dependencies[2],
+      xcode: dependencies[3],
+      adb: dependencies[4]
+    };
+    const dep = toolMap[params.tool];
+    if (!dep) {
+      return createTextResult(`Unknown tool: ${params.tool}`);
+    }
+    const status = checkDependency(dep);
+    if (status.installed) {
+      return createTextResult(`${dep.name} is installed (version: ${status.version})`);
+    } else {
+      return createTextResult(`${dep.name} is NOT installed.
+Install with: ${dep.installHint}`);
+    }
+  }
+};
+var setupInitTool = {
+  name: "dlab.setup.init",
+  description: "Initialize DiscoveryLab data directories and database.",
+  inputSchema: z.object({}),
+  handler: async () => {
+    try {
+      const { getDatabase, DATA_DIR: DATA_DIR2, PROJECTS_DIR, EXPORTS_DIR, FRAMES_DIR } = await import("./db-ADBEBNH6.js");
+      getDatabase();
+      return createJsonResult({
+        message: "DiscoveryLab initialized successfully",
+        directories: {
+          data: DATA_DIR2,
+          projects: PROJECTS_DIR,
+          exports: EXPORTS_DIR,
+          frames: FRAMES_DIR
+        }
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Initialization failed";
+      return createTextResult(`Error: ${message}`);
+    }
+  }
+};
+var setupInstallTool = {
+  name: "dlab.setup.install",
+  description: "Get installation commands for missing DiscoveryLab dependencies. Claude should run these commands after user approval.",
+  inputSchema: z.object({
+    tool: z.enum(["all", "ffmpeg", "maestro", "playwright", "xcode", "adb"]).optional().describe("Specific tool to install (default: all missing)")
+  }),
+  handler: async (params) => {
+    const toolToInstall = params.tool || "all";
+    const installCommands = [];
+    const isMac = platform() === "darwin";
+    if (toolToInstall === "all" || toolToInstall === "ffmpeg") {
+      const status = checkDependency(dependencies[0]);
+      if (!status.installed) {
+        installCommands.push({
+          name: "FFmpeg",
+          command: isMac ? "brew install ffmpeg" : "sudo apt install -y ffmpeg",
+          description: "Required for video processing and export"
+        });
+      }
+    }
+    if (toolToInstall === "all" || toolToInstall === "maestro") {
+      const status = checkDependency(dependencies[1]);
+      if (!status.installed) {
+        installCommands.push({
+          name: "Maestro CLI",
+          command: 'curl -Ls "https://get.maestro.mobile.dev" | bash',
+          description: "Mobile app testing automation"
+        });
+      }
+    }
+    if (toolToInstall === "all" || toolToInstall === "playwright") {
+      const status = checkDependency(dependencies[2]);
+      if (!status.installed) {
+        installCommands.push({
+          name: "Playwright",
+          command: "npm install -g playwright && npx playwright install",
+          description: "Web app testing and browser automation"
+        });
+      }
+    }
+    if (isMac && (toolToInstall === "all" || toolToInstall === "xcode")) {
+      const status = checkDependency(dependencies[3]);
+      if (!status.installed) {
+        installCommands.push({
+          name: "Xcode CLI Tools",
+          command: "xcode-select --install",
+          description: "Required for iOS Simulator access"
+        });
+      }
+    }
+    if (toolToInstall === "all" || toolToInstall === "adb") {
+      const status = checkDependency(dependencies[4]);
+      if (!status.installed) {
+        installCommands.push({
+          name: "ADB (Android Debug Bridge)",
+          command: isMac ? "brew install android-platform-tools" : "sudo apt install -y adb",
+          description: "Required for Android Emulator access"
+        });
+      }
+    }
+    if (installCommands.length === 0) {
+      return createTextResult(
+        toolToInstall === "all" ? "\u2705 All dependencies are already installed!" : `\u2705 ${toolToInstall} is already installed!`
+      );
+    }
+    const instructions = installCommands.map(
+      (cmd, i) => `${i + 1}. **${cmd.name}** (${cmd.description})
+   \`\`\`bash
+   ${cmd.command}
+   \`\`\``
+    ).join("\n\n");
+    return createTextResult(
+      `## Missing Dependencies
+
+Please run the following commands to install missing dependencies:
+
+` + instructions + `
+
+*Run these commands one at a time and verify each installation before proceeding.*`
+    );
+  }
+};
+var setupTools = [setupStatusTool, setupCheckTool, setupInitTool, setupInstallTool];
+
+export {
+  setupStatusTool,
+  setupCheckTool,
+  setupInitTool,
+  setupInstallTool,
+  setupTools
+};

package/dist/chunk-XKX6NBHF.js

@@ -0,0 +1,209 @@
+import {
+  APP_VERSION
+} from "./chunk-6EGBXRDK.js";
+
+// src/mcp/server.ts
+import { z } from "zod";
+var MCPServer = class {
+  tools = /* @__PURE__ */ new Map();
+  serverInfo = {
+    name: "discoverylab",
+    version: APP_VERSION
+  };
+  registerTool(tool) {
+    this.tools.set(tool.name, tool);
+  }
+  registerTools(tools) {
+    for (const tool of tools) {
+      this.registerTool(tool);
+    }
+  }
+  async handleRequest(request) {
+    const { id, method, params } = request;
+    try {
+      switch (method) {
+        case "initialize":
+          return this.handleInitialize(id, params);
+        case "tools/list":
+          return this.handleToolsList(id);
+        case "tools/call":
+          return this.handleToolCall(id, params);
+        case "ping":
+          return { jsonrpc: "2.0", id, result: { pong: true } };
+        default:
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: -32601, message: `Method not found: ${method}` }
+          };
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return {
+        jsonrpc: "2.0",
+        id,
+        error: { code: -32603, message }
+      };
+    }
+  }
+  handleInitialize(id, params) {
+    return {
+      jsonrpc: "2.0",
+      id,
+      result: {
+        protocolVersion: "2024-11-05",
+        serverInfo: this.serverInfo,
+        capabilities: {
+          tools: {}
+        }
+      }
+    };
+  }
+  handleToolsList(id) {
+    const tools = Array.from(this.tools.values()).map((tool) => ({
+      name: tool.name,
+      description: tool.description,
+      inputSchema: this.zodToJsonSchema(tool.inputSchema)
+    }));
+    return {
+      jsonrpc: "2.0",
+      id,
+      result: { tools }
+    };
+  }
+  async handleToolCall(id, params) {
+    const { name, arguments: args } = params;
+    const tool = this.tools.get(name);
+    if (!tool) {
+      return {
+        jsonrpc: "2.0",
+        id,
+        error: { code: -32602, message: `Tool not found: ${name}` }
+      };
+    }
+    try {
+      const validatedArgs = tool.inputSchema.parse(args || {});
+      const result = await tool.handler(validatedArgs);
+      return {
+        jsonrpc: "2.0",
+        id,
+        result
+      };
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        return {
+          jsonrpc: "2.0",
+          id,
+          error: {
+            code: -32602,
+            message: "Invalid parameters",
+            data: error.errors
+          }
+        };
+      }
+      const message = error instanceof Error ? error.message : "Tool execution failed";
+      return {
+        jsonrpc: "2.0",
+        id,
+        result: {
+          content: [{ type: "text", text: `Error: ${message}` }],
+          isError: true
+        }
+      };
+    }
+  }
+  zodToJsonSchema(schema) {
+    if (schema instanceof z.ZodObject) {
+      const shape = schema.shape;
+      const properties = {};
+      const required = [];
+      for (const [key, value] of Object.entries(shape)) {
+        properties[key] = this.zodToJsonSchema(value);
+        if (!value.isOptional()) {
+          required.push(key);
+        }
+      }
+      return {
+        type: "object",
+        properties,
+        required: required.length > 0 ? required : void 0
+      };
+    }
+    if (schema instanceof z.ZodString) {
+      return { type: "string" };
+    }
+    if (schema instanceof z.ZodNumber) {
+      return { type: "number" };
+    }
+    if (schema instanceof z.ZodBoolean) {
+      return { type: "boolean" };
+    }
+    if (schema instanceof z.ZodArray) {
+      return {
+        type: "array",
+        items: this.zodToJsonSchema(schema.element)
+      };
+    }
+    if (schema instanceof z.ZodOptional) {
+      return this.zodToJsonSchema(schema.unwrap());
+    }
+    if (schema instanceof z.ZodEnum) {
+      return {
+        type: "string",
+        enum: schema.options
+      };
+    }
+    return { type: "object" };
+  }
+  // STDIO transport
+  async runStdio() {
+    const readline = await import("readline");
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      terminal: false
+    });
+    rl.on("line", async (line) => {
+      try {
+        const request = JSON.parse(line);
+        const response = await this.handleRequest(request);
+        console.log(JSON.stringify(response));
+      } catch (error) {
+        const errorResponse = {
+          jsonrpc: "2.0",
+          id: 0,
+          error: { code: -32700, message: "Parse error" }
+        };
+        console.log(JSON.stringify(errorResponse));
+      }
+    });
+    rl.on("close", () => {
+      process.exit(0);
+    });
+  }
+};
+function createTextResult(text) {
+  return {
+    content: [{ type: "text", text }]
+  };
+}
+function createErrorResult(message) {
+  return {
+    content: [{ type: "text", text: `Error: ${message}` }],
+    isError: true
+  };
+}
+function createJsonResult(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+}
+var mcpServer = new MCPServer();
+
+export {
+  MCPServer,
+  createTextResult,
+  createErrorResult,
+  createJsonResult,
+  mcpServer
+};