@ghosty-ai/cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+function getVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf8"));
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function printHelp() {
+  console.log(`
+  ghosty \u2014 Ghosty Plugin Development CLI
+
+  Usage:
+    ghosty create [name]   Scaffold a new plugin project
+    ghosty dev             Start dev server with hot reload
+    ghosty --help          Show this help
+    ghosty --version       Show version
+
+  Docs: https://dev.ghosty.to
+`);
+}
+async function main() {
+  const [, , command, ...args] = process.argv;
+  switch (command) {
+    case "create": {
+      const { runCreate } = await import("./create-MLDT2ZRH.js");
+      await runCreate(args[0]);
+      break;
+    }
+    case "dev": {
+      const { runDev } = await import("./dev-WPS3QYGP.js");
+      await runDev();
+      break;
+    }
+    case "--version":
+    case "-v":
+      console.log(getVersion());
+      break;
+    case "--help":
+    case "-h":
+    case void 0:
+      printHelp();
+      break;
+    default:
+      console.error(`  Unknown command: ${command}
+`);
+      printHelp();
+      process.exit(1);
+  }
+}
+main().catch((err) => {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+});

package/dist/create-MLDT2ZRH.js

@@ -0,0 +1,153 @@
+#!/usr/bin/env node
+
+// src/create.ts
+import { mkdirSync, writeFileSync, existsSync } from "fs";
+import { join } from "path";
+import { createInterface } from "readline";
+function prompt(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+function validateName(name) {
+  if (name.length < 1 || name.length > 50) return "Name must be 1-50 characters";
+  if (!/^[a-z0-9][a-z0-9-]*$/.test(name)) return "Name must be lowercase alphanumeric with hyphens (e.g. my-plugin)";
+  return null;
+}
+var MANIFEST_TEMPLATE = `{
+  "version": "1.0.0",
+  "entry": "main.ts",
+  "permissions": []
+}
+`;
+function mainTsTemplate(name) {
+  return `import { createPlugin } from '@ghosty-ai/sdk';
+
+const plugin = createPlugin();
+
+// Set context for the AI chat overlay
+plugin.setContext({
+  title: '${name}',
+  data: { message: 'Hello from ${name}!' },
+  summary: 'This plugin is running.',
+});
+
+// Listen for theme changes
+plugin.onThemeChange((theme) => {
+  document.documentElement.setAttribute('data-theme', theme);
+});
+
+// Signal that the plugin is ready
+plugin.ready();
+
+// Your plugin code goes here
+const app = document.getElementById('app');
+if (app) {
+  app.innerHTML = \`
+    <div class="container">
+      <h1>${name}</h1>
+      <p>Edit <code>main.ts</code> and save to see changes.</p>
+    </div>
+  \`;
+}
+`;
+}
+var STYLES_TEMPLATE = `/* Ghosty Plugin Styles */
+
+:root {
+  --bg: #ffffff;
+  --text: #23272a;
+  --text-secondary: #6b7280;
+  --surface: #f9fafb;
+  --border: #e5e7eb;
+  --primary: #5865f2;
+}
+
+[data-theme='dark'] {
+  --bg: #171717;
+  --text: #ffffff;
+  --text-secondary: #8b8b8b;
+  --surface: #1f1f1f;
+  --border: #292929;
+  --primary: #7983f5;
+}
+
+*, *::before, *::after {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+body {
+  font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+  background: var(--bg);
+  color: var(--text);
+  line-height: 1.5;
+  transition: background 300ms, color 300ms;
+}
+
+.container {
+  max-width: 600px;
+  margin: 2rem auto;
+  padding: 0 1rem;
+}
+
+h1 {
+  font-size: 1.5rem;
+  font-weight: 700;
+  margin-bottom: 0.5rem;
+}
+
+p {
+  color: var(--text-secondary);
+}
+
+code {
+  background: var(--surface);
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  padding: 0.125rem 0.375rem;
+  font-size: 0.875em;
+}
+`;
+async function runCreate(nameArg) {
+  let name = nameArg;
+  if (!name) {
+    name = await prompt("  Plugin name: ");
+  }
+  if (!name) {
+    console.error("  Plugin name is required.");
+    process.exit(1);
+  }
+  const error = validateName(name);
+  if (error) {
+    console.error(`  ${error}`);
+    process.exit(1);
+  }
+  const dir = join(process.cwd(), name);
+  if (existsSync(dir)) {
+    console.error(`  Directory "${name}" already exists.`);
+    process.exit(1);
+  }
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "ghosty.manifest.json"), MANIFEST_TEMPLATE);
+  writeFileSync(join(dir, "main.ts"), mainTsTemplate(name));
+  writeFileSync(join(dir, "styles.css"), STYLES_TEMPLATE);
+  console.log(`
+  Created plugin project: ${name}/
+    ghosty.manifest.json
+    main.ts
+    styles.css
+
+  Next steps:
+    cd ${name}
+    ghosty dev
+`);
+}
+export {
+  runCreate
+};

package/dist/dev-WPS3QYGP.js

@@ -0,0 +1,608 @@
+#!/usr/bin/env node
+
+// src/dev.ts
+import { watch } from "chokidar";
+import { exec } from "child_process";
+
+// src/build.ts
+import * as esbuild from "esbuild";
+import { readFileSync, existsSync, readdirSync, statSync } from "fs";
+import { join, extname } from "path";
+import { createRequire } from "module";
+var esmRequire = createRequire(import.meta.url);
+var _sdkSource = null;
+function getSdkSource() {
+  if (_sdkSource !== null) return _sdkSource;
+  try {
+    const sdkPath = esmRequire.resolve("@ghosty-ai/sdk/dist/umd/index.global.js");
+    _sdkSource = readFileSync(sdkPath, "utf8");
+  } catch {
+    throw new Error(
+      "Could not load @ghosty-ai/sdk UMD bundle.\nIf developing locally: npm run -w @ghosty-ai/sdk build\nIf installed globally: npm install -g @ghosty-ai/sdk"
+    );
+  }
+  return _sdkSource;
+}
+var SDK_SHIM = `
+var __sdk = globalThis.GhostySDK;
+export default __sdk;
+export var createPlugin = __sdk.createPlugin;
+export var isBridgeMessage = __sdk.isBridgeMessage;
+export var sendMessage = __sdk.sendMessage;
+export var sendRequest = __sdk.sendRequest;
+export var sendResponse = __sdk.sendResponse;
+export var onMessage = __sdk.onMessage;
+`.trim();
+function createSdkShimPlugin() {
+  return {
+    name: "ghosty-sdk-shim",
+    setup(build2) {
+      build2.onResolve({ filter: /^(@ghosty-ai\/sdk|ghosty-sdk)/ }, () => ({
+        path: "ghosty-sdk-shim",
+        namespace: "ghosty-shim"
+      }));
+      build2.onResolve({ filter: /ghosty-sdk(\.min)?\.js$/ }, () => ({
+        path: "ghosty-sdk-shim",
+        namespace: "ghosty-shim"
+      }));
+      build2.onLoad({ filter: /.*/, namespace: "ghosty-shim" }, () => ({
+        contents: SDK_SHIM,
+        loader: "js"
+      }));
+      build2.onResolve({ filter: /\.css$/ }, (args) => ({
+        path: args.path,
+        external: true
+      }));
+    }
+  };
+}
+function collectFiles(dir, base = "") {
+  const files = /* @__PURE__ */ new Map();
+  for (const entry of readdirSync(dir)) {
+    if (entry === "node_modules" || entry === ".git" || entry === "dist") continue;
+    const fullPath = join(dir, entry);
+    const relativePath = base ? `${base}/${entry}` : entry;
+    if (statSync(fullPath).isDirectory()) {
+      for (const [k, v] of collectFiles(fullPath, relativePath)) {
+        files.set(k, v);
+      }
+    } else {
+      files.set(relativePath, fullPath);
+    }
+  }
+  return files;
+}
+function generateHtml(entry, cssFiles) {
+  const cssLinks = cssFiles.map((f) => `  <link rel="stylesheet" href="${f}" />`).join("\n");
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Plugin</title>
+${cssLinks ? cssLinks + "\n" : ""}</head>
+<body>
+  <div id="app"></div>
+  <script src="${entry}"></script>
+</body>
+</html>`;
+}
+function injectSdk(html) {
+  if (/ghosty-sdk(\.min)?\.js/.test(html)) return html;
+  const sdkSource = getSdkSource().replace(/<\/script>/gi, "<\\/script>");
+  const sdkTag = `  <script>/* Ghosty SDK */${sdkSource}</script>`;
+  if (html.includes("</head>")) {
+    return html.replace("</head>", `${sdkTag}
+</head>`);
+  }
+  if (html.includes("<script")) {
+    return html.replace("<script", `${sdkTag}
+<script`);
+  }
+  return html.replace("<body>", `<body>
+${sdkTag}`);
+}
+async function buildPlugin(cwd) {
+  const manifestPath = join(cwd, "ghosty.manifest.json");
+  if (!existsSync(manifestPath)) {
+    throw new Error("No ghosty.manifest.json found. Run from a plugin directory or use `ghosty create`.");
+  }
+  const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+  const output = /* @__PURE__ */ new Map();
+  const sourceFiles = collectFiles(cwd);
+  let html;
+  const hasIndex = sourceFiles.has("index.html");
+  if (hasIndex) {
+    html = readFileSync(sourceFiles.get("index.html"), "utf8");
+  } else if (manifest.entry) {
+    const cssFiles = [];
+    for (const name of sourceFiles.keys()) {
+      if (name.endsWith(".css")) cssFiles.push(name);
+    }
+    cssFiles.sort();
+    html = generateHtml(manifest.entry, cssFiles);
+  } else {
+    throw new Error('Bundle must have index.html or specify "entry" in the manifest.');
+  }
+  html = injectSdk(html);
+  const scriptRegex = /<script\b([^>]*)>/gi;
+  const entryPoints = [];
+  let scriptMatch;
+  while ((scriptMatch = scriptRegex.exec(html)) !== null) {
+    const attrs = scriptMatch[1] ?? "";
+    const srcMatch = attrs.match(/\bsrc\s*=\s*["']([^"']+)["']/);
+    if (!srcMatch) continue;
+    const src = srcMatch[1];
+    const ext = extname(src);
+    const needsBuild = [".ts", ".tsx", ".jsx"].includes(ext) || /\btype\s*=\s*["']module["']/i.test(attrs);
+    if (needsBuild) {
+      entryPoints.push({ src, original: src });
+    }
+  }
+  if (entryPoints.length === 0) {
+    const jsMatch = html.match(/src\s*=\s*["']([^"']+\.m?js)["']/);
+    if (jsMatch) {
+      const src = jsMatch[1];
+      const fullPath = sourceFiles.get(src);
+      if (fullPath) {
+        const content = readFileSync(fullPath, "utf8");
+        if (/\b(import\s+|import\s*\{|export\s+|export\s*\{|export\s+default)\b/.test(content)) {
+          entryPoints.push({ src, original: src });
+        }
+      }
+    }
+  }
+  const consumedFiles = /* @__PURE__ */ new Set();
+  for (const ep of entryPoints) {
+    const fullPath = sourceFiles.get(ep.src);
+    if (!fullPath) {
+      throw new Error(`Script "${ep.src}" referenced in HTML not found in bundle.`);
+    }
+    const result = await esbuild.build({
+      entryPoints: [fullPath],
+      bundle: true,
+      write: false,
+      format: "iife",
+      target: "es2020",
+      platform: "browser",
+      minify: false,
+      sourcemap: false,
+      metafile: true,
+      plugins: [createSdkShimPlugin()],
+      logLevel: "silent"
+    });
+    if (result.errors.length > 0) {
+      const messages = result.errors.map((e) => {
+        const loc = e.location ? `${e.location.file}:${e.location.line}:${e.location.column}` : ep.src;
+        return `  ${loc}: ${e.text}`;
+      });
+      throw new Error(`Build failed:
+${messages.join("\n")}`);
+    }
+    const outputFile = result.outputFiles?.[0];
+    if (outputFile) {
+      const outName = ep.src.replace(/\.(ts|tsx|jsx)$/, ".js");
+      output.set(outName, Buffer.from(outputFile.contents));
+      if (ep.src !== outName) {
+        html = html.split(ep.src).join(outName);
+      }
+      html = html.replace(
+        new RegExp(`(<script[^>]*?)\\s*type\\s*=\\s*["']module["']([^>]*src\\s*=\\s*["']${outName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["'])`, "i"),
+        "$1$2"
+      );
+    }
+    if (result.metafile) {
+      for (const inputPath of Object.keys(result.metafile.inputs)) {
+        for (const [relPath, absPath] of sourceFiles) {
+          if (inputPath === absPath || inputPath.endsWith(relPath)) {
+            consumedFiles.add(relPath);
+          }
+        }
+      }
+    }
+  }
+  for (const [relPath, absPath] of sourceFiles) {
+    if (consumedFiles.has(relPath)) continue;
+    if (relPath === "index.html") continue;
+    if (!output.has(relPath)) {
+      output.set(relPath, readFileSync(absPath));
+    }
+  }
+  output.set("index.html", Buffer.from(html, "utf8"));
+  return { files: output, manifest };
+}
+
+// src/shell.ts
+function generateShellHtml(options) {
+  const { pluginName, manifest, port } = options;
+  const manifestJson = JSON.stringify(manifest);
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Ghosty Dev \u2014 ${pluginName}</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body { font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; background: #0d0d0d; color: #fff; height: 100vh; display: flex; flex-direction: column; }
+
+    .toolbar { display: flex; align-items: center; justify-content: space-between; padding: 0 16px; height: 40px; background: #171717; border-bottom: 1px solid #292929; flex-shrink: 0; }
+    .toolbar-left { display: flex; align-items: center; gap: 10px; }
+    .toolbar-dot { width: 8px; height: 8px; border-radius: 50%; background: #22c55e; }
+    .toolbar-title { font-size: 12px; font-weight: 500; color: rgba(255,255,255,0.5); }
+    .toolbar-name { color: rgba(255,255,255,0.8); font-weight: 600; }
+    .toolbar-actions { display: flex; gap: 6px; align-items: center; }
+    .theme-btn { background: #292929; border: 1px solid #3a3a3a; border-radius: 6px; padding: 4px 12px; color: #ccc; cursor: pointer; font-size: 11px; font-weight: 500; font-family: inherit; transition: all 150ms; }
+    .theme-btn:hover { background: #3a3a3a; color: #fff; }
+    .theme-btn.light { background: #5865f2; border-color: #5865f2; color: #fff; }
+
+    .iframe-wrap { flex: 1; position: relative; background: #000; }
+    .iframe-wrap iframe { width: 100%; height: 100%; border: 0; }
+
+    .debug { flex-shrink: 0; background: #111; border-top: 1px solid #292929; display: flex; flex-direction: column; max-height: 220px; transition: max-height 200ms; }
+    .debug.collapsed { max-height: 32px; }
+    .debug-header { display: flex; align-items: center; justify-content: space-between; padding: 0 16px; height: 32px; background: #171717; cursor: pointer; user-select: none; flex-shrink: 0; }
+    .debug-header span { font-size: 11px; font-weight: 600; color: rgba(255,255,255,0.4); }
+    .debug-count { background: #292929; padding: 1px 7px; border-radius: 9999px; font-size: 10px; color: rgba(255,255,255,0.5); margin-left: 8px; }
+    .debug-log { flex: 1; overflow-y: auto; padding: 6px 16px; font-family: 'SF Mono', 'Cascadia Code', Consolas, monospace; font-size: 11px; line-height: 1.7; }
+    .debug-log::-webkit-scrollbar { width: 5px; }
+    .debug-log::-webkit-scrollbar-thumb { background: #333; border-radius: 3px; }
+    .msg { padding: 1px 0; opacity: 0.8; }
+    .msg:hover { opacity: 1; }
+    .msg-time { color: rgba(255,255,255,0.2); margin-right: 8px; }
+    .msg-in { color: #4ade80; }
+    .msg-out { color: #facc15; }
+    .msg-sys { color: #7983f5; }
+    .msg-type { font-weight: 600; }
+    .msg-payload { color: rgba(255,255,255,0.3); margin-left: 6px; }
+  </style>
+</head>
+<body>
+  <div class="toolbar">
+    <div class="toolbar-left">
+      <div class="toolbar-dot"></div>
+      <span class="toolbar-title"><span class="toolbar-name">${pluginName}</span> \u2014 localhost:${port}</span>
+    </div>
+    <div class="toolbar-actions">
+      <button class="theme-btn" id="themeBtn">Dark</button>
+    </div>
+  </div>
+
+  <div class="iframe-wrap">
+    <iframe id="frame" src="/plugin/index.html" sandbox="allow-scripts"></iframe>
+  </div>
+
+  <div class="debug" id="debug">
+    <div class="debug-header" id="debugToggle">
+      <div><span>Bridge</span><span class="debug-count" id="msgCount">0</span></div>
+      <span id="arrow">&#9660;</span>
+    </div>
+    <div class="debug-log" id="log"></div>
+  </div>
+
+  <script>
+    var theme = 'dark';
+    var manifest = ${manifestJson};
+    var frame = document.getElementById('frame');
+    var log = document.getElementById('log');
+    var msgTotal = 0;
+
+    function ts() {
+      return new Date().toLocaleTimeString('en-US', { hour12: false, fractionalSecondDigits: 3 });
+    }
+
+    function logMsg(dir, type, payload) {
+      var el = document.createElement('div');
+      el.className = 'msg';
+      var cls = dir === 'IN' ? 'msg-in' : dir === 'OUT' ? 'msg-out' : 'msg-sys';
+      var pl = payload !== undefined ? JSON.stringify(payload).slice(0, 300) : '';
+      el.innerHTML = '<span class="msg-time">' + ts() + '</span><span class="' + cls + ' msg-type">' + dir + ' ' + type + '</span>' + (pl ? '<span class="msg-payload">' + pl + '</span>' : '');
+      log.appendChild(el);
+      log.scrollTop = log.scrollHeight;
+      msgTotal++;
+      document.getElementById('msgCount').textContent = msgTotal;
+    }
+
+    function send(type, messageId, payload) {
+      if (!frame.contentWindow) return;
+      frame.contentWindow.postMessage({ protocol: 'ghosty-bridge', version: 1, type: type, messageId: messageId, payload: payload }, '*');
+      logMsg('OUT', type, payload);
+    }
+
+    window.addEventListener('message', function(e) {
+      var msg = e.data;
+      if (!msg || msg.protocol !== 'ghosty-bridge' || msg.version !== 1) return;
+      if (e.source !== frame.contentWindow) return;
+
+      logMsg('IN', msg.type, msg.payload);
+
+      switch (msg.type) {
+        case 'GHOSTY_READY':
+          send('GHOSTY_THEME_CHANGE', 'init-' + Date.now(), { theme: theme });
+          break;
+
+        case 'GHOSTY_SET_CONTEXT':
+          break;
+
+        case 'GHOSTY_GET_USER':
+          send('GHOSTY_GET_USER_RESPONSE', msg.messageId, { displayName: 'Developer', avatarUrl: null, theme: theme });
+          break;
+
+        case 'GHOSTY_GET_MANIFEST':
+          send('GHOSTY_GET_MANIFEST_RESPONSE', msg.messageId, manifest);
+          break;
+
+        case 'GHOSTY_GET_MEDIA_BASE':
+          send('GHOSTY_GET_MEDIA_BASE_RESPONSE', msg.messageId, { apiBaseUrl: 'http://localhost:${port}', pluginId: 'dev' });
+          break;
+
+        case 'GHOSTY_FETCH':
+          var url = (msg.payload && msg.payload.url) || '';
+          var opts = (msg.payload && msg.payload.options) || {};
+          if (!url) {
+            send('GHOSTY_FETCH_RESPONSE', msg.messageId, { ok: false, status: 0, data: 'No URL', contentType: '' });
+            break;
+          }
+          fetch('/proxy?url=' + encodeURIComponent(url), {
+            method: opts.method || 'GET',
+            headers: Object.assign({ 'x-proxy-method': opts.method || 'GET' }, opts.headers || {}),
+            body: opts.body ? JSON.stringify(opts.body) : undefined
+          })
+          .then(function(res) { return res.json(); })
+          .then(function(data) { send('GHOSTY_FETCH_RESPONSE', msg.messageId, data); })
+          .catch(function(err) {
+            send('GHOSTY_FETCH_RESPONSE', msg.messageId, { ok: false, status: 0, data: err.message, contentType: '' });
+          });
+          break;
+
+        case 'GHOSTY_REGISTER_TOOLS':
+          break;
+
+        case 'GHOSTY_TOOL_CALL_RESPONSE':
+          break;
+      }
+    });
+
+    // Theme toggle
+    var themeBtn = document.getElementById('themeBtn');
+    themeBtn.addEventListener('click', function() {
+      theme = theme === 'dark' ? 'light' : 'dark';
+      themeBtn.textContent = theme === 'dark' ? 'Dark' : 'Light';
+      themeBtn.classList.toggle('light', theme === 'light');
+      send('GHOSTY_THEME_CHANGE', 'theme-' + Date.now(), { theme: theme });
+    });
+
+    // Debug toggle
+    var debugPanel = document.getElementById('debug');
+    document.getElementById('debugToggle').addEventListener('click', function() {
+      debugPanel.classList.toggle('collapsed');
+      document.getElementById('arrow').innerHTML = debugPanel.classList.contains('collapsed') ? '&#9650;' : '&#9660;';
+    });
+
+    // Hot reload
+    (function connect() {
+      var ws = new WebSocket('ws://localhost:${port}/__ws');
+      ws.onmessage = function(e) {
+        if (e.data === 'reload') {
+          frame.src = frame.src;
+          logMsg('SYS', 'HOT_RELOAD', { message: 'Rebuilt, reloading...' });
+        }
+        if (e.data.startsWith('error:')) {
+          logMsg('SYS', 'BUILD_ERROR', { message: e.data.slice(6) });
+        }
+      };
+      ws.onclose = function() { setTimeout(connect, 1000); };
+    })();
+  </script>
+</body>
+</html>`;
+}
+
+// src/serve.ts
+import { createServer } from "http";
+import { WebSocketServer, WebSocket } from "ws";
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".mjs": "application/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".svg": "image/svg+xml",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf"
+};
+function mimeType(path) {
+  const ext = path.slice(path.lastIndexOf("."));
+  return MIME[ext] ?? "application/octet-stream";
+}
+function startServer(options) {
+  const { shellHtml, getPluginFiles } = options;
+  let resolvedPort = options.port;
+  const wss = new WebSocketServer({ noServer: true });
+  const server = createServer(async (req, res) => {
+    const url = new URL(req.url ?? "/", `http://localhost:${resolvedPort}`);
+    const pathname = url.pathname;
+    if (pathname === "/" || pathname === "/index.html") {
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(shellHtml);
+      return;
+    }
+    if (pathname.startsWith("/plugin/")) {
+      const filePath = pathname.slice("/plugin/".length) || "index.html";
+      const files = getPluginFiles();
+      const data = files.get(filePath);
+      if (data) {
+        res.writeHead(200, {
+          "Content-Type": mimeType(filePath),
+          "Cache-Control": "no-cache"
+        });
+        res.end(data);
+      } else {
+        res.writeHead(404);
+        res.end("Not found");
+      }
+      return;
+    }
+    if (pathname === "/proxy") {
+      const targetUrl = url.searchParams.get("url");
+      if (!targetUrl) {
+        res.writeHead(400, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: false, status: 0, data: "Missing url param", contentType: "" }));
+        return;
+      }
+      try {
+        const method = req.headers["x-proxy-method"] || "GET";
+        const proxyRes = await fetch(targetUrl, { method });
+        const contentType = proxyRes.headers.get("content-type") ?? "";
+        let data;
+        if (contentType.includes("json")) {
+          data = await proxyRes.json();
+        } else {
+          data = await proxyRes.text();
+        }
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: proxyRes.ok, status: proxyRes.status, data, contentType }));
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ ok: false, status: 0, data: message, contentType: "" }));
+      }
+      return;
+    }
+    res.writeHead(404);
+    res.end("Not found");
+  });
+  server.on("upgrade", (req, socket, head) => {
+    const pathname = new URL(req.url ?? "/", `http://localhost:${resolvedPort}`).pathname;
+    if (pathname === "/__ws") {
+      wss.handleUpgrade(req, socket, head, (ws) => {
+        wss.emit("connection", ws, req);
+      });
+    } else {
+      socket.destroy();
+    }
+  });
+  function broadcastReload() {
+    for (const client of wss.clients) {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send("reload");
+      }
+    }
+  }
+  function broadcastError(message) {
+    for (const client of wss.clients) {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(`error:${message}`);
+      }
+    }
+  }
+  return new Promise((resolve, reject) => {
+    function tryListen(port, attempts) {
+      server.listen(port, () => {
+        resolvedPort = port;
+        resolve({
+          port,
+          broadcastReload,
+          broadcastError,
+          close: () => {
+            wss.close();
+            server.close();
+          }
+        });
+      });
+      server.once("error", (err) => {
+        if (err.code === "EADDRINUSE" && attempts < 10) {
+          server.removeAllListeners("error");
+          tryListen(port + 1, attempts + 1);
+        } else {
+          reject(err);
+        }
+      });
+    }
+    tryListen(options.port, 0);
+  });
+}
+
+// src/dev.ts
+var DEFAULT_PORT = 3100;
+function openBrowser(url) {
+  const cmd = process.platform === "win32" ? `start "" "${url}"` : process.platform === "darwin" ? `open "${url}"` : `xdg-open "${url}"`;
+  exec(cmd, () => {
+  });
+}
+async function runDev() {
+  const cwd = process.cwd();
+  console.log("\n  Building plugin...\n");
+  let buildResult;
+  try {
+    buildResult = await buildPlugin(cwd);
+  } catch (err) {
+    console.error(`  ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+  }
+  const pluginName = buildResult.manifest.entry ?? "Plugin";
+  const shell = generateShellHtml({
+    pluginName,
+    manifest: buildResult.manifest,
+    port: DEFAULT_PORT
+  });
+  const server = await startServer({
+    port: DEFAULT_PORT,
+    shellHtml: shell,
+    getPluginFiles: () => buildResult.files
+  });
+  console.log(`  Ghosty Dev Server
+`);
+  console.log(`  Preview: http://localhost:${server.port}`);
+  console.log(`  Plugin:  http://localhost:${server.port}/plugin/index.html
+`);
+  console.log(`  Watching for changes...
+`);
+  openBrowser(`http://localhost:${server.port}`);
+  let rebuildTimer = null;
+  const watcher = watch(
+    ["**/*.ts", "**/*.tsx", "**/*.js", "**/*.jsx", "**/*.css", "**/*.html", "**/*.json"],
+    {
+      cwd,
+      ignored: ["**/node_modules/**", "**/dist/**", "**/.git/**"],
+      ignoreInitial: true
+    }
+  );
+  watcher.on("all", (event, path) => {
+    if (rebuildTimer) clearTimeout(rebuildTimer);
+    rebuildTimer = setTimeout(async () => {
+      const time = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false });
+      console.log(`  [${time}] Change detected: ${path}`);
+      try {
+        buildResult = await buildPlugin(cwd);
+        server.broadcastReload();
+        console.log(`  [${time}] Rebuilt successfully`);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`  [${time}] Build error: ${message}`);
+        server.broadcastError(message);
+      }
+    }, 100);
+  });
+  process.on("SIGINT", () => {
+    console.log("\n  Shutting down...\n");
+    watcher.close();
+    server.close();
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    watcher.close();
+    server.close();
+    process.exit(0);
+  });
+}
+export {
+  runDev
+};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@ghosty-ai/cli",
+  "version": "0.1.0",
+  "description": "CLI tools for Ghosty plugin development — scaffold, preview, and test plugins locally.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "ghosty": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@ghosty-ai/sdk": "*",
+    "chokidar": "^4.0.3",
+    "esbuild": "^0.25.0",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.18.1",
+    "tsup": "^8.5.1",
+    "typescript": "^5.7.3"
+  }
+}