@hawk.so/nextjs 0.0.0-stage → 1.0.0

package/dist/index.js

@@ -0,0 +1,496 @@
+// src/with-hawk-config.ts
+import { createRequire } from "module";
+import path4 from "path";
+import process2 from "process";
+
+// src/release.ts
+import { execFileSync } from "child_process";
+import process from "process";
+var RELEASE_ENV_VARIABLE = "HAWK_RELEASE";
+var COMMIT_SHA_ENV_VARIABLES = [
+  "GITHUB_SHA",
+  "CI_COMMIT_SHA",
+  "CI_MERGE_REQUEST_SOURCE_BRANCH_SHA",
+  "BITBUCKET_COMMIT",
+  "CIRCLE_SHA1",
+  "BUILDKITE_COMMIT",
+  "DRONE_COMMIT_SHA",
+  "TRAVIS_COMMIT",
+  "VERCEL_GIT_COMMIT_SHA",
+  "CF_PAGES_COMMIT_SHA",
+  "RAILWAY_GIT_COMMIT_SHA",
+  "RENDER_GIT_COMMIT",
+  "HEROKU_BUILD_COMMIT",
+  "SOURCE_VERSION",
+  "GIT_COMMIT",
+  "COMMIT_REF"
+];
+function getGitRevision(cwd) {
+  try {
+    const revision = execFileSync("git", ["rev-parse", "HEAD"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return revision !== "" ? revision : void 0;
+  } catch (_error) {
+    return void 0;
+  }
+}
+function resolveRelease(release, cwd) {
+  if (release !== void 0 && String(release) !== "") {
+    return String(release);
+  }
+  const candidates = [RELEASE_ENV_VARIABLE, ...COMMIT_SHA_ENV_VARIABLES].map((name) => process.env[name]);
+  const fromEnv = candidates.find((value) => value !== void 0 && value !== "");
+  if (fromEnv !== void 0) {
+    return fromEnv;
+  }
+  return getGitRevision(cwd) ?? (/* @__PURE__ */ new Date()).toISOString();
+}
+
+// src/token.ts
+import { Buffer } from "buffer";
+function getIntegrationId(token) {
+  try {
+    const payload = JSON.parse(Buffer.from(token, "base64").toString("utf-8"));
+    if (typeof payload.integrationId === "string" && payload.integrationId !== "") {
+      return payload.integrationId;
+    }
+  } catch (_error) {
+  }
+  return void 0;
+}
+function getDefaultCollectorEndpoint(integrationId) {
+  return `https://${integrationId}.k1.hawk.so/release`;
+}
+
+// src/upload-release.ts
+import { readFile as readFile2 } from "fs/promises";
+
+// src/cleanup.ts
+import { readFile, unlink, writeFile } from "fs/promises";
+import path3 from "path";
+
+// src/sourcemaps.ts
+import { createHash } from "crypto";
+import { access } from "fs/promises";
+import path2 from "path";
+
+// src/utils/fs.ts
+import { Buffer as Buffer2 } from "buffer";
+import { open, readdir } from "fs/promises";
+import path from "path";
+var MAX_PARALLEL_FILE_OPERATIONS = 16;
+async function listFiles(dir) {
+  try {
+    const entries = await readdir(dir, { withFileTypes: true });
+    const files = await Promise.all(entries.map(async (entry) => {
+      if (entry.isDirectory()) {
+        return (await listFiles(path.join(dir, entry.name))).map((file) => `${entry.name}/${file}`);
+      }
+      return entry.isFile() ? [entry.name] : [];
+    }));
+    return files.flat();
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
+    }
+    throw error;
+  }
+}
+async function readFileTail(filePath, maxBytes) {
+  const file = await open(filePath, "r");
+  try {
+    const { size } = await file.stat();
+    const length = Math.min(maxBytes, size);
+    const { bytesRead, buffer } = await file.read(Buffer2.alloc(length), 0, length, size - length);
+    const tail = buffer.subarray(0, bytesRead).toString("utf8");
+    if (length === size) {
+      return tail;
+    }
+    const cutLineEnd = tail.indexOf("\n");
+    return cutLineEnd === -1 ? "" : tail.slice(cutLineEnd);
+  } finally {
+    await file.close();
+  }
+}
+
+// src/utils/pool.ts
+async function mapConcurrently(items, limit, mapper) {
+  const results = [];
+  let nextIndex = 0;
+  const runWorker = async () => {
+    while (nextIndex < items.length) {
+      const index = nextIndex;
+      nextIndex += 1;
+      results[index] = await mapper(items[index]);
+    }
+  };
+  const workersCount = Math.max(1, Math.min(limit, items.length));
+  await Promise.all(Array.from({ length: workersCount }, runWorker));
+  return results;
+}
+
+// src/sourcemaps.ts
+var STATIC_DIR = "static";
+var PUBLIC_PATH_PREFIX = "/_next/";
+var PATH_HASH_LENGTH = 8;
+var CHUNK_TAIL_SIZE = 4096;
+var JS_SOURCE_MAPPING_URL = /(?:^|\n)\/\/[#@] sourceMappingURL=([^\s'"`*]+)\s*$/;
+var SOURCE_PATH_PREFIXES = [
+  /^turbopack:\/\/\/\[project\]\//,
+  /^webpack:\/\/[^/]*\/(\.\/)?/
+];
+function isRawSourceMap(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeSourcePath(source) {
+  const prefix = SOURCE_PATH_PREFIXES.find((pattern) => pattern.test(source));
+  return prefix !== void 0 ? source.replace(prefix, "") : source;
+}
+function normalizeSources(map) {
+  if (Array.isArray(map.sources)) {
+    map.sources = map.sources.map((source) => typeof source === "string" ? normalizeSourcePath(source) : source);
+  }
+}
+function getSourceMapPath(chunk, content) {
+  const url = JS_SOURCE_MAPPING_URL.exec(content)?.[1];
+  if (url === void 0 || url.startsWith("/") || /^[a-z][a-z\d+.-]*:/i.test(url)) {
+    return void 0;
+  }
+  try {
+    const mapPath = path2.posix.join(path2.posix.dirname(chunk), decodeURIComponent(url));
+    return mapPath.startsWith("../") ? void 0 : mapPath;
+  } catch (_error) {
+    return void 0;
+  }
+}
+function encodeUrlPath(filePath) {
+  return filePath.split("/").map((segment) => encodeURIComponent(segment)).join("/");
+}
+function getSourceMapName(chunk) {
+  const extension = path2.posix.extname(chunk);
+  const hash = createHash("sha256").update(chunk).digest("hex").slice(0, PATH_HASH_LENGTH);
+  return `${path2.posix.basename(chunk, extension)}.${hash}${extension}.map`;
+}
+async function fileExists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch (_error) {
+    return false;
+  }
+}
+async function findClientSourceMaps(distDir) {
+  const staticDir = path2.join(distDir, STATIC_DIR);
+  const chunks = (await listFiles(staticDir)).filter((entry) => /\.[cm]?js$/.test(entry)).sort();
+  const maps = await mapConcurrently(chunks, MAX_PARALLEL_FILE_OPERATIONS, async (chunk) => {
+    const mapPath = getSourceMapPath(chunk, await readFileTail(path2.join(staticDir, chunk), CHUNK_TAIL_SIZE));
+    if (mapPath === void 0 || !await fileExists(path2.join(staticDir, mapPath))) {
+      return void 0;
+    }
+    return {
+      path: path2.join(staticDir, mapPath),
+      chunkUrl: `${PUBLIC_PATH_PREFIX}${STATIC_DIR}/${encodeUrlPath(chunk)}`,
+      name: getSourceMapName(chunk)
+    };
+  });
+  return maps.filter((map) => map !== void 0);
+}
+function prepareSourceMap(content, chunkUrl) {
+  const map = JSON.parse(content);
+  if (!isRawSourceMap(map)) {
+    throw new Error("Source map is not a JSON object");
+  }
+  map.file = chunkUrl;
+  normalizeSources(map);
+  if (Array.isArray(map.sections)) {
+    for (const section of map.sections) {
+      const sectionMap = isRawSourceMap(section) ? section.map : void 0;
+      if (isRawSourceMap(sectionMap)) {
+        normalizeSources(sectionMap);
+      }
+    }
+  }
+  return JSON.stringify(map);
+}
+
+// src/cleanup.ts
+var CSS_SOURCE_MAPPING_URL = /(?:^|\n)\/\*[#@] sourceMappingURL=[^\s*]+\s*\*\/\s*$/;
+async function deleteClientSourceMaps(distDir) {
+  const staticDir = path3.join(distDir, STATIC_DIR);
+  const maps = (await listFiles(staticDir)).filter((entry) => entry.endsWith(".map"));
+  await mapConcurrently(maps, MAX_PARALLEL_FILE_OPERATIONS, (entry) => unlink(path3.join(staticDir, entry)));
+  return maps.length;
+}
+async function stripSourceMappingUrlComments(distDir) {
+  const staticDir = path3.join(distDir, STATIC_DIR);
+  const assets = (await listFiles(staticDir)).filter((entry) => /\.([cm]?js|css)$/.test(entry));
+  const updated = await mapConcurrently(assets, MAX_PARALLEL_FILE_OPERATIONS, async (entry) => {
+    const filePath = path3.join(staticDir, entry);
+    const pattern = entry.endsWith(".css") ? CSS_SOURCE_MAPPING_URL : JS_SOURCE_MAPPING_URL;
+    const content = await readFile(filePath, "utf8");
+    const stripped = content.replace(pattern, "");
+    if (stripped === content) {
+      return false;
+    }
+    await writeFile(filePath, stripped);
+    return true;
+  });
+  return updated.filter(Boolean).length;
+}
+
+// src/commits.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+var FIELD_SEPARATOR = "";
+var RECORD_SEPARATOR = "";
+async function getCommits(repo, count) {
+  const { stdout } = await execFileAsync("git", [
+    "log",
+    `--max-count=${count}`,
+    "--format=%H%x1f%s%x1f%ae%x1f%aI%x1e"
+  ], {
+    cwd: repo,
+    encoding: "utf8"
+  });
+  return stdout.split(RECORD_SEPARATOR).map((record) => record.trim()).filter((record) => record !== "").map((record) => {
+    const [hash, title, author, date] = record.split(FIELD_SEPARATOR);
+    return {
+      hash,
+      title,
+      author,
+      date
+    };
+  });
+}
+
+// src/uploader.ts
+var MAX_RESPONSE_PREVIEW_LENGTH = 200;
+function sanitizeCollectorMessage(message) {
+  return message.startsWith("Integration token invalid") ? "Integration token invalid" : message;
+}
+async function send(collector, body) {
+  const response = await fetch(collector.endpoint, {
+    method: "POST",
+    body,
+    headers: [["Authorization", `Bearer ${collector.token}`]],
+    signal: AbortSignal.timeout(collector.timeout)
+  });
+  const text = await response.text();
+  let data;
+  try {
+    data = JSON.parse(text);
+  } catch (_error) {
+    throw new Error(`Unexpected collector response (HTTP ${response.status}): ${text.slice(0, MAX_RESPONSE_PREVIEW_LENGTH)}`);
+  }
+  if (data.error === true || !response.ok) {
+    throw new Error(sanitizeCollectorMessage(data.message ?? `HTTP ${response.status}`));
+  }
+}
+async function sendSourceMap(collector, name, content) {
+  const body = new FormData();
+  body.set("release", collector.release);
+  body.set("file", new Blob([content], { type: "application/json" }), name);
+  await send(collector, body);
+}
+async function sendCommits(collector, commits) {
+  const body = new FormData();
+  body.set("release", collector.release);
+  body.set("commits", JSON.stringify(commits));
+  await send(collector, body);
+}
+
+// src/utils/log.ts
+var consoleColors = {
+  fgRed: 31,
+  fgGreen: 32,
+  fgYellow: 33,
+  fgCyan: 36
+};
+function wrapInColor(message, color) {
+  return `\x1B[${color}m${message}\x1B[0m`;
+}
+function log(message, color = consoleColors.fgCyan) {
+  console.log(wrapInColor("\u{1F985} Hawk | " + message, color));
+}
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/upload-release.ts
+var MAX_PARALLEL_UPLOADS = 5;
+var REQUEST_TIMEOUT = 3e4;
+function getCollector(options) {
+  if (options.token === void 0 || options.token === "") {
+    log("Integration Token is not provided, release will not be sent", consoleColors.fgYellow);
+    return void 0;
+  }
+  const integrationId = getIntegrationId(options.token);
+  const endpoint = options.collectorEndpoint ?? (integrationId !== void 0 ? getDefaultCollectorEndpoint(integrationId) : void 0);
+  if (endpoint === void 0) {
+    log("Invalid Integration Token, release will not be sent", consoleColors.fgRed);
+    return void 0;
+  }
+  return {
+    endpoint,
+    token: options.token,
+    release: options.release,
+    timeout: REQUEST_TIMEOUT
+  };
+}
+async function uploadCommits(collector, repo, count) {
+  let commits;
+  try {
+    commits = await getCommits(repo, count);
+  } catch (_error) {
+    log("Commits are not sent: git history is not available. Pass `commits: false` to skip them", consoleColors.fgYellow);
+    return;
+  }
+  if (commits.length === 0) {
+    return;
+  }
+  try {
+    await sendCommits(collector, commits);
+    log(`Recent commits sent: ${commits.length}`, consoleColors.fgGreen);
+  } catch (error) {
+    log(`(\u2310\u25A0_\u25A0) Sending commits failed: ${getErrorMessage(error)}`, consoleColors.fgRed);
+  }
+}
+async function uploadSourceMaps(collector, distDir) {
+  const maps = await findClientSourceMaps(distDir);
+  if (maps.length === 0) {
+    log("No client source maps found. Make sure `productionBrowserSourceMaps` is not disabled in next.config", consoleColors.fgYellow);
+    return;
+  }
+  let sentCount = 0;
+  await mapConcurrently(maps, MAX_PARALLEL_UPLOADS, async (map) => {
+    try {
+      const content = prepareSourceMap(await readFile2(map.path, "utf8"), map.chunkUrl);
+      await sendSourceMap(collector, map.name, content);
+      sentCount += 1;
+    } catch (error) {
+      log(`(\u2310\u25A0_\u25A0) ${map.chunkUrl}.map \u2013 sending failed: ${getErrorMessage(error)}`, consoleColors.fgRed);
+    }
+  });
+  const color = sentCount === maps.length ? consoleColors.fgGreen : consoleColors.fgYellow;
+  log(`${sentCount} of ${maps.length} source maps sent for release "${collector.release}"`, color);
+}
+async function removeSourceMaps(distDir, stripSourceMappingUrls) {
+  const removedCount = await deleteClientSourceMaps(distDir);
+  if (removedCount > 0) {
+    log(`${removedCount} client source maps removed`);
+  }
+  if (stripSourceMappingUrls) {
+    await stripSourceMappingUrlComments(distDir);
+  }
+}
+async function uploadRelease(metadata, options) {
+  const startedAt = Date.now();
+  try {
+    const collector = getCollector(options);
+    if (collector === void 0) {
+      return;
+    }
+    try {
+      if (options.commits !== false) {
+        await uploadCommits(collector, options.commits.repo ?? metadata.projectDir, options.commits.number);
+      }
+      await uploadSourceMaps(collector, metadata.distDir);
+    } finally {
+      if (options.removeSourceMaps) {
+        await removeSourceMaps(metadata.distDir, options.stripSourceMappingUrls);
+      }
+    }
+    log(`Release "${collector.release}" processed in ${Date.now() - startedAt} ms`);
+  } catch (error) {
+    log(`(\u2310\u25A0_\u25A0) Release uploading failed: ${getErrorMessage(error)}`, consoleColors.fgRed);
+  }
+}
+
+// src/with-hawk-config.ts
+var MIN_NEXT_VERSION = "15.4.1";
+var DEFAULT_COMMITS_NUMBER = 5;
+function isVersionAtLeast(version, minVersion) {
+  const toNumbers = (value) => value.split("-")[0].split(".").map(Number);
+  const actual = toNumbers(version);
+  const min = toNumbers(minVersion);
+  for (const [i, minPart] of min.entries()) {
+    const part = actual[i] ?? 0;
+    if (part !== minPart) {
+      return part > minPart;
+    }
+  }
+  return true;
+}
+function getNextVersion(projectDir) {
+  try {
+    const requireFromProject = createRequire(path4.join(projectDir, "package.json"));
+    return requireFromProject("next/package.json").version;
+  } catch (_error) {
+    return void 0;
+  }
+}
+function getCommitsOptions(commits = true) {
+  if (commits === false) {
+    return false;
+  }
+  const custom = commits === true ? {} : commits;
+  return {
+    repo: custom.repo,
+    number: custom.number ?? DEFAULT_COMMITS_NUMBER
+  };
+}
+function applyHawkConfig(config, options) {
+  const projectDir = process2.cwd();
+  const release = resolveRelease(options.release, projectDir);
+  process2.env[RELEASE_ENV_VARIABLE] = release;
+  const result = {
+    ...config,
+    env: {
+      ...config.env,
+      [RELEASE_ENV_VARIABLE]: release
+    }
+  };
+  const nextVersion = getNextVersion(projectDir);
+  if (nextVersion !== void 0 && !isVersionAtLeast(nextVersion, MIN_NEXT_VERSION)) {
+    log(`Next.js ${nextVersion} is not supported, update it to ${MIN_NEXT_VERSION} or newer to send releases`, consoleColors.fgYellow);
+    return result;
+  }
+  const token = options.token ?? process2.env.HAWK_TOKEN;
+  const hasToken = token !== void 0 && token !== "";
+  const canUpload = hasToken && (options.collectorEndpoint !== void 0 || getIntegrationId(token) !== void 0);
+  if (canUpload && config.productionBrowserSourceMaps === void 0) {
+    result.productionBrowserSourceMaps = true;
+  }
+  const uploadOptions = {
+    token,
+    release,
+    collectorEndpoint: options.collectorEndpoint,
+    removeSourceMaps: options.removeSourceMaps ?? true,
+    stripSourceMappingUrls: config.experimental?.sri === void 0,
+    commits: getCommitsOptions(options.commits)
+  };
+  const userHook = config.compiler?.runAfterProductionCompile;
+  result.compiler = {
+    ...config.compiler,
+    runAfterProductionCompile: async (metadata) => {
+      if (userHook !== void 0) {
+        await userHook(metadata);
+      }
+      await uploadRelease(metadata, uploadOptions);
+    }
+  };
+  return result;
+}
+function withHawkConfig(nextConfig, options = {}) {
+  if (typeof nextConfig === "function") {
+    return async (phase, context) => applyHawkConfig(await nextConfig(phase, context), options);
+  }
+  return applyHawkConfig(nextConfig, options);
+}
+export {
+  withHawkConfig
+};

package/global.d.ts

@@ -0,0 +1,16 @@
+declare global {
+  namespace NodeJS {
+    /**
+     * Environment variables inlined by Next.js
+     */
+    interface ProcessEnv {
+      /**
+       * Hawk release identifier, injected at build time by withHawkConfig
+       */
+      // eslint-disable-next-line @typescript-eslint/naming-convention
+      HAWK_RELEASE: string;
+    }
+  }
+}
+
+export {};

package/package.json

@@ -1,6 +1,70 @@
 {
   "name": "@hawk.so/nextjs",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.0",
+  "description": "Next.js integration for sending releases with source maps to Hawk",
+  "keywords": [
+    "hawk",
+    "nextjs",
+    "turbopack",
+    "source maps",
+    "error tracking"
+  ],
+  "repository": "https://github.com/codex-team/hawk.nextjs.git",
+  "author": "CodeX <team@codex.so>",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./global": {
+      "types": "./global.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "global.d.ts"
+  ],
+  "workspaces": [
+    "example"
+  ],
+  "engines": {
+    "node": ">=20.9.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:dev": "vitest",
+    "e2e": "yarn build && node scripts/e2e.mjs",
+    "prepublishOnly": "yarn build"
+  },
+  "peerDependencies": {
+    "next": ">=15.4.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.19.2",
+    "eslint": "^9.39.5",
+    "eslint-config-codex": "^2.0.3",
+    "next": "^16.4.3",
+    "tsup": "^9.0.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.70.0",
+    "vite": "^8.0.0",
+    "vitest": "^5.0.5"
+  },
+  "packageManager": "yarn@4.18.1"
 }