chron-mcp 0.1.13 → 0.1.14

package/dashboards/logscale/ai-tool-usage.lql

@@ -0,0 +1,5 @@
+// AI tool adoption breakdown — pie/bar widget
+event_type = "session_started"
+| groupby(ai_tool, function=count())
+| rename(count(), as=sessions)
+| sort(sessions, order=desc)

package/dashboards/logscale/api-key-alert.lql

@@ -0,0 +1,5 @@
+// Alert: API key or credential sent to AI tool
+// Use as a Scheduled Search alert — notify SOC on any match
+event_type = "secret_detected"
+| detection_type in ["api_key", "aws_key", "gcp_key", "azure_key", "private_key", "jwt"]
+| table([#host, ai_tool, detection_type, masked_value, session_id_prefix, @timestamp])

package/dashboards/logscale/chron-ai-activity.yaml

@@ -0,0 +1,66 @@
+$schema: "https://schemas.humio.com/dashboard/v0.1.0"
+name: "Chron — AI Activity"
+updateFrequency: 60
+timeSelector:
+  defaultRelativeTimeRange: "7d"
+
+widgets:
+  - id: daily-active-developers
+    title: "Daily Active Developers"
+    type: time-chart
+    x: 0
+    y: 0
+    width: 8
+    height: 4
+    query: |
+      event_type = "session_started"
+      | timechart(unit=1d, function=count(#host, distinct=true))
+
+  - id: ai-tool-usage
+    title: "AI Tool Usage"
+    type: pie-chart
+    x: 8
+    y: 0
+    width: 4
+    height: 4
+    query: |
+      event_type = "session_started"
+      | groupby(ai_tool, function=count())
+      | rename(count(), as=sessions)
+      | sort(sessions, order=desc)
+
+  - id: secrets-by-type
+    title: "Secrets Detected by Type (7d)"
+    type: time-chart
+    x: 0
+    y: 4
+    width: 8
+    height: 4
+    query: |
+      event_type = "secret_detected"
+      | timechart(detection_type, unit=1d, function=count())
+
+  - id: sessions-by-developer
+    title: "Sessions by Developer"
+    type: table
+    x: 8
+    y: 4
+    width: 4
+    height: 4
+    query: |
+      event_type = "session_started"
+      | groupby([#host, ai_tool], function=count())
+      | rename(count(), as=sessions)
+      | sort(sessions, order=desc)
+
+  - id: api-key-alerts
+    title: "Credential Exposures — Requires Attention"
+    type: table
+    x: 0
+    y: 8
+    width: 12
+    height: 4
+    query: |
+      event_type = "secret_detected"
+      | detection_type in ["api_key", "aws_key", "gcp_key", "azure_key", "private_key", "jwt"]
+      | table([#host, ai_tool, detection_type, masked_value, session_id_prefix, @timestamp])

package/dashboards/logscale/daily-active-developers.lql

@@ -0,0 +1,3 @@
+// Daily active developers — time-series widget
+event_type = "session_started"
+| timechart(unit=1d, function=count(#host, distinct=true))

package/dashboards/logscale/secrets-by-type.lql

@@ -0,0 +1,3 @@
+// Secrets detected by type — timechart (use as time-series widget, 7d window)
+event_type = "secret_detected"
+| timechart(detection_type, unit=1d, function=count())

package/dashboards/logscale/sessions-by-developer.lql

@@ -0,0 +1,6 @@
+// Sessions per developer — bar/table widget
+// #host is the actual hostname sent in the LogScale tags (set by chron MCP)
+event_type = "session_started"
+| groupby([#host, ai_tool], function=count())
+| rename(count(), as=sessions)
+| sort(sessions, order=desc)

package/dist/cli/index.js

@@ -1184,7 +1184,7 @@ var init_sql = __esm({
         return new SQL([new StringChunk(str)]);
       }
       sql2.raw = raw;
-      function join3(chunks, separator) {
+      function join4(chunks, separator) {
         const result = [];
         for (const [i, chunk] of chunks.entries()) {
           if (i > 0 && separator !== void 0) {
@@ -1194,7 +1194,7 @@ var init_sql = __esm({
         }
         return new SQL(result);
       }
-      sql2.join = join3;
+      sql2.join = join4;
       function identifier(value) {
         return new Name(value);
       }
@@ -2806,7 +2806,7 @@ var require_filesystem = __commonJS({
     "use strict";
     var fs = require("fs");
     var LDD_PATH = "/usr/bin/ldd";
-    var readFileSync = (path) => fs.readFileSync(path, "utf-8");
+    var readFileSync2 = (path) => fs.readFileSync(path, "utf-8");
     var readFile = (path) => new Promise((resolve, reject) => {
       fs.readFile(path, "utf-8", (err, data) => {
         if (err) {
@@ -2818,7 +2818,7 @@ var require_filesystem = __commonJS({
     });
     module2.exports = {
       LDD_PATH,
-      readFileSync,
+      readFileSync: readFileSync2,
       readFile
     };
   }
@@ -2830,7 +2830,7 @@ var require_detect_libc = __commonJS({
     "use strict";
     var childProcess = require("child_process");
     var { isLinux, getReport } = require_process();
-    var { LDD_PATH, readFile, readFileSync } = require_filesystem();
+    var { LDD_PATH, readFile, readFileSync: readFileSync2 } = require_filesystem();
     var cachedFamilyFilesystem;
     var cachedVersionFilesystem;
     var command2 = "getconf GNU_LIBC_VERSION 2>&1 || true; ldd --version 2>&1 || true";
@@ -2911,7 +2911,7 @@ var require_detect_libc = __commonJS({
       }
       cachedFamilyFilesystem = null;
       try {
-        const lddContent = readFileSync(LDD_PATH);
+        const lddContent = readFileSync2(LDD_PATH);
         cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
       } catch (e) {
       }
@@ -2968,7 +2968,7 @@ var require_detect_libc = __commonJS({
       }
       cachedVersionFilesystem = null;
       try {
-        const lddContent = readFileSync(LDD_PATH);
+        const lddContent = readFileSync2(LDD_PATH);
         const versionMatch = lddContent.match(RE_GLIBC_VERSION);
         if (versionMatch) {
           cachedVersionFilesystem = versionMatch[1];
@@ -11068,8 +11068,8 @@ var init_stream3 = __esm({
         let promise;
         try {
           const request = createRequest();
-          const fetch = this.#fetch;
-          promise = fetch(request);
+          const fetch2 = this.#fetch;
+          promise = fetch2(request);
         } catch (error) {
           promise = Promise.reject(error);
         }
@@ -11136,11 +11136,11 @@ var init_stream3 = __esm({
 
 // node_modules/@libsql/hrana-client/lib-esm/http/client.js
 async function findEndpoint(customFetch, clientUrl) {
-  const fetch = customFetch;
+  const fetch2 = customFetch;
   for (const endpoint of checkEndpoints) {
     const url = new URL(endpoint.versionPath, clientUrl);
     const request = new Request(url.toString(), { method: "GET" });
-    const response = await fetch(request);
+    const response = await fetch2(request);
     await response.arrayBuffer();
     if (response.ok) {
       return endpoint;
@@ -14252,7 +14252,7 @@ var init_select2 = __esm({
           const tableName = getTableLikeName(table);
           for (const item of extractUsedTable(table))
             this.usedTables.add(item);
-          if (typeof tableName === "string" && this.config.joins?.some((join3) => join3.alias === tableName)) {
+          if (typeof tableName === "string" && this.config.joins?.some((join4) => join4.alias === tableName)) {
             throw new Error(`Alias "${tableName}" is already used in this query`);
           }
           if (!this.isPartialSelect) {
@@ -15141,7 +15141,7 @@ var init_update = __esm({
       createJoin(joinType) {
         return (table, on) => {
           const tableName = getTableLikeName(table);
-          if (typeof tableName === "string" && this.config.joins.some((join3) => join3.alias === tableName)) {
+          if (typeof tableName === "string" && this.config.joins.some((join4) => join4.alias === tableName)) {
             throw new Error(`Alias "${tableName}" is already used in this query`);
           }
           if (typeof on === "function") {
@@ -17026,6 +17026,250 @@ var init_secrets = __esm({
   }
 });
 
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports2, module2) {
+    module2.exports = {
+      name: "chron-mcp",
+      version: "0.1.14",
+      mcpName: "io.github.sirinivask/chron",
+      description: "Audit-grade timestamped logs for every AI conversation",
+      repository: {
+        type: "git",
+        url: "https://github.com/sirinivask/chron.git"
+      },
+      main: "dist/index.js",
+      vitest: {
+        include: [
+          "tests/**/*.test.ts"
+        ],
+        globals: true
+      },
+      bin: {
+        "chron-mcp": "dist/index.js",
+        chron: "dist/cli/index.js"
+      },
+      files: [
+        "dist",
+        "skills",
+        ".claude-plugin",
+        "assets",
+        "dashboards",
+        "README.md"
+      ],
+      engines: {
+        node: ">=18"
+      },
+      scripts: {
+        build: "npx esbuild src/index.ts --bundle --format=cjs --outfile=dist/index.js --platform=node && chmod +x dist/index.js && npx esbuild src/cli/index.ts --bundle --format=cjs --outfile=dist/cli/index.js --platform=node && chmod +x dist/cli/index.js",
+        "build:cli": "npx esbuild src/cli/index.ts --bundle --format=cjs --outfile=dist/cli/index.js --platform=node && chmod +x dist/cli/index.js",
+        typecheck: "tsc --noEmit",
+        dev: "tsc --watch",
+        start: "node dist/index.js",
+        test: "vitest run",
+        "test:watch": "vitest",
+        prepublishOnly: "npm test && npm run build"
+      },
+      keywords: [
+        "mcp",
+        "ai",
+        "audit",
+        "logging",
+        "claude",
+        "cursor"
+      ],
+      license: "SEE LICENSE IN LICENSE",
+      dependencies: {
+        "@libsql/client": "^0.17.3",
+        "@modelcontextprotocol/sdk": "^1.12.0",
+        "drizzle-orm": "^0.45.2",
+        express: "^4.18.2",
+        uuid: "^11.1.1",
+        zod: "^3.22.4"
+      },
+      devDependencies: {
+        "@types/express": "^4.17.21",
+        "@types/node": "^20.0.0",
+        "@types/uuid": "^9.0.0",
+        "drizzle-kit": "^0.20.14",
+        typescript: "^5.4.5",
+        vitest: "^1.4.0"
+      }
+    };
+  }
+});
+
+// src/cli/connect.ts
+var connect_exports = {};
+__export(connect_exports, {
+  runConnect: () => runConnect
+});
+function prompt(rl, question) {
+  return new Promise((resolve) => rl.question(question, resolve));
+}
+function configPath() {
+  return (0, import_path3.join)((0, import_os3.homedir)(), ".chron", "config.json");
+}
+function loadConfig() {
+  try {
+    return JSON.parse((0, import_fs2.readFileSync)(configPath(), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function saveConfig(data) {
+  const dir = (0, import_path3.join)((0, import_os3.homedir)(), ".chron");
+  (0, import_fs2.mkdirSync)(dir, { recursive: true });
+  (0, import_fs2.writeFileSync)(configPath(), JSON.stringify(data, null, 2), "utf8");
+}
+async function connectCrowdStrike() {
+  process.stdout.write(`
+${BOLD5}Connect Chron \u2192 CrowdStrike LogScale${RESET5}
+
+`);
+  process.stdout.write(`${DIM4}Events will be sent directly to your LogScale repository.
+`);
+  process.stdout.write(`No message content is transmitted \u2014 metadata only.${RESET5}
+
+`);
+  const rl = (0, import_readline.createInterface)({ input: process.stdin, output: process.stdout });
+  let url;
+  let token;
+  try {
+    url = (await prompt(rl, `  LogScale ingest URL  ${DIM4}(e.g. https://cloud.us.humio.com/api/v1/ingest/humio-structured)${RESET5}
+  ${CYAN4}>${RESET5} `)).trim();
+    if (!url.startsWith("https://")) {
+      process.stdout.write(`
+${RED}URL must start with https://${RESET5}
+`);
+      process.exit(1);
+    }
+    token = (await prompt(rl, `
+  LogScale ingest token
+  ${CYAN4}>${RESET5} `)).trim();
+    if (!token) {
+      process.stdout.write(`
+${RED}Token cannot be empty${RESET5}
+`);
+      process.exit(1);
+    }
+  } finally {
+    rl.close();
+  }
+  process.stdout.write(`
+${DIM4}Sending test event...${RESET5} `);
+  const testPayload = JSON.stringify([{
+    tags: { host: require("os").hostname(), source: "chron-mcp" },
+    events: [{
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      attributes: {
+        event_type: "connection_test",
+        chron_version: require_package().version,
+        os: process.platform,
+        message: "chron connect crowdstrike \u2014 test event"
+      }
+    }]
+  }]);
+  let ok = false;
+  let statusCode = 0;
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: testPayload
+    });
+    statusCode = res.status;
+    ok = res.ok;
+  } catch (e) {
+    process.stdout.write(`${RED}failed${RESET5}
+`);
+    process.stderr.write(`  ${RED}Error: ${e.message}${RESET5}
+
+`);
+    process.exit(1);
+  }
+  if (!ok) {
+    process.stdout.write(`${RED}failed (HTTP ${statusCode})${RESET5}
+`);
+    process.stderr.write(`  ${RED}Check your URL and token, then try again.${RESET5}
+
+`);
+    process.exit(1);
+  }
+  process.stdout.write(`${GREEN}OK${RESET5}
+
+`);
+  const config = loadConfig();
+  config.logscale = { url, connected_at: (/* @__PURE__ */ new Date()).toISOString() };
+  saveConfig(config);
+  process.stdout.write(`${GREEN}${BOLD5}Connected!${RESET5} Test event appeared in LogScale.
+
+`);
+  process.stdout.write(`${BOLD5}Add these env vars to your MCP client config:${RESET5}
+
+`);
+  process.stdout.write(`  ${CYAN4}CHRON_LOGSCALE_URL${RESET5}   ${url}
+`);
+  process.stdout.write(`  ${CYAN4}CHRON_LOGSCALE_TOKEN${RESET5} ${DIM4}<your-token>${RESET5}
+
+`);
+  process.stdout.write(`${DIM4}For Claude Code \u2014 add to the "env" block of the chron entry in ~/.claude.json:${RESET5}
+
+`);
+  process.stdout.write(`  ${DIM4}"env": {
+`);
+  process.stdout.write(`    "CHRON_LOGSCALE_URL": "${url}",
+`);
+  process.stdout.write(`    "CHRON_LOGSCALE_TOKEN": "<your-token>"
+`);
+  process.stdout.write(`  }${RESET5}
+
+`);
+  process.stdout.write(`${DIM4}Connection saved to ~/.chron/config.json${RESET5}
+
+`);
+}
+async function runConnect(args2) {
+  const [subcommand] = args2;
+  switch (subcommand) {
+    case "crowdstrike":
+      await connectCrowdStrike();
+      break;
+    default: {
+      const name = subcommand ? `Unknown integration: ${subcommand}
+
+` : "";
+      process.stdout.write(
+        `${name}Usage: chron connect <integration>
+
+Integrations:
+  crowdstrike    Connect to CrowdStrike LogScale (direct ingest)
+`
+      );
+      process.exit(subcommand ? 1 : 0);
+    }
+  }
+}
+var import_readline, import_os3, import_path3, import_fs2, RESET5, BOLD5, DIM4, CYAN4, GREEN, RED;
+var init_connect = __esm({
+  "src/cli/connect.ts"() {
+    "use strict";
+    import_readline = require("readline");
+    import_os3 = require("os");
+    import_path3 = require("path");
+    import_fs2 = require("fs");
+    RESET5 = "\x1B[0m";
+    BOLD5 = "\x1B[1m";
+    DIM4 = "\x1B[2m";
+    CYAN4 = "\x1B[36m";
+    GREEN = "\x1B[32m";
+    RED = "\x1B[31m";
+  }
+});
+
 // src/cli/index.ts
 var [, , command, ...args] = process.argv;
 async function main() {
@@ -17055,6 +17299,11 @@ async function main() {
       await runSecrets2(args);
       break;
     }
+    case "connect": {
+      const { runConnect: runConnect2 } = await Promise.resolve().then(() => (init_connect(), connect_exports));
+      await runConnect2(args);
+      break;
+    }
     default: {
       const name = command ? `Unknown command: ${command}
 
@@ -17068,6 +17317,7 @@ Commands:
   export          Export a session as markdown
   secrets         List detected secrets across sessions
   settings        View current configuration
+  connect         Connect to a SIEM integration (crowdstrike)
 
 Options (history):
   --limit=<n>     Max sessions to show (default: 20)

package/dist/index.js

@@ -9320,7 +9320,7 @@ var require_websocket = __commonJS({
     var http = require("http");
     var net = require("net");
     var tls = require("tls");
-    var { randomBytes, createHash: createHash2 } = require("crypto");
+    var { randomBytes, createHash: createHash3 } = require("crypto");
     var { Duplex, Readable } = require("stream");
     var { URL: URL3 } = require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
@@ -10000,7 +10000,7 @@ var require_websocket = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest = createHash2("sha1").update(key + GUID).digest("base64");
+        const digest = createHash3("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -10387,7 +10387,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter = require("events");
     var http = require("http");
     var { Duplex } = require("stream");
-    var { createHash: createHash2 } = require("crypto");
+    var { createHash: createHash3 } = require("crypto");
     var extension2 = require_extension();
     var PerMessageDeflate2 = require_permessage_deflate();
     var subprotocol2 = require_subprotocol();
@@ -10696,7 +10696,7 @@ var require_websocket_server = __commonJS({
         }
         if (this._state > RUNNING)
           return abortHandshake(socket, 503);
-        const digest = createHash2("sha1").update(key + GUID).digest("base64");
+        const digest = createHash3("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -32535,6 +32535,92 @@ var init_time = __esm({
   }
 });
 
+// package.json
+var version4;
+var init_package = __esm({
+  "package.json"() {
+    version4 = "0.1.14";
+  }
+});
+
+// src/utils/relay.ts
+function getMachineId() {
+  if (!_machineId) {
+    _machineId = "sha256:" + (0, import_crypto3.createHash)("sha256").update((0, import_os2.hostname)()).digest("hex").slice(0, 16);
+  }
+  return _machineId;
+}
+function toLogScaleAttributes(payload) {
+  const attrs = {
+    event_type: payload.event_type,
+    session_id_prefix: payload.session.id_prefix,
+    ai_tool: payload.session.ai_tool ?? "",
+    os: process.platform,
+    chron_version: version4
+  };
+  if (payload.event_type === "message_logged") {
+    attrs.role = payload.message.role;
+  } else if (payload.event_type === "secret_detected") {
+    attrs.detection_type = payload.detection.type;
+    attrs.masked_value = payload.detection.masked_value;
+  }
+  return attrs;
+}
+function emitToLogScale(payload) {
+  const url = process.env.CHRON_LOGSCALE_URL;
+  const token = process.env.CHRON_LOGSCALE_TOKEN;
+  if (!url || !token)
+    return;
+  const body = JSON.stringify([{
+    tags: { host: (0, import_os2.hostname)(), source: "chron-mcp" },
+    events: [{ timestamp: payload.timestamp, attributes: toLogScaleAttributes(payload) }]
+  }]);
+  setImmediate(
+    () => fetch(url, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body
+    }).catch(() => void 0)
+  );
+}
+function emitEvent(payload) {
+  const url = process.env.CHRON_RELAY_URL;
+  const token = process.env.CHRON_RELAY_TOKEN;
+  if (url && token) {
+    const event = {
+      schema_version: "1.0",
+      chron_version: version4,
+      machine_id: getMachineId(),
+      os: process.platform,
+      ...payload
+    };
+    setImmediate(
+      () => fetch(url, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${token}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(event)
+      }).catch(() => void 0)
+    );
+  }
+  emitToLogScale(payload);
+}
+var import_crypto3, import_os2, _machineId;
+var init_relay = __esm({
+  "src/utils/relay.ts"() {
+    "use strict";
+    import_crypto3 = require("crypto");
+    import_os2 = require("os");
+    init_package();
+    _machineId = null;
+  }
+});
+
 // src/tools/sessions.ts
 function startSession(db) {
   return async (args) => {
@@ -32548,6 +32634,7 @@ function startSession(db) {
         created_at: now,
         updated_at: now
       });
+      emitEvent({ event_type: "session_started", timestamp: now, session: { id_prefix: id.slice(0, 8), ai_tool: args.ai_tool ?? null } });
       return {
         content: [{
           type: "text",
@@ -32562,6 +32649,7 @@ function startSession(db) {
       const session = existing[0];
       const [countRow] = await db.select({ count: sql`count(*)` }).from(messages).where(eq(messages.session_id, session.id));
       await db.update(sessions).set({ updated_at: now }).where(eq(sessions.id, session.id));
+      emitEvent({ event_type: "session_started", timestamp: now, session: { id_prefix: session.id.slice(0, 8), ai_tool: session.ai_tool } });
       return {
         content: [{
           type: "text",
@@ -32600,6 +32688,7 @@ function initSession(db) {
       created = false;
       ai_tool = session.ai_tool;
     }
+    emitEvent({ event_type: "session_started", timestamp: now, session: { id_prefix: session_id.slice(0, 8), ai_tool } });
     const limit = args.limit ?? 10;
     const [countRow] = await db.select({
       count: sql`count(*)`,
@@ -32683,18 +32772,19 @@ var init_sessions = __esm({
     init_esm2();
     init_schema();
     init_time();
+    init_relay();
   }
 });
 
 // src/utils/hash.ts
 function computeContentHash(sessionId, role, content, createdAt, prevHash) {
-  return (0, import_crypto3.createHash)("sha256").update(`${sessionId}|${role}|${content}|${createdAt}|${prevHash ?? ""}`).digest("hex");
+  return (0, import_crypto4.createHash)("sha256").update(`${sessionId}|${role}|${content}|${createdAt}|${prevHash ?? ""}`).digest("hex");
 }
-var import_crypto3;
+var import_crypto4;
 var init_hash = __esm({
   "src/utils/hash.ts"() {
     "use strict";
-    import_crypto3 = require("crypto");
+    import_crypto4 = require("crypto");
   }
 });
 
@@ -32823,16 +32913,19 @@ async function writeDetections(db, session_id, message_id, content) {
   if (found.length === 0)
     return;
   const now = localISOString();
-  await db.insert(secrets_detected).values(
-    found.map((s) => ({
-      id: v4_default(),
-      session_id,
-      message_id,
-      type: s.type,
-      masked_value: maskValue(s.value),
-      detected_at: now
-    }))
-  );
+  const rows = found.map((s) => ({
+    id: v4_default(),
+    session_id,
+    message_id,
+    type: s.type,
+    masked_value: maskValue(s.value),
+    detected_at: now
+  }));
+  await db.insert(secrets_detected).values(rows);
+  const sessionIdPrefix = session_id.slice(0, 8);
+  for (const row of rows) {
+    emitEvent({ event_type: "secret_detected", timestamp: now, session: { id_prefix: sessionIdPrefix, ai_tool: null }, detection: { type: row.type, masked_value: row.masked_value } });
+  }
 }
 function isFkError(e) {
   return e?.message?.includes("FOREIGN KEY constraint failed") || e?.code === "SQLITE_CONSTRAINT_FOREIGNKEY" || e?.cause?.message?.includes("FOREIGN KEY constraint failed") || e?.cause?.extendedCode === "SQLITE_CONSTRAINT_FOREIGNKEY";
@@ -32842,6 +32935,7 @@ function logMessage(db) {
     let id;
     let now;
     let contentHash;
+    let sessionAiTool;
     try {
       const result = await db.transaction(async (tx) => {
         const last = await tx.select({ content_hash: messages.content_hash }).from(messages).where(eq(messages.session_id, args.session_id)).orderBy(desc(messages.created_at), desc(sql`rowid`)).limit(1);
@@ -32859,17 +32953,20 @@ function logMessage(db) {
           content_hash: hash
         });
         await tx.update(sessions).set({ updated_at: ts }).where(eq(sessions.id, args.session_id));
-        return { id: msgId, now: ts, contentHash: hash };
+        const [sessionRow] = await tx.select({ ai_tool: sessions.ai_tool }).from(sessions).where(eq(sessions.id, args.session_id)).limit(1);
+        return { id: msgId, now: ts, contentHash: hash, ai_tool: sessionRow?.ai_tool ?? null };
       });
       id = result.id;
       now = result.now;
       contentHash = result.contentHash;
+      sessionAiTool = result.ai_tool;
     } catch (e) {
       if (isFkError(e)) {
         return { content: [{ type: "text", text: `Session not found: ${args.session_id}` }], isError: true };
       }
       throw e;
     }
+    emitEvent({ event_type: "message_logged", timestamp: now, session: { id_prefix: args.session_id.slice(0, 8), ai_tool: sessionAiTool }, message: { role: args.role } });
     if (args.role === "user") {
       setImmediate(() => writeDetections(db, args.session_id, id, args.content).catch(() => void 0));
     }
@@ -32886,6 +32983,7 @@ function logExchange(db) {
     let assistantNow;
     let userHash;
     let assistantHash;
+    let sessionAiTool;
     try {
       const result = await db.transaction(async (tx) => {
         const last = await tx.select({ content_hash: messages.content_hash }).from(messages).where(eq(messages.session_id, args.session_id)).orderBy(desc(messages.created_at), desc(sql`rowid`)).limit(1);
@@ -32915,7 +33013,8 @@ function logExchange(db) {
           content_hash: aHash
         });
         await tx.update(sessions).set({ updated_at: aNow }).where(eq(sessions.id, args.session_id));
-        return { uId, aId, uNow, aNow, uHash, aHash };
+        const [sessionRow] = await tx.select({ ai_tool: sessions.ai_tool }).from(sessions).where(eq(sessions.id, args.session_id)).limit(1);
+        return { uId, aId, uNow, aNow, uHash, aHash, ai_tool: sessionRow?.ai_tool ?? null };
       });
       userId = result.uId;
       assistantId = result.aId;
@@ -32923,12 +33022,16 @@ function logExchange(db) {
       assistantNow = result.aNow;
       userHash = result.uHash;
       assistantHash = result.aHash;
+      sessionAiTool = result.ai_tool;
     } catch (e) {
       if (isFkError(e)) {
         return { content: [{ type: "text", text: `Session not found: ${args.session_id}` }], isError: true };
       }
       throw e;
     }
+    const idPrefix = args.session_id.slice(0, 8);
+    emitEvent({ event_type: "message_logged", timestamp: userNow, session: { id_prefix: idPrefix, ai_tool: sessionAiTool }, message: { role: "user" } });
+    emitEvent({ event_type: "message_logged", timestamp: assistantNow, session: { id_prefix: idPrefix, ai_tool: sessionAiTool }, message: { role: "assistant" } });
     setImmediate(() => writeDetections(db, args.session_id, userId, args.user_content).catch(() => void 0));
     return {
       content: [{
@@ -32954,6 +33057,7 @@ var init_messages = __esm({
     init_time();
     init_hash();
     init_detect();
+    init_relay();
   }
 });
 
@@ -33082,14 +33186,6 @@ var init_detect2 = __esm({
   }
 });
 
-// package.json
-var version4;
-var init_package = __esm({
-  "package.json"() {
-    version4 = "0.1.13";
-  }
-});
-
 // src/server.ts
 function createServer(db) {
   const server = new McpServer({
@@ -33208,7 +33304,7 @@ __export(setup_exports, {
   runSetup: () => runSetup
 });
 function configPath(...parts) {
-  return (0, import_path2.join)((0, import_os2.homedir)(), ...parts);
+  return (0, import_path2.join)((0, import_os3.homedir)(), ...parts);
 }
 function readJson(filePath) {
   if (!(0, import_fs2.existsSync)(filePath))
@@ -33246,7 +33342,7 @@ function configureClaudeCode() {
   try {
     (0, import_child_process.execSync)("claude mcp add chron -- npx -y chron-mcp", { stdio: "pipe" });
   } catch {
-    const result = configureTool("Claude Code", (0, import_path2.join)((0, import_os2.homedir)(), ".claude", "settings.json"));
+    const result = configureTool("Claude Code", (0, import_path2.join)((0, import_os3.homedir)(), ".claude", "settings.json"));
     if (result.status === "error")
       return result;
   }
@@ -33255,12 +33351,12 @@ function configureClaudeCode() {
 }
 function installClaudeCodeHook() {
   const skillSrc = (0, import_path2.join)(__dirname, "..", "skills", "chron.skill.md");
-  const skillDst = (0, import_path2.join)((0, import_os2.homedir)(), ".chron", "chron.skill.md");
+  const skillDst = (0, import_path2.join)((0, import_os3.homedir)(), ".chron", "chron.skill.md");
   if ((0, import_fs2.existsSync)(skillSrc)) {
     (0, import_fs2.mkdirSync)((0, import_path2.dirname)(skillDst), { recursive: true });
     (0, import_fs2.copyFileSync)(skillSrc, skillDst);
   }
-  const settingsPath = (0, import_path2.join)((0, import_os2.homedir)(), ".claude", "settings.json");
+  const settingsPath = (0, import_path2.join)((0, import_os3.homedir)(), ".claude", "settings.json");
   const settings = readJson(settingsPath);
   if (!settings.hooks)
     settings.hooks = {};
@@ -33284,12 +33380,12 @@ async function runSetup() {
   }
   return results.filter((r) => r.status !== "skipped");
 }
-var import_fs2, import_os2, import_path2, import_child_process, CHRON_ENTRY, TOOLS;
+var import_fs2, import_os3, import_path2, import_child_process, CHRON_ENTRY, TOOLS;
 var init_setup = __esm({
   "src/setup.ts"() {
     "use strict";
     import_fs2 = require("fs");
-    import_os2 = require("os");
+    import_os3 = require("os");
     import_path2 = require("path");
     import_child_process = require("child_process");
     CHRON_ENTRY = {
@@ -57090,17 +57186,17 @@ var require_request = __commonJS({
       return addrs;
     });
     defineGetter(req, "subdomains", function subdomains() {
-      var hostname2 = this.hostname;
-      if (!hostname2)
+      var hostname3 = this.hostname;
+      if (!hostname3)
         return [];
       var offset = this.app.get("subdomain offset");
-      var subdomains2 = !isIP(hostname2) ? hostname2.split(".").reverse() : [hostname2];
+      var subdomains2 = !isIP(hostname3) ? hostname3.split(".").reverse() : [hostname3];
       return subdomains2.slice(offset);
     });
     defineGetter(req, "path", function path() {
       return parse3(this).pathname;
     });
-    defineGetter(req, "hostname", function hostname2() {
+    defineGetter(req, "hostname", function hostname3() {
       var trust = this.app.get("trust proxy fn");
       var host = this.get("X-Forwarded-Host");
       if (!host || !trust(this.connection.remoteAddress, 0)) {
@@ -62419,7 +62515,7 @@ var StdioServerTransport = class {
 };
 
 // src/index.ts
-var import_os3 = require("os");
+var import_os4 = require("os");
 var import_path3 = require("path");
 
 // node_modules/@libsql/core/lib-esm/api.js
@@ -66420,8 +66516,8 @@ var HttpStream = class extends Stream {
     let promise;
     try {
       const request = createRequest();
-      const fetch = this.#fetch;
-      promise = fetch(request);
+      const fetch2 = this.#fetch;
+      promise = fetch2(request);
     } catch (error2) {
       promise = Promise.reject(error2);
     }
@@ -66641,11 +66737,11 @@ var HttpClient = class extends Client {
   }
 };
 async function findEndpoint(customFetch, clientUrl) {
-  const fetch = customFetch;
+  const fetch2 = customFetch;
   for (const endpoint of checkEndpoints) {
     const url = new URL(endpoint.versionPath, clientUrl);
     const request = new Request(url.toString(), { method: "GET" });
-    const response = await fetch(request);
+    const response = await fetch2(request);
     await response.arrayBuffer();
     if (response.ok) {
       return endpoint;
@@ -67896,7 +67992,7 @@ if (process.argv[2] === "--version" || process.argv[2] === "-v") {
   process.exit(0);
 }
 async function main() {
-  const dbPath = process.env.CHRON_DB_PATH ?? (0, import_path3.join)((0, import_os3.homedir)(), ".chron", "chron.db");
+  const dbPath = process.env.CHRON_DB_PATH ?? (0, import_path3.join)((0, import_os4.homedir)(), ".chron", "chron.db");
   if (process.stdin.isTTY) {
     process.stdout.write(`chron-mcp ${version4}
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chron-mcp",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "mcpName": "io.github.sirinivask/chron",
   "description": "Audit-grade timestamped logs for every AI conversation",
   "repository": {
@@ -23,6 +23,7 @@
     "skills",
     ".claude-plugin",
     "assets",
+    "dashboards",
     "README.md"
   ],
   "engines": {