chron-mcp 0.1.5 → 0.1.7

package/dist/db/index.js

@@ -49,7 +49,7 @@ function getDbPath() {
 const CREATE_SQL = [
     `CREATE TABLE IF NOT EXISTS sessions (
     id TEXT PRIMARY KEY,
-    title TEXT NOT NULL,
+    title TEXT NOT NULL UNIQUE,
     ai_tool TEXT,
     created_at TEXT NOT NULL,
     updated_at TEXT NOT NULL
@@ -60,8 +60,10 @@ const CREATE_SQL = [
     role TEXT NOT NULL CHECK (role IN ('user', 'assistant')),
     content TEXT NOT NULL,
     created_at TEXT NOT NULL,
-    FOREIGN KEY (session_id) REFERENCES sessions(id)
+    FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
   )`,
+    `CREATE UNIQUE INDEX IF NOT EXISTS idx_sessions_title ON sessions(title)`,
+    `CREATE INDEX IF NOT EXISTS idx_messages_session_id ON messages(session_id)`,
 ];
 async function initDb(dbPath) {
     const path = dbPath ?? getDbPath();

package/dist/db/schema.js

@@ -4,14 +4,14 @@ exports.messages = exports.sessions = void 0;
 const sqlite_core_1 = require("drizzle-orm/sqlite-core");
 exports.sessions = (0, sqlite_core_1.sqliteTable)('sessions', {
     id: (0, sqlite_core_1.text)('id').primaryKey(),
-    title: (0, sqlite_core_1.text)('title').notNull(),
+    title: (0, sqlite_core_1.text)('title').notNull().unique(),
     ai_tool: (0, sqlite_core_1.text)('ai_tool'),
     created_at: (0, sqlite_core_1.text)('created_at').notNull(),
     updated_at: (0, sqlite_core_1.text)('updated_at').notNull(),
 });
 exports.messages = (0, sqlite_core_1.sqliteTable)('messages', {
     id: (0, sqlite_core_1.text)('id').primaryKey(),
-    session_id: (0, sqlite_core_1.text)('session_id').notNull(),
+    session_id: (0, sqlite_core_1.text)('session_id').notNull().references(() => exports.sessions.id),
     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(),

package/dist/http/server.js

@@ -10,29 +10,45 @@ const middleware_1 = require("./middleware");
 const server_1 = require("../server");
 async function startHttpServer(server, db) {
     const app = (0, express_1.default)();
-    app.use(express_1.default.json());
+    app.use(express_1.default.json({ limit: '1mb' }));
     const apiKey = process.env.CHRON_API_KEY;
     if (apiKey) {
         app.use((0, middleware_1.apiKeyMiddleware)(apiKey));
     }
     const transports = new Map();
     app.get('/sse', async (req, res) => {
-        const instanceServer = (0, server_1.createServer)(db);
-        const transport = new sse_js_1.SSEServerTransport('/messages', res);
-        transports.set(transport.sessionId, { transport, server: instanceServer });
-        transport.onclose = () => transports.delete(transport.sessionId);
-        await instanceServer.connect(transport);
+        try {
+            const instanceServer = (0, server_1.createServer)(db);
+            const transport = new sse_js_1.SSEServerTransport('/messages', res);
+            transports.set(transport.sessionId, { transport, server: instanceServer });
+            transport.onclose = () => transports.delete(transport.sessionId);
+            await instanceServer.connect(transport);
+        }
+        catch (err) {
+            process.stderr.write(`SSE error: ${err}\n`);
+            if (!res.headersSent)
+                res.status(500).json({ error: 'Internal server error' });
+        }
     });
     app.post('/messages', async (req, res) => {
-        const sessionId = req.query.sessionId;
-        const entry = transports.get(sessionId);
-        if (!entry) {
-            res.status(404).json({ error: 'Session not found' });
-            return;
+        try {
+            const sessionId = req.query.sessionId;
+            const entry = transports.get(sessionId);
+            if (!entry) {
+                res.status(404).json({ error: 'Session not found' });
+                return;
+            }
+            await entry.transport.handlePostMessage(req, res);
+        }
+        catch (err) {
+            process.stderr.write(`Messages error: ${err}\n`);
+            if (!res.headersSent)
+                res.status(500).json({ error: 'Internal server error' });
         }
-        await entry.transport.handlePostMessage(req, res);
     });
     const port = parseInt(process.env.PORT ?? '3001', 10);
+    if (isNaN(port))
+        throw new Error(`Invalid PORT value: ${process.env.PORT}`);
     await new Promise(resolve => app.listen(port, resolve));
     process.stderr.write(`Chron HTTP server listening on port ${port}\n`);
 }

package/dist/server.js

@@ -9,19 +9,19 @@ const roleEnum = zod_1.z.enum(['user', 'assistant']);
 function createServer(db) {
     const server = new mcp_js_1.McpServer({
         name: 'chron',
-        version: '0.1.0',
+        version: '0.1.7',
     });
     // @ts-expect-error — MCP SDK deep generic type instantiation limit hit; runtime types are correct
     server.tool('start_session', 'Create a new audit session or resume an existing one by title. Call this at the start of every conversation.', {
         title: zod_1.z.string().describe('Descriptive session title, e.g. "Contract review — 2026-05-08"'),
         ai_tool: zod_1.z.string().optional().describe('AI tool name: "claude", "cursor", "windsurf", etc.'),
     }, (0, sessions_1.startSession)(db));
-    server.tool('log_message', 'Record a single message (user or assistant) with the current UTC datetime. Call before responding for user messages, and before sending for assistant messages.', {
+    server.tool('log_message', 'Record a single message (user or assistant) with the current local datetime and timezone offset. Call before responding for user messages, and before sending for assistant messages.', {
         session_id: zod_1.z.string().describe('Session ID returned by start_session'),
         role: roleEnum,
         content: zod_1.z.string().describe('Full message text'),
     }, (0, messages_1.logMessage)(db));
-    server.tool('log_exchange', 'Log a user message and assistant response together in one call. Preferred over two log_message calls — faster and atomic.', {
+    server.tool('log_exchange', 'Record a user+assistant exchange from historical or batch imports only. Do NOT use for live conversations — both timestamps are captured at the same instant with no real gap. For live sessions always call log_message twice: once for the user message, once for the assistant response.', {
         session_id: zod_1.z.string().describe('Session ID returned by start_session'),
         user_content: zod_1.z.string().describe('The exact user message'),
         assistant_content: zod_1.z.string().describe('The exact assistant response'),

package/dist/tools/messages.d.ts

@@ -8,6 +8,13 @@ export declare function logMessage(db: Db): (args: {
         type: "text";
         text: string;
     }[];
+    isError: boolean;
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError?: undefined;
 }>;
 export declare function logExchange(db: Db): (args: {
     session_id: string;
@@ -18,4 +25,11 @@ export declare function logExchange(db: Db): (args: {
         type: "text";
         text: string;
     }[];
+    isError: boolean;
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError?: undefined;
 }>;

package/dist/tools/messages.js

@@ -8,6 +8,10 @@ const schema_1 = require("../db/schema");
 const time_1 = require("../utils/time");
 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 now = (0, time_1.localISOString)();
         const id = (0, uuid_1.v4)();
         await db.insert(schema_1.messages).values({
@@ -27,6 +31,10 @@ function logMessage(db) {
 }
 function logExchange(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 userNow = (0, time_1.localISOString)();
         const userId = (0, uuid_1.v4)();
         const assistantNow = (0, time_1.localISOString)();

package/dist/tools/sessions.js

@@ -9,34 +9,37 @@ const schema_1 = require("../db/schema");
 const time_1 = require("../utils/time");
 function startSession(db) {
     return async (args) => {
-        const existing = await db.select().from(schema_1.sessions).where((0, drizzle_orm_1.eq)(schema_1.sessions.title, args.title));
-        if (existing.length > 0) {
+        const id = (0, uuid_1.v4)();
+        const now = (0, time_1.localISOString)();
+        try {
+            await db.insert(schema_1.sessions).values({
+                id,
+                title: args.title,
+                ai_tool: args.ai_tool ?? null,
+                created_at: now,
+                updated_at: now,
+            });
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({ session_id: id, created: true, message_count: 0, ai_tool: args.ai_tool ?? null }),
+                    }],
+            };
+        }
+        catch (e) {
+            if (!e?.message?.includes('UNIQUE constraint failed'))
+                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];
-            const now = (0, time_1.localISOString)();
-            const allMessages = await db.select().from(schema_1.messages).where((0, drizzle_orm_1.eq)(schema_1.messages.session_id, session.id));
+            const [countRow] = await db.select({ count: (0, drizzle_orm_1.sql) `count(*)` }).from(schema_1.messages).where((0, drizzle_orm_1.eq)(schema_1.messages.session_id, session.id));
             await db.update(schema_1.sessions).set({ updated_at: now }).where((0, drizzle_orm_1.eq)(schema_1.sessions.id, session.id));
             return {
                 content: [{
                         type: 'text',
-                        text: JSON.stringify({ session_id: session.id, created: false, message_count: allMessages.length, ai_tool: session.ai_tool }),
+                        text: JSON.stringify({ session_id: session.id, created: false, message_count: countRow?.count ?? 0, ai_tool: session.ai_tool }),
                     }],
             };
         }
-        const now = (0, time_1.localISOString)();
-        const id = (0, uuid_1.v4)();
-        await db.insert(schema_1.sessions).values({
-            id,
-            title: args.title,
-            ai_tool: args.ai_tool ?? null,
-            created_at: now,
-            updated_at: now,
-        });
-        return {
-            content: [{
-                    type: 'text',
-                    text: JSON.stringify({ session_id: id, created: true, message_count: 0, ai_tool: args.ai_tool ?? null }),
-                }],
-        };
     };
 }
 function listSessions(db) {
@@ -64,16 +67,21 @@ function listSessions(db) {
 }
 function getSessionHistory(db) {
     return async (args) => {
-        const all = await db.select().from(schema_1.messages)
+        const [countRow] = await db.select({ count: (0, drizzle_orm_1.sql) `count(*)` })
+            .from(schema_1.messages)
+            .where((0, drizzle_orm_1.eq)(schema_1.messages.session_id, args.session_id));
+        const total = countRow?.count ?? 0;
+        const baseQuery = 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));
-        const limited = args.limit != null ? all.slice(-args.limit) : all;
+            .orderBy((0, drizzle_orm_1.desc)(schema_1.messages.created_at), (0, drizzle_orm_1.desc)((0, drizzle_orm_1.sql) `rowid`));
+        const rows = await (args.limit != null ? baseQuery.limit(args.limit) : baseQuery);
+        const limited = rows.reverse();
         return {
             content: [{
                     type: 'text',
                     text: JSON.stringify({
                         messages: limited.map(m => ({ role: m.role, content: m.content, created_at: m.created_at })),
-                        total: all.length,
+                        total,
                     }),
                 }],
         };

package/dist/utils/time.js

@@ -14,5 +14,6 @@ function localISOString() {
     const hours = String(d.getHours()).padStart(2, '0');
     const minutes = String(d.getMinutes()).padStart(2, '0');
     const seconds = String(d.getSeconds()).padStart(2, '0');
-    return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}${sign}${hh}:${mm}`;
+    const ms = String(d.getMilliseconds()).padStart(3, '0');
+    return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}.${ms}${sign}${hh}:${mm}`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chron-mcp",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "mcpName": "io.github.SirinivasK/chron",
   "description": "Audit-grade timestamped logs for every AI conversation",
   "repository": {

package/skills/chron.skill.md

@@ -1,5 +1,7 @@
 # Chron — AI Audit Log Skill
 
+> **Applies in ALL contexts** — main sessions, dispatched subagents, parallel agents, and worktrees. The `SUBAGENT-STOP` guard in `using-superpowers` does NOT apply here. Log every exchange regardless of context.
+
 Chron creates an audit trail of every AI conversation. Every message is logged with a precise local datetime (with timezone offset) to a local SQLite database the user owns.
 
 ## Session Start
@@ -14,9 +16,9 @@ Call `get_session_history` for the returned `session_id`. If prior messages exis
 The rule is simple: **any time you output text and wait for input, log it.** This includes mid-task check-ins, not just clean user→assistant→user flows.
 
 1. Call `log_message(session_id, role="user", content=<exact user message>)` → returns T1
-2. Compose your response body (plain text only — no timestamp header)
+2. Compose your response body internally (plain text only — no timestamp header). **Do NOT output any text yet.**
 3. Call `log_message(session_id, role="assistant", content=<response body>)` → returns T2
-4. Output header + body:
+4. Only now output the header + body — exactly once:
 
 ```
 [user: YYYY-MM-DD HH:MM:SS ±HH:MM | assistant: YYYY-MM-DD HH:MM:SS ±HH:MM]
@@ -24,11 +26,13 @@ The rule is simple: **any time you output text and wait for input, log it.** Thi
 <response body>
 ```
 
+**Never output text before step 3.** Doing so causes the response to appear twice — once before the log call and once after. Compose fully in your head, log, then output.
+
 T1 and T2 are real server timestamps — T2 − T1 is the actual generation time. The DB stores clean body content without the header.
 
 **Mid-task check-ins follow the same rule.** If you pause mid-task and ask the user something ("I've done the analysis, what's next?" / "Which approach do you prefer?"), that pause is an exchange — log the assistant message before outputting it, log the user's reply when it arrives. Every turn that crosses the user boundary gets timestamped, regardless of whether the task is "complete."
 
-**Permission grants** — if Claude pauses for a permission prompt and the user allows/denies, log a user message on resume: `"[permission: <tool> <action> — allowed/denied]"`. This is the only visible record of the interaction since permission clicks are not typed messages.
+**Permission grants** — whenever Claude resumes after a permission prompt (allow or deny), log a user message IMMEDIATELY before any other output or tool call: `"[permission: <tool> <action> — allowed/denied]"`. This applies mid-task, mid-worktree, and mid-subagent. Do not skip it even if the task is already in progress. This is the only visible record of the interaction since permission clicks are not typed messages.
 
 **Do not use `log_exchange` for live conversations** — it captures both timestamps at the same instant and cannot show a real gap. Use it only for batch imports of historical messages.