pixelmuse 0.2.0

package/dist/cli.js

@@ -0,0 +1,531 @@
+#!/usr/bin/env node
+import {
+  generateImage
+} from "./chunk-743CKPHW.js";
+import {
+  PixelmuseClient,
+  deleteApiKey,
+  extractVariables,
+  getApiKey,
+  getTemplate,
+  interpolate,
+  isValidKeyFormat,
+  listTemplates,
+  saveApiKey,
+  saveTemplate,
+  slugify
+} from "./chunk-ZVJQFWUI.js";
+import {
+  renderImageDirect
+} from "./chunk-MZZY4JXW.js";
+import {
+  readSettings
+} from "./chunk-7ARYEFAH.js";
+
+// src/cli.ts
+import meow from "meow";
+import chalk from "chalk";
+import ora from "ora";
+import { readFileSync, watchFile, unwatchFile } from "fs";
+import { resolve } from "path";
+
+// src/core/utils.ts
+function timeAgo(date) {
+  const seconds = Math.floor((Date.now() - date.getTime()) / 1e3);
+  if (seconds < 60) return "just now";
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ago`;
+  if (seconds < 604800) return `${Math.floor(seconds / 86400)}d ago`;
+  return date.toLocaleDateString();
+}
+
+// src/cli.ts
+var cli = meow(
+  `
+  ${chalk.bold("Usage")}
+    $ pixelmuse "prompt"                     Generate with defaults
+    $ pixelmuse "prompt" -o hero.png         Save to specific path
+    $ pixelmuse "prompt" -m nano-banana-pro  Choose model
+    $ pixelmuse --json "prompt"              Machine-readable output
+    $ echo "prompt" | pixelmuse             Pipe from stdin
+
+  ${chalk.bold("Commands")}
+    pixelmuse models                         List available models
+    pixelmuse account                        View balance & usage
+    pixelmuse history                        Recent generations
+    pixelmuse open <id>                      Open generation in viewer
+    pixelmuse login                          Authenticate
+    pixelmuse logout                         Remove credentials
+    pixelmuse ui                             Launch interactive TUI
+    pixelmuse template <list|use|init|show>  Manage prompt templates
+
+  ${chalk.bold("Options")}
+    -m, --model          Model ID (default: nano-banana-2)
+    -a, --aspect-ratio   Aspect ratio (default: 1:1)
+    -s, --style          Style: realistic, anime, artistic, none
+    -o, --output         Output file path
+    --json               Output JSON (for scripting)
+    --no-preview         Skip image preview
+    --open               Open result in system viewer
+    --watch <file>       Watch a prompt file and regenerate on save
+    --no-save            Don't save image to disk
+    --clipboard          Copy image to clipboard
+    -h, --help           Show this help
+    -v, --version        Show version
+
+  ${chalk.bold("Examples")}
+    $ pixelmuse "astronaut riding a horse"
+    $ pixelmuse "app icon, minimal" -a 1:1 -o icon.png
+    $ pixelmuse --watch prompt.txt -o output.png
+    $ pixelmuse template use blog-thumbnail --var subject="React hooks"
+`,
+  {
+    importMeta: import.meta,
+    flags: {
+      model: { type: "string", shortFlag: "m" },
+      aspectRatio: { type: "string", shortFlag: "a" },
+      style: { type: "string", shortFlag: "s" },
+      output: { type: "string", shortFlag: "o" },
+      json: { type: "boolean", default: false },
+      preview: { type: "boolean", default: true },
+      open: { type: "boolean", default: false },
+      watch: { type: "string" },
+      save: { type: "boolean", default: true },
+      clipboard: { type: "boolean", default: false },
+      var: { type: "string", isMultiple: true }
+    }
+  }
+);
+var [subcommand, ...rest] = cli.input;
+async function readStdin() {
+  if (process.stdin.isTTY) return null;
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8").trim() || null;
+}
+async function requireClient() {
+  const key = await getApiKey();
+  if (!key) {
+    console.error(chalk.red("Not authenticated. Run: pixelmuse login"));
+    process.exit(1);
+  }
+  return new PixelmuseClient(key);
+}
+async function copyToClipboard(imagePath) {
+  const { execSync } = await import("child_process");
+  try {
+    if (process.platform === "darwin") {
+      execSync(`osascript -e 'set the clipboard to (read (POSIX file "${imagePath}") as TIFF picture)'`);
+    } else {
+      execSync(`xclip -selection clipboard -t image/png -i "${imagePath}"`);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function handleGenerate(prompt) {
+  const client = await requireClient();
+  const settings = readSettings();
+  const model = cli.flags.model ?? settings.defaultModel;
+  const aspectRatio = cli.flags.aspectRatio ?? settings.defaultAspectRatio;
+  const style = cli.flags.style ?? settings.defaultStyle;
+  let balance = null;
+  let creditCost = null;
+  try {
+    const [account, models] = await Promise.all([
+      client.getAccount(),
+      PixelmuseClient.listModels()
+    ]);
+    balance = account.credits.total;
+    creditCost = models.find((m) => m.id === model)?.credit_cost ?? null;
+  } catch {
+  }
+  if (cli.flags.json) {
+    try {
+      const result = await generateImage(client, {
+        prompt,
+        model,
+        aspectRatio,
+        style,
+        output: cli.flags.output,
+        noSave: !cli.flags.save
+      });
+      console.log(
+        JSON.stringify({
+          id: result.generation.id,
+          status: result.generation.status,
+          model: result.generation.model,
+          prompt: result.generation.prompt,
+          credits_charged: result.generation.credits_charged,
+          elapsed_seconds: Math.round(result.elapsed * 10) / 10,
+          output_path: result.imagePath
+        })
+      );
+    } catch (err) {
+      console.error(JSON.stringify({ error: err instanceof Error ? err.message : "Generation failed" }));
+      process.exit(1);
+    }
+    return;
+  }
+  const costStr = creditCost !== null ? `${creditCost} credit${creditCost > 1 ? "s" : ""}` : "";
+  const balStr = balance !== null ? ` (balance: ${balance})` : "";
+  const spinner = ora(`${chalk.bold(model)} \xB7 ${costStr}${balStr} \u2014 generating...`).start();
+  try {
+    const result = await generateImage(client, {
+      prompt,
+      model,
+      aspectRatio,
+      style,
+      output: cli.flags.output,
+      noSave: !cli.flags.save,
+      onProgress: (elapsed) => {
+        spinner.text = `${chalk.bold(model)} \xB7 ${costStr}${balStr} \u2014 generating... ${chalk.gray(`${elapsed.toFixed(1)}s`)}`;
+      }
+    });
+    const charged = result.generation.credits_charged;
+    const remaining = balance !== null ? balance - charged : null;
+    const remainStr = remaining !== null ? ` (remaining: ${remaining})` : "";
+    spinner.succeed(
+      `Generated in ${result.elapsed.toFixed(1)}s \xB7 ${charged} credit${charged > 1 ? "s" : ""} charged${remainStr}`
+    );
+    if (result.imagePath) {
+      console.log(chalk.gray(`  Saved to ${result.imagePath}`));
+    }
+    if (cli.flags.preview && result.imagePath) {
+      const previewed = renderImageDirect(result.imagePath);
+      if (!previewed) console.log(chalk.gray("  Install chafa for terminal image preview"));
+    }
+    if (cli.flags.clipboard && result.imagePath) {
+      const ok = await copyToClipboard(result.imagePath);
+      if (ok) console.log(chalk.gray("  Copied to clipboard"));
+    }
+    if (cli.flags.open && result.imagePath) {
+      const { default: open } = await import("open");
+      await open(result.imagePath);
+    }
+  } catch (err) {
+    spinner.fail(err instanceof Error ? err.message : "Generation failed");
+    process.exit(1);
+  }
+}
+async function handleWatch(filePath) {
+  const absPath = resolve(filePath);
+  const client = await requireClient();
+  const settings = readSettings();
+  console.log(chalk.cyan(`Watching ${absPath} for changes... (Ctrl+C to stop)`));
+  let generating = false;
+  const generate = async () => {
+    if (generating) return;
+    generating = true;
+    const prompt = readFileSync(absPath, "utf-8").trim();
+    if (!prompt) {
+      generating = false;
+      return;
+    }
+    const model = cli.flags.model ?? settings.defaultModel;
+    const aspectRatio = cli.flags.aspectRatio ?? settings.defaultAspectRatio;
+    const style = cli.flags.style ?? settings.defaultStyle;
+    const time = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false });
+    const spinner = ora(`[${time}] Generating... (${model})`).start();
+    try {
+      const result = await generateImage(client, {
+        prompt,
+        model,
+        aspectRatio,
+        style,
+        output: cli.flags.output
+      });
+      spinner.succeed(`[${time}] Saved to ${result.imagePath} (${result.elapsed.toFixed(1)}s)`);
+    } catch (err) {
+      spinner.fail(`[${time}] ${err instanceof Error ? err.message : "Failed"}`);
+    }
+    generating = false;
+  };
+  await generate();
+  watchFile(absPath, { interval: 500 }, generate);
+  process.on("SIGINT", () => {
+    unwatchFile(absPath);
+    console.log(chalk.gray("\nStopped watching."));
+    process.exit(0);
+  });
+  await new Promise(() => {
+  });
+}
+async function handleModels() {
+  const spinner = ora("Loading models...").start();
+  try {
+    const models = await PixelmuseClient.listModels();
+    spinner.stop();
+    const nameW = 22;
+    const costW = 10;
+    console.log(
+      chalk.bold("Model".padEnd(nameW)) + chalk.bold("Credits".padEnd(costW)) + chalk.bold("Best For")
+    );
+    console.log(chalk.gray("\u2500".repeat(70)));
+    for (const m of models) {
+      const cost = m.credit_cost > 1 ? chalk.yellow(String(m.credit_cost)) : chalk.green(String(m.credit_cost));
+      console.log(
+        m.name.padEnd(nameW) + cost.padEnd(costW + (cost.length - String(m.credit_cost).length)) + chalk.gray(m.strengths.join(", "))
+      );
+    }
+  } catch (err) {
+    spinner.fail(err instanceof Error ? err.message : "Failed to load models");
+    process.exit(1);
+  }
+}
+async function handleAccount() {
+  const client = await requireClient();
+  const spinner = ora("Loading account...").start();
+  try {
+    const account = await client.getAccount();
+    spinner.stop();
+    console.log(`${chalk.bold("Email:")}    ${account.email}`);
+    console.log(`${chalk.bold("Plan:")}     ${chalk.cyan(account.plan)}`);
+    console.log(
+      `${chalk.bold("Credits:")}  ${chalk.green(String(account.credits.total))} (${account.credits.subscription} subscription + ${account.credits.purchased} purchased)`
+    );
+    console.log(`${chalk.bold("Rate:")}     ${account.rate_limit.requests_per_minute} req/min`);
+  } catch (err) {
+    spinner.fail(err instanceof Error ? err.message : "Failed to load account");
+    process.exit(1);
+  }
+}
+async function handleHistory() {
+  const client = await requireClient();
+  const spinner = ora("Loading history...").start();
+  try {
+    const result = await client.listGenerations({ limit: 20 });
+    spinner.stop();
+    if (result.data.length === 0) {
+      console.log("No generations yet.");
+      return;
+    }
+    const idW = 18;
+    const modelW = 22;
+    const promptW = 34;
+    console.log(
+      chalk.bold("ID".padEnd(idW)) + chalk.bold("Model".padEnd(modelW)) + chalk.bold("Prompt".padEnd(promptW)) + chalk.bold("Date")
+    );
+    console.log(chalk.gray("\u2500".repeat(90)));
+    for (const gen of result.data) {
+      const id = gen.id.slice(0, 15) + "...";
+      const prompt = gen.prompt.length > 30 ? gen.prompt.slice(0, 30) + "..." : gen.prompt;
+      const date = timeAgo(new Date(gen.created_at));
+      const status = gen.status === "succeeded" ? chalk.green("\u25CF") : gen.status === "failed" ? chalk.red("\u2717") : chalk.yellow("\u25CC");
+      console.log(
+        chalk.gray(id.padEnd(idW)) + `${status} ${gen.model}`.padEnd(modelW + status.length - 1) + prompt.padEnd(promptW) + chalk.gray(date)
+      );
+    }
+  } catch (err) {
+    spinner.fail(err instanceof Error ? err.message : "Failed to load history");
+    process.exit(1);
+  }
+}
+async function handleOpen(id) {
+  const client = await requireClient();
+  const spinner = ora("Loading generation...").start();
+  try {
+    const gen = await client.getGeneration(id);
+    spinner.stop();
+    if (gen.output?.[0]) {
+      const { imageToBuffer: imageToBuffer2, saveImage: saveImage2 } = await import("./image-2H3GUQI6.js");
+      const { PATHS: PATHS2 } = await import("./config-RMVFR3GN.js");
+      const { join } = await import("path");
+      const buf = await imageToBuffer2(gen.output[0]);
+      const path = join(PATHS2.generations, `${gen.id}.png`);
+      saveImage2(buf, path);
+      const { default: open } = await import("open");
+      await open(path);
+      console.log(`Opened ${path}`);
+    } else {
+      console.log(`Generation ${id} has no output (status: ${gen.status})`);
+    }
+  } catch (err) {
+    spinner.fail(err instanceof Error ? err.message : "Failed");
+    process.exit(1);
+  }
+}
+async function handleLogin() {
+  const { createInterface } = await import("readline");
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const key = await new Promise((resolve2) => {
+    rl.question("API key (from pixelmuse.studio/settings/api-keys): ", (answer) => {
+      rl.close();
+      resolve2(answer.trim());
+    });
+  });
+  if (!isValidKeyFormat(key)) {
+    console.error(chalk.red("Invalid key format. Keys start with pm_live_ or pm_test_"));
+    process.exit(1);
+  }
+  const spinner = ora("Validating...").start();
+  try {
+    const client = new PixelmuseClient(key);
+    const account = await client.getAccount();
+    await saveApiKey(key);
+    spinner.succeed(`Authenticated as ${chalk.bold(account.email)} (${chalk.green(`${account.credits.total} credits`)})`);
+  } catch (err) {
+    spinner.fail(err instanceof Error ? err.message : "Authentication failed");
+    process.exit(1);
+  }
+}
+async function handleTemplate() {
+  const [, templateCmd, ...templateArgs] = cli.input;
+  switch (templateCmd) {
+    case "list": {
+      const templates = listTemplates();
+      if (templates.length === 0) {
+        console.log("No templates. Create one with: pixelmuse template init <name>");
+        return;
+      }
+      for (const t of templates) {
+        console.log(`${chalk.bold(t.name)} ${chalk.gray(`\u2014 ${t.description}`)}`);
+        if (t.tags.length > 0) console.log(chalk.gray(`  tags: ${t.tags.join(", ")}`));
+      }
+      break;
+    }
+    case "show": {
+      const name = templateArgs.join(" ");
+      if (!name) {
+        console.error(chalk.red("Usage: pixelmuse template show <name>"));
+        process.exit(1);
+      }
+      const template = getTemplate(name);
+      if (!template) {
+        console.error(chalk.red(`Template "${name}" not found`));
+        process.exit(1);
+      }
+      console.log(chalk.bold(template.name));
+      console.log(chalk.gray(template.description));
+      console.log(`
+${chalk.bold("Prompt:")} ${template.prompt}`);
+      const vars = extractVariables(template.prompt);
+      if (vars.length > 0) {
+        console.log(`${chalk.bold("Variables:")} ${vars.join(", ")}`);
+        for (const [k, v] of Object.entries(template.variables)) {
+          console.log(chalk.gray(`  ${k} = "${v}"`));
+        }
+      }
+      if (template.defaults.model) console.log(`${chalk.bold("Model:")} ${template.defaults.model}`);
+      if (template.defaults.aspect_ratio) console.log(`${chalk.bold("Aspect:")} ${template.defaults.aspect_ratio}`);
+      break;
+    }
+    case "init": {
+      const name = templateArgs.join(" ");
+      if (!name) {
+        console.error(chalk.red("Usage: pixelmuse template init <name>"));
+        process.exit(1);
+      }
+      const existing = getTemplate(name);
+      if (existing) {
+        console.error(chalk.red(`Template "${name}" already exists`));
+        process.exit(1);
+      }
+      const template = {
+        name,
+        description: `${name} template`,
+        prompt: "A {{subject}} with dramatic lighting",
+        defaults: { model: "nano-banana-2", aspect_ratio: "16:9" },
+        variables: { subject: "landscape" },
+        tags: []
+      };
+      saveTemplate(template);
+      const { PATHS: PATHS2 } = await import("./config-RMVFR3GN.js");
+      const path = `${PATHS2.prompts}/${slugify(name)}.yaml`;
+      console.log(`Created template: ${chalk.bold(path)}`);
+      console.log(chalk.gray("Edit the YAML file to customize your template."));
+      break;
+    }
+    case "use": {
+      const name = templateArgs.join(" ");
+      if (!name) {
+        console.error(chalk.red("Usage: pixelmuse template use <name> [--var key=value]"));
+        process.exit(1);
+      }
+      const template = getTemplate(name);
+      if (!template) {
+        console.error(chalk.red(`Template "${name}" not found`));
+        process.exit(1);
+      }
+      const vars = { ...template.variables };
+      for (const v of cli.flags.var ?? []) {
+        const eq = v.indexOf("=");
+        if (eq > 0) {
+          vars[v.slice(0, eq)] = v.slice(eq + 1);
+        }
+      }
+      const prompt = interpolate(template.prompt, vars);
+      if (template.defaults.model && !cli.flags.model) {
+        cli.flags.model = template.defaults.model;
+      }
+      if (template.defaults.aspect_ratio && !cli.flags.aspectRatio) {
+        cli.flags.aspectRatio = template.defaults.aspect_ratio;
+      }
+      if (template.defaults.style && !cli.flags.style) {
+        cli.flags.style = template.defaults.style;
+      }
+      await handleGenerate(prompt);
+      break;
+    }
+    default:
+      console.log(`Usage: pixelmuse template <list|show|init|use> [name]`);
+      break;
+  }
+}
+async function main() {
+  const stdinPrompt = await readStdin();
+  switch (subcommand) {
+    case "models":
+      return handleModels();
+    case "account":
+      return handleAccount();
+    case "history":
+      return handleHistory();
+    case "open":
+      if (!rest[0]) {
+        console.error(chalk.red("Usage: pixelmuse open <generation-id>"));
+        process.exit(1);
+      }
+      return handleOpen(rest[0]);
+    case "login":
+      return handleLogin();
+    case "logout":
+      await deleteApiKey();
+      console.log("Logged out.");
+      return;
+    case "template":
+      return handleTemplate();
+    case "ui": {
+      const { launchTui } = await import("./tui.js");
+      return launchTui();
+    }
+    // Explicit generate or default with prompt
+    case "generate": {
+      const prompt = rest.join(" ") || stdinPrompt;
+      if (!prompt) {
+        console.error(chalk.red('Usage: pixelmuse generate "your prompt"'));
+        process.exit(1);
+      }
+      if (cli.flags.watch) return handleWatch(cli.flags.watch);
+      return handleGenerate(prompt);
+    }
+    default: {
+      const prompt = cli.input.join(" ") || stdinPrompt;
+      if (!prompt) {
+        if (process.stdin.isTTY) {
+          cli.showHelp();
+        }
+        return;
+      }
+      if (cli.flags.watch) return handleWatch(cli.flags.watch);
+      return handleGenerate(prompt);
+    }
+  }
+}
+main().catch((err) => {
+  console.error(chalk.red(err instanceof Error ? err.message : "Fatal error"));
+  process.exit(1);
+});

package/dist/config-RMVFR3GN.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import {
+  PATHS,
+  ensureDirs,
+  readSettings,
+  writeSettings
+} from "./chunk-7ARYEFAH.js";
+export {
+  PATHS,
+  ensureDirs,
+  readSettings,
+  writeSettings
+};

package/dist/image-2H3GUQI6.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import {
+  autoSave,
+  hasChafa,
+  imageToBuffer,
+  renderImageDirect,
+  saveImage
+} from "./chunk-MZZY4JXW.js";
+import "./chunk-7ARYEFAH.js";
+export {
+  autoSave,
+  hasChafa,
+  imageToBuffer,
+  renderImageDirect,
+  saveImage
+};

package/dist/mcp/server.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+import {
+  generateImage
+} from "../chunk-743CKPHW.js";
+import {
+  CLI_VERSION,
+  PixelmuseClient,
+  getApiKey
+} from "../chunk-ZVJQFWUI.js";
+import "../chunk-MZZY4JXW.js";
+import {
+  readSettings
+} from "../chunk-7ARYEFAH.js";
+
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+var MODELS = [
+  "nano-banana-2",
+  "nano-banana-pro",
+  "flux-schnell",
+  "imagen-3",
+  "recraft-v4",
+  "recraft-v4-pro"
+];
+var ASPECT_RATIOS = ["1:1", "16:9", "9:16", "3:2", "2:3", "4:5", "5:4", "3:4", "4:3", "21:9", "9:21"];
+var STYLES = ["none", "realistic", "anime", "artistic"];
+async function getClient() {
+  const key = await getApiKey();
+  if (!key) throw new Error("No API key found. Set PIXELMUSE_API_KEY environment variable.");
+  return new PixelmuseClient(key);
+}
+var server = new McpServer({
+  name: "pixelmuse",
+  version: CLI_VERSION
+});
+server.tool(
+  "generate_image",
+  "Generate an AI image using Pixelmuse. Returns the saved file path and generation metadata.",
+  {
+    prompt: z.string().describe("Image description / prompt"),
+    model: z.enum(MODELS).optional().default("nano-banana-2").describe("Model to use"),
+    aspect_ratio: z.enum(ASPECT_RATIOS).optional().default("1:1").describe("Image aspect ratio"),
+    style: z.enum(STYLES).optional().default("none").describe("Visual style"),
+    output_path: z.string().optional().describe("Where to save the image (default: current directory)")
+  },
+  async (args) => {
+    const client = await getClient();
+    const settings = readSettings();
+    const result = await generateImage(client, {
+      prompt: args.prompt,
+      model: args.model ?? settings.defaultModel,
+      aspectRatio: args.aspect_ratio ?? settings.defaultAspectRatio,
+      style: args.style ?? settings.defaultStyle,
+      output: args.output_path
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            id: result.generation.id,
+            status: result.generation.status,
+            model: result.generation.model,
+            prompt: result.generation.prompt,
+            credits_charged: result.generation.credits_charged,
+            elapsed_seconds: Math.round(result.elapsed * 10) / 10,
+            output_path: result.imagePath
+          }, null, 2)
+        }
+      ]
+    };
+  }
+);
+server.tool(
+  "list_models",
+  "List all available Pixelmuse image generation models with their costs and capabilities.",
+  {},
+  async () => {
+    const models = await PixelmuseClient.listModels();
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            models.map((m) => ({
+              id: m.id,
+              name: m.name,
+              credit_cost: m.credit_cost,
+              strengths: m.strengths,
+              supported_aspect_ratios: m.supported_aspect_ratios
+            })),
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+);
+server.tool(
+  "check_balance",
+  "Check Pixelmuse account credit balance and plan info.",
+  {},
+  async () => {
+    const client = await getClient();
+    const account = await client.getAccount();
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            email: account.email,
+            plan: account.plan,
+            credits_total: account.credits.total,
+            credits_subscription: account.credits.subscription,
+            credits_purchased: account.credits.purchased,
+            rate_limit: account.rate_limit.requests_per_minute
+          }, null, 2)
+        }
+      ]
+    };
+  }
+);
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((err) => {
+  console.error("MCP server error:", err);
+  process.exit(1);
+});