@wrongstack/core 0.313.0 → 0.316.1

package/dist/chunk-GTCU6DZ3.js

@@ -0,0 +1 @@
+//# sourceMappingURL=chunk-GTCU6DZ3.js.map

package/dist/chunk-HA4ZYA6T.js

@@ -0,0 +1,178 @@
+// src/observability/network-telemetry.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+import { createHash, randomUUID } from "node:crypto";
+import { channel } from "node:diagnostics_channel";
+var storage = new AsyncLocalStorage();
+var requests = /* @__PURE__ */ new WeakMap();
+var users = 0;
+var unsubscribe;
+function runWithNetworkTelemetry(context, run) {
+  return storage.run(context, run);
+}
+function startNetworkTelemetryMonitor() {
+  users++;
+  if (!unsubscribe) unsubscribe = subscribe();
+  let stopped = false;
+  return () => {
+    if (stopped) return;
+    stopped = true;
+    users--;
+    if (users <= 0) {
+      unsubscribe?.();
+      unsubscribe = void 0;
+      users = 0;
+    }
+  };
+}
+function subscribe() {
+  const create = channel("undici:request:create");
+  const headers = channel("undici:request:headers");
+  const error = channel("undici:request:error");
+  const onCreate = (message) => {
+    const context = storage.getStore();
+    const request = objectField(message, "request");
+    if (!context || !request) return;
+    const target = safeTarget(request);
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const requestBytes = numberField(request, "contentLength");
+    const state = {
+      ...context,
+      requestId: randomUUID(),
+      ...target,
+      ...requestBytes !== void 0 ? { requestBytes } : {},
+      startedAt,
+      startedNs: process.hrtime.bigint()
+    };
+    requests.set(request, state);
+    context.events.emit("network.request.started", {
+      ...identity(state),
+      requestId: state.requestId,
+      method: state.method,
+      scheme: state.scheme,
+      serverAddress: state.serverAddress,
+      ...state.serverPort !== void 0 ? { serverPort: state.serverPort } : {},
+      pathHash: state.pathHash,
+      queryKeys: queryKeys(request),
+      ...state.requestBytes !== void 0 ? { requestBytes: state.requestBytes } : {},
+      startedAt
+    });
+  };
+  const onHeaders = (message) => {
+    const request = objectField(message, "request");
+    if (!request) return;
+    const state = requests.get(request);
+    if (!state) return;
+    requests.delete(request);
+    const response = objectField(message, "response");
+    const responseBytes = contentLength(response);
+    state.events.emit("network.request.completed", {
+      ...identity(state),
+      requestId: state.requestId,
+      method: state.method,
+      scheme: state.scheme,
+      serverAddress: state.serverAddress,
+      ...state.serverPort !== void 0 ? { serverPort: state.serverPort } : {},
+      pathHash: state.pathHash,
+      statusCode: numberField(response, "statusCode") ?? 0,
+      durationMs: elapsed(state.startedNs),
+      ...state.requestBytes !== void 0 ? { requestBytes: state.requestBytes } : {},
+      ...responseBytes !== void 0 ? { responseBytes } : {},
+      completedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  };
+  const onError = (message) => {
+    const request = objectField(message, "request");
+    if (!request) return;
+    const state = requests.get(request);
+    if (!state) return;
+    requests.delete(request);
+    const err = objectField(message, "error");
+    const errorCode = stringField(err, "code");
+    state.events.emit("network.request.failed", {
+      ...identity(state),
+      requestId: state.requestId,
+      method: state.method,
+      scheme: state.scheme,
+      serverAddress: state.serverAddress,
+      ...state.serverPort !== void 0 ? { serverPort: state.serverPort } : {},
+      pathHash: state.pathHash,
+      durationMs: elapsed(state.startedNs),
+      errorName: stringField(err, "name") ?? "Error",
+      ...errorCode ? { errorCode } : {},
+      failedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  };
+  create.subscribe(onCreate);
+  headers.subscribe(onHeaders);
+  error.subscribe(onError);
+  return () => {
+    create.unsubscribe(onCreate);
+    headers.unsubscribe(onHeaders);
+    error.unsubscribe(onError);
+  };
+}
+function identity(state) {
+  return {
+    sessionId: state.sessionId,
+    ...state.traceId ? { traceId: state.traceId } : {},
+    ...state.agentId ? { agentId: state.agentId } : {},
+    ...state.toolCallId ? { toolCallId: state.toolCallId } : {},
+    ...state.attemptId ? { attemptId: state.attemptId } : {},
+    initiator: state.initiator,
+    operationName: state.operationName
+  };
+}
+function safeTarget(request) {
+  const origin = String(request.origin ?? "");
+  const path = String(request.path ?? "");
+  let url;
+  try {
+    url = new URL(path, origin);
+  } catch {
+    url = new URL("http://invalid.local/");
+  }
+  return {
+    method: String(request.method ?? "GET").toUpperCase(),
+    scheme: url.protocol.replace(":", ""),
+    serverAddress: url.hostname,
+    ...url.port ? { serverPort: Number(url.port) } : {},
+    pathHash: hash(url.pathname)
+  };
+}
+function queryKeys(request) {
+  try {
+    return [...new URL(String(request.path ?? ""), String(request.origin ?? "")).searchParams.keys()].filter((v, i, a) => a.indexOf(v) === i).slice(0, 50);
+  } catch {
+    return [];
+  }
+}
+function contentLength(response) {
+  const raw = response?.headers;
+  if (!Array.isArray(raw)) return void 0;
+  for (let index = 0; index < raw.length - 1; index += 2) if (String(raw[index]).toLowerCase() === "content-length") {
+    const value = Number(String(raw[index + 1]));
+    return Number.isFinite(value) ? value : void 0;
+  }
+  return void 0;
+}
+function objectField(value, key) {
+  return value && typeof value === "object" && value[key] && typeof value[key] === "object" ? value[key] : void 0;
+}
+function stringField(value, key) {
+  return typeof value?.[key] === "string" ? value[key] : void 0;
+}
+function numberField(value, key) {
+  return typeof value?.[key] === "number" ? value[key] : void 0;
+}
+function elapsed(start) {
+  return Number(process.hrtime.bigint() - start) / 1e6;
+}
+function hash(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+
+export {
+  runWithNetworkTelemetry,
+  startNetworkTelemetryMonitor
+};
+//# sourceMappingURL=chunk-HA4ZYA6T.js.map

package/dist/chunk-HI3JGZR2.js

@@ -0,0 +1,188 @@
+import {
+  atomicWrite
+} from "./chunk-OSGLYW5J.js";
+
+// src/utils/ulid.ts
+import { randomBytes } from "node:crypto";
+var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var ENCODING_LEN = ENCODING.length;
+var TIME_LEN = 10;
+var RANDOM_LEN = 16;
+function encodeTime(now, len) {
+  let mod;
+  let str = "";
+  for (let i = len - 1; i >= 0; i--) {
+    mod = now % ENCODING_LEN;
+    str = ENCODING[mod] + str;
+    now = (now - mod) / ENCODING_LEN;
+  }
+  return str;
+}
+function encodeRandom(len) {
+  const bytes = randomBytes(len);
+  let str = "";
+  for (let i = 0; i < len; i++) {
+    str += ENCODING[bytes[i] % ENCODING_LEN];
+  }
+  return str;
+}
+function ulid(seedTime = Date.now()) {
+  const safeTime = typeof seedTime === "number" && Number.isFinite(seedTime) && seedTime > 0 ? seedTime : Date.now();
+  return encodeTime(safeTime, TIME_LEN) + encodeRandom(RANDOM_LEN);
+}
+function isUlid(value) {
+  if (typeof value !== "string" || value.length !== TIME_LEN + RANDOM_LEN) return false;
+  for (const ch of value) {
+    if (!ENCODING.includes(ch)) return false;
+  }
+  return true;
+}
+
+// src/utils/project-identity.ts
+import * as fs from "node:fs";
+import * as fsPromises from "node:fs/promises";
+import * as path from "node:path";
+var PROJECT_IDENTITY_VERSION = 1;
+var PROJECT_ID_PREFIX = "proj_";
+var PROJECT_IDENTITY_RELATIVE_PATH = path.join(".wrongstack", "project.json");
+var PROJECT_GITIGNORE_RULES = [
+  ".wrongstack/",
+  "!/.wrongstack/",
+  "/.wrongstack/*",
+  "!/.wrongstack/project.json"
+];
+function projectIdentityPath(projectRoot) {
+  return path.join(projectRoot, PROJECT_IDENTITY_RELATIVE_PATH);
+}
+function createProjectId(seedTime = Date.now()) {
+  return `${PROJECT_ID_PREFIX}${ulid(seedTime)}`;
+}
+function isProjectId(value) {
+  return value.startsWith(PROJECT_ID_PREFIX) && isUlid(value.slice(PROJECT_ID_PREFIX.length));
+}
+function readProjectIdentitySync(projectRoot) {
+  const filePath = projectIdentityPath(projectRoot);
+  try {
+    return parseProjectIdentity(fs.readFileSync(filePath, "utf8"), filePath);
+  } catch (error) {
+    if (isMissingFileError(error)) return void 0;
+    throw error;
+  }
+}
+async function readProjectIdentity(projectRoot) {
+  const filePath = projectIdentityPath(projectRoot);
+  try {
+    return parseProjectIdentity(await fsPromises.readFile(filePath, "utf8"), filePath);
+  } catch (error) {
+    if (isMissingFileError(error)) return void 0;
+    throw error;
+  }
+}
+async function ensureProjectIdentity(projectRoot, idFactory = createProjectId) {
+  const existing = await readProjectIdentity(projectRoot);
+  if (existing) return { identity: existing, created: false };
+  const filePath = projectIdentityPath(projectRoot);
+  const identity = makeIdentity(idFactory());
+  await fsPromises.mkdir(path.dirname(filePath), { recursive: true });
+  try {
+    await fsPromises.writeFile(filePath, serializeProjectIdentity(identity), {
+      encoding: "utf8",
+      flag: "wx"
+    });
+    return { identity, created: true };
+  } catch (error) {
+    if (!isAlreadyExistsError(error)) throw error;
+    const winner = await readProjectIdentity(projectRoot);
+    if (!winner) throw error;
+    return { identity: winner, created: false };
+  }
+}
+async function rekeyProjectIdentity(projectRoot, idFactory = createProjectId) {
+  const previous = await readProjectIdentity(projectRoot);
+  const identity = makeIdentity(idFactory());
+  const filePath = projectIdentityPath(projectRoot);
+  await fsPromises.mkdir(path.dirname(filePath), { recursive: true });
+  await atomicWrite(filePath, serializeProjectIdentity(identity));
+  return { previous, identity };
+}
+async function ensureProjectGitignore(projectRoot) {
+  const filePath = path.join(projectRoot, ".gitignore");
+  let content = "";
+  try {
+    content = await fsPromises.readFile(filePath, "utf8");
+  } catch (error) {
+    if (!isMissingFileError(error)) throw error;
+  }
+  const hadTrailingNewline = content.endsWith("\n");
+  const lines = content.length === 0 ? [] : content.split(/\r?\n/);
+  if (hadTrailingNewline) lines.pop();
+  let changed = false;
+  for (let index = 0; index < lines.length; index++) {
+    if (lines[index]?.trim() === ".wrongstack/*") {
+      lines[index] = ".wrongstack/";
+      changed = true;
+    }
+  }
+  for (const entry of PROJECT_GITIGNORE_RULES) {
+    if (!lines.some((line) => line.trim() === entry)) {
+      if (entry === ".wrongstack/" && lines.length > 0 && lines.at(-1) !== "") lines.push("");
+      lines.push(entry);
+      changed = true;
+    }
+  }
+  if (!changed) return;
+  const eol = content.includes("\r\n") ? "\r\n" : "\n";
+  await atomicWrite(filePath, `${lines.join(eol)}${eol}`);
+}
+function makeIdentity(projectId) {
+  if (!isProjectId(projectId)) {
+    throw new Error(`Invalid WrongStack project id: ${projectId}`);
+  }
+  return { version: PROJECT_IDENTITY_VERSION, projectId };
+}
+function parseProjectIdentity(raw, filePath) {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    throw new Error(`Invalid JSON in WrongStack project identity file: ${filePath}`);
+  }
+  if (typeof value !== "object" || value === null) {
+    throw new Error(`Invalid WrongStack project identity file: ${filePath}`);
+  }
+  const record = value;
+  if (record["version"] !== PROJECT_IDENTITY_VERSION) {
+    throw new Error(`Unsupported WrongStack project identity version in ${filePath}`);
+  }
+  if (typeof record["projectId"] !== "string" || !isProjectId(record["projectId"])) {
+    throw new Error(`Invalid projectId in WrongStack project identity file: ${filePath}`);
+  }
+  return { version: PROJECT_IDENTITY_VERSION, projectId: record["projectId"] };
+}
+function serializeProjectIdentity(identity) {
+  return `${JSON.stringify(identity, null, 2)}
+`;
+}
+function isMissingFileError(error) {
+  return error?.code === "ENOENT";
+}
+function isAlreadyExistsError(error) {
+  return error?.code === "EEXIST";
+}
+
+export {
+  ulid,
+  isUlid,
+  PROJECT_IDENTITY_VERSION,
+  PROJECT_ID_PREFIX,
+  PROJECT_IDENTITY_RELATIVE_PATH,
+  projectIdentityPath,
+  createProjectId,
+  isProjectId,
+  readProjectIdentitySync,
+  readProjectIdentity,
+  ensureProjectIdentity,
+  rekeyProjectIdentity,
+  ensureProjectGitignore
+};
+//# sourceMappingURL=chunk-HI3JGZR2.js.map