@willjackson/claude-code-bridge 0.2.4 → 0.4.1

package/dist/{chunk-5HWFDZKH.js → chunk-MHUQYPTB.js}

@@ -1,7 +1,7 @@
 // src/utils/logger.ts
 import pino from "pino";
-function isDevelopment() {
-  return process.env.NODE_ENV !== "production";
+function usePrettyPrint() {
+  return process.env.NODE_ENV === "development";
 }
 function getDefaultLevel() {
   const envLevel = process.env.LOG_LEVEL?.toLowerCase();
@@ -17,7 +17,7 @@ function createLogger(name, level) {
     name,
     level: logLevel
   };
-  if (isDevelopment()) {
+  if (usePrettyPrint()) {
     options.transport = {
       target: "pino-pretty",
       options: {
@@ -1613,350 +1613,6 @@ var Bridge = class {
   }
 };
 
-// src/transport/discovery.ts
-import { execSync } from "child_process";
-var logger3 = createLogger("transport:discovery");
-function parseDockerLabels(labels) {
-  if (!labels) {
-    return null;
-  }
-  const labelMap = {};
-  for (const label of labels.split(",")) {
-    const [key, value] = label.split("=");
-    if (key && value) {
-      labelMap[key.trim()] = value.trim();
-    }
-  }
-  if (labelMap["claude.bridge.enabled"] !== "true") {
-    return null;
-  }
-  return {
-    enabled: true,
-    port: labelMap["claude.bridge.port"] ? parseInt(labelMap["claude.bridge.port"], 10) : void 0,
-    name: labelMap["claude.bridge.name"]
-  };
-}
-function isDockerAvailable() {
-  try {
-    execSync("docker info", { stdio: "pipe", timeout: 5e3 });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function discoverDockerPeers() {
-  const peers = [];
-  if (!isDockerAvailable()) {
-    logger3.debug("Docker is not available");
-    return peers;
-  }
-  try {
-    const output = execSync(
-      'docker ps --format "{{.ID}}|{{.Names}}|{{.Labels}}|{{.Status}}|{{.Ports}}"',
-      {
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"],
-        timeout: 1e4
-      }
-    );
-    const lines = output.trim().split("\n").filter(Boolean);
-    for (const line of lines) {
-      const [id, names, labels, status, ports] = line.split("|");
-      if (!id || !names) continue;
-      const bridgeConfig = parseDockerLabels(labels);
-      if (!bridgeConfig) continue;
-      let port = bridgeConfig.port;
-      if (!port && ports) {
-        const portMatch = ports.match(/0\.0\.0\.0:(\d+)/);
-        if (portMatch) {
-          port = parseInt(portMatch[1], 10);
-        }
-      }
-      if (port) {
-        peers.push({
-          name: bridgeConfig.name || names,
-          source: "docker",
-          url: `ws://localhost:${port}`,
-          containerId: id,
-          status
-        });
-        logger3.debug(
-          { containerId: id, name: bridgeConfig.name || names, port },
-          "Found bridge-enabled container"
-        );
-      }
-    }
-  } catch (error) {
-    logger3.debug(
-      { error: error.message },
-      "Failed to discover Docker peers"
-    );
-  }
-  return peers;
-}
-function discoverDocksalProjects() {
-  const peers = [];
-  try {
-    execSync("which fin", { stdio: "pipe" });
-    const output = execSync('fin project list 2>/dev/null || echo ""', {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 1e4
-    });
-    const lines = output.trim().split("\n").filter(Boolean);
-    for (const line of lines) {
-      if (line.includes("NAME") || line.startsWith("-")) continue;
-      const parts = line.trim().split(/\s+/);
-      const projectName = parts[0];
-      const status = parts.slice(1).join(" ");
-      if (projectName && status.toLowerCase().includes("running")) {
-        peers.push({
-          name: projectName,
-          source: "docksal",
-          url: `ws://${projectName}.docksal:8765`,
-          status: "running"
-        });
-        logger3.debug({ projectName }, "Found Docksal project");
-      }
-    }
-  } catch (error) {
-    logger3.debug(
-      { error: error.message },
-      "Docksal not available or no projects found"
-    );
-  }
-  return peers;
-}
-function discoverDdevProjects() {
-  const peers = [];
-  try {
-    execSync("which ddev", { stdio: "pipe" });
-    const output = execSync('ddev list --json-output 2>/dev/null || echo "[]"', {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 1e4
-    });
-    try {
-      const data = JSON.parse(output);
-      const projects = data.raw || [];
-      for (const project of projects) {
-        if (project.status === "running") {
-          peers.push({
-            name: project.name,
-            source: "ddev",
-            url: `ws://${project.name}.ddev.site:8765`,
-            status: "running"
-          });
-          logger3.debug({ projectName: project.name }, "Found DDEV project");
-        }
-      }
-    } catch {
-      logger3.debug("Failed to parse DDEV JSON output, trying text parsing");
-      const lines = output.trim().split("\n").filter(Boolean);
-      for (const line of lines) {
-        if (line.includes("running")) {
-          const parts = line.trim().split(/\s+/);
-          if (parts[0]) {
-            peers.push({
-              name: parts[0],
-              source: "ddev",
-              url: `ws://${parts[0]}.ddev.site:8765`,
-              status: "running"
-            });
-          }
-        }
-      }
-    }
-  } catch (error) {
-    logger3.debug(
-      { error: error.message },
-      "DDEV not available or no projects found"
-    );
-  }
-  return peers;
-}
-function discoverLandoProjects() {
-  const peers = [];
-  try {
-    execSync("which lando", { stdio: "pipe" });
-    const output = execSync('lando list --format json 2>/dev/null || echo "[]"', {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 1e4
-    });
-    try {
-      const apps = JSON.parse(output);
-      for (const app of apps) {
-        if (app.running) {
-          peers.push({
-            name: app.app || app.name,
-            source: "lando",
-            url: `ws://localhost:8765`,
-            // Would need to check app config for actual port
-            status: "running"
-          });
-          logger3.debug({ appName: app.app || app.name }, "Found Lando app");
-        }
-      }
-    } catch {
-      logger3.debug("Failed to parse Lando JSON output");
-    }
-  } catch (error) {
-    logger3.debug(
-      { error: error.message },
-      "Lando not available or no projects found"
-    );
-  }
-  return peers;
-}
-function discoverAllPeers() {
-  const allPeers = [];
-  const dockerPeers = discoverDockerPeers();
-  allPeers.push(...dockerPeers);
-  logger3.debug({ count: dockerPeers.length }, "Docker peers discovered");
-  const docksalPeers = discoverDocksalProjects();
-  allPeers.push(...docksalPeers);
-  logger3.debug({ count: docksalPeers.length }, "Docksal peers discovered");
-  const ddevPeers = discoverDdevProjects();
-  allPeers.push(...ddevPeers);
-  logger3.debug({ count: ddevPeers.length }, "DDEV peers discovered");
-  const landoPeers = discoverLandoProjects();
-  allPeers.push(...landoPeers);
-  logger3.debug({ count: landoPeers.length }, "Lando peers discovered");
-  return allPeers;
-}
-
-// src/environment/detect.ts
-import { existsSync as existsSync2 } from "fs";
-function isInDocker() {
-  return existsSync2("/.dockerenv");
-}
-function isDocksalEnvironment() {
-  return !!process.env.DOCKSAL_STACK;
-}
-function isDdevEnvironment() {
-  return process.env.IS_DDEV_PROJECT === "true";
-}
-function isLandoEnvironment() {
-  return process.env.LANDO === "ON";
-}
-function isDockerComposeEnvironment() {
-  return !!process.env.COMPOSE_PROJECT_NAME;
-}
-function detectEnvironment() {
-  const platform = process.platform;
-  const inDocker = isInDocker();
-  if (isDocksalEnvironment()) {
-    return {
-      type: "docksal",
-      isContainer: true,
-      projectName: process.env.DOCKSAL_PROJECT,
-      projectRoot: process.env.PROJECT_ROOT,
-      hostGateway: getHostGateway(),
-      platform,
-      meta: {
-        stack: process.env.DOCKSAL_STACK || "",
-        environment: process.env.DOCKSAL_ENVIRONMENT || ""
-      }
-    };
-  }
-  if (isDdevEnvironment()) {
-    return {
-      type: "ddev",
-      isContainer: true,
-      projectName: process.env.DDEV_PROJECT,
-      projectRoot: process.env.DDEV_DOCROOT,
-      hostGateway: getHostGateway(),
-      platform,
-      meta: {
-        hostname: process.env.DDEV_HOSTNAME || "",
-        primaryUrl: process.env.DDEV_PRIMARY_URL || ""
-      }
-    };
-  }
-  if (isLandoEnvironment()) {
-    return {
-      type: "lando",
-      isContainer: true,
-      projectName: process.env.LANDO_APP_NAME,
-      projectRoot: process.env.LANDO_APP_ROOT,
-      hostGateway: getHostGateway(),
-      platform,
-      meta: {
-        service: process.env.LANDO_SERVICE_NAME || "",
-        type: process.env.LANDO_SERVICE_TYPE || ""
-      }
-    };
-  }
-  if (isDockerComposeEnvironment() && inDocker) {
-    return {
-      type: "docker-compose",
-      isContainer: true,
-      projectName: process.env.COMPOSE_PROJECT_NAME,
-      hostGateway: getHostGateway(),
-      platform,
-      meta: {
-        service: process.env.COMPOSE_SERVICE || ""
-      }
-    };
-  }
-  if (inDocker) {
-    return {
-      type: "docker",
-      isContainer: true,
-      hostGateway: getHostGateway(),
-      platform
-    };
-  }
-  return {
-    type: "native",
-    isContainer: false,
-    platform
-  };
-}
-function getHostGateway() {
-  if (process.env.DOCKER_HOST_GATEWAY) {
-    return process.env.DOCKER_HOST_GATEWAY;
-  }
-  if (process.platform === "darwin" || process.platform === "win32") {
-    return "host.docker.internal";
-  }
-  if (isInDocker()) {
-    return "host.docker.internal";
-  }
-  return "localhost";
-}
-function getDefaultConfig(env) {
-  const baseConfig = {
-    mode: "peer",
-    instanceName: env.projectName || `${env.type}-instance`
-  };
-  if (env.isContainer) {
-    return {
-      ...baseConfig,
-      listen: {
-        port: 8765,
-        host: "0.0.0.0"
-      },
-      connect: {
-        url: `ws://${env.hostGateway || "host.docker.internal"}:8766`,
-        hostGateway: true
-      }
-    };
-  }
-  return {
-    ...baseConfig,
-    listen: {
-      port: 8766,
-      host: "0.0.0.0"
-    },
-    connect: {
-      url: "ws://localhost:8765",
-      hostGateway: false
-    }
-  };
-}
-
 // src/utils/config.ts
 import * as fs2 from "fs";
 import * as path2 from "path";
@@ -2061,6 +1717,406 @@ function loadConfigSync(configPath) {
   return { ...DEFAULT_CONFIG };
 }
 
+// src/mcp/tools.ts
+import { z as z2 } from "zod";
+var logger3 = createLogger("mcp:tools");
+var ReadFileInputSchema = z2.object({
+  path: z2.string().describe("Path to the file to read")
+});
+var WriteFileInputSchema = z2.object({
+  path: z2.string().describe("Path to the file to write"),
+  content: z2.string().describe("Content to write to the file")
+});
+var DeleteFileInputSchema = z2.object({
+  path: z2.string().describe("Path to the file to delete")
+});
+var ListDirectoryInputSchema = z2.object({
+  path: z2.string().describe("Path to the directory to list")
+});
+var DelegateTaskInputSchema = z2.object({
+  description: z2.string().describe("Description of the task to delegate"),
+  scope: z2.enum(["execute", "analyze", "suggest"]).describe("Task scope"),
+  data: z2.record(z2.unknown()).optional().describe("Additional task data")
+});
+var RequestContextInputSchema = z2.object({
+  query: z2.string().describe("Query describing what files to retrieve")
+});
+var TOOL_DEFINITIONS = [
+  {
+    name: "bridge_read_file",
+    description: "Read a file from the remote connected instance",
+    inputSchema: ReadFileInputSchema
+  },
+  {
+    name: "bridge_write_file",
+    description: "Write a file to the remote connected instance",
+    inputSchema: WriteFileInputSchema
+  },
+  {
+    name: "bridge_delete_file",
+    description: "Delete a file on the remote connected instance",
+    inputSchema: DeleteFileInputSchema
+  },
+  {
+    name: "bridge_list_directory",
+    description: "List files and folders in a directory on the remote connected instance",
+    inputSchema: ListDirectoryInputSchema
+  },
+  {
+    name: "bridge_delegate_task",
+    description: "Delegate a custom task to the remote connected instance",
+    inputSchema: DelegateTaskInputSchema
+  },
+  {
+    name: "bridge_request_context",
+    description: "Request files matching a query from the remote connected instance",
+    inputSchema: RequestContextInputSchema
+  },
+  {
+    name: "bridge_status",
+    description: "Get bridge status and connected peers",
+    inputSchema: z2.object({})
+  }
+];
+function createToolHandlers(bridge) {
+  const handlers = {};
+  function errorResponse(message) {
+    return {
+      content: [{ type: "text", text: `Error: ${message}` }],
+      isError: true
+    };
+  }
+  function successResponse(text) {
+    return {
+      content: [{ type: "text", text }]
+    };
+  }
+  async function delegateFileTask(action, data, description) {
+    const taskId = `mcp-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+    return bridge.delegateTask({
+      id: taskId,
+      description,
+      scope: "execute",
+      data: { action, ...data }
+    });
+  }
+  handlers["bridge_read_file"] = async (args) => {
+    const input = ReadFileInputSchema.parse(args);
+    logger3.debug({ path: input.path }, "Reading file");
+    try {
+      const result = await delegateFileTask(
+        "read_file",
+        { path: input.path },
+        `Read file: ${input.path}`
+      );
+      if (!result.success) {
+        return errorResponse(result.error || "Failed to read file");
+      }
+      return successResponse(result.data.content);
+    } catch (err) {
+      logger3.error({ error: err.message, path: input.path }, "Failed to read file");
+      return errorResponse(err.message);
+    }
+  };
+  handlers["bridge_write_file"] = async (args) => {
+    const input = WriteFileInputSchema.parse(args);
+    logger3.debug({ path: input.path, contentLength: input.content.length }, "Writing file");
+    try {
+      const result = await delegateFileTask(
+        "write_file",
+        { path: input.path, content: input.content },
+        `Write file: ${input.path}`
+      );
+      if (!result.success) {
+        return errorResponse(result.error || "Failed to write file");
+      }
+      return successResponse(`File written successfully: ${input.path} (${result.data.bytesWritten} bytes)`);
+    } catch (err) {
+      logger3.error({ error: err.message, path: input.path }, "Failed to write file");
+      return errorResponse(err.message);
+    }
+  };
+  handlers["bridge_delete_file"] = async (args) => {
+    const input = DeleteFileInputSchema.parse(args);
+    logger3.debug({ path: input.path }, "Deleting file");
+    try {
+      const result = await delegateFileTask(
+        "delete_file",
+        { path: input.path },
+        `Delete file: ${input.path}`
+      );
+      if (!result.success) {
+        return errorResponse(result.error || "Failed to delete file");
+      }
+      return successResponse(`File deleted successfully: ${input.path}`);
+    } catch (err) {
+      logger3.error({ error: err.message, path: input.path }, "Failed to delete file");
+      return errorResponse(err.message);
+    }
+  };
+  handlers["bridge_list_directory"] = async (args) => {
+    const input = ListDirectoryInputSchema.parse(args);
+    logger3.debug({ path: input.path }, "Listing directory");
+    try {
+      const result = await delegateFileTask(
+        "list_directory",
+        { path: input.path },
+        `List directory: ${input.path}`
+      );
+      if (!result.success) {
+        return errorResponse(result.error || "Failed to list directory");
+      }
+      const entries = result.data.entries;
+      if (!entries || entries.length === 0) {
+        return successResponse(`Directory is empty: ${input.path}`);
+      }
+      const listing = entries.map((e) => `${e.type === "directory" ? "\u{1F4C1}" : "\u{1F4C4}"} ${e.name}`).join("\n");
+      return successResponse(`Contents of ${input.path}:
+${listing}`);
+    } catch (err) {
+      logger3.error({ error: err.message, path: input.path }, "Failed to list directory");
+      return errorResponse(err.message);
+    }
+  };
+  handlers["bridge_delegate_task"] = async (args) => {
+    const input = DelegateTaskInputSchema.parse(args);
+    logger3.debug({ description: input.description, scope: input.scope }, "Delegating task");
+    try {
+      const taskId = `mcp-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+      const result = await bridge.delegateTask({
+        id: taskId,
+        description: input.description,
+        scope: input.scope,
+        data: input.data
+      });
+      if (!result.success) {
+        return errorResponse(result.error || "Task failed");
+      }
+      return successResponse(JSON.stringify(result.data, null, 2));
+    } catch (err) {
+      logger3.error({ error: err.message }, "Failed to delegate task");
+      return errorResponse(err.message);
+    }
+  };
+  handlers["bridge_request_context"] = async (args) => {
+    const input = RequestContextInputSchema.parse(args);
+    logger3.debug({ query: input.query }, "Requesting context");
+    try {
+      const files = await bridge.requestContext(input.query);
+      if (files.length === 0) {
+        return successResponse("No files found matching the query.");
+      }
+      const fileResults = files.map((f) => {
+        const header = `=== ${f.path} ===`;
+        const content = f.content;
+        return `${header}
+${content}`;
+      }).join("\n\n");
+      return successResponse(`Found ${files.length} file(s):
+
+${fileResults}`);
+    } catch (err) {
+      logger3.error({ error: err.message }, "Failed to request context");
+      return errorResponse(err.message);
+    }
+  };
+  handlers["bridge_status"] = async () => {
+    logger3.debug("Getting bridge status");
+    const peers = bridge.getPeers();
+    const peerCount = bridge.getPeerCount();
+    const isStarted = bridge.isStarted();
+    const mode = bridge.getMode();
+    const instanceName = bridge.getInstanceName();
+    const status = {
+      instanceName,
+      mode,
+      started: isStarted,
+      peerCount,
+      peers: peers.map((p) => ({
+        id: p.id,
+        name: p.name,
+        connectedAt: new Date(p.connectedAt).toISOString(),
+        lastActivity: new Date(p.lastActivity).toISOString()
+      }))
+    };
+    return successResponse(JSON.stringify(status, null, 2));
+  };
+  return handlers;
+}
+function zodToJsonSchema(schema) {
+  if (schema instanceof z2.ZodObject) {
+    const shape = schema.shape;
+    const properties = {};
+    const required = [];
+    for (const [key, value] of Object.entries(shape)) {
+      const zodValue = value;
+      properties[key] = zodToJsonSchema(zodValue);
+      if (!(zodValue instanceof z2.ZodOptional)) {
+        required.push(key);
+      }
+    }
+    return {
+      type: "object",
+      properties,
+      ...required.length > 0 ? { required } : {}
+    };
+  }
+  if (schema instanceof z2.ZodString) {
+    const result = { type: "string" };
+    if (schema.description) {
+      result.description = schema.description;
+    }
+    return result;
+  }
+  if (schema instanceof z2.ZodEnum) {
+    return {
+      type: "string",
+      enum: schema.options
+    };
+  }
+  if (schema instanceof z2.ZodOptional) {
+    return zodToJsonSchema(schema.unwrap());
+  }
+  if (schema instanceof z2.ZodRecord) {
+    return {
+      type: "object",
+      additionalProperties: true
+    };
+  }
+  if (schema instanceof z2.ZodUnknown) {
+    return {};
+  }
+  return { type: "string" };
+}
+
+// src/mcp/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+var logger4 = createLogger("mcp:server");
+var BridgeMcpServer = class {
+  server;
+  bridge;
+  config;
+  toolHandlers = null;
+  constructor(config) {
+    this.config = config;
+    this.server = new Server(
+      {
+        name: config.name ?? "claude-bridge",
+        version: config.version ?? "0.4.0"
+      },
+      {
+        capabilities: {
+          tools: {}
+        }
+      }
+    );
+    const bridgeConfig = {
+      mode: "client",
+      instanceName: config.instanceName ?? `mcp-server-${process.pid}`,
+      connect: {
+        url: config.bridgeUrl
+      },
+      taskTimeout: config.taskTimeout ?? 6e4
+    };
+    this.bridge = new Bridge(bridgeConfig);
+    this.registerHandlers();
+  }
+  /**
+   * Register MCP request handlers
+   */
+  registerHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      logger4.debug("Listing tools");
+      return {
+        tools: TOOL_DEFINITIONS.map((tool) => ({
+          name: tool.name,
+          description: tool.description,
+          inputSchema: zodToJsonSchema(tool.inputSchema)
+        }))
+      };
+    });
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+      logger4.debug({ tool: name }, "Tool call received");
+      if (!this.toolHandlers) {
+        this.toolHandlers = createToolHandlers(this.bridge);
+      }
+      const handler = this.toolHandlers[name];
+      if (!handler) {
+        logger4.warn({ tool: name }, "Unknown tool requested");
+        return {
+          content: [{ type: "text", text: `Unknown tool: ${name}` }],
+          isError: true
+        };
+      }
+      try {
+        const result = await handler(args ?? {});
+        logger4.debug({ tool: name, isError: result.isError }, "Tool call completed");
+        return {
+          content: result.content,
+          isError: result.isError
+        };
+      } catch (err) {
+        logger4.error({ tool: name, error: err.message }, "Tool call failed");
+        return {
+          content: [{ type: "text", text: `Error: ${err.message}` }],
+          isError: true
+        };
+      }
+    });
+  }
+  /**
+   * Start the MCP server
+   * Connects to bridge daemon and starts listening on stdio
+   */
+  async start() {
+    console.error("[MCP] Starting bridge MCP server...");
+    console.error(`[MCP] Connecting to bridge at ${this.config.bridgeUrl}`);
+    try {
+      await this.bridge.start();
+      console.error("[MCP] Connected to bridge daemon");
+      this.toolHandlers = createToolHandlers(this.bridge);
+      const transport = new StdioServerTransport();
+      await this.server.connect(transport);
+      console.error("[MCP] MCP server started and listening on stdio");
+      logger4.info("MCP server started");
+    } catch (err) {
+      console.error(`[MCP] Failed to start: ${err.message}`);
+      throw err;
+    }
+  }
+  /**
+   * Stop the MCP server
+   */
+  async stop() {
+    console.error("[MCP] Stopping MCP server...");
+    try {
+      await this.bridge.stop();
+      await this.server.close();
+      console.error("[MCP] MCP server stopped");
+      logger4.info("MCP server stopped");
+    } catch (err) {
+      console.error(`[MCP] Error during shutdown: ${err.message}`);
+    }
+  }
+  /**
+   * Get the bridge instance
+   */
+  getBridge() {
+    return this.bridge;
+  }
+};
+async function startMcpServer(config) {
+  const server = new BridgeMcpServer(config);
+  await server.start();
+  return server;
+}
+
 export {
   createLogger,
   createChildLogger,
@@ -2086,19 +2142,13 @@ export {
   createContextRequestMessage,
   createNotificationMessage,
   Bridge,
-  parseDockerLabels,
-  isDockerAvailable,
-  discoverDockerPeers,
-  discoverDocksalProjects,
-  discoverDdevProjects,
-  discoverLandoProjects,
-  discoverAllPeers,
-  detectEnvironment,
-  getHostGateway,
-  getDefaultConfig,
   DEFAULT_CONFIG,
   mergeConfig,
   loadConfig,
-  loadConfigSync
+  loadConfigSync,
+  TOOL_DEFINITIONS,
+  createToolHandlers,
+  BridgeMcpServer,
+  startMcpServer
 };
-//# sourceMappingURL=chunk-5HWFDZKH.js.map
+//# sourceMappingURL=chunk-MHUQYPTB.js.map