@kenkaiiii/gg-pixel 4.3.90 → 4.3.91

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);
 
@@ -520,6 +522,7 @@ async function install(opts = {}) {
     projectSecret: created.secret,
     projectName,
     projectKind: kind,
+    projectRoot: nodeRoot,
     initFilePath: wired.primaryInitPath,
     envFilePath,
     projectsJsonPath,
@@ -1599,6 +1602,7 @@ func init() {
     projectSecret: created.secret,
     projectName,
     projectKind: "go",
+    projectRoot,
     initFilePath,
     envFilePath,
     projectsJsonPath,
@@ -1664,6 +1668,7 @@ GGPixel.init(
     projectSecret: created.secret,
     projectName,
     projectKind: "ruby",
+    projectRoot,
     initFilePath,
     envFilePath,
     projectsJsonPath,
@@ -1733,6 +1738,7 @@ async function installPython(ctx) {
     projectSecret: created.secret,
     projectName,
     projectKind: "python",
+    projectRoot,
     initFilePath,
     envFilePath,
     projectsJsonPath,
@@ -1864,6 +1870,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 +2119,8 @@ function defaultRuntime() {
   flushPixel,
   initPixel,
   install,
-  reportPixel
+  isInstallProbeFingerprint,
+  reportPixel,
+  verifyInstall
 });
 //# sourceMappingURL=index.cjs.map