@kenkaiiii/gg-pixel 4.3.72 → 4.3.74

package/dist/index.js

@@ -408,7 +408,14 @@ var LocalSqliteSink = class {
 };
 
 // src/install.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync, appendFileSync, mkdirSync as mkdirSync2 } from "fs";
+import {
+  existsSync as existsSync2,
+  readFileSync as readFileSync2,
+  writeFileSync,
+  appendFileSync,
+  mkdirSync as mkdirSync2,
+  readdirSync
+} from "fs";
 import { homedir as homedir2 } from "os";
 import { dirname as dirname2, join as join2, relative, resolve, sep } from "path";
 import { spawnSync as spawnSync2 } from "child_process";
@@ -420,17 +427,25 @@ async function install(opts = {}) {
   const home = opts.homeDir ?? homedir2();
   const nodeRoot = findProjectRoot(cwd);
   const pythonRoot = findPythonProjectRoot(cwd);
-  if (!nodeRoot && !pythonRoot) {
+  const goRoot = findGoProjectRoot(cwd);
+  const rubyRoot = findRubyProjectRoot(cwd);
+  if (!nodeRoot && !pythonRoot && !goRoot && !rubyRoot) {
     throw new Error(
-      `No project found at ${cwd}: looked for package.json (Node/JS), pyproject.toml, setup.py, requirements.txt, Pipfile (Python).`
+      `No project found at ${cwd}: looked for package.json, pyproject.toml/setup.py/requirements.txt/Pipfile, go.mod, Gemfile/*.gemspec.`
     );
   }
-  const useNode = pickCloserRoot(nodeRoot, pythonRoot) === nodeRoot;
-  if (!useNode && pythonRoot) {
+  const closestRoot = pickClosestRoot([nodeRoot, pythonRoot, goRoot, rubyRoot]);
+  if (closestRoot === goRoot && goRoot) {
+    return installGo({ projectRoot: goRoot, opts, ingestUrl, fetchFn, home });
+  }
+  if (closestRoot === rubyRoot && rubyRoot) {
+    return installRuby({ projectRoot: rubyRoot, opts, ingestUrl, fetchFn, home });
+  }
+  if (closestRoot === pythonRoot && pythonRoot) {
     return installPython({ projectRoot: pythonRoot, opts, ingestUrl, fetchFn, home });
   }
   if (!nodeRoot) {
-    throw new Error("Internal: no nodeRoot but useNode==true");
+    throw new Error("Internal: closest root is Node but nodeRoot is null");
   }
   const pkgPath = join2(nodeRoot, "package.json");
   const pkg = JSON.parse(readFileSync2(pkgPath, "utf8"));
@@ -666,6 +681,9 @@ function isCommonJsEntry(entryPath, pkg) {
 }
 function detectJsProjectKind(pkg, projectRoot) {
   const all = { ...pkg.dependencies ?? {}, ...pkg.devDependencies ?? {} };
+  if (existsSync2(join2(projectRoot, "wrangler.toml")) || existsSync2(join2(projectRoot, "wrangler.jsonc")) || existsSync2(join2(projectRoot, "wrangler.json"))) {
+    return "cloudflare-workers";
+  }
   if ("electron" in all) return "electron";
   if (existsSync2(join2(projectRoot, "src-tauri")) || "@tauri-apps/api" in all) return "tauri";
   if ("react-native" in all) return "react-native";
@@ -696,8 +714,12 @@ function wireFramework(w) {
       return wireTauri(w);
     case "react-native":
       return wireReactNative(w);
+    case "cloudflare-workers":
+      return wireWorkers(w);
     case "python":
-      throw new Error("Internal: python should have been handled earlier");
+    case "go":
+    case "ruby":
+      throw new Error(`Internal: ${w.kind} should have been handled earlier`);
   }
 }
 function wireNode({ projectRoot, pkg, ingestUrl }) {
@@ -723,6 +745,7 @@ function wireNextjs({ projectRoot, projectKey, ingestUrl }) {
   const serverInitPath = pickPath(projectRoot, ["instrumentation.ts", "instrumentation.js"]);
   const finalServerPath = serverInitPath ?? join2(projectRoot, "instrumentation.ts");
   writeNextInstrumentation(finalServerPath, ingestUrl);
+  patchNextConfig(projectRoot);
   const clientInitPath = join2(projectRoot, "gg-pixel.client.mjs");
   writeFileSync(clientInitPath, renderBrowserInitFile(ingestUrl, projectKey), "utf8");
   const layoutPath = findNextLayout(projectRoot);
@@ -795,6 +818,56 @@ function findNextLayout(projectRoot) {
   }
   return null;
 }
+function patchNextConfig(projectRoot) {
+  const candidates = ["next.config.ts", "next.config.mjs", "next.config.js", "next.config.cjs"];
+  let configPath = null;
+  for (const c of candidates) {
+    const p = join2(projectRoot, c);
+    if (existsSync2(p)) {
+      configPath = p;
+      break;
+    }
+  }
+  if (!configPath) {
+    configPath = join2(projectRoot, "next.config.ts");
+    writeFileSync(
+      configPath,
+      `import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+  // Keeps Next's bundler from trying to compile better-sqlite3 (native dep).
+  serverExternalPackages: ["@kenkaiiii/gg-pixel"],
+};
+
+export default nextConfig;
+`,
+      "utf8"
+    );
+    return;
+  }
+  const content = readFileSync2(configPath, "utf8");
+  if (content.includes("@kenkaiiii/gg-pixel")) return;
+  if (content.includes("serverExternalPackages")) {
+    const updated = content.replace(
+      /serverExternalPackages\s*:\s*\[([^\]]*)\]/,
+      (_match, inside) => {
+        const trimmed = inside.trim();
+        const sep2 = trimmed.length > 0 ? ", " : "";
+        return `serverExternalPackages: [${trimmed}${sep2}"@kenkaiiii/gg-pixel"]`;
+      }
+    );
+    if (updated !== content) writeFileSync(configPath, updated, "utf8");
+    return;
+  }
+  const objStart = /(const\s+\w+\s*:\s*NextConfig\s*=\s*\{|module\.exports\s*=\s*\{|export\s+default\s*\{)/;
+  const m = objStart.exec(content);
+  if (m) {
+    const insertAt = m.index + m[0].length;
+    const updated = content.slice(0, insertAt) + `
+  serverExternalPackages: ["@kenkaiiii/gg-pixel"],` + content.slice(insertAt);
+    writeFileSync(configPath, updated, "utf8");
+  }
+}
 function wireSveltekit({ projectRoot, projectKey, ingestUrl }) {
   const serverPath = join2(projectRoot, "src/hooks.server.ts");
   const clientPath = join2(projectRoot, "src/hooks.client.ts");
@@ -956,6 +1029,48 @@ function wireTauri({ projectRoot, pkg, projectKey, ingestUrl }) {
     ]
   };
 }
+function wireWorkers({ projectRoot, projectKey, ingestUrl }) {
+  const initPath = join2(projectRoot, "gg-pixel.workers.snippet.ts");
+  writeFileSync(
+    initPath,
+    `// gg-pixel \u2014 Cloudflare Workers wiring snippet.
+// Auto-generated by ggcoder pixel install. Wrap your default export with
+// withPixel(...) so any throw in your handler is auto-reported. Example:
+//
+//   import { withPixel } from "@kenkaiiii/gg-pixel/workers";
+//
+//   export default withPixel(
+//     { projectKey: ${JSON.stringify(projectKey)} },
+//     {
+//       async fetch(req, env, ctx) { /* your code */ },
+//       async scheduled(evt, env, ctx) { /* your code */ },
+//     },
+//   );
+//
+// For manual reports inside a handler:
+//
+//   import { reportPixel } from "@kenkaiiii/gg-pixel/workers";
+//   reportPixel(ctx, { projectKey: ${JSON.stringify(projectKey)} }, {
+//     message: "user clicked the broken button",
+//   });
+//
+// Your project_key is publishable \u2014 safe to commit.
+
+import { withPixel, reportPixel } from "@kenkaiiii/gg-pixel/workers";
+export const PIXEL_KEY = ${JSON.stringify(projectKey)};
+export const PIXEL_INGEST = ${JSON.stringify(ingestUrl)};
+export { withPixel, reportPixel };
+`,
+    "utf8"
+  );
+  return {
+    primaryInitPath: initPath,
+    entryWiring: { kind: "no_entry_found" },
+    warnings: [
+      `Cloudflare Workers default exports can't be auto-wrapped safely. Open ${initPath} for a 3-line snippet you can paste into your worker.`
+    ]
+  };
+}
 function wireReactNative({ projectRoot }) {
   return {
     primaryInitPath: join2(projectRoot, "(not-installed)"),
@@ -1061,10 +1176,191 @@ function detectPythonPackageManager(projectRoot) {
   if (existsSync2(join2(projectRoot, "Pipfile.lock"))) return "pipenv";
   return "pip";
 }
-function pickCloserRoot(a, b) {
-  if (!a) return b;
-  if (!b) return a;
-  return a.length >= b.length ? a : b;
+function pickClosestRoot(roots) {
+  let best = null;
+  for (const r of roots) {
+    if (!r) continue;
+    if (!best || r.length > best.length) best = r;
+  }
+  return best;
+}
+var GO_MARKER = "go.mod";
+var RUBY_MARKERS = ["Gemfile"];
+function findGoProjectRoot(start) {
+  let dir = start;
+  for (let i = 0; i < 20; i++) {
+    if (existsSync2(join2(dir, GO_MARKER))) return dir;
+    const parent = dirname2(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+  return null;
+}
+function findRubyProjectRoot(start) {
+  let dir = start;
+  for (let i = 0; i < 20; i++) {
+    for (const m of RUBY_MARKERS) {
+      if (existsSync2(join2(dir, m))) return dir;
+    }
+    try {
+      const entries = readdirSync(dir);
+      if (entries.some((e) => e.endsWith(".gemspec"))) return dir;
+    } catch {
+    }
+    const parent = dirname2(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+  return null;
+}
+async function installGo(ctx) {
+  const { projectRoot, opts, ingestUrl, fetchFn, home } = ctx;
+  const projectName = opts.projectName ?? readGoModuleName(projectRoot) ?? projectRoot.split("/").pop() ?? "unnamed";
+  const projectsJsonPath = join2(home, ".gg", "projects.json");
+  const envFilePath = join2(projectRoot, ".env");
+  const existing = findMappingByPath(projectsJsonPath, projectRoot);
+  const existingKey = readEnvKey(envFilePath, "GG_PIXEL_KEY");
+  let created;
+  let reused = false;
+  if (existing && existingKey) {
+    created = { id: existing.id, key: existingKey };
+    reused = true;
+  } else {
+    created = await createProject(fetchFn, ingestUrl, projectName);
+  }
+  const packageInstalled = opts.skipPackageInstall ? false : runGoGet(projectRoot);
+  const initFilePath = join2(projectRoot, "gg_pixel_init.go");
+  writeFileSync(
+    initFilePath,
+    `// gg-pixel init \u2014 auto-generated by ggcoder pixel install.
+package main
+
+import (
+	"os"
+	gg "github.com/kenkaiiii/gg-pixel-go"
+)
+
+func init() {
+	key := os.Getenv("GG_PIXEL_KEY")
+	if key == "" {
+		key = ${JSON.stringify(created.key)}
+	}
+	_ = gg.Init(gg.Options{ProjectKey: key, IngestURL: ${JSON.stringify(`${ingestUrl}/ingest`)}})
+}
+`,
+    "utf8"
+  );
+  writeEnvKey(envFilePath, "GG_PIXEL_KEY", created.key);
+  writeProjectsMapping(projectsJsonPath, created.id, projectName, projectRoot);
+  return {
+    projectId: created.id,
+    projectKey: created.key,
+    projectName,
+    projectKind: "go",
+    initFilePath,
+    envFilePath,
+    projectsJsonPath,
+    packageManager: "pip",
+    packageInstalled,
+    entryWiring: { kind: "no_entry_found" },
+    reused,
+    warnings: [
+      "Add `defer ggpixel.Recover()` near the top of your main() so panics are captured before the process exits."
+    ]
+  };
+}
+function readGoModuleName(projectRoot) {
+  try {
+    const content = readFileSync2(join2(projectRoot, "go.mod"), "utf8");
+    const match = /^\s*module\s+(\S+)\s*$/m.exec(content);
+    if (!match) return null;
+    return match[1].split("/").pop() ?? null;
+  } catch {
+    return null;
+  }
+}
+function runGoGet(projectRoot) {
+  const result = spawnSync2("go", ["get", "github.com/kenkaiiii/gg-pixel-go@latest"], {
+    cwd: projectRoot,
+    stdio: "inherit"
+  });
+  return result.status === 0;
+}
+async function installRuby(ctx) {
+  const { projectRoot, opts, ingestUrl, fetchFn, home } = ctx;
+  const projectName = opts.projectName ?? readRubyAppName(projectRoot) ?? projectRoot.split("/").pop() ?? "unnamed";
+  const projectsJsonPath = join2(home, ".gg", "projects.json");
+  const envFilePath = join2(projectRoot, ".env");
+  const existing = findMappingByPath(projectsJsonPath, projectRoot);
+  const existingKey = readEnvKey(envFilePath, "GG_PIXEL_KEY");
+  let created;
+  let reused = false;
+  if (existing && existingKey) {
+    created = { id: existing.id, key: existingKey };
+    reused = true;
+  } else {
+    created = await createProject(fetchFn, ingestUrl, projectName);
+  }
+  const packageInstalled = opts.skipPackageInstall ? false : runRubyInstall(projectRoot);
+  const initFilePath = join2(projectRoot, "gg_pixel_init.rb");
+  writeFileSync(
+    initFilePath,
+    `# gg-pixel init \u2014 auto-generated by ggcoder pixel install.
+require "gg_pixel"
+GGPixel.init(
+  project_key: ENV["GG_PIXEL_KEY"] || ${JSON.stringify(created.key)},
+  ingest_url: ${JSON.stringify(`${ingestUrl}/ingest`)},
+)
+`,
+    "utf8"
+  );
+  writeEnvKey(envFilePath, "GG_PIXEL_KEY", created.key);
+  writeProjectsMapping(projectsJsonPath, created.id, projectName, projectRoot);
+  return {
+    projectId: created.id,
+    projectKey: created.key,
+    projectName,
+    projectKind: "ruby",
+    initFilePath,
+    envFilePath,
+    projectsJsonPath,
+    packageManager: "pip",
+    packageInstalled,
+    entryWiring: { kind: "no_entry_found" },
+    reused,
+    warnings: [
+      `Add \`require "./gg_pixel_init"\` at the top of your entry script (often \`config/application.rb\` for Rails, \`app.rb\` for Sinatra, or your main file).`
+    ]
+  };
+}
+function readRubyAppName(projectRoot) {
+  try {
+    const entries = readdirSync(projectRoot);
+    const gemspec = entries.find((e) => e.endsWith(".gemspec"));
+    if (!gemspec) return null;
+    return gemspec.replace(/\.gemspec$/, "");
+  } catch {
+    return null;
+  }
+}
+function runRubyInstall(projectRoot) {
+  if (existsSync2(join2(projectRoot, "Gemfile"))) {
+    try {
+      const content = readFileSync2(join2(projectRoot, "Gemfile"), "utf8");
+      if (!content.includes("gg_pixel")) {
+        writeFileSync(
+          join2(projectRoot, "Gemfile"),
+          content + (content.endsWith("\n") ? "" : "\n") + 'gem "gg_pixel"\n',
+          "utf8"
+        );
+      }
+    } catch {
+    }
+    const r = spawnSync2("bundle", ["install"], { cwd: projectRoot, stdio: "inherit" });
+    if (r.status === 0) return true;
+  }
+  const r2 = spawnSync2("gem", ["install", "gg_pixel"], { cwd: projectRoot, stdio: "inherit" });
+  return r2.status === 0;
 }
 async function installPython(ctx) {
   const { projectRoot, opts, ingestUrl, fetchFn, home } = ctx;