@kenkaiiii/gg-pixel 4.3.69 → 4.3.71

package/dist/cli.js

@@ -28,7 +28,7 @@ async function install(opts = {}) {
   const pkgPath = join(nodeRoot, "package.json");
   const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
   const projectName = opts.projectName ?? pkg.name ?? nodeRoot.split("/").pop() ?? "unnamed";
-  const isBrowser = isBrowserProject(pkg, nodeRoot);
+  const kind = detectJsProjectKind(pkg, nodeRoot);
   const projectsJsonPath = join(home, ".gg", "projects.json");
   const envFilePath = join(nodeRoot, ".env");
   const existing = findMappingByPath(projectsJsonPath, nodeRoot);
@@ -43,26 +43,31 @@ async function install(opts = {}) {
   }
   const pm = detectPackageManager(nodeRoot);
   const packageInstalled = opts.skipPackageInstall ? false : runInstall(nodeRoot, pm, "@kenkaiiii/gg-pixel");
-  const initFilePath = join(nodeRoot, "gg-pixel.init.mjs");
-  const initContent = isBrowser ? renderBrowserInitFile(ingestUrl, created.key) : renderInitFile(ingestUrl);
-  writeFileSync(initFilePath, initContent, "utf8");
-  if (!isBrowser) {
+  const wired = wireFramework({
+    kind,
+    projectRoot: nodeRoot,
+    pkg,
+    projectKey: created.key,
+    ingestUrl
+  });
+  if (kind !== "browser" && kind !== "tauri") {
     writeEnvKey(envFilePath, "GG_PIXEL_KEY", created.key);
   }
   writeProjectsMapping(projectsJsonPath, created.id, projectName, nodeRoot);
-  const entryWiring = wireEntryFile(nodeRoot, initFilePath, pkg);
   return {
     projectId: created.id,
     projectKey: created.key,
     projectName,
-    projectKind: isBrowser ? "browser" : "node",
-    initFilePath,
+    projectKind: kind,
+    initFilePath: wired.primaryInitPath,
     envFilePath,
     projectsJsonPath,
     packageManager: pm,
     packageInstalled,
-    entryWiring,
-    reused
+    entryWiring: wired.entryWiring,
+    reused,
+    secondaryInit: wired.secondaryInit,
+    warnings: wired.warnings
   };
 }
 function findMappingByPath(projectsJsonPath, projectRoot) {
@@ -252,6 +257,349 @@ function isCommonJsEntry(entryPath, pkg) {
   if (entryPath.endsWith(".ts") || entryPath.endsWith(".tsx")) return false;
   return pkg.type !== "module";
 }
+function detectJsProjectKind(pkg, projectRoot) {
+  const all = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+  if ("electron" in all) return "electron";
+  if (existsSync(join(projectRoot, "src-tauri")) || "@tauri-apps/api" in all) return "tauri";
+  if ("react-native" in all) return "react-native";
+  if ("next" in all) return "nextjs";
+  if ("@sveltejs/kit" in all) return "sveltekit";
+  if ("nuxt" in all || "nuxt3" in all) return "nuxt";
+  if ("@remix-run/react" in all || "@remix-run/node" in all) return "remix";
+  if (isBrowserProject(pkg, projectRoot)) return "browser";
+  return "node";
+}
+function wireFramework(w) {
+  switch (w.kind) {
+    case "node":
+      return wireNode(w);
+    case "browser":
+      return wireBrowser(w);
+    case "nextjs":
+      return wireNextjs(w);
+    case "sveltekit":
+      return wireSveltekit(w);
+    case "nuxt":
+      return wireNuxt(w);
+    case "remix":
+      return wireRemix(w);
+    case "electron":
+      return wireElectron(w);
+    case "tauri":
+      return wireTauri(w);
+    case "react-native":
+      return wireReactNative(w);
+    case "python":
+      throw new Error("Internal: python should have been handled earlier");
+  }
+}
+function wireNode({ projectRoot, pkg, ingestUrl }) {
+  const initPath = join(projectRoot, "gg-pixel.init.mjs");
+  writeFileSync(initPath, renderInitFile(ingestUrl), "utf8");
+  return {
+    primaryInitPath: initPath,
+    entryWiring: wireEntryFile(projectRoot, initPath, pkg),
+    warnings: []
+  };
+}
+function wireBrowser({ projectRoot, pkg, projectKey, ingestUrl }) {
+  const initPath = join(projectRoot, "gg-pixel.init.mjs");
+  writeFileSync(initPath, renderBrowserInitFile(ingestUrl, projectKey), "utf8");
+  return {
+    primaryInitPath: initPath,
+    entryWiring: wireEntryFile(projectRoot, initPath, pkg),
+    warnings: []
+  };
+}
+function wireNextjs({ projectRoot, projectKey, ingestUrl }) {
+  const warnings = [];
+  const serverInitPath = pickPath(projectRoot, ["instrumentation.ts", "instrumentation.js"]);
+  const finalServerPath = serverInitPath ?? join(projectRoot, "instrumentation.ts");
+  writeNextInstrumentation(finalServerPath, ingestUrl);
+  const clientInitPath = join(projectRoot, "gg-pixel.client.mjs");
+  writeFileSync(clientInitPath, renderBrowserInitFile(ingestUrl, projectKey), "utf8");
+  const layoutPath = findNextLayout(projectRoot);
+  let entryWiring;
+  if (!layoutPath) {
+    warnings.push(
+      'Could not auto-wire the Next.js client init \u2014 no app/layout.{tsx,jsx} or pages/_app.{tsx,jsx} found. Add `import "./gg-pixel.client.mjs";` to your root layout/_app.'
+    );
+    entryWiring = { kind: "no_entry_found" };
+  } else {
+    entryWiring = injectImport(layoutPath, clientInitPath);
+  }
+  return {
+    primaryInitPath: clientInitPath,
+    entryWiring,
+    secondaryInit: {
+      path: finalServerPath,
+      description: "Next.js server instrumentation (auto-loaded by Next runtime)"
+    },
+    warnings
+  };
+}
+function writeNextInstrumentation(path, ingestUrl) {
+  const existing = existsSync(path) ? readFileSync(path, "utf8") : "";
+  if (existing.includes("@kenkaiiii/gg-pixel")) return;
+  const newContent = existing ? existing + "\n" + nextInstrumentationAppend(ingestUrl) : nextInstrumentationStandalone(ingestUrl);
+  writeFileSync(path, newContent, "utf8");
+}
+function nextInstrumentationStandalone(ingestUrl) {
+  return `// Next.js auto-loads this file on server start. Pixel hooks the
+// uncaughtExceptionMonitor + unhandledRejection events for API routes,
+// Server Components, and route handlers.
+export async function register() {
+  if (process.env.NEXT_RUNTIME === "nodejs") {
+    const { initPixel } = await import("@kenkaiiii/gg-pixel");
+    initPixel({
+      projectKey: process.env.GG_PIXEL_KEY ?? "",
+      sink: { kind: "http", ingestUrl: ${JSON.stringify(`${ingestUrl}/ingest`)} },
+    });
+  }
+}
+`;
+}
+function nextInstrumentationAppend(ingestUrl) {
+  return `// gg-pixel: server-side error tracking
+import { initPixel } from "@kenkaiiii/gg-pixel";
+if (typeof process !== "undefined" && process.env.NEXT_RUNTIME === "nodejs") {
+  initPixel({
+    projectKey: process.env.GG_PIXEL_KEY ?? "",
+    sink: { kind: "http", ingestUrl: ${JSON.stringify(`${ingestUrl}/ingest`)} },
+  });
+}
+`;
+}
+function findNextLayout(projectRoot) {
+  const candidates = [
+    "app/layout.tsx",
+    "app/layout.jsx",
+    "app/layout.ts",
+    "src/app/layout.tsx",
+    "src/app/layout.jsx",
+    "pages/_app.tsx",
+    "pages/_app.jsx",
+    "src/pages/_app.tsx",
+    "src/pages/_app.jsx"
+  ];
+  for (const c of candidates) {
+    const p = join(projectRoot, c);
+    if (existsSync(p)) return p;
+  }
+  return null;
+}
+function wireSveltekit({ projectRoot, projectKey, ingestUrl }) {
+  const serverPath = join(projectRoot, "src/hooks.server.ts");
+  const clientPath = join(projectRoot, "src/hooks.client.ts");
+  if (!existsSync(dirname(serverPath))) mkdirSync(dirname(serverPath), { recursive: true });
+  appendOrCreate(
+    serverPath,
+    `import { initPixel } from "@kenkaiiii/gg-pixel";
+initPixel({
+  projectKey: process.env.GG_PIXEL_KEY ?? "",
+  sink: { kind: "http", ingestUrl: ${JSON.stringify(`${ingestUrl}/ingest`)} },
+});
+`,
+    "@kenkaiiii/gg-pixel"
+  );
+  appendOrCreate(
+    clientPath,
+    `import { initPixel } from "@kenkaiiii/gg-pixel/browser";
+initPixel({
+  projectKey: ${JSON.stringify(projectKey)},
+  ingestUrl: ${JSON.stringify(ingestUrl)},
+});
+`,
+    "@kenkaiiii/gg-pixel/browser"
+  );
+  return {
+    primaryInitPath: clientPath,
+    entryWiring: { kind: "injected", entryPath: clientPath },
+    secondaryInit: {
+      path: serverPath,
+      description: "SvelteKit server hooks (auto-loaded)"
+    },
+    warnings: []
+  };
+}
+function wireNuxt({ projectRoot, projectKey, ingestUrl }) {
+  const pluginsDir = join(projectRoot, "plugins");
+  mkdirSync(pluginsDir, { recursive: true });
+  const serverPath = join(pluginsDir, "gg-pixel.server.ts");
+  const clientPath = join(pluginsDir, "gg-pixel.client.ts");
+  writeFileSync(
+    serverPath,
+    `import { initPixel } from "@kenkaiiii/gg-pixel";
+export default defineNuxtPlugin(() => {
+  initPixel({
+    projectKey: process.env.GG_PIXEL_KEY ?? "",
+    sink: { kind: "http", ingestUrl: ${JSON.stringify(`${ingestUrl}/ingest`)} },
+  });
+});
+`,
+    "utf8"
+  );
+  writeFileSync(
+    clientPath,
+    `import { initPixel } from "@kenkaiiii/gg-pixel/browser";
+export default defineNuxtPlugin(() => {
+  initPixel({
+    projectKey: ${JSON.stringify(projectKey)},
+    ingestUrl: ${JSON.stringify(ingestUrl)},
+  });
+});
+`,
+    "utf8"
+  );
+  return {
+    primaryInitPath: clientPath,
+    entryWiring: { kind: "injected", entryPath: clientPath },
+    secondaryInit: { path: serverPath, description: "Nuxt server plugin (auto-loaded)" },
+    warnings: []
+  };
+}
+function wireRemix({ projectRoot, projectKey, ingestUrl }) {
+  const serverPath = pickPath(projectRoot, ["app/entry.server.tsx", "app/entry.server.jsx"]);
+  const clientPath = pickPath(projectRoot, ["app/entry.client.tsx", "app/entry.client.jsx"]);
+  const warnings = [];
+  const clientInitPath = join(projectRoot, "gg-pixel.client.mjs");
+  writeFileSync(clientInitPath, renderBrowserInitFile(ingestUrl, projectKey), "utf8");
+  if (clientPath) {
+    injectImport(clientPath, clientInitPath);
+  } else {
+    warnings.push(
+      "No app/entry.client.tsx found. Run `npx remix reveal` then re-run pixel install."
+    );
+  }
+  const serverInitPath = join(projectRoot, "gg-pixel.server.mjs");
+  writeFileSync(serverInitPath, renderInitFile(ingestUrl), "utf8");
+  let serverEntry = { kind: "no_entry_found" };
+  if (serverPath) {
+    serverEntry = injectImport(serverPath, serverInitPath);
+  } else {
+    warnings.push(
+      "No app/entry.server.tsx found. Run `npx remix reveal` then re-run pixel install."
+    );
+  }
+  void serverEntry;
+  return {
+    primaryInitPath: clientInitPath,
+    entryWiring: clientPath ? { kind: "injected", entryPath: clientPath } : { kind: "no_entry_found" },
+    secondaryInit: { path: serverInitPath, description: "Remix server init" },
+    warnings
+  };
+}
+function wireElectron({ projectRoot, pkg, projectKey, ingestUrl }) {
+  const mainInitPath = join(projectRoot, "gg-pixel.main.mjs");
+  writeFileSync(mainInitPath, renderInitFile(ingestUrl), "utf8");
+  const rendererInitPath = join(projectRoot, "gg-pixel.renderer.mjs");
+  writeFileSync(rendererInitPath, renderBrowserInitFile(ingestUrl, projectKey), "utf8");
+  const mainEntry = pkg.main ? join(projectRoot, pkg.main) : pickPath(projectRoot, [
+    "main.js",
+    "main.ts",
+    "src/main.js",
+    "src/main.ts",
+    "electron/main.js",
+    "electron/main.ts"
+  ]);
+  let mainWiring = { kind: "no_entry_found" };
+  if (mainEntry && existsSync(mainEntry)) {
+    mainWiring = injectImport(mainEntry, mainInitPath);
+  }
+  const rendererEntry = pickPath(projectRoot, [
+    "src/renderer/index.ts",
+    "src/renderer/index.tsx",
+    "src/renderer/main.ts",
+    "src/renderer/main.tsx",
+    "renderer/index.ts",
+    "renderer/index.tsx",
+    "renderer.ts",
+    "renderer.tsx",
+    "src/index.tsx",
+    "src/main.tsx"
+  ]);
+  if (rendererEntry) {
+    injectImport(rendererEntry, rendererInitPath);
+  }
+  const warnings = [];
+  if (!rendererEntry) {
+    warnings.push(
+      'Could not auto-detect the Electron renderer entry. Add `import "./gg-pixel.renderer.mjs";` to the top of your renderer entry file.'
+    );
+  }
+  return {
+    primaryInitPath: rendererInitPath,
+    entryWiring: rendererEntry ? { kind: "injected", entryPath: rendererEntry } : { kind: "no_entry_found" },
+    secondaryInit: {
+      path: mainInitPath,
+      description: "Electron main-process init" + (mainWiring.kind === "injected" ? ` (wired into ${mainEntry})` : "")
+    },
+    warnings
+  };
+}
+function wireTauri({ projectRoot, pkg, projectKey, ingestUrl }) {
+  const initPath = join(projectRoot, "gg-pixel.init.mjs");
+  writeFileSync(initPath, renderBrowserInitFile(ingestUrl, projectKey), "utf8");
+  const entryWiring = wireEntryFile(projectRoot, initPath, pkg);
+  return {
+    primaryInitPath: initPath,
+    entryWiring,
+    warnings: [
+      "Tauri Rust backend is not instrumented \u2014 no Rust SDK exists yet. Frontend errors are captured."
+    ]
+  };
+}
+function wireReactNative({ projectRoot }) {
+  return {
+    primaryInitPath: join(projectRoot, "(not-installed)"),
+    entryWiring: { kind: "skipped", reason: "react-native SDK not built yet" },
+    warnings: [
+      "React Native is not yet supported \u2014 its JS runtime is neither browser nor Node.",
+      "A dedicated React Native SDK will be a future slice."
+    ]
+  };
+}
+function pickPath(root, candidates) {
+  for (const c of candidates) {
+    const p = join(root, c);
+    if (existsSync(p)) return p;
+  }
+  return null;
+}
+function appendOrCreate(filePath, snippet, marker) {
+  if (existsSync(filePath)) {
+    const existing = readFileSync(filePath, "utf8");
+    if (existing.includes(marker)) return;
+    writeFileSync(filePath, existing + "\n" + snippet, "utf8");
+    return;
+  }
+  writeFileSync(filePath, snippet, "utf8");
+}
+function injectImport(entryPath, initFilePath) {
+  let content;
+  try {
+    content = readFileSync(entryPath, "utf8");
+  } catch (err) {
+    return { kind: "skipped", reason: `unreadable: ${err.message}` };
+  }
+  const initBasename = initFilePath.split(sep).pop() ?? "gg-pixel.init.mjs";
+  if (content.includes(initBasename) || content.includes("@kenkaiiii/gg-pixel")) {
+    return { kind: "already_present", entryPath };
+  }
+  const fromDir = dirname(entryPath);
+  let spec = relative(fromDir, initFilePath).split(sep).join("/");
+  if (!spec.startsWith(".")) spec = "./" + spec;
+  const importLine = `import ${JSON.stringify(spec)};`;
+  const lines = content.split("\n");
+  let insertAt = 0;
+  if (lines[0]?.startsWith("#!")) insertAt = 1;
+  while (insertAt < lines.length && /^\s*(?:["']use strict["']|\/\/|\/\*)/.test(lines[insertAt] ?? "")) {
+    insertAt++;
+  }
+  const updated = [...lines.slice(0, insertAt), importLine, ...lines.slice(insertAt)].join("\n");
+  writeFileSync(entryPath, updated, "utf8");
+  return { kind: "injected", entryPath };
+}
 function isBrowserProject(pkg, projectRoot) {
   const all = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
   const browserishDeps = [
@@ -344,7 +692,8 @@ async function installPython(ctx) {
     packageManager: pm,
     packageInstalled,
     entryWiring,
-    reused
+    reused,
+    warnings: []
   };
 }
 function readPyprojectName(projectRoot) {
@@ -533,6 +882,13 @@ async function main(argv) {
   if (!result.packageInstalled && !args.skipPackageInstall) {
     console.log(`  \u26A0  Package install failed via ${result.packageManager}. Run it manually.`);
   }
+  if (result.secondaryInit) {
+    console.log(`  Also wrote:    ${result.secondaryInit.path}`);
+    console.log(`                 ${result.secondaryInit.description}`);
+  }
+  for (const w of result.warnings) {
+    console.log(`  \u26A0  ${w}`);
+  }
   console.log("");
 }
 main(process.argv.slice(2)).catch((err) => {