@openscout/scout 0.2.105 → 0.2.106

package/dist/node/main.mjs

@@ -14595,6 +14595,99 @@ var CONTROL_PLANE_SCHEMA_VERSION = 18;
 // ../runtime/dist/sqlite-adapter.js
 import { createRequire as createRequire2 } from "node:module";
 
+// ../runtime/dist/sqlite-observation.js
+import { createHash } from "node:crypto";
+function observeSqliteDatabase(database, options) {
+  const configured = options.thresholdMs ?? Number(process.env.OPENSCOUT_SLOW_DB_MS ?? 100);
+  const threshold = Number.isFinite(configured) && configured >= 0 ? configured : 100;
+  if (threshold === 0)
+    return database;
+  const now = options.now ?? (() => performance.now());
+  const emit = options.emit ?? ((event) => console.warn("[scout-db]", JSON.stringify(event)));
+  const statements = new WeakMap;
+  let windowStart = -Infinity;
+  let emitted = 0;
+  let suppressed = 0;
+  function timed(operation, sql, call) {
+    const start = now();
+    let outcome = "error";
+    try {
+      const result = call();
+      outcome = "ok";
+      return result;
+    } finally {
+      try {
+        const end = now();
+        const duration = end - start;
+        if (duration >= threshold) {
+          if (end - windowStart >= 60000) {
+            windowStart = end;
+            emitted = 0;
+          }
+          if (emitted >= 10) {
+            suppressed += 1;
+          } else {
+            emitted += 1;
+            const caller = (new Error().stack ?? "").split(`
+`).filter((line) => !/sqlite-observation\.(?:ts|js):/.test(line)).map((line) => line.match(/(?:packages|apps)\/[\w./-]+:\d+:\d+/)?.[0]).filter((line) => Boolean(line)).slice(0, 4);
+            emit({
+              event: "slow_sqlite",
+              database: options.database,
+              pid: process.pid,
+              operation,
+              queryId: createHash("sha256").update(sql).digest("hex").slice(0, 16),
+              durationMs: Math.round(duration * 100) / 100,
+              outcome,
+              suppressed,
+              caller
+            });
+            suppressed = 0;
+          }
+        }
+      } catch {}
+    }
+  }
+  function statementProxy(statement, sql) {
+    const existing = statements.get(statement);
+    if (existing)
+      return existing;
+    const proxy = bindProxy(statement, (key, method, args) => {
+      if (["all", "get", "run", "values"].includes(key)) {
+        return timed(key, sql, () => Reflect.apply(method, statement, args));
+      }
+      return Reflect.apply(method, statement, args);
+    });
+    statements.set(statement, proxy);
+    return proxy;
+  }
+  return bindProxy(database, (key, method, args) => {
+    if (["query", "prepare"].includes(key) && typeof args[0] === "string") {
+      const sql = args[0];
+      const statement = timed(`${key}.prepare`, sql, () => Reflect.apply(method, database, args));
+      return statementProxy(statement, sql);
+    }
+    if (["exec", "run"].includes(key) && typeof args[0] === "string") {
+      return timed(key, args[0], () => Reflect.apply(method, database, args));
+    }
+    return Reflect.apply(method, database, args);
+  });
+}
+function bindProxy(target, invoke) {
+  const methods = new Map;
+  return new Proxy(target, {
+    get(object, key) {
+      const value = Reflect.get(object, key, object);
+      if (typeof value !== "function" || key === "constructor")
+        return value;
+      const cached = methods.get(key);
+      if (cached?.original === value)
+        return cached.wrapped;
+      const wrapped = (...args) => invoke(String(key), value, args);
+      methods.set(key, { original: value, wrapped });
+      return wrapped;
+    }
+  });
+}
 // ../runtime/dist/runtime-adapters.js
 function detectRuntimeHost(globalScope = globalThis) {
   return typeof globalScope.Bun === "undefined" ? "node" : "bun";
@@ -14660,13 +14753,13 @@ function openRuntimeSqliteDatabase(path, options) {
   const adapter = controlPlaneSqliteAdapterKind();
   if (adapter === "bun-sqlite") {
     const { Database } = require2("bun:sqlite");
-    return new Database(path, options);
+    return observeSqliteDatabase(new Database(path, options), { database: "runtime" });
   }
   const { DatabaseSync } = require2("node:sqlite");
-  return new NodeSqliteDatabaseAdapter(new DatabaseSync(path, {
+  return observeSqliteDatabase(new NodeSqliteDatabaseAdapter(new DatabaseSync(path, {
     open: true,
     readOnly: options?.readonly === true
-  }));
+  })), { database: "runtime" });
 }
 function prepareNodeSqliteSql(sql) {
   const numberedParamIndexes = [];
@@ -16231,7 +16324,7 @@ import { homedir as homedir3, hostname as osHostname } from "node:os";
 import { dirname as dirname2, join as join4 } from "node:path";
 
 // ../runtime/dist/node-identity.js
-import { createHash, createPrivateKey, createPublicKey, generateKeyPairSync, randomBytes, sign, verify } from "node:crypto";
+import { createHash as createHash2, createPrivateKey, createPublicKey, generateKeyPairSync, randomBytes, sign, verify } from "node:crypto";
 import { chmodSync, existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync3, renameSync, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
 import { dirname, join as join3 } from "node:path";
 var NODE_IDENTITY_FILE = "node-identity.json";
@@ -16348,10 +16441,10 @@ function createNodeIdentity(supportDirectory) {
   return identity;
 }
 function nodeKeyId(publicKeyBase64) {
-  return createHash("sha256").update(Buffer.from(publicKeyBase64, "base64")).digest("hex");
+  return createHash2("sha256").update(Buffer.from(publicKeyBase64, "base64")).digest("hex");
 }
 function nodeFingerprint(publicKeyBase64) {
-  const digest = createHash("sha256").update(Buffer.from(publicKeyBase64, "base64")).digest();
+  const digest = createHash2("sha256").update(Buffer.from(publicKeyBase64, "base64")).digest();
   const encoded = base32Encode(digest.subarray(0, 10)).toLowerCase();
   return `${NODE_FINGERPRINT_PREFIX}:${encoded.slice(0, 4)}-${encoded.slice(4, 8)}`;
 }
@@ -20966,6 +21059,8 @@ var scoutBrokerPaths = {
     machines: "/v1/machines",
     machinesScan: "/v1/machines/scan",
     messages: "/v1/messages",
+    messageReactions: "/v1/message-reactions",
+    messageReactionsRemove: "/v1/message-reactions/remove",
     brokerMessages: "/v1/broker/messages",
     eventsStream: "/v1/events/stream",
     commands: "/v1/commands",
@@ -21049,7 +21144,7 @@ function isOpenScoutClaudeStatuslineCommand(command, wrapperPath = resolveClaude
 }
 
 // ../runtime/dist/managed-installs.js
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import { mkdir as mkdir3, readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
 import { dirname as dirname7 } from "node:path";
 function emptyManagedInstallsFile(now = Date.now()) {
@@ -21068,7 +21163,7 @@ function stableInstallId(input) {
     input.provider ?? "",
     input.targetPath ?? ""
   ].join("\x00");
-  return `install.${createHash2("sha256").update(key).digest("hex").slice(0, 18)}`;
+  return `install.${createHash3("sha256").update(key).digest("hex").slice(0, 18)}`;
 }
 function normalizeManagedInstallsFile(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -25815,6 +25910,15 @@ var messageMentionsTable = sqliteTable("message_mentions", {
 }, (table) => [
   primaryKey({ columns: [table.messageId, table.actorId] })
 ]);
+var messageReactionsTable = sqliteTable("message_reactions", {
+  messageId: text2("message_id").notNull().references(() => messagesTable.id, { onDelete: "cascade" }),
+  actorId: text2("actor_id").notNull().references(() => actorsTable.id, { onDelete: "restrict" }),
+  emoji: text2("emoji").notNull(),
+  createdAt: integer("created_at").notNull()
+}, (table) => [
+  primaryKey({ columns: [table.messageId, table.actorId, table.emoji] }),
+  index("idx_message_reactions_message").on(table.messageId)
+]);
 var messageAttachmentsTable = sqliteTable("message_attachments", {
   id: text2("id").primaryKey(),
   messageId: text2("message_id").notNull().references(() => messagesTable.id, { onDelete: "cascade" }),
@@ -26662,6 +26766,16 @@ CREATE TABLE IF NOT EXISTS message_mentions (
   PRIMARY KEY (message_id, actor_id)
 );
 
+CREATE TABLE IF NOT EXISTS message_reactions (
+  message_id TEXT NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
+  actor_id TEXT NOT NULL REFERENCES actors(id) ON DELETE RESTRICT,
+  emoji TEXT NOT NULL,
+  created_at INTEGER NOT NULL,
+  PRIMARY KEY (message_id, actor_id, emoji)
+);
+CREATE INDEX IF NOT EXISTS idx_message_reactions_message
+  ON message_reactions (message_id);
+
 CREATE TABLE IF NOT EXISTS message_attachments (
   id TEXT PRIMARY KEY,
   message_id TEXT NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
@@ -28049,7 +28163,7 @@ class InMemoryControlRuntime {
   }
 }
 // ../runtime/dist/conversation-thread-artifact.js
-import { createHash as createHash3, randomBytes as randomBytes2 } from "node:crypto";
+import { createHash as createHash4, randomBytes as randomBytes2 } from "node:crypto";
 import { existsSync as existsSync12, mkdirSync as mkdirSync6, readFileSync as readFileSync8, readdirSync, renameSync as renameSync4, rmSync as rmSync3, statSync as statSync3, writeFileSync as writeFileSync6 } from "node:fs";
 import { basename as basename5, dirname as dirname12, join as join14 } from "node:path";
 var NATIVE_READ_THREAD_ARTIFACT_SCHEMA = "openscout.native.read.thread-cache/v1";
@@ -28176,7 +28290,7 @@ function artifactBytes(artifact) {
   return Buffer.byteLength(encodedArtifact(artifact), "utf8");
 }
 function contentCursorForArtifact(artifact) {
-  return createHash3("sha256").update(JSON.stringify({
+  return createHash4("sha256").update(JSON.stringify({
     feedId: artifact.feedId,
     entityKind: artifact.entityKind,
     conversationId: artifact.conversationId,
@@ -28186,7 +28300,7 @@ function contentCursorForArtifact(artifact) {
   })).digest("hex");
 }
 function nativeReadThreadArtifactPath(outputDirectory, feedId) {
-  const digest = createHash3("sha256").update(feedId).digest("hex");
+  const digest = createHash4("sha256").update(feedId).digest("hex");
   return join14(outputDirectory, `${ARTIFACT_PREFIX}${digest}${ARTIFACT_SUFFIX}`);
 }
 function buildNativeReadThreadArtifact(snapshot) {
@@ -28355,7 +28469,7 @@ var QUOTA_HISTORY_BUCKET_MS = 60 * 60 * 1000;
 // ../runtime/dist/sqlite-store.js
 var RUNTIME_SESSION_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
 // ../runtime/dist/mesh-peer-auth.js
-import { createHash as createHash4, randomBytes as randomBytes3 } from "node:crypto";
+import { createHash as createHash5, randomBytes as randomBytes3 } from "node:crypto";
 var PEER_AUTH_HEADERS = {
   peer: "x-openscout-peer",
   ts: "x-openscout-ts",
@@ -28390,7 +28504,7 @@ function peerRequestSigningPayload(input) {
 `);
 }
 function sha256Hex(body) {
-  return createHash4("sha256").update(body).digest("hex");
+  return createHash5("sha256").update(body).digest("hex");
 }
 function signPeerRequest(identity, input) {
   const ts = input.ts ?? Date.now();
@@ -28454,7 +28568,7 @@ import { Agent as HttpsAgent, request as httpsRequest } from "node:https";
 import { connect as tlsConnect } from "node:tls";
 
 // ../runtime/dist/node-tls-identity.js
-import { createHash as createHash5, createPrivateKey as createPrivateKey2, createPublicKey as createPublicKey2, generateKeyPairSync as generateKeyPairSync2, randomBytes as randomBytes4 } from "node:crypto";
+import { createHash as createHash6, createPrivateKey as createPrivateKey2, createPublicKey as createPublicKey2, generateKeyPairSync as generateKeyPairSync2, randomBytes as randomBytes4 } from "node:crypto";
 
 // ../../node_modules/.bun/@peculiar+x509@1.12.3/node_modules/@peculiar/x509/build/x509.cjs.js
 /*!
@@ -30795,7 +30909,7 @@ var $X509Certificate = X509Certificate;
 var TLS_CERT_VALIDITY_MS = 365 * 24 * 60 * 60 * 1000;
 var TLS_CERT_RENEWAL_WINDOW_MS = 30 * 24 * 60 * 60 * 1000;
 function tlsSpkiFingerprintFromDer(spkiDer) {
-  return createHash5("sha256").update(spkiDer).digest("hex");
+  return createHash6("sha256").update(spkiDer).digest("hex");
 }
 function tlsSpkiFingerprintFromCertificateDer(certificateDer) {
   const certificate = new $X509Certificate(asBufferSource(certificateDer));
@@ -31335,7 +31449,7 @@ var MAX_PEER_AGENT_SNAPSHOT_BYTES = 2 * 1024 * 1024;
 import { createRequire as createRequire3 } from "node:module";
 var require3 = createRequire3(import.meta.url);
 // ../runtime/dist/mesh-sas.js
-import { createHash as createHash6, createHmac } from "node:crypto";
+import { createHash as createHash7, createHmac } from "node:crypto";
 
 // ../runtime/dist/eff-short-wordlist.js
 var EFF_SHORT_WORDLIST = [
@@ -32640,7 +32754,7 @@ var EFF_SHORT_WORDLIST = [
 // ../runtime/dist/mesh-sas.js
 var SAS_WORD_COUNT = 6;
 function createEnrollmentCommitment(nonce, cardSignature) {
-  return createHash6("sha256").update(Buffer.concat([nonce, Buffer.from(cardSignature, "utf8")])).digest("base64");
+  return createHash7("sha256").update(Buffer.concat([nonce, Buffer.from(cardSignature, "utf8")])).digest("base64");
 }
 function verifyEnrollmentCommitment(commitment, nonce, cardSignature) {
   const expected = createEnrollmentCommitment(nonce, cardSignature);