chron-mcp 0.1.7 → 0.1.9

package/README.md

@@ -150,6 +150,23 @@ Chron ships with `skills/chron.skill.md` — a plain-text instruction file that
 | `log_exchange` | Log a user/assistant pair atomically (for batch imports) |
 | `list_sessions` | List all sessions ordered by most recently active |
 | `get_session_history` | Retrieve the full timestamped log for a session |
+| `verify_session` | Verify the tamper-evident hash chain — detects any post-log edits |
+
+---
+
+## Tamper-evident hash chaining
+
+Every message is linked to the previous one via a SHA-256 chain:
+
+```
+content_hash = SHA256(session_id | role | content | created_at | prev_hash)
+```
+
+`verify_session` walks the chain and returns:
+- `valid: true` — no messages were modified after logging
+- `valid: false, first_break: <id>` — exact row ID of the first tampered message
+
+This turns your local log into a verifiable audit artifact. Any edit to a stored message — content, timestamp, or role — breaks the chain and is detected immediately.
 
 ---
 

package/dist/db/index.d.ts

@@ -1,3 +1,5 @@
 import * as schema from './schema';
-export declare function initDb(dbPath?: string): Promise<import("drizzle-orm/libsql").LibSQLDatabase<typeof schema>>;
+export declare function initDb(dbPath?: string): Promise<import("drizzle-orm/libsql").LibSQLDatabase<typeof schema> & {
+    $client: import("@libsql/client").Client;
+}>;
 export type Db = Awaited<ReturnType<typeof initDb>>;

package/dist/db/index.js

@@ -60,6 +60,8 @@ const CREATE_SQL = [
     role TEXT NOT NULL CHECK (role IN ('user', 'assistant')),
     content TEXT NOT NULL,
     created_at TEXT NOT NULL,
+    prev_hash TEXT,
+    content_hash TEXT,
     FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
   )`,
     `CREATE UNIQUE INDEX IF NOT EXISTS idx_sessions_title ON sessions(title)`,
@@ -76,5 +78,14 @@ async function initDb(dbPath) {
     for (const sql of CREATE_SQL) {
         await client.execute(sql);
     }
+    // Migrate existing messages tables that predate hash chaining columns
+    const tableInfo = await client.execute('PRAGMA table_info(messages)');
+    const columns = tableInfo.rows.map((r) => r[1]);
+    if (!columns.includes('prev_hash')) {
+        await client.execute('ALTER TABLE messages ADD COLUMN prev_hash TEXT');
+    }
+    if (!columns.includes('content_hash')) {
+        await client.execute('ALTER TABLE messages ADD COLUMN content_hash TEXT');
+    }
     return (0, libsql_1.drizzle)(client, { schema });
 }

package/dist/db/schema.d.ts

@@ -11,9 +11,16 @@ export declare const sessions: import("drizzle-orm/sqlite-core").SQLiteTableWith
             driverParam: string;
             notNull: true;
             hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
             enumValues: [string, ...string[]];
             baseColumn: never;
-        }, object>;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
         title: import("drizzle-orm/sqlite-core").SQLiteColumn<{
             name: "title";
             tableName: "sessions";
@@ -23,9 +30,16 @@ export declare const sessions: import("drizzle-orm/sqlite-core").SQLiteTableWith
             driverParam: string;
             notNull: true;
             hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
             enumValues: [string, ...string[]];
             baseColumn: never;
-        }, object>;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
         ai_tool: import("drizzle-orm/sqlite-core").SQLiteColumn<{
             name: "ai_tool";
             tableName: "sessions";
@@ -35,9 +49,16 @@ export declare const sessions: import("drizzle-orm/sqlite-core").SQLiteTableWith
             driverParam: string;
             notNull: false;
             hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
             enumValues: [string, ...string[]];
             baseColumn: never;
-        }, object>;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
         created_at: import("drizzle-orm/sqlite-core").SQLiteColumn<{
             name: "created_at";
             tableName: "sessions";
@@ -47,9 +68,16 @@ export declare const sessions: import("drizzle-orm/sqlite-core").SQLiteTableWith
             driverParam: string;
             notNull: true;
             hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
             enumValues: [string, ...string[]];
             baseColumn: never;
-        }, object>;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
         updated_at: import("drizzle-orm/sqlite-core").SQLiteColumn<{
             name: "updated_at";
             tableName: "sessions";
@@ -59,9 +87,16 @@ export declare const sessions: import("drizzle-orm/sqlite-core").SQLiteTableWith
             driverParam: string;
             notNull: true;
             hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
             enumValues: [string, ...string[]];
             baseColumn: never;
-        }, object>;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
     };
     dialect: "sqlite";
 }>;
@@ -78,9 +113,16 @@ export declare const messages: import("drizzle-orm/sqlite-core").SQLiteTableWith
             driverParam: string;
             notNull: true;
             hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
             enumValues: [string, ...string[]];
             baseColumn: never;
-        }, object>;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
         session_id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
             name: "session_id";
             tableName: "messages";
@@ -90,9 +132,16 @@ export declare const messages: import("drizzle-orm/sqlite-core").SQLiteTableWith
             driverParam: string;
             notNull: true;
             hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
             enumValues: [string, ...string[]];
             baseColumn: never;
-        }, object>;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
         role: import("drizzle-orm/sqlite-core").SQLiteColumn<{
             name: "role";
             tableName: "messages";
@@ -102,9 +151,16 @@ export declare const messages: import("drizzle-orm/sqlite-core").SQLiteTableWith
             driverParam: string;
             notNull: true;
             hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
             enumValues: ["user", "assistant"];
             baseColumn: never;
-        }, object>;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
         content: import("drizzle-orm/sqlite-core").SQLiteColumn<{
             name: "content";
             tableName: "messages";
@@ -114,9 +170,16 @@ export declare const messages: import("drizzle-orm/sqlite-core").SQLiteTableWith
             driverParam: string;
             notNull: true;
             hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
             enumValues: [string, ...string[]];
             baseColumn: never;
-        }, object>;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
         created_at: import("drizzle-orm/sqlite-core").SQLiteColumn<{
             name: "created_at";
             tableName: "messages";
@@ -126,9 +189,54 @@ export declare const messages: import("drizzle-orm/sqlite-core").SQLiteTableWith
             driverParam: string;
             notNull: true;
             hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
             enumValues: [string, ...string[]];
             baseColumn: never;
-        }, object>;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        prev_hash: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "prev_hash";
+            tableName: "messages";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        content_hash: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "content_hash";
+            tableName: "messages";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
     };
     dialect: "sqlite";
 }>;

package/dist/db/schema.js

@@ -15,4 +15,6 @@ exports.messages = (0, sqlite_core_1.sqliteTable)('messages', {
     role: (0, sqlite_core_1.text)('role', { enum: ['user', 'assistant'] }).notNull(),
     content: (0, sqlite_core_1.text)('content').notNull(),
     created_at: (0, sqlite_core_1.text)('created_at').notNull(),
+    prev_hash: (0, sqlite_core_1.text)('prev_hash'),
+    content_hash: (0, sqlite_core_1.text)('content_hash'),
 });

package/dist/index.js

@@ -35,9 +35,20 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const os_1 = require("os");
+const path_1 = require("path");
 const index_1 = require("./db/index");
 const server_1 = require("./server");
+const VERSION = '0.1.9';
+// --version: quick install check, safe to run anywhere
+if (process.argv[2] === '--version' || process.argv[2] === '-v') {
+    process.stdout.write(`chron-mcp ${VERSION}\n`);
+    process.exit(0);
+}
 async function main() {
+    const dbPath = process.env.CHRON_DB_PATH ?? (0, path_1.join)((0, os_1.homedir)(), '.chron', 'chron.db');
+    process.stderr.write(`chron-mcp ${VERSION} starting\n`);
+    process.stderr.write(`database: ${dbPath}\n`);
     const db = await (0, index_1.initDb)();
     const server = (0, server_1.createServer)(db);
     if (process.env.CHRON_TRANSPORT === 'http') {
@@ -47,6 +58,7 @@ async function main() {
     else {
         const transport = new stdio_js_1.StdioServerTransport();
         await server.connect(transport);
+        process.stderr.write('ready\n');
     }
 }
 main().catch((err) => {

package/dist/server.js

@@ -5,6 +5,7 @@ const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const zod_1 = require("zod");
 const sessions_1 = require("./tools/sessions");
 const messages_1 = require("./tools/messages");
+const verify_1 = require("./tools/verify");
 const roleEnum = zod_1.z.enum(['user', 'assistant']);
 function createServer(db) {
     const server = new mcp_js_1.McpServer({
@@ -34,5 +35,8 @@ function createServer(db) {
         session_id: zod_1.z.string(),
         limit: zod_1.z.number().int().positive().optional().describe('Return only the most recent N messages'),
     }, (0, sessions_1.getSessionHistory)(db));
+    server.tool('verify_session', 'Verify the tamper-evident hash chain for a session. Returns valid=true if no rows were edited after logging, or the first broken link if tampering is detected.', {
+        session_id: zod_1.z.string().describe('Session ID to verify'),
+    }, (0, verify_1.verifySession)(db));
     return server;
 }

package/dist/tools/messages.js

@@ -6,26 +6,36 @@ const drizzle_orm_1 = require("drizzle-orm");
 const uuid_1 = require("uuid");
 const schema_1 = require("../db/schema");
 const time_1 = require("../utils/time");
+const hash_1 = require("../utils/hash");
 function logMessage(db) {
     return async (args) => {
         const existing = await db.select({ id: schema_1.sessions.id }).from(schema_1.sessions).where((0, drizzle_orm_1.eq)(schema_1.sessions.id, args.session_id)).limit(1);
         if (existing.length === 0) {
             return { content: [{ type: 'text', text: `Session not found: ${args.session_id}` }], isError: true };
         }
+        const last = await db.select({ content_hash: schema_1.messages.content_hash })
+            .from(schema_1.messages)
+            .where((0, drizzle_orm_1.eq)(schema_1.messages.session_id, args.session_id))
+            .orderBy((0, drizzle_orm_1.desc)(schema_1.messages.created_at), (0, drizzle_orm_1.desc)((0, drizzle_orm_1.sql) `rowid`))
+            .limit(1);
         const now = (0, time_1.localISOString)();
         const id = (0, uuid_1.v4)();
+        const prevHash = last[0]?.content_hash ?? null;
+        const contentHash = (0, hash_1.computeContentHash)(args.session_id, args.role, args.content, now, prevHash);
         await db.insert(schema_1.messages).values({
             id,
             session_id: args.session_id,
             role: args.role,
             content: args.content,
             created_at: now,
+            prev_hash: prevHash,
+            content_hash: contentHash,
         });
         await db.update(schema_1.sessions)
             .set({ updated_at: now })
             .where((0, drizzle_orm_1.eq)(schema_1.sessions.id, args.session_id));
         return {
-            content: [{ type: 'text', text: JSON.stringify({ message_id: id, created_at: now }) }],
+            content: [{ type: 'text', text: JSON.stringify({ message_id: id, created_at: now, content_hash: contentHash }) }],
         };
     };
 }
@@ -35,16 +45,26 @@ function logExchange(db) {
         if (existing.length === 0) {
             return { content: [{ type: 'text', text: `Session not found: ${args.session_id}` }], isError: true };
         }
+        const last = await db.select({ content_hash: schema_1.messages.content_hash })
+            .from(schema_1.messages)
+            .where((0, drizzle_orm_1.eq)(schema_1.messages.session_id, args.session_id))
+            .orderBy((0, drizzle_orm_1.desc)(schema_1.messages.created_at), (0, drizzle_orm_1.desc)((0, drizzle_orm_1.sql) `rowid`))
+            .limit(1);
         const userNow = (0, time_1.localISOString)();
         const userId = (0, uuid_1.v4)();
         const assistantNow = (0, time_1.localISOString)();
         const assistantId = (0, uuid_1.v4)();
+        const prevHash = last[0]?.content_hash ?? null;
+        const userHash = (0, hash_1.computeContentHash)(args.session_id, 'user', args.user_content, userNow, prevHash);
+        const assistantHash = (0, hash_1.computeContentHash)(args.session_id, 'assistant', args.assistant_content, assistantNow, userHash);
         await db.insert(schema_1.messages).values({
             id: userId,
             session_id: args.session_id,
             role: 'user',
             content: args.user_content,
             created_at: userNow,
+            prev_hash: prevHash,
+            content_hash: userHash,
         });
         await db.insert(schema_1.messages).values({
             id: assistantId,
@@ -52,6 +72,8 @@ function logExchange(db) {
             role: 'assistant',
             content: args.assistant_content,
             created_at: assistantNow,
+            prev_hash: userHash,
+            content_hash: assistantHash,
         });
         await db.update(schema_1.sessions)
             .set({ updated_at: assistantNow })
@@ -62,8 +84,10 @@ function logExchange(db) {
                     text: JSON.stringify({
                         user_message_id: userId,
                         user_created_at: userNow,
+                        user_content_hash: userHash,
                         assistant_message_id: assistantId,
                         assistant_created_at: assistantNow,
+                        assistant_content_hash: assistantHash,
                     }),
                 }],
         };

package/dist/tools/sessions.js

@@ -27,7 +27,11 @@ function startSession(db) {
             };
         }
         catch (e) {
-            if (!e?.message?.includes('UNIQUE constraint failed'))
+            const isUnique = e?.message?.includes('UNIQUE constraint failed') ||
+                e?.code === 'SQLITE_CONSTRAINT_UNIQUE' ||
+                e?.cause?.message?.includes('UNIQUE constraint failed') ||
+                e?.cause?.extendedCode === 'SQLITE_CONSTRAINT_UNIQUE';
+            if (!isUnique)
                 throw e;
             const existing = await db.select().from(schema_1.sessions).where((0, drizzle_orm_1.eq)(schema_1.sessions.title, args.title)).limit(1);
             const session = existing[0];

package/dist/tools/verify.d.ts

@@ -0,0 +1,9 @@
+import type { Db } from '../db/index';
+export declare function verifySession(db: Db): (args: {
+    session_id: string;
+}) => Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/verify.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifySession = verifySession;
+const drizzle_orm_1 = require("drizzle-orm");
+const schema_1 = require("../db/schema");
+const hash_1 = require("../utils/hash");
+function verifySession(db) {
+    return async (args) => {
+        const rows = await db.select().from(schema_1.messages)
+            .where((0, drizzle_orm_1.eq)(schema_1.messages.session_id, args.session_id))
+            .orderBy((0, drizzle_orm_1.asc)(schema_1.messages.created_at), (0, drizzle_orm_1.asc)((0, drizzle_orm_1.sql) `rowid`));
+        const chained = rows.filter(r => r.content_hash !== null);
+        if (chained.length === 0) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ valid: true, messages: rows.length, chained: 0, note: 'No chained messages — pre-dates hash chaining' }),
+                    }],
+            };
+        }
+        for (let i = 0; i < chained.length; i++) {
+            const row = chained[i];
+            const expectedPrev = i === 0 ? null : chained[i - 1].content_hash;
+            if (row.prev_hash !== expectedPrev) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({ valid: false, first_break: row.id, reason: 'prev_hash mismatch' }),
+                        }],
+                };
+            }
+            const expected = (0, hash_1.computeContentHash)(row.session_id, row.role, row.content, row.created_at, row.prev_hash);
+            if (row.content_hash !== expected) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({ valid: false, first_break: row.id, reason: 'content_hash mismatch — row was tampered' }),
+                        }],
+                };
+            }
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({ valid: true, messages: rows.length, chained: chained.length }),
+                }],
+        };
+    };
+}

package/dist/utils/hash.d.ts

@@ -0,0 +1 @@
+export declare function computeContentHash(sessionId: string, role: string, content: string, createdAt: string, prevHash: string | null): string;

package/dist/utils/hash.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeContentHash = computeContentHash;
+const crypto_1 = require("crypto");
+function computeContentHash(sessionId, role, content, createdAt, prevHash) {
+    return (0, crypto_1.createHash)('sha256')
+        .update(`${sessionId}|${role}|${content}|${createdAt}|${prevHash ?? ''}`)
+        .digest('hex');
+}

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "chron-mcp",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "mcpName": "io.github.SirinivasK/chron",
   "description": "Audit-grade timestamped logs for every AI conversation",
   "repository": {
     "type": "git",
-    "url": "https://github.com/nivaya/chron.git"
+    "url": "https://github.com/sirinivask/chron.git"
   },
   "main": "dist/index.js",
   "vitest": {
@@ -47,7 +47,7 @@
   "dependencies": {
     "@libsql/client": "^0.17.3",
     "@modelcontextprotocol/sdk": "^1.12.0",
-    "drizzle-orm": "^0.30.10",
+    "drizzle-orm": "^0.45.2",
     "express": "^4.18.2",
     "uuid": "^11.1.1",
     "zod": "^3.22.4"