@hasna/logs 0.3.26 → 0.3.27

package/dist/count-bmj4r2zb.js

@@ -0,0 +1,10 @@
+// @bun
+import {
+  countLogs
+} from "./index-gcd14q2f.js";
+import"./index-b5c72f1p.js";
+import"./index-hq6kzaah.js";
+import"./index-re3ntm60.js";
+export {
+  countLogs
+};

package/dist/{diagnose-e0w5rwbc.js → diagnose-3q5cy9ra.js}

@@ -1,8 +1,8 @@
 // @bun
 import {
   diagnose
-} from "./index-7w7v7hnr.js";
-import"./index-997bkzr2.js";
+} from "./index-by1pdzbr.js";
+import"./index-hq6kzaah.js";
 import"./index-re3ntm60.js";
 export {
   diagnose

package/dist/{export-c3eqjste.js → export-cngdb9fh.js}

@@ -2,7 +2,7 @@
 import {
   exportToCsv,
   exportToJson
-} from "./index-eh9bkbpa.js";
+} from "./index-e72k53yq.js";
 import"./index-re3ntm60.js";
 export {
   exportToJson,

package/dist/{http-zm3ph78w.js → http-r0xc3d2s.js}

@@ -7,14 +7,16 @@ import {
   isJSONRPCErrorResponse,
   isJSONRPCRequest,
   isJSONRPCResultResponse
-} from "./index-5qznfyah.js";
+} from "./index-q27bgpr1.js";
 import"./index-re3ntm60.js";
 
 // src/mcp/http.ts
-import { createServer } from "http";
+import {
+  createServer
+} from "http";
 
 // node_modules/@hono/node-server/dist/index.mjs
-import { Http2ServerRequest as Http2ServerRequest2 } from "http2";
+import { Http2ServerRequest as Http2ServerRequest2, constants as h2constants } from "http2";
 import { Http2ServerRequest } from "http2";
 import { Readable } from "stream";
 import crypto2 from "crypto";
@@ -154,6 +156,17 @@ var requestPrototype = {
     }
   });
 });
+Object.defineProperty(requestPrototype, Symbol.for("nodejs.util.inspect.custom"), {
+  value: function(depth, options, inspectFn) {
+    const props = {
+      method: this.method,
+      url: this.url,
+      headers: this.headers,
+      nativeRequest: this[requestCache]
+    };
+    return `Request (lightweight) ${inspectFn(props, { ...options, depth: depth == null ? null : depth - 1 })}`;
+  }
+});
 Object.setPrototypeOf(requestPrototype, Request.prototype);
 var newRequest = (incoming, defaultHostname) => {
   const req = Object.create(requestPrototype);
@@ -254,6 +267,17 @@ var Response2 = class _Response {
     }
   });
 });
+Object.defineProperty(Response2.prototype, Symbol.for("nodejs.util.inspect.custom"), {
+  value: function(depth, options, inspectFn) {
+    const props = {
+      status: this.status,
+      headers: this.headers,
+      ok: this.ok,
+      nativeResponse: this[responseCache]
+    };
+    return `Response (lightweight) ${inspectFn(props, { ...options, depth: depth == null ? null : depth - 1 })}`;
+  }
+});
 Object.setPrototypeOf(Response2, GlobalResponse);
 Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
 async function readWithoutBlocking(readPromise) {
@@ -324,6 +348,48 @@ if (typeof global.crypto === "undefined") {
   global.crypto = crypto2;
 }
 var outgoingEnded = Symbol("outgoingEnded");
+var incomingDraining = Symbol("incomingDraining");
+var DRAIN_TIMEOUT_MS = 500;
+var MAX_DRAIN_BYTES = 64 * 1024 * 1024;
+var drainIncoming = (incoming) => {
+  const incomingWithDrainState = incoming;
+  if (incoming.destroyed || incomingWithDrainState[incomingDraining]) {
+    return;
+  }
+  incomingWithDrainState[incomingDraining] = true;
+  if (incoming instanceof Http2ServerRequest2) {
+    try {
+      incoming.stream?.close?.(h2constants.NGHTTP2_NO_ERROR);
+    } catch {}
+    return;
+  }
+  let bytesRead = 0;
+  const cleanup = () => {
+    clearTimeout(timer);
+    incoming.off("data", onData);
+    incoming.off("end", cleanup);
+    incoming.off("error", cleanup);
+  };
+  const forceClose = () => {
+    cleanup();
+    const socket = incoming.socket;
+    if (socket && !socket.destroyed) {
+      socket.destroySoon();
+    }
+  };
+  const timer = setTimeout(forceClose, DRAIN_TIMEOUT_MS);
+  timer.unref?.();
+  const onData = (chunk) => {
+    bytesRead += chunk.length;
+    if (bytesRead > MAX_DRAIN_BYTES) {
+      forceClose();
+    }
+  };
+  incoming.on("data", onData);
+  incoming.on("end", cleanup);
+  incoming.on("error", cleanup);
+  incoming.resume();
+};
 var handleRequestError = () => new Response(null, {
   status: 400
 });
@@ -487,14 +553,18 @@ var getRequestListener = (fetchCallback, options = {}) => {
               setTimeout(() => {
                 if (!incomingEnded) {
                   setTimeout(() => {
-                    incoming.destroy();
-                    outgoing.destroy();
+                    drainIncoming(incoming);
                   });
                 }
               });
             }
           };
         }
+        outgoing.on("finish", () => {
+          if (!incomingEnded) {
+            drainIncoming(incoming);
+          }
+        });
       }
       outgoing.on("close", () => {
         const abortController = req[abortControllerKey];
@@ -509,7 +579,7 @@ var getRequestListener = (fetchCallback, options = {}) => {
           setTimeout(() => {
             if (!incomingEnded) {
               setTimeout(() => {
-                incoming.destroy();
+                drainIncoming(incoming);
               });
             }
           });
@@ -1147,8 +1217,9 @@ function isStdioMode(argv = process.argv, env = process.env) {
 }
 function resolveMcpHttpPort(argv = process.argv, env = process.env) {
   const portIdx = argv.indexOf("--port");
-  if (portIdx !== -1 && argv[portIdx + 1]) {
-    return parsePort(argv[portIdx + 1], "--port");
+  const portValue = argv[portIdx + 1];
+  if (portIdx !== -1 && portValue) {
+    return parsePort(portValue, "--port");
   }
   if (env.MCP_HTTP_PORT) {
     return parsePort(env.MCP_HTTP_PORT, "MCP_HTTP_PORT");

package/dist/index-931pbyn5.js

@@ -0,0 +1,141 @@
+// @bun
+// src/lib/identity.ts
+import { execFileSync } from "child_process";
+import { createHash } from "crypto";
+import { existsSync, readFileSync } from "fs";
+import { arch, hostname, platform, release } from "os";
+import { dirname, join, resolve } from "path";
+function detectRuntimeIdentity(db, cwd, opts = {}) {
+  const environment = opts.environment ?? "development" ?? "development";
+  const machine = upsertMachine(db);
+  const repo = detectRepo(cwd);
+  if (repo)
+    upsertRepo(db, repo);
+  const app = detectApp(cwd, repo?.id ?? null, opts.project_id ?? null, environment);
+  if (app)
+    upsertApp(db, app);
+  return {
+    machine_id: machine,
+    repo_id: repo?.id ?? null,
+    app_id: app?.id ?? null,
+    environment
+  };
+}
+function upsertMachine(db) {
+  const info = {
+    hostname: hostname(),
+    platform: platform(),
+    arch: arch(),
+    os_release: release()
+  };
+  const id = `machine_${sha256(`${info.hostname}:${info.platform}:${info.arch}`).slice(0, 16)}`;
+  db.prepare(`
+    INSERT INTO machines (id, hostname, platform, arch, os_release, metadata, last_seen_at)
+    VALUES (?, ?, ?, ?, ?, ?, strftime('%Y-%m-%dT%H:%M:%fZ','now'))
+    ON CONFLICT(id) DO UPDATE SET
+      hostname = excluded.hostname,
+      platform = excluded.platform,
+      arch = excluded.arch,
+      os_release = excluded.os_release,
+      metadata = excluded.metadata,
+      last_seen_at = excluded.last_seen_at
+  `).run(id, info.hostname, info.platform, info.arch, info.os_release, JSON.stringify(info));
+  return id;
+}
+function detectRepo(cwd) {
+  const root = git(cwd, ["rev-parse", "--show-toplevel"]);
+  if (!root)
+    return null;
+  const remote = git(root, ["config", "--get", "remote.origin.url"]);
+  const branch = git(root, ["rev-parse", "--abbrev-ref", "HEAD"]);
+  const sha = git(root, ["rev-parse", "HEAD"]);
+  const dirty = git(root, ["status", "--porcelain"]) ? 1 : 0;
+  return {
+    id: `repo_${sha256(root).slice(0, 16)}`,
+    root_path: root,
+    remote_url: remote,
+    branch,
+    commit_sha: sha,
+    dirty
+  };
+}
+function upsertRepo(db, repo) {
+  db.prepare(`
+    INSERT INTO repositories (id, root_path, remote_url, branch, commit_sha, dirty, metadata, last_seen_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, strftime('%Y-%m-%dT%H:%M:%fZ','now'))
+    ON CONFLICT(id) DO UPDATE SET
+      root_path = excluded.root_path,
+      remote_url = excluded.remote_url,
+      branch = excluded.branch,
+      commit_sha = excluded.commit_sha,
+      dirty = excluded.dirty,
+      metadata = excluded.metadata,
+      last_seen_at = excluded.last_seen_at
+  `).run(repo.id, repo.root_path, repo.remote_url, repo.branch, repo.commit_sha, repo.dirty, JSON.stringify(repo));
+}
+function detectApp(cwd, repoId, projectId, environment) {
+  const packageJsonPath = findNearestPackageJson(cwd);
+  if (!packageJsonPath)
+    return null;
+  try {
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    const name = packageJson.name ?? dirname(packageJsonPath).split(/[\\/]/).pop() ?? "app";
+    return {
+      id: `app_${sha256(packageJsonPath).slice(0, 16)}`,
+      repo_id: repoId,
+      project_id: projectId,
+      name,
+      runtime: "cli",
+      environment,
+      version: packageJson.version ?? null,
+      metadata: { package_json_path: packageJsonPath }
+    };
+  } catch {
+    return null;
+  }
+}
+function upsertApp(db, app) {
+  db.prepare(`
+    INSERT INTO apps (id, repo_id, project_id, name, runtime, environment, version, metadata, last_seen_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, strftime('%Y-%m-%dT%H:%M:%fZ','now'))
+    ON CONFLICT(id) DO UPDATE SET
+      repo_id = excluded.repo_id,
+      project_id = excluded.project_id,
+      name = excluded.name,
+      runtime = excluded.runtime,
+      environment = excluded.environment,
+      version = excluded.version,
+      metadata = excluded.metadata,
+      last_seen_at = excluded.last_seen_at
+  `).run(app.id, app.repo_id, app.project_id, app.name, app.runtime, app.environment, app.version, JSON.stringify(app.metadata));
+}
+function findNearestPackageJson(cwd) {
+  let dir = resolve(cwd);
+  while (true) {
+    const candidate = join(dir, "package.json");
+    if (existsSync(candidate))
+      return candidate;
+    const parent = dirname(dir);
+    if (parent === dir)
+      return null;
+    dir = parent;
+  }
+}
+function git(cwd, args) {
+  try {
+    const output = execFileSync("git", args, {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 1000
+    }).trim();
+    return output || null;
+  } catch {
+    return null;
+  }
+}
+function sha256(input) {
+  return createHash("sha256").update(input).digest("hex");
+}
+
+export { detectRuntimeIdentity };

package/dist/index-b5c72f1p.js

@@ -0,0 +1,7 @@
+// @bun
+// src/lib/sqlite-bindings.ts
+function sqlBindings(values) {
+  return values;
+}
+
+export { sqlBindings };