made-refine 0.2.0 → 0.2.1-beta.1

package/README.md

@@ -31,7 +31,7 @@ This detects your framework, installs the package, previews file changes, and ap
 - Renders inside Shadow DOM for full CSS isolation from your app
 - Babel/Vite plugin adds source location metadata to every JSX element
 - Hooks into React DevTools fiber tree for component name resolution
-- Built-in MCP server enables hands-free agent workflows
+- Integrates with the desktop app MCP broker for hands-free agent workflows
 
 ## Supported frameworks
 

package/dist/cli.cjs

@@ -8435,185 +8435,8 @@ function installPackage(cwd) {
     console.log(import_picocolors.default.dim(`    ${cmd}`));
   }
 }
-var BABEL_JSON_CONFIG_FILES = [".babelrc", ".babelrc.json", "babel.config.json"];
-var BABEL_JS_CONFIG_FILES = [
-  ".babelrc.js",
-  ".babelrc.cjs",
-  ".babelrc.mjs",
-  "babel.config.js",
-  "babel.config.cjs",
-  "babel.config.mjs"
-];
-function findBabelConfigFile(cwd) {
-  for (const file of BABEL_JSON_CONFIG_FILES) {
-    const absolutePath = import_path2.default.join(cwd, file);
-    if (import_fs2.default.existsSync(absolutePath)) {
-      return {
-        absolutePath,
-        relativePath: file,
-        kind: "json"
-      };
-    }
-  }
-  for (const file of BABEL_JS_CONFIG_FILES) {
-    const absolutePath = import_path2.default.join(cwd, file);
-    if (import_fs2.default.existsSync(absolutePath)) {
-      return {
-        absolutePath,
-        relativePath: file,
-        kind: "js"
-      };
-    }
-  }
-  const packageJsonPath = import_path2.default.join(cwd, "package.json");
-  if (import_fs2.default.existsSync(packageJsonPath)) {
-    try {
-      const packageJson = JSON.parse(import_fs2.default.readFileSync(packageJsonPath, "utf-8"));
-      if (packageJson.babel !== void 0) {
-        return {
-          absolutePath: packageJsonPath,
-          relativePath: "package.json#babel",
-          kind: "package-json"
-        };
-      }
-    } catch {
-    }
-  }
-  return null;
-}
-function isMadeRefinePlugin(plugin) {
-  if (typeof plugin === "string") {
-    return plugin === "made-refine/babel";
-  }
-  if (Array.isArray(plugin) && typeof plugin[0] === "string") {
-    return plugin[0] === "made-refine/babel";
-  }
-  return false;
-}
-function hasMadeRefinePlugin(plugins) {
-  if (!Array.isArray(plugins)) return false;
-  return plugins.some((plugin) => isMadeRefinePlugin(plugin));
-}
-function ensureMadeRefineInDevelopmentEnv(config) {
-  if (hasMadeRefinePlugin(config.plugins)) {
-    return "already-configured";
-  }
-  const existingEnv = config.env;
-  if (existingEnv !== void 0 && (typeof existingEnv !== "object" || existingEnv === null || Array.isArray(existingEnv))) {
-    return "unsupported-shape";
-  }
-  if (!config.env) {
-    config.env = {};
-  }
-  const env = config.env;
-  const existingDevelopment = env.development;
-  if (existingDevelopment !== void 0 && (typeof existingDevelopment !== "object" || existingDevelopment === null || Array.isArray(existingDevelopment))) {
-    return "unsupported-shape";
-  }
-  if (!env.development) {
-    env.development = {};
-  }
-  const development = env.development;
-  if (hasMadeRefinePlugin(development.plugins)) {
-    return "already-configured";
-  }
-  if (development.plugins === void 0) {
-    development.plugins = ["made-refine/babel"];
-    return "updated";
-  }
-  if (!Array.isArray(development.plugins)) {
-    return "unsupported-shape";
-  }
-  development.plugins = [...development.plugins, "made-refine/babel"];
-  return "updated";
-}
-function printManualNextBabelInstructions() {
-  console.log(
-    import_picocolors.default.dim(
-      "    env: { development: { plugins: ['made-refine/babel'] } }\n    (or add 'made-refine/babel' in your existing Babel plugin list)"
-    )
-  );
-}
-function configureNextBabel(cwd) {
-  const configFile = findBabelConfigFile(cwd);
-  if (!configFile) {
-    console.log(
-      import_picocolors.default.yellow("  \u26A0 No existing Babel config found \u2014 skipping Babel config to preserve SWC/Turbopack defaults.")
-    );
-    console.log(import_picocolors.default.dim("    Source detection will use React fiber fallback (less precise than Babel attributes)."));
-    return;
-  }
-  if (configFile.kind === "js") {
-    console.log(import_picocolors.default.yellow(`  \u26A0 Found ${configFile.relativePath} (JS Babel config) \u2014 verify/add plugin manually:`));
-    printManualNextBabelInstructions();
-    return;
-  }
-  if (configFile.kind === "package-json") {
-    let packageJson;
-    try {
-      packageJson = JSON.parse(import_fs2.default.readFileSync(configFile.absolutePath, "utf-8"));
-    } catch {
-      console.log(import_picocolors.default.yellow("  \u26A0 Could not parse package.json \u2014 add plugin manually:"));
-      printManualNextBabelInstructions();
-      return;
-    }
-    if (typeof packageJson !== "object" || packageJson === null || Array.isArray(packageJson)) {
-      console.log(import_picocolors.default.yellow("  \u26A0 package.json has unsupported shape \u2014 add plugin manually:"));
-      printManualNextBabelInstructions();
-      return;
-    }
-    const pkg = packageJson;
-    if (typeof pkg.babel !== "object" || pkg.babel === null || Array.isArray(pkg.babel)) {
-      console.log(import_picocolors.default.yellow("  \u26A0 package.json#babel has unsupported shape \u2014 add plugin manually:"));
-      printManualNextBabelInstructions();
-      return;
-    }
-    const result2 = ensureMadeRefineInDevelopmentEnv(pkg.babel);
-    if (result2 === "already-configured") {
-      console.log(import_picocolors.default.dim("  package.json#babel \u2014 already configured"));
-      return;
-    }
-    if (result2 === "unsupported-shape") {
-      console.log(import_picocolors.default.yellow("  \u26A0 package.json#babel has unsupported shape \u2014 add plugin manually:"));
-      printManualNextBabelInstructions();
-      return;
-    }
-    import_fs2.default.writeFileSync(configFile.absolutePath, `${JSON.stringify(pkg, null, 2)}
-`, "utf-8");
-    console.log(import_picocolors.default.green('  \u2713 Updated package.json#babel (added "made-refine/babel" in development env)'));
-    return;
-  }
-  const content = import_fs2.default.readFileSync(configFile.absolutePath, "utf-8");
-  let parsed;
-  try {
-    parsed = JSON.parse(content);
-  } catch {
-    console.log(import_picocolors.default.yellow(`  \u26A0 Could not parse ${configFile.relativePath} as JSON \u2014 add plugin manually:`));
-    printManualNextBabelInstructions();
-    return;
-  }
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-    console.log(import_picocolors.default.yellow(`  \u26A0 ${configFile.relativePath} has unsupported shape \u2014 add plugin manually:`));
-    printManualNextBabelInstructions();
-    return;
-  }
-  const result = ensureMadeRefineInDevelopmentEnv(parsed);
-  if (result === "already-configured") {
-    console.log(import_picocolors.default.dim(`  ${configFile.relativePath} \u2014 already configured`));
-    return;
-  }
-  if (result === "unsupported-shape") {
-    console.log(import_picocolors.default.yellow(`  \u26A0 ${configFile.relativePath} has unsupported shape \u2014 add plugin manually:`));
-    printManualNextBabelInstructions();
-    return;
-  }
-  import_fs2.default.writeFileSync(configFile.absolutePath, `${JSON.stringify(parsed, null, 2)}
-`, "utf-8");
-  console.log(import_picocolors.default.green(`  \u2713 Updated ${configFile.relativePath} (added "made-refine/babel" in development env)`));
-}
 async function setupNextJs(cwd) {
   console.log(import_picocolors.default.bold("\nConfiguring for Next.js...\n"));
-  configureNextBabel(cwd);
   const preloadSrc = import_path2.default.join(cwd, "node_modules/made-refine/dist/preload/preload.js");
   const publicDir = import_path2.default.join(cwd, "public");
   const preloadDest = import_path2.default.join(publicDir, "made-refine-preload.js");

package/dist/index.js

@@ -2425,44 +2425,335 @@ function hslToRgb(h, s, l) {
 }
 
 // src/mcp-client.ts
-var MCP_BASE = "http://127.0.0.1:4747";
-var cachedToken = null;
-async function getSessionToken(forceRefresh = false) {
-  if (!forceRefresh && cachedToken) return cachedToken;
+var PROTOCOL_VERSION = 1;
+var BOOTSTRAP_TIMEOUT_MS = 2500;
+var REQUEST_TIMEOUT_MS = 3e3;
+var SESSION_EXPIRY_SKEW_MS = 5e3;
+var CLIENT_NAME = "made-refine";
+var DEFAULT_CLIENT_VERSION = "unknown";
+var BOOTSTRAP_ENV_KEYS = [
+  "MADE_REFINE_MCP_BOOTSTRAP_URL",
+  "VITE_MADE_REFINE_MCP_BOOTSTRAP_URL",
+  "NEXT_PUBLIC_MADE_REFINE_MCP_BOOTSTRAP_URL"
+];
+var CLIENT_VERSION_ENV_KEYS = [
+  "MADE_REFINE_VERSION",
+  "VITE_MADE_REFINE_VERSION",
+  "NEXT_PUBLIC_MADE_REFINE_VERSION"
+];
+var cachedSession = null;
+function getTimeoutSignal(timeoutMs) {
+  const timeout = AbortSignal.timeout;
+  return typeof timeout === "function" ? timeout(timeoutMs) : void 0;
+}
+function getRuntimeMcpConfig() {
+  if (typeof window === "undefined") return null;
+  const config = window.__MADE_REFINE_CONFIG__;
+  const bootstrapUrl = config?.mcp?.bootstrapUrl ?? config?.mcpBootstrapUrl ?? window.__MADE_REFINE_MCP_BOOTSTRAP_URL__;
+  if (!config?.mcp && typeof bootstrapUrl !== "string") return null;
+  return {
+    ...config?.mcp ?? {},
+    ...typeof bootstrapUrl === "string" ? { bootstrapUrl } : {}
+  };
+}
+function toNonEmptyString(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function getStaticProcessEnvValue(key) {
+  switch (key) {
+    case "MADE_REFINE_MCP_BOOTSTRAP_URL":
+      return toNonEmptyString(typeof process !== "undefined" ? process.env?.MADE_REFINE_MCP_BOOTSTRAP_URL : void 0);
+    case "VITE_MADE_REFINE_MCP_BOOTSTRAP_URL":
+      return toNonEmptyString(typeof process !== "undefined" ? process.env?.VITE_MADE_REFINE_MCP_BOOTSTRAP_URL : void 0);
+    case "NEXT_PUBLIC_MADE_REFINE_MCP_BOOTSTRAP_URL":
+      return toNonEmptyString(typeof process !== "undefined" ? process.env?.NEXT_PUBLIC_MADE_REFINE_MCP_BOOTSTRAP_URL : void 0);
+    case "MADE_REFINE_VERSION":
+      return toNonEmptyString(typeof process !== "undefined" ? process.env?.MADE_REFINE_VERSION : void 0);
+    case "VITE_MADE_REFINE_VERSION":
+      return toNonEmptyString(typeof process !== "undefined" ? process.env?.VITE_MADE_REFINE_VERSION : void 0);
+    case "NEXT_PUBLIC_MADE_REFINE_VERSION":
+      return toNonEmptyString(typeof process !== "undefined" ? process.env?.NEXT_PUBLIC_MADE_REFINE_VERSION : void 0);
+    default:
+      return null;
+  }
+}
+function getDynamicProcessEnvValue(keys) {
+  const processLike = globalThis.process;
+  const env = processLike?.env;
+  if (!env) return null;
+  for (const key of keys) {
+    const value = toNonEmptyString(env[key]);
+    if (value) return value;
+  }
+  return null;
+}
+function getEnvValue(keys) {
+  for (const key of keys) {
+    const processValue = getStaticProcessEnvValue(key);
+    if (processValue) return processValue;
+  }
+  return getDynamicProcessEnvValue(keys);
+}
+function normalizeUrl(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  if (/^https?:\/\//i.test(trimmed)) {
+    return trimmed.replace(/\/+$/, "");
+  }
+  if (typeof window === "undefined" || !window.location?.origin) return null;
   try {
-    const res = await fetch(`${MCP_BASE}/api/health`, { signal: AbortSignal.timeout(2e3) });
-    if (!res.ok) return null;
-    const data = await res.json();
-    cachedToken = typeof data.sessionToken === "string" ? data.sessionToken : null;
-    return cachedToken;
+    return new URL(trimmed, window.location.origin).toString().replace(/\/+$/, "");
   } catch {
     return null;
   }
 }
-async function postWithSessionToken(path, payload) {
-  const send = async (token2) => {
+function normalizeBootstrapUrl(value) {
+  const normalized = normalizeUrl(value);
+  if (!normalized) return null;
+  try {
+    const url = new URL(normalized);
+    const normalizedPathname = url.pathname.replace(/\/+$/, "");
+    url.pathname = normalizedPathname.endsWith("/v1/bootstrap") ? normalizedPathname : `${normalizedPathname}/v1/bootstrap`;
+    return url.toString();
+  } catch {
+    return normalized.endsWith("/v1/bootstrap") ? normalized : `${normalized}/v1/bootstrap`;
+  }
+}
+function toSafeBootstrapUrl(value) {
+  const normalized = normalizeBootstrapUrl(value);
+  if (!normalized) return null;
+  return isLoopbackHttpUrl(normalized) ? normalized : null;
+}
+function joinUrl(base, path) {
+  return `${base.replace(/\/+$/, "")}${path}`;
+}
+function readString(record, key) {
+  const value = record?.[key];
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function parseExpiresAt(value) {
+  if (typeof value !== "string") return null;
+  const timestamp = Date.parse(value);
+  return Number.isFinite(timestamp) ? timestamp : null;
+}
+function readNumber(record, key) {
+  const value = record?.[key];
+  if (typeof value !== "number" || !Number.isFinite(value)) return null;
+  return value;
+}
+function isLoopbackIpv4(hostname) {
+  if (!/^127(?:\.\d{1,3}){3}$/.test(hostname)) return false;
+  const segments = hostname.split(".");
+  return segments.every((segment) => {
+    const value = Number(segment);
+    return Number.isInteger(value) && value >= 0 && value <= 255;
+  });
+}
+function isLoopbackHostname(hostname) {
+  if (hostname === "localhost" || hostname.endsWith(".localhost")) return true;
+  if (hostname === "::1" || hostname === "[::1]") return true;
+  return isLoopbackIpv4(hostname);
+}
+function isLoopbackHttpUrl(value) {
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+    return isLoopbackHostname(url.hostname);
+  } catch {
+    return false;
+  }
+}
+function buildBootstrapRequestBody(runtimeConfig) {
+  const locationPath = typeof window !== "undefined" ? window.location.pathname : "";
+  const locationOrigin = typeof window !== "undefined" ? window.location.origin : null;
+  return {
+    protocolVersion: PROTOCOL_VERSION,
+    projectFingerprint: {
+      path: runtimeConfig?.projectFingerprint?.path || locationPath || "unknown",
+      gitRemoteHash: runtimeConfig?.projectFingerprint?.gitRemoteHash ?? null
+    },
+    ...runtimeConfig?.workspaceId ? {
+      workspaceId: runtimeConfig.workspaceId
+    } : {},
+    client: {
+      name: CLIENT_NAME,
+      version: runtimeConfig?.clientVersion ?? getEnvValue(CLIENT_VERSION_ENV_KEYS) ?? DEFAULT_CLIENT_VERSION,
+      origin: locationOrigin
+    }
+  };
+}
+function resolveBootstrapUrl() {
+  const runtimeConfig = getRuntimeMcpConfig();
+  const runtimeUrl = toSafeBootstrapUrl(runtimeConfig?.bootstrapUrl);
+  if (runtimeUrl) return runtimeUrl;
+  const envUrl = toSafeBootstrapUrl(getEnvValue(BOOTSTRAP_ENV_KEYS));
+  if (envUrl) return envUrl;
+  return null;
+}
+function isSessionUsable(session, bootstrapUrl) {
+  if (!session) return false;
+  if (session.bootstrapUrl !== bootstrapUrl) return false;
+  if (session.expiresAt == null) return true;
+  return Date.now() < session.expiresAt - SESSION_EXPIRY_SKEW_MS;
+}
+async function readJsonRecord(response) {
+  try {
+    const data = await response.json();
+    if (!data || typeof data !== "object") return null;
+    return data;
+  } catch {
+    return null;
+  }
+}
+async function bootstrapSession(force = false) {
+  const bootstrapUrl = resolveBootstrapUrl();
+  if (!bootstrapUrl) {
+    cachedSession = null;
+    return null;
+  }
+  if (!force && isSessionUsable(cachedSession, bootstrapUrl)) {
+    return cachedSession;
+  }
+  const runtimeConfig = getRuntimeMcpConfig();
+  try {
+    const response = await fetch(bootstrapUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(buildBootstrapRequestBody(runtimeConfig)),
+      signal: getTimeoutSignal(BOOTSTRAP_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      cachedSession = null;
+      return null;
+    }
+    const data = await readJsonRecord(response);
+    const protocolVersion = readNumber(data, "protocolVersion");
+    if (protocolVersion !== PROTOCOL_VERSION) {
+      cachedSession = null;
+      return null;
+    }
+    const ingestBaseUrl = normalizeUrl(readString(data, "ingestBaseUrl"));
+    if (!ingestBaseUrl || !isLoopbackHttpUrl(ingestBaseUrl)) {
+      cachedSession = null;
+      return null;
+    }
+    const nextSession = {
+      bootstrapUrl,
+      ingestBaseUrl,
+      serverInstanceId: readString(data, "serverInstanceId"),
+      projectId: readString(data, "projectId"),
+      sessionId: readString(data, "sessionId"),
+      accessToken: readString(data, "accessToken"),
+      expiresAt: parseExpiresAt(data?.expiresAt)
+    };
+    cachedSession = nextSession;
+    return nextSession;
+  } catch {
+    cachedSession = null;
+    return null;
+  }
+}
+async function refreshSessionToken(session) {
+  try {
     const headers = { "Content-Type": "application/json" };
-    if (token2) headers["X-Session-Token"] = token2;
-    return fetch(`${MCP_BASE}${path}`, {
+    if (session.accessToken) {
+      headers.Authorization = `Bearer ${session.accessToken}`;
+    }
+    const response = await fetch(joinUrl(session.ingestBaseUrl, "/v1/sessions/refresh"), {
       method: "POST",
       headers,
-      body: JSON.stringify(payload)
+      body: JSON.stringify({
+        protocolVersion: PROTOCOL_VERSION,
+        projectId: session.projectId,
+        sessionId: session.sessionId
+      }),
+      signal: getTimeoutSignal(REQUEST_TIMEOUT_MS)
     });
+    if (response.status === 404 || response.status === 405) {
+      return null;
+    }
+    if (!response.ok) {
+      return null;
+    }
+    const data = await readJsonRecord(response);
+    const nextToken = readString(data, "accessToken");
+    if (!nextToken) {
+      return null;
+    }
+    const refreshedSession = {
+      ...session,
+      accessToken: nextToken,
+      expiresAt: parseExpiresAt(data?.expiresAt) ?? session.expiresAt
+    };
+    cachedSession = refreshedSession;
+    return refreshedSession;
+  } catch {
+    return null;
+  }
+}
+function createIdempotencyKey() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).slice(2, 12);
+  return `${timestamp}-${random}`;
+}
+async function sendAnnotationRequest(session, path, payload, idempotencyKey) {
+  const headers = {
+    "Content-Type": "application/json",
+    "X-Idempotency-Key": idempotencyKey
   };
-  let token = await getSessionToken();
-  let res = await send(token);
-  if (res.status === 403) {
-    cachedToken = null;
-    token = await getSessionToken(true);
-    res = await send(token);
+  if (session.accessToken) {
+    headers.Authorization = `Bearer ${session.accessToken}`;
+  }
+  return fetch(joinUrl(session.ingestBaseUrl, path), {
+    method: "POST",
+    headers,
+    body: JSON.stringify(payload),
+    signal: getTimeoutSignal(REQUEST_TIMEOUT_MS)
+  });
+}
+async function toClientResponse(response) {
+  const data = await readJsonRecord(response);
+  const bodyOk = data?.ok;
+  const parsedOk = typeof bodyOk === "boolean" ? bodyOk : response.ok;
+  return {
+    ok: parsedOk && response.ok,
+    id: readString(data, "id") ?? ""
+  };
+}
+async function postWithSessionToken(path, payload) {
+  const idempotencyKey = createIdempotencyKey();
+  let session = await bootstrapSession();
+  if (!session) return { ok: false, id: "" };
+  let response;
+  try {
+    response = await sendAnnotationRequest(session, path, payload, idempotencyKey);
+  } catch {
+    return { ok: false, id: "" };
+  }
+  if (response.status === 401 || response.status === 403) {
+    session = await refreshSessionToken(session) ?? await bootstrapSession(true);
+    if (!session) return { ok: false, id: "" };
+    try {
+      response = await sendAnnotationRequest(session, path, payload, idempotencyKey);
+    } catch {
+      return { ok: false, id: "" };
+    }
   }
-  return res.json();
+  return toClientResponse(response);
 }
 async function sendEditToAgent(edit) {
-  return postWithSessionToken("/api/edit", edit);
+  return postWithSessionToken("/v1/annotations/edit", edit);
 }
 async function sendCommentToAgent(comment) {
-  return postWithSessionToken("/api/comment", comment);
+  return postWithSessionToken("/v1/annotations/comment", comment);
 }
 
 // src/provider.tsx