@minus-ai/dev-vite-plugin 0.1.0-beta.1

package/dist/index.js

@@ -0,0 +1,653 @@
+// src/index.ts
+import { createProxyMiddleware } from "http-proxy-middleware";
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, unlinkSync as unlinkSync2, rmSync, cpSync, renameSync, realpathSync, statSync } from "node:fs";
+import { resolve as resolve2, join as join2 } from "node:path";
+import http from "node:http";
+import https from "node:https";
+
+// src/cleanup.ts
+import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync } from "node:fs";
+import { join, resolve } from "node:path";
+var PID_FILE = ".minus/dev.pid";
+function killOldProcess(pidFile) {
+  if (!existsSync(pidFile)) return;
+  let pid;
+  try {
+    pid = parseInt(readFileSync(pidFile, "utf8").trim(), 10);
+  } catch {
+    return;
+  }
+  if (!pid || pid <= 0) return;
+  try {
+    process.kill(pid, 0);
+  } catch {
+    try {
+      unlinkSync(pidFile);
+    } catch {
+    }
+    return;
+  }
+  console.log(`[minus-dev] killing residual dev server (PID ${pid})`);
+  try {
+    process.kill(-pid, "SIGTERM");
+  } catch {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+    }
+  }
+  const deadline = Date.now() + 3e3;
+  while (Date.now() < deadline) {
+    try {
+      process.kill(pid, 0);
+    } catch {
+      break;
+    }
+    const wait = Date.now() + 100;
+    while (Date.now() < wait) {
+    }
+  }
+  try {
+    process.kill(-pid, "SIGKILL");
+  } catch {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+    }
+  }
+  try {
+    unlinkSync(pidFile);
+  } catch {
+  }
+  console.log("[minus-dev] cleanup done");
+}
+function writePid(projectDir) {
+  const dir = join(projectDir, ".minus");
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(projectDir, PID_FILE), String(process.pid) + "\n");
+}
+function cleanupDev(projectDir) {
+  const dir = resolve(projectDir ?? process.cwd());
+  killOldProcess(join(dir, PID_FILE));
+}
+if (process.argv[1]?.endsWith("minus-dev-cleanup") || process.argv[1]?.endsWith("cleanup.ts") || process.argv[1]?.endsWith("cleanup.js")) {
+  cleanupDev();
+}
+
+// src/index.ts
+function readSkillJson(skillDir) {
+  const p = join2(skillDir, ".minus", "skill.json");
+  if (!existsSync2(p)) return {};
+  try {
+    return JSON.parse(readFileSync2(p, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function readPipelineVersion(skillDir) {
+  const path = join2(skillDir, "pipeline.py");
+  if (!existsSync2(path)) return null;
+  const src = readFileSync2(path, "utf8");
+  const m = src.match(/^\s*version\s*=\s*["']([^"']+)["']/m);
+  return m ? m[1] : null;
+}
+function promoteToBuilds(skillDir) {
+  const meta = readSkillJson(skillDir);
+  const version = meta.version ?? readPipelineVersion(skillDir);
+  if (!version) {
+    console.log("[minus-dev] No version found, skipping promote.");
+    return;
+  }
+  const staticDir = join2(skillDir, "static");
+  if (!existsSync2(staticDir)) {
+    console.log("[minus-dev] No static/ dir, skipping promote.");
+    return;
+  }
+  const buildsRoot = join2(skillDir, "builds");
+  mkdirSync2(buildsRoot, { recursive: true });
+  const targetDir = join2(buildsRoot, version);
+  if (existsSync2(targetDir)) {
+    rmSync(targetDir, { recursive: true, force: true });
+  }
+  try {
+    renameSync(staticDir, targetDir);
+  } catch (e) {
+    if (e.code === "EXDEV") {
+      mkdirSync2(targetDir, { recursive: true });
+      cpSync(staticDir, targetDir, { recursive: true });
+      rmSync(staticDir, { recursive: true, force: true });
+    } else {
+      throw e;
+    }
+  }
+  console.log(`[minus-dev] static/ \u2192 builds/${version}/`);
+  const embedPath = join2(targetDir, "embed.html");
+  if (existsSync2(embedPath)) {
+    const IMPORT_MAP = `<script type="importmap">{"imports":{"react":"/runtime/react-all/react-all.js","react-dom":"/runtime/react-all/react-all.js","react-dom/client":"/runtime/react-all/react-all.js","react/jsx-runtime":"/runtime/react-all/react-all.js","react/jsx-dev-runtime":"/runtime/react-all/react-all.js","@minus/widget-framework":"/runtime/widget-framework/index.js","@minus/embed-sdk":"/runtime/embed-sdk/index.js","@minus/platform-widgets":"/runtime/platform-widgets/index.js","@minus/platform-utils":"/runtime/platform-utils/index.js","@minus/platform-hooks":"/runtime/platform-hooks/index.js"}}</script>`;
+    const ES_MODULE_SHIMS = `<script async src="https://ga.jspm.io/npm:es-module-shims@1.10.1/dist/es-module-shims.js"></script>`;
+    let html = readFileSync2(embedPath, "utf8");
+    html = html.replace("<head>", `<head>
+${ES_MODULE_SHIMS}
+${IMPORT_MAP}`);
+    writeFileSync2(embedPath, html, "utf8");
+    console.log("[minus-dev] importmap injected into embed.html");
+  }
+  writeFileSync2(join2(buildsRoot, ".current"), version + "\n", "utf8");
+}
+function minusDev(opts = {}) {
+  const skillDir = resolve2(process.cwd(), "..");
+  const meta = readSkillJson(skillDir);
+  let envPlatformUrl;
+  const envLocalPath = join2(skillDir, ".env.local");
+  if (existsSync2(envLocalPath)) {
+    const envContent = readFileSync2(envLocalPath, "utf8");
+    const match = envContent.match(/^MINUS_AI_PLATFORM_URL=(.+)$/m);
+    if (match) envPlatformUrl = match[1].trim();
+  }
+  let devApiKey;
+  const credentialsPath = join2(process.env.HOME || "", ".minus", "credentials.json");
+  if (existsSync2(credentialsPath)) {
+    try {
+      const creds = JSON.parse(readFileSync2(credentialsPath, "utf8"));
+      if (creds.api_key) devApiKey = creds.api_key;
+    } catch {
+    }
+  }
+  const gateway = opts.gateway ?? envPlatformUrl ?? meta.gateway ?? "http://localhost:18686";
+  const version = opts.version ?? meta.version ?? readPipelineVersion(skillDir) ?? "1.0.0";
+  const skillId = meta.skillId;
+  const localBackend = opts.localBackend;
+  let localRuntimeDir = null;
+  for (const base of [skillDir, join2(skillDir, "frontend")]) {
+    try {
+      const pluginLink = join2(base, "node_modules", "@minus", "dev-vite-plugin");
+      const pluginReal = realpathSync(pluginLink);
+      const candidate = resolve2(pluginReal, "..", "..", "runtime");
+      if (existsSync2(candidate)) {
+        localRuntimeDir = candidate;
+        break;
+      }
+    } catch {
+    }
+  }
+  if (!localRuntimeDir) {
+    for (const base of [skillDir, join2(skillDir, "frontend")]) {
+      try {
+        const pkg = JSON.parse(readFileSync2(join2(base, "package.json"), "utf8"));
+        const ref = pkg.dependencies?.["@minus-ai/dev-vite-plugin"] ?? pkg.devDependencies?.["@minus-ai/dev-vite-plugin"];
+        if (typeof ref === "string" && ref.startsWith("file:")) {
+          const pluginSrc = resolve2(base, ref.slice("file:".length));
+          const candidate = resolve2(pluginSrc, "..", "..", "runtime");
+          if (existsSync2(candidate)) {
+            localRuntimeDir = candidate;
+            break;
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  const devPlugin = {
+    name: "minus-dev-proxy",
+    apply: "serve",
+    enforce: "pre",
+    configureServer(server) {
+      cleanupDev(skillDir);
+      writePid(skillDir);
+      server.httpServer?.once("close", () => {
+        const pidFile = join2(skillDir, ".minus", "dev.pid");
+        try {
+          unlinkSync2(pidFile);
+        } catch {
+        }
+      });
+      const streamingProxy = createProxyMiddleware({
+        target: gateway,
+        changeOrigin: true,
+        cookieDomainRewrite: "",
+        proxyTimeout: 0,
+        timeout: 0
+      });
+      const bufferedProxy = createProxyMiddleware({
+        target: gateway,
+        changeOrigin: true,
+        cookieDomainRewrite: "",
+        selfHandleResponse: true,
+        proxyTimeout: 0,
+        timeout: 0,
+        on: {
+          proxyRes: (proxyRes, _req, res) => {
+            const chunks = [];
+            let finished = false;
+            const finalize = () => {
+              if (finished) return;
+              finished = true;
+              const body = Buffer.concat(chunks);
+              const headers = { ...proxyRes.headers };
+              delete headers["transfer-encoding"];
+              delete headers["connection"];
+              headers["content-length"] = String(body.length);
+              if (!res.headersSent) res.writeHead(proxyRes.statusCode || 502, headers);
+              res.end(body);
+            };
+            proxyRes.on("data", (c) => chunks.push(c));
+            proxyRes.on("end", finalize);
+            proxyRes.on("aborted", finalize);
+            proxyRes.on("error", finalize);
+          }
+        }
+      });
+      let localStreamingProxy = null;
+      let localBufferedProxy = null;
+      if (localBackend) {
+        localStreamingProxy = createProxyMiddleware({
+          target: localBackend,
+          changeOrigin: true,
+          proxyTimeout: 0,
+          timeout: 0
+        });
+        localBufferedProxy = createProxyMiddleware({
+          target: localBackend,
+          changeOrigin: true,
+          selfHandleResponse: true,
+          proxyTimeout: 0,
+          timeout: 0,
+          on: {
+            proxyRes: (proxyRes, _req, res) => {
+              const chunks = [];
+              let finished = false;
+              const finalize = () => {
+                if (finished) return;
+                finished = true;
+                const body = Buffer.concat(chunks);
+                const headers = { ...proxyRes.headers };
+                delete headers["transfer-encoding"];
+                delete headers["connection"];
+                headers["content-length"] = String(body.length);
+                if (!res.headersSent) res.writeHead(proxyRes.statusCode || 502, headers);
+                res.end(body);
+              };
+              proxyRes.on("data", (c) => chunks.push(c));
+              proxyRes.on("end", finalize);
+              proxyRes.on("aborted", finalize);
+              proxyRes.on("error", finalize);
+            }
+          }
+        });
+      }
+      const isSSE = (p) => p.includes("/pipeline/stream");
+      const localPrefix = skillId ? `/skill/${skillId}/` : null;
+      let devSessionInstalled = false;
+      if (devApiKey) {
+        server.middlewares.use((req, res, next) => {
+          if (devSessionInstalled) return next();
+          const cookie = req.headers.cookie || "";
+          const sidMatch = cookie.match(/MINUS_AI_SID=([^;]*)/);
+          if (sidMatch && sidMatch[1] === devApiKey) {
+            devSessionInstalled = true;
+            return next();
+          }
+          const urlPath = (req.url || "").split("?")[0];
+          if (!urlPath.endsWith(".html") && urlPath !== "/" && urlPath !== "") return next();
+          const body = JSON.stringify({ apiKey: devApiKey });
+          const gwUrl = new URL("/api/auth/dev-session", gateway);
+          const mod = gwUrl.protocol === "https:" ? https : http;
+          const gwReq = mod.request(gwUrl, { method: "POST", headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) } }, (gwRes) => {
+            const setCookie = gwRes.headers["set-cookie"];
+            if (setCookie) {
+              devSessionInstalled = true;
+              res.setHeader("Set-Cookie", setCookie);
+            }
+            next();
+          });
+          gwReq.on("error", () => next());
+          gwReq.end(body);
+        });
+      }
+      server.middlewares.use((req, res, next) => {
+        const urlPath = (req.url || "").split("?")[0];
+        if (urlPath === "/login") {
+          if (devApiKey) {
+            devSessionInstalled = false;
+            res.setHeader("Set-Cookie", "MINUS_AI_SID=; Path=/; Max-Age=0");
+            res.writeHead(302, { Location: "/" });
+            res.end();
+          } else {
+            const devOrigin = `http://localhost:${server.httpServer?.address()?.port || 5173}`;
+            const loginUrl = new URL("/login", gateway);
+            loginUrl.searchParams.set("returnTo", devOrigin);
+            res.writeHead(302, { Location: loginUrl.toString() });
+            res.end();
+          }
+          return;
+        }
+        next();
+      });
+      server.middlewares.use((req, res, next) => {
+        const url = req.url || "";
+        const urlPath = url.split("?")[0];
+        if (!req.headers["x-workspace-mode"]) req.headers["x-workspace-mode"] = "dev";
+        if (localPrefix && localBackend && urlPath.startsWith(localPrefix) && urlPath.includes("/api/")) {
+          const apiStart = urlPath.indexOf("/api/");
+          req.url = url.slice(apiStart);
+          return (isSSE(urlPath) ? localStreamingProxy : localBufferedProxy)(req, res, next);
+        }
+        if (urlPath.startsWith("/runtime/") && localRuntimeDir) {
+          let localPath = join2(localRuntimeDir, urlPath.slice("/runtime/".length));
+          if (!existsSync2(localPath)) {
+            const parts = urlPath.slice("/runtime/".length).split("/");
+            if (parts.length >= 2) {
+              const pkgDir = join2(localRuntimeDir, parts[0]);
+              const fileName = parts.slice(1).join("/");
+              if (existsSync2(pkgDir)) {
+                const subdirs = readdirSync(pkgDir).filter((d) => {
+                  try {
+                    return statSync(join2(pkgDir, d)).isDirectory();
+                  } catch {
+                    return false;
+                  }
+                });
+                if (subdirs.length > 0) {
+                  const resolved = join2(pkgDir, subdirs[0], fileName);
+                  if (existsSync2(resolved)) localPath = resolved;
+                }
+              }
+            }
+          }
+          if (existsSync2(localPath)) {
+            const content = readFileSync2(localPath);
+            const ext = localPath.split(".").pop();
+            const mime = ext === "js" ? "application/javascript" : ext === "css" ? "text/css" : "application/octet-stream";
+            res.writeHead(200, { "Content-Type": mime, "Content-Length": content.length });
+            res.end(content);
+            return;
+          }
+        }
+        if (urlPath.startsWith("/api/") || urlPath === "/api" || urlPath.startsWith("/auth/") || urlPath === "/auth" || urlPath.startsWith("/skill/") || urlPath === "/skill" || urlPath.startsWith("/runtime/")) {
+          return (isSSE(urlPath) ? streamingProxy : bufferedProxy)(req, res, next);
+        }
+        if (skillId && (urlPath === "/" || urlPath === "")) {
+          res.writeHead(302, { Location: `/embed.html?skill_id=${skillId}` });
+          res.end();
+          return;
+        }
+        return next();
+      });
+    },
+    // 注入 dev 配置到 HTML；独立模式下模拟 embed host 完成握手
+    transformIndexHtml(html) {
+      const devConfig = `<script>window.__MINUS_DEV__=${JSON.stringify({ version })}</script>`;
+      const importMap = `<script type="importmap">{"imports":{"react":"/runtime/react-all/react-all.js","react-dom":"/runtime/react-all/react-all.js","react-dom/client":"/runtime/react-all/react-all.js","react/jsx-runtime":"/runtime/react-all/react-all.js","react/jsx-dev-runtime":"/runtime/react-all/react-all.js","@minus/widget-framework":"/runtime/widget-framework/index.js","@minus/embed-sdk":"/runtime/embed-sdk/index.js","@minus/platform-widgets":"/runtime/platform-widgets/index.js","@minus/platform-utils":"/runtime/platform-utils/index.js","@minus/platform-hooks":"/runtime/platform-hooks/index.js"}}</script>`;
+      const embedShim = `<script>
+(function(){
+  if (window.parent !== window) return;
+  var skillId = new URLSearchParams(location.search).get("skill_id");
+  if (!skillId) return;
+  var VER = ${JSON.stringify(version)};
+
+  function uid(){ return crypto.randomUUID ? crypto.randomUUID() : Date.now().toString(36) + Math.random().toString(36).slice(2); }
+  function env(kind, type, payload, reqId){ return { sif:"v1", id: reqId||uid(), kind:kind, type:type, payload:payload, error:null, meta:{ts:Date.now(),from:"parent",skillId:skillId} }; }
+  function respond(reqId, payload){ window.postMessage(Object.assign(env("res","",payload,reqId),{type:""}), "*"); }
+
+  // \u901A\u7528 req \u54CD\u5E94\uFF1A\u5339\u914D id\uFF0C\u586B\u5145 kind=res
+  function sendRes(reqId, type, payload){
+    window.postMessage({ sif:"v1", id:reqId, kind:"res", type:type, payload:payload, error:null, meta:{ts:Date.now(),from:"parent",skillId:skillId} }, "*");
+  }
+  function sendEvt(type, payload){
+    window.postMessage(env("evt",type,payload), "*");
+  }
+
+  window.addEventListener("message", function(e){
+    var d = e.data;
+    if (!d || d.sif !== "v1") return;
+    if (d.meta && d.meta.from === "parent") return; // \u5FFD\u7565\u81EA\u5DF1\u53D1\u7684
+    // \u62E6\u622A child \u53D1\u51FA\u7684\u6D88\u606F\uFF0C\u9632\u6B62 child \u7684 RpcChannel \u6536\u5230\u81EA\u5DF1\u7684 req
+    e.stopImmediatePropagation();
+
+    // embed.ready (evt) \u2192 \u56DE embed.init (req)
+    if (d.kind === "evt" && d.type === "embed.ready") {
+      fetch("/api/skills/" + encodeURIComponent(skillId) + "/versions/" + encodeURIComponent(VER), { credentials:"include" })
+        .then(function(r){ return r.ok ? r.json() : null; })
+        .catch(function(){ return null; })
+        .then(function(skill){
+          var flow = skill ? { title:skill.displayName||skillId, description:skill.description||"", skillId:skillId, useCases:skill.useCases||[], tags:skill.tags||[] } : { title:skillId, description:"", skillId:skillId };
+          window.postMessage(env("req","embed.init",{ flow:flow, instanceId:null, currentStep:0 }), "*");
+        });
+      return;
+    }
+
+    // flow.start (req) \u2192 \u521B\u5EFA session\uFF0C\u542F\u52A8 SSE
+    if (d.kind === "req" && d.type === "flow.start") {
+      var reqId = d.id;
+      var input = d.payload && d.payload.input || {};
+      fetch("/api/skills/" + encodeURIComponent(skillId) + "/versions/" + encodeURIComponent(VER) + "/sessions", {
+        method:"POST", credentials:"include",
+        headers: {"Content-Type":"application/json"},
+        body: JSON.stringify({ entryParams: input })
+      })
+      .then(function(r){ return r.json(); })
+      .then(function(ses){
+        sendRes(reqId, "flow.start", { sessionId: ses.id, instanceId: ses.id });
+        // \u542F\u52A8 SSE pipeline stream\uFF08\u901A\u8FC7 dev proxy \u5230\u672C\u5730\u540E\u7AEF\uFF09
+        var streamUrl = "/skill/" + encodeURIComponent(skillId) + "/" + VER + "/api/sessions/" + encodeURIComponent(ses.id) + "/pipeline/stream";
+        var es = new EventSource(streamUrl);
+        es.onmessage = function(ev){
+          try {
+            var data = JSON.parse(ev.data);
+            sendEvt("state.update", data);
+          } catch(e){}
+        };
+        es.onerror = function(){ es.close(); };
+      })
+      .catch(function(err){
+        window.postMessage({ sif:"v1", id:reqId, kind:"res", type:"flow.start", payload:null, error:{code:"INTERNAL_ERROR",message:err.message}, meta:{ts:Date.now(),from:"parent",skillId:skillId} }, "*");
+      });
+      return;
+    }
+
+    // flow.resolve (req) \u2192 \u76F4\u63A5 ack
+    if (d.kind === "req" && d.type === "flow.resolve") {
+      sendRes(d.id, "flow.resolve", { ok:true });
+      return;
+    }
+
+    // api.call (req) \u2192 \u4EE3\u7406 API \u8C03\u7528
+    if (d.kind === "req" && d.type === "api.call") {
+      var p = d.payload;
+      fetch(p.url, { method:p.method||"GET", headers:p.headers||{}, body:p.body||null, credentials:"include" })
+        .then(function(r){ return r.text().then(function(t){ return {status:r.status,body:t}; }); })
+        .then(function(res){ sendRes(d.id, "api.call", res); })
+        .catch(function(err){ sendRes(d.id, "api.call", {status:500,body:err.message}); });
+      return;
+    }
+
+    // notify.toast (req) \u2192 ack
+    if (d.kind === "req" && d.type === "notify.toast") {
+      sendRes(d.id, "notify.toast", { ok:true });
+      return;
+    }
+  });
+})();
+</script>`;
+      return html.replace("<head>", `<head>
+${importMap}`).replace("</head>", `${devConfig}
+${embedShim}
+</head>`);
+    }
+  };
+  const EXTERNAL_URL_MAP = {
+    "react": "/runtime/react-all/react-all.js",
+    "react-dom": "/runtime/react-all/react-all.js",
+    "react-dom/client": "/runtime/react-all/react-all.js",
+    "react/jsx-runtime": "/runtime/react-all/react-all.js",
+    "react/jsx-dev-runtime": "/runtime/react-all/react-all.js",
+    "@minus/widget-framework": "/runtime/widget-framework/index.js",
+    "@minus/embed-sdk": "/runtime/embed-sdk/index.js",
+    "@minus/platform-widgets": "/runtime/platform-widgets/index.js",
+    "@minus/platform-utils": "/runtime/platform-utils/index.js",
+    "@minus/platform-hooks": "/runtime/platform-hooks/index.js"
+  };
+  const EXTERNALS = Object.keys(EXTERNAL_URL_MAP);
+  let isServe = false;
+  let devServerOrigin = "";
+  const VIRTUAL_PREFIX = "\0runtime:";
+  const exportsCache = /* @__PURE__ */ new Map();
+  async function getRemoteExports(source) {
+    if (exportsCache.has(source)) return exportsCache.get(source);
+    let code;
+    const relPath = EXTERNAL_URL_MAP[source];
+    let localFile = null;
+    if (localRuntimeDir) {
+      const direct = join2(localRuntimeDir, relPath.slice("/runtime/".length));
+      if (existsSync2(direct)) {
+        localFile = direct;
+      } else {
+        const parts = relPath.slice("/runtime/".length).split("/");
+        if (parts.length >= 2) {
+          const pkgDir = join2(localRuntimeDir, parts[0]);
+          const fileName = parts.slice(1).join("/");
+          if (existsSync2(pkgDir)) {
+            const latestFile = join2(pkgDir, "latest");
+            let hash = null;
+            if (existsSync2(latestFile)) {
+              hash = readFileSync2(latestFile, "utf8").trim();
+            } else {
+              const subdirs = readdirSync(pkgDir).filter((d) => {
+                try {
+                  return statSync(join2(pkgDir, d)).isDirectory();
+                } catch {
+                  return false;
+                }
+              });
+              if (subdirs.length > 0) hash = subdirs[0];
+            }
+            if (hash) {
+              const versioned = join2(pkgDir, hash, fileName);
+              if (existsSync2(versioned)) localFile = versioned;
+            }
+          }
+        }
+      }
+    }
+    if (localFile) {
+      code = readFileSync2(localFile, "utf8");
+    } else {
+      const resp = await fetch(gateway + relPath, { redirect: "follow" });
+      code = await resp.text();
+    }
+    const names = [];
+    for (const m of code.matchAll(/export\s*\{([^}]+)\}/g)) {
+      for (const item of m[1].split(",")) {
+        const trimmed = item.trim();
+        if (!trimmed) continue;
+        const asMatch = trimmed.match(/(?:\S+\s+as\s+)?(\S+)/);
+        if (asMatch) names.push(asMatch[1]);
+      }
+    }
+    for (const m of code.matchAll(/export\s+(function|const|let|var|class)\s+(\w+)/g)) {
+      names.push(m[2]);
+    }
+    const unique = [...new Set(names)].filter((n) => n !== "default");
+    exportsCache.set(source, unique);
+    return unique;
+  }
+  const externalsPlugin = {
+    name: "minus-dev-externals",
+    enforce: "pre",
+    config(_config, { command }) {
+      if (command !== "serve") return;
+      return {
+        optimizeDeps: {
+          esbuildOptions: {
+            plugins: [{
+              name: "externalize-react",
+              setup(build) {
+                build.onResolve({ filter: /^react(-dom)?(\/.*)?$/ }, (args) => {
+                  if (args.importer) {
+                    return { path: args.path, external: true };
+                  }
+                });
+              }
+            }]
+          }
+        }
+      };
+    },
+    configResolved(config) {
+      isServe = config.command === "serve";
+      if (isServe) {
+        const port = config.server?.port ?? 5173;
+        const host = "localhost";
+        devServerOrigin = `http://${host}:${port}`;
+      }
+    },
+    configureServer(server) {
+      server.httpServer?.once("listening", () => {
+        const addr = server.httpServer?.address();
+        if (addr && typeof addr === "object") {
+          devServerOrigin = `http://localhost:${addr.port}`;
+          const portsFile = join2(skillDir, ".minus", "dev-ports.json");
+          const ports = { frontend: addr.port };
+          if (localBackend) {
+            try {
+              ports.backend = new URL(localBackend).port ? parseInt(new URL(localBackend).port, 10) : 0;
+            } catch {
+            }
+          }
+          try {
+            mkdirSync2(join2(skillDir, ".minus"), { recursive: true });
+            writeFileSync2(portsFile, JSON.stringify(ports, null, 2) + "\n");
+          } catch {
+          }
+        }
+      });
+    },
+    resolveId(source) {
+      if (!EXTERNAL_URL_MAP[source]) return;
+      if (isServe) return VIRTUAL_PREFIX + source;
+      return { id: source, external: true };
+    },
+    async load(id) {
+      if (!id.startsWith(VIRTUAL_PREFIX)) return;
+      const source = id.slice(VIRTUAL_PREFIX.length);
+      const path = EXTERNAL_URL_MAP[source];
+      const exports = await getRemoteExports(source);
+      const importUrl = `${devServerOrigin}${path}`;
+      const lines = [
+        `const __m = await import("${importUrl}");`,
+        `export default __m.default;`
+      ];
+      if (exports.length > 0) {
+        lines.push(`const { ${exports.join(", ")} } = __m;`);
+        lines.push(`export { ${exports.join(", ")} };`);
+      }
+      if (source === "react/jsx-dev-runtime" || source === "react/jsx-runtime") {
+        if (!exports.includes("jsxDEV") && exports.includes("jsx")) {
+          lines.push(`export const jsxDEV = __m.jsx;`);
+        }
+      }
+      return lines.join("\n");
+    }
+  };
+  const buildPlugin = {
+    name: "minus-dev-build",
+    apply: "build",
+    config(_config, { command }) {
+      if (command !== "build") return {};
+      return {
+        build: {
+          rollupOptions: { external: EXTERNALS }
+        }
+      };
+    },
+    closeBundle() {
+      promoteToBuilds(skillDir);
+    }
+  };
+  return [externalsPlugin, devPlugin, buildPlugin];
+}
+export {
+  cleanupDev,
+  minusDev,
+  writePid
+};

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@minus-ai/dev-vite-plugin",
+  "version": "0.1.0-beta.1",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "src/index.ts",
+  "bin": {
+    "minus-dev-cleanup": "dist/cleanup.js"
+  },
+  "files": [
+    "dist/",
+    "src/"
+  ],
+  "scripts": {
+    "build": "esbuild src/index.ts --bundle --outfile=dist/index.js --format=esm --platform=node --target=node18 --packages=external && esbuild src/cleanup.ts --bundle --outfile=dist/cleanup.js --format=esm --platform=node --target=node18 --packages=external && chmod +x dist/cleanup.js"
+  },
+  "dependencies": {
+    "http-proxy-middleware": "^3.0.3"
+  },
+  "devDependencies": {
+    "esbuild": "^0.21.0"
+  },
+  "peerDependencies": {
+    "vite": "^5.0.0"
+  }
+}

package/src/.minus/session-counter

@@ -0,0 +1 @@
+7