@kenkaiiii/gg-pixel 4.3.90 → 4.3.92

package/dist/index.cjs

@@ -25,7 +25,9 @@ __export(index_exports, {
   flushPixel: () => flushPixel,
   initPixel: () => initPixel,
   install: () => install,
-  reportPixel: () => reportPixel
+  isInstallProbeFingerprint: () => isInstallProbeFingerprint,
+  reportPixel: () => reportPixel,
+  verifyInstall: () => verifyInstall
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -454,9 +456,12 @@ var LocalSqliteSink = class {
 
 // src/install.ts
 var import_node_fs3 = require("fs");
+var import_node_module2 = require("module");
 var import_node_os2 = require("os");
 var import_node_path2 = require("path");
 var import_node_child_process2 = require("child_process");
+var import_meta2 = {};
+var nodeRequire = (0, import_node_module2.createRequire)(import_meta2.url);
 var DEFAULT_INGEST_URL = "https://gg-pixel-server.buzzbeamaustralia.workers.dev";
 async function install(opts = {}) {
   const cwd = (0, import_node_path2.resolve)(opts.cwd ?? process.cwd());
@@ -520,6 +525,7 @@ async function install(opts = {}) {
     projectSecret: created.secret,
     projectName,
     projectKind: kind,
+    projectRoot: nodeRoot,
     initFilePath: wired.primaryInitPath,
     envFilePath,
     projectsJsonPath,
@@ -952,26 +958,85 @@ export default nextConfig;
     );
     return;
   }
-  const content = (0, import_node_fs3.readFileSync)(configPath, "utf8");
-  if (content.includes("@kenkaiiii/gg-pixel")) return;
+  patchNextConfigViaAst(configPath);
+}
+var PIXEL_PKG = "@kenkaiiii/gg-pixel";
+function patchNextConfigViaAst(configPath) {
+  const original = (0, import_node_fs3.readFileSync)(configPath, "utf8");
+  if (original.includes(PIXEL_PKG)) return;
+  let parseModule;
+  let generateCode;
+  try {
+    const mod = nodeRequire("magicast");
+    parseModule = mod.parseModule;
+    generateCode = mod.generateCode;
+  } catch {
+    return patchNextConfigViaRegex(configPath, original);
+  }
+  let module_;
+  try {
+    module_ = parseModule(original);
+  } catch {
+    return patchNextConfigViaRegex(configPath, original);
+  }
+  const cfg = resolveNextConfigObject(module_);
+  if (!cfg) {
+    return patchNextConfigViaRegex(configPath, original);
+  }
+  const existing = cfg.serverExternalPackages;
+  const isArrayLike = Array.isArray(existing) || typeof existing === "object" && existing !== null && existing.$type === "array";
+  if (isArrayLike) {
+    const arr = existing;
+    if (arr.includes(PIXEL_PKG)) return;
+    arr.push(PIXEL_PKG);
+  } else {
+    cfg.serverExternalPackages = [PIXEL_PKG];
+  }
+  const out = generateCode(module_).code;
+  if (out !== original) (0, import_node_fs3.writeFileSync)(configPath, out, "utf8");
+}
+function resolveNextConfigObject(mod) {
+  const root = mod.exports.default ?? mod.exports;
+  if (!root) return null;
+  return unwrapWrappers(root);
+}
+function unwrapWrappers(node) {
+  let cur = node;
+  for (let i = 0; i < 6; i++) {
+    if (cur.$type === "function-call") {
+      const args = cur.$args ?? [];
+      const objArg = args.find(
+        (a) => typeof a === "object" && a !== null && a.$type !== "function-call"
+      );
+      if (!objArg) return null;
+      cur = objArg;
+      continue;
+    }
+    if (cur.$type === "object" || cur.$type === void 0) return cur;
+    return null;
+  }
+  return null;
+}
+function patchNextConfigViaRegex(configPath, content) {
+  if (content.includes(PIXEL_PKG)) 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"]`;
+        return `serverExternalPackages: [${trimmed}${sep2}${JSON.stringify(PIXEL_PKG)}]`;
       }
     );
     if (updated !== content) (0, import_node_fs3.writeFileSync)(configPath, updated, "utf8");
     return;
   }
-  const objStart = /(const\s+\w+\s*:\s*NextConfig\s*=\s*\{|module\.exports\s*=\s*\{|export\s+default\s*\{)/;
+  const objStart = /(const\s+\w+\s*(?::\s*\w+)?\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);
+  serverExternalPackages: [${JSON.stringify(PIXEL_PKG)}],` + content.slice(insertAt);
     (0, import_node_fs3.writeFileSync)(configPath, updated, "utf8");
   }
 }
@@ -1599,6 +1664,7 @@ func init() {
     projectSecret: created.secret,
     projectName,
     projectKind: "go",
+    projectRoot,
     initFilePath,
     envFilePath,
     projectsJsonPath,
@@ -1664,6 +1730,7 @@ GGPixel.init(
     projectSecret: created.secret,
     projectName,
     projectKind: "ruby",
+    projectRoot,
     initFilePath,
     envFilePath,
     projectsJsonPath,
@@ -1733,6 +1800,7 @@ async function installPython(ctx) {
     projectSecret: created.secret,
     projectName,
     projectKind: "python",
+    projectRoot,
     initFilePath,
     envFilePath,
     projectsJsonPath,
@@ -1864,6 +1932,203 @@ function writeProjectsMapping(projectsJsonPath, projectId, name, path, secret) {
 `, "utf8");
 }
 
+// src/verify.ts
+var import_node_child_process3 = require("child_process");
+var import_node_fs4 = require("fs");
+var import_node_path3 = require("path");
+var import_node_crypto3 = require("crypto");
+var PROBE_FINGERPRINT_PREFIX = "__pixel_install_probe__";
+function isInstallProbeFingerprint(fingerprint2) {
+  return typeof fingerprint2 === "string" && fingerprint2.startsWith(PROBE_FINGERPRINT_PREFIX);
+}
+async function verifyInstall(opts) {
+  const fetchFn = opts.fetchFn ?? fetch;
+  const spawnFn = opts.spawnFn ?? import_node_child_process3.spawn;
+  const timeoutMs = opts.timeoutMs ?? 5e3;
+  const ingest = opts.ingestUrl.replace(/\/+$/, "");
+  const fingerprint2 = `${PROBE_FINGERPRINT_PREFIX}${(0, import_node_crypto3.randomBytes)(6).toString("hex")}`;
+  const start = Date.now();
+  let method;
+  let probeError = null;
+  if (opts.skipChildProbe) {
+    try {
+      await postDirectIngest({
+        ingestUrl: ingest,
+        projectKey: opts.projectKey,
+        fingerprint: fingerprint2,
+        fetchFn
+      });
+      method = "direct_ingest";
+    } catch (err) {
+      return {
+        kind: "failed",
+        reason: "Direct ingest failed",
+        hint: err.message
+      };
+    }
+  } else {
+    try {
+      await runChildProbe({
+        projectRoot: opts.projectRoot,
+        ingestUrl: ingest,
+        projectKey: opts.projectKey,
+        fingerprint: fingerprint2,
+        spawnFn
+      });
+      method = "child_process";
+    } catch (err) {
+      probeError = err.message;
+      try {
+        await postDirectIngest({
+          ingestUrl: ingest,
+          projectKey: opts.projectKey,
+          fingerprint: fingerprint2,
+          fetchFn
+        });
+        method = "direct_ingest";
+      } catch (err2) {
+        return {
+          kind: "failed",
+          reason: "Could not deliver probe event",
+          hint: `child-process: ${probeError}; direct ingest: ${err2.message}`
+        };
+      }
+    }
+  }
+  const probeRow = await pollForFingerprint({
+    ingestUrl: ingest,
+    projectId: opts.projectId,
+    projectSecret: opts.projectSecret,
+    fingerprint: fingerprint2,
+    timeoutMs,
+    fetchFn
+  });
+  if (!probeRow) {
+    return {
+      kind: "failed",
+      reason: `Probe sent (${method}) but didn't appear in /api/projects/${opts.projectId}/errors within ${timeoutMs}ms`,
+      hint: probeError ?? void 0
+    };
+  }
+  try {
+    await fetchFn(`${ingest}/api/errors/${probeRow.id}`, {
+      method: "DELETE",
+      headers: { authorization: `Bearer ${opts.projectSecret}` }
+    });
+  } catch {
+  }
+  return {
+    kind: "ok",
+    method,
+    latencyMs: Date.now() - start
+  };
+}
+async function runChildProbe(args) {
+  const ggDir = (0, import_node_path3.join)(args.projectRoot, ".gg");
+  if (!(0, import_node_fs4.existsSync)(ggDir)) (0, import_node_fs4.mkdirSync)(ggDir, { recursive: true });
+  const probePath = (0, import_node_path3.join)(ggDir, `pixel-probe-${(0, import_node_crypto3.randomBytes)(4).toString("hex")}.mjs`);
+  const script = `import "@kenkaiiii/gg-pixel";
+const body = ${JSON.stringify({
+    project_key: args.projectKey,
+    fingerprint: args.fingerprint,
+    type: "InstallProbe",
+    message: "Install verification probe \u2014 auto-generated, safe to delete",
+    stack: [],
+    code_context: null,
+    runtime: "",
+    manual_report: true,
+    level: "error"
+  })};
+body.event_id = "evt_probe_" + crypto.randomUUID();
+body.runtime = "installer-node-" + process.versions.node;
+body.occurred_at = new Date().toISOString();
+const res = await fetch(${JSON.stringify(args.ingestUrl + "/ingest")}, {
+  method: "POST",
+  headers: { "content-type": "application/json" },
+  body: JSON.stringify(body),
+});
+if (!res.ok) {
+  const txt = await res.text().catch(() => "");
+  console.error("probe ingest failed: status=" + res.status + " body=" + txt.slice(0, 200));
+  process.exit(1);
+}
+`;
+  (0, import_node_fs4.writeFileSync)(probePath, script, "utf8");
+  try {
+    await new Promise((resolve2, reject) => {
+      const opts = { cwd: args.projectRoot, stdio: "pipe" };
+      const child = args.spawnFn("node", [probePath], opts);
+      let stderr = "";
+      child.stderr?.on("data", (b) => {
+        stderr += b.toString();
+      });
+      const timer = setTimeout(() => {
+        child.kill("SIGKILL");
+        reject(new Error("Probe child timed out after 10s"));
+      }, 1e4);
+      child.on("error", (err) => {
+        clearTimeout(timer);
+        reject(err);
+      });
+      child.on("exit", (code) => {
+        clearTimeout(timer);
+        if (code === 0) resolve2();
+        else reject(new Error(`Probe exited code=${code}; stderr: ${stderr.trim().slice(0, 400)}`));
+      });
+    });
+  } finally {
+    try {
+      (0, import_node_fs4.unlinkSync)(probePath);
+    } catch {
+    }
+  }
+}
+async function postDirectIngest(args) {
+  const res = await args.fetchFn(`${args.ingestUrl}/ingest`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+      event_id: `evt_probe_${(0, import_node_crypto3.randomBytes)(8).toString("hex")}`,
+      project_key: args.projectKey,
+      fingerprint: args.fingerprint,
+      type: "InstallProbe",
+      message: "Install verification probe",
+      stack: [],
+      code_context: null,
+      runtime: `installer-node-${process.versions.node}`,
+      manual_report: true,
+      level: "error",
+      occurred_at: (/* @__PURE__ */ new Date()).toISOString()
+    })
+  });
+  if (!res.ok) {
+    let body = "";
+    try {
+      body = await res.text();
+    } catch {
+    }
+    throw new Error(`POST /ingest \u2192 ${res.status} ${body.slice(0, 200)}`);
+  }
+}
+async function pollForFingerprint(args) {
+  const deadline = Date.now() + args.timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      const res = await args.fetchFn(`${args.ingestUrl}/api/projects/${args.projectId}/errors`, {
+        headers: { authorization: `Bearer ${args.projectSecret}` }
+      });
+      if (res.ok) {
+        const body = await res.json();
+        const match = body.errors.find((e) => e.fingerprint === args.fingerprint);
+        if (match) return { id: match.id };
+      }
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, 250));
+  }
+  return null;
+}
+
 // src/index.ts
 var active = null;
 function initPixel(options) {
@@ -1916,6 +2181,8 @@ function defaultRuntime() {
   flushPixel,
   initPixel,
   install,
-  reportPixel
+  isInstallProbeFingerprint,
+  reportPixel,
+  verifyInstall
 });
 //# sourceMappingURL=index.cjs.map