morphbox/build/server/chunks/_server.ts-BKjJ8gDG.js

Docker-based AI sandbox for development with Claude integration

import { j as json } from './index-3BbzJtgI.js';
import { access, readFile } from 'fs/promises';
import { join } from 'path';
import { homedir } from 'os';
import { v as validateMorphFile } from './morph-f-EPjDPR.js';

const PANELS_DIR = join(homedir(), "morphbox", "panels");
function parseEmbeddedMetadata(source, id) {
  const metadataRegex = /<!--\s*@morphbox-panel\s*([\s\S]*?)-->/;
  const match = source.match(metadataRegex);
  if (!match) return null;
  try {
    const metadataText = match[1];
    const metadata = { id };
    const lines = metadataText.split("\n");
    for (const line of lines) {
      const colonIndex = line.indexOf(":");
      if (colonIndex === -1) continue;
      const key = line.substring(0, colonIndex).trim();
      const value = line.substring(colonIndex + 1).trim();
      if (!key) continue;
      if (value.startsWith("[") && value.endsWith("]")) {
        metadata[key] = value.slice(1, -1).split(",").map((v) => v.trim().replace(/['"]/g, ""));
      } else if (value.startsWith("{") && value.endsWith("}")) {
        try {
          metadata[key] = JSON.parse(value);
        } catch {
          metadata[key] = value;
        }
      } else if (value === "true" || value === "false") {
        metadata[key] = value === "true";
      } else if (!isNaN(Number(value))) {
        metadata[key] = Number(value);
      } else {
        metadata[key] = value.replace(/['"]/g, "");
      }
    }
    metadata.description = metadata.description || "";
    metadata.features = metadata.features || [];
    metadata.version = metadata.version || "1.0.0";
    metadata.createdAt = (/* @__PURE__ */ new Date()).toISOString();
    return metadata;
  } catch (error) {
    console.error("Failed to parse embedded panel metadata:", error);
    return null;
  }
}
const GET = async ({ params }) => {
  try {
    const { id } = params;
    if (!id) {
      return json({ error: "Panel ID is required" }, { status: 400 });
    }
    const morphPath = join(PANELS_DIR, `${id}.morph`);
    try {
      await access(morphPath);
      const morphContent = await readFile(morphPath, "utf-8");
      const morphData = JSON.parse(morphContent);
      if (validateMorphFile(morphData)) {
        return json({
          ...morphData.metadata,
          createdAt: morphData.createdAt,
          updatedAt: morphData.updatedAt,
          promptHistory: morphData.promptHistory
        });
      } else {
        console.error("Invalid .morph file format");
      }
    } catch (morphError) {
    }
    const metadataPath = join(PANELS_DIR, `${id}.json`);
    try {
      await access(metadataPath);
      const metadataContent = await readFile(metadataPath, "utf-8");
      const metadata = JSON.parse(metadataContent);
      return json(metadata);
    } catch (jsonError) {
      const svelteFilePath = join(PANELS_DIR, `${id}.svelte`);
      try {
        await access(svelteFilePath);
        const svelteContent = await readFile(svelteFilePath, "utf-8");
        const embeddedMetadata = parseEmbeddedMetadata(svelteContent, id);
        if (embeddedMetadata) {
          return json(embeddedMetadata);
        } else {
          return json({ error: "No valid metadata found in panel file" }, { status: 404 });
        }
      } catch (svelteError) {
        return json({ error: "Panel metadata not found" }, { status: 404 });
      }
    }
  } catch (error) {
    console.error("Failed to get panel metadata:", error);
    return json({
      error: error instanceof Error ? error.message : "Failed to get metadata"
    }, { status: 500 });
  }
};

export { GET };
//# sourceMappingURL=_server.ts-BKjJ8gDG.js.map