npm - claudit - Versions diffs - 0.1.0 - Mend

claudit 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (40) hide show

package/README.md +139 -0
package/bin/claudit-mcp.js +3 -0
package/bin/claudit.js +11 -0
package/client/dist/assets/index-DhjH_2Wd.css +32 -0
package/client/dist/assets/index-Dwom-XdC.js +98 -0
package/client/dist/index.html +13 -0
package/package.json +40 -0
package/server/dist/server/src/index.js +170 -0
package/server/dist/server/src/mcp-server.js +144 -0
package/server/dist/server/src/routes/cron.js +101 -0
package/server/dist/server/src/routes/filesystem.js +71 -0
package/server/dist/server/src/routes/groups.js +60 -0
package/server/dist/server/src/routes/sessions.js +206 -0
package/server/dist/server/src/routes/todo.js +93 -0
package/server/dist/server/src/routes/todoProviders.js +179 -0
package/server/dist/server/src/services/claudeProcess.js +220 -0
package/server/dist/server/src/services/cronScheduler.js +163 -0
package/server/dist/server/src/services/cronStorage.js +154 -0
package/server/dist/server/src/services/database.js +103 -0
package/server/dist/server/src/services/eventBus.js +11 -0
package/server/dist/server/src/services/groupStorage.js +52 -0
package/server/dist/server/src/services/historyIndex.js +100 -0
package/server/dist/server/src/services/jsonStore.js +41 -0
package/server/dist/server/src/services/managedSessions.js +96 -0
package/server/dist/server/src/services/providerConfigStorage.js +80 -0
package/server/dist/server/src/services/providers/TodoProvider.js +1 -0
package/server/dist/server/src/services/providers/larkDocsProvider.js +75 -0
package/server/dist/server/src/services/providers/mcpClient.js +151 -0
package/server/dist/server/src/services/providers/meegoProvider.js +99 -0
package/server/dist/server/src/services/providers/registry.js +17 -0
package/server/dist/server/src/services/providers/supabaseProvider.js +172 -0
package/server/dist/server/src/services/ptyManager.js +263 -0
package/server/dist/server/src/services/sessionIndexCache.js +24 -0
package/server/dist/server/src/services/sessionParser.js +98 -0
package/server/dist/server/src/services/sessionScanner.js +244 -0
package/server/dist/server/src/services/todoStorage.js +112 -0
package/server/dist/server/src/services/todoSyncEngine.js +170 -0
package/server/dist/server/src/types.js +1 -0
package/server/dist/shared/src/index.js +1 -0
package/server/dist/shared/src/types.js +2 -0

package/client/dist/index.html ADDED Viewed

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Claude Session Manager</title>
+    <script type="module" crossorigin src="/assets/index-Dwom-XdC.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-DhjH_2Wd.css">
+  </head>
+  <body class="bg-gray-950 text-gray-100">
+    <div id="root"></div>
+  </body>
+</html>

package/package.json ADDED Viewed

@@ -0,0 +1,40 @@
+{
+  "name": "claudit",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "A web dashboard for managing Claude Code sessions, cron tasks, and todos",
+  "license": "MIT",
+  "keywords": [
+    "claude",
+    "cli",
+    "dashboard",
+    "claude-code"
+  ],
+  "bin": {
+    "claudit": "./bin/claudit.js",
+    "claudit-mcp": "./bin/claudit-mcp.js"
+  },
+  "files": [
+    "bin/",
+    "server/dist/",
+    "client/dist/"
+  ],
+  "scripts": {
+    "dev": "concurrently -n server,client -c blue,green \"npm run dev --prefix server\" \"npm run dev --prefix client\"",
+    "build": "npm run build --prefix client && npm run build --prefix server",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "better-sqlite3": "^11.10.0",
+    "cors": "^2.8.5",
+    "express": "^4.21.0",
+    "node-cron": "^4.2.1",
+    "node-pty": "^1.1.0",
+    "ws": "^8.18.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "concurrently": "^9.1.0"
+  }
+}

package/server/dist/server/src/index.js ADDED Viewed

@@ -0,0 +1,170 @@
+import express from 'express';
+import cors from 'cors';
+import path from 'path';
+import { createServer } from 'http';
+import { WebSocketServer, WebSocket } from 'ws';
+import sessionRoutes from './routes/sessions.js';
+import cronRoutes from './routes/cron.js';
+import todoRoutes from './routes/todo.js';
+import groupRoutes from './routes/groups.js';
+import todoProviderRoutes from './routes/todoProviders.js';
+import filesystemRoutes from './routes/filesystem.js';
+import { ClaudeProcess } from './services/claudeProcess.js';
+import { initScheduler, stopAllJobs } from './services/cronScheduler.js';
+import { initProviderSync, stopProviderSync } from './services/todoSyncEngine.js';
+import { closeMcpConnections } from './services/providers/mcpClient.js';
+import { handleTerminalConnection } from './services/ptyManager.js';
+import { eventBus } from './services/eventBus.js';
+import { closeDb } from './services/database.js';
+const app = express();
+const PORT = parseInt(process.env.PORT || '3001', 10);
+const CLAUDIT_ROOT = process.env.CLAUDIT_ROOT;
+app.use(cors());
+app.use(express.json());
+// REST routes
+app.use('/api/sessions', sessionRoutes);
+app.use('/api/cron', cronRoutes);
+app.use('/api/todo/providers', todoProviderRoutes);
+app.use('/api/todo/groups', groupRoutes);
+app.use('/api/todo', todoRoutes);
+app.use('/api/filesystem', filesystemRoutes);
+// Health check
+app.get('/api/health', (_req, res) => {
+    res.json({ status: 'ok' });
+});
+// Production mode: serve client static files
+if (CLAUDIT_ROOT) {
+    const clientDist = path.join(CLAUDIT_ROOT, 'client', 'dist');
+    app.use(express.static(clientDist));
+    // SPA fallback: non-API/WS requests return index.html
+    app.get('*', (_req, res) => {
+        res.sendFile(path.join(clientDist, 'index.html'));
+    });
+}
+const server = createServer(app);
+// WebSocket servers (noServer mode to avoid multiple upgrade handler conflicts)
+const wss = new WebSocketServer({ noServer: true });
+const wssTerminal = new WebSocketServer({ noServer: true });
+const wssEvents = new WebSocketServer({ noServer: true });
+server.on('upgrade', (request, socket, head) => {
+    const { pathname } = new URL(request.url || '', `http://${request.headers.host}`);
+    if (pathname === '/ws/chat') {
+        wss.handleUpgrade(request, socket, head, (ws) => {
+            wss.emit('connection', ws, request);
+        });
+    }
+    else if (pathname === '/ws/terminal') {
+        wssTerminal.handleUpgrade(request, socket, head, (ws) => {
+            wssTerminal.emit('connection', ws, request);
+        });
+    }
+    else if (pathname === '/ws/events') {
+        wssEvents.handleUpgrade(request, socket, head, (ws) => {
+            wssEvents.emit('connection', ws, request);
+        });
+    }
+    else {
+        socket.destroy();
+    }
+});
+wssTerminal.on('connection', (ws) => {
+    handleTerminalConnection(ws);
+});
+wssEvents.on('connection', (ws) => {
+    const unsubscribe = eventBus.onSessionEvent((event) => {
+        if (ws.readyState === WebSocket.OPEN) {
+            ws.send(JSON.stringify(event));
+        }
+    });
+    ws.on('close', () => unsubscribe());
+});
+wss.on('connection', (ws) => {
+    console.log('[ws] Client connected');
+    let claude = null;
+    const safeSend = (data) => {
+        if (ws.readyState === WebSocket.OPEN) {
+            ws.send(JSON.stringify(data));
+        }
+    };
+    ws.on('message', (raw) => {
+        let msg;
+        try {
+            msg = JSON.parse(raw.toString());
+        }
+        catch {
+            safeSend({ type: 'error', message: 'Invalid JSON' });
+            return;
+        }
+        console.log(`[ws] Received: ${msg.type}`);
+        switch (msg.type) {
+            case 'resume': {
+                if (claude)
+                    claude.stop();
+                claude = new ClaudeProcess(msg.sessionId, msg.projectPath);
+                claude.on('ready', () => {
+                    console.log('[ws] Claude CLI ready');
+                });
+                claude.on('assistant_text', (text) => {
+                    safeSend({ type: 'assistant_text', text });
+                });
+                claude.on('assistant_thinking', (text) => {
+                    safeSend({ type: 'assistant_thinking', text });
+                });
+                claude.on('tool_use', (data) => {
+                    safeSend({ type: 'tool_use', ...data });
+                });
+                claude.on('tool_result', (data) => {
+                    safeSend({ type: 'tool_result', ...data });
+                });
+                claude.on('done', () => {
+                    safeSend({ type: 'done' });
+                });
+                claude.on('error', (message) => {
+                    safeSend({ type: 'error', message });
+                });
+                claude.start();
+                // Send connected immediately — CLI waits for stdin so no init event until message sent
+                safeSend({ type: 'connected', sessionId: msg.sessionId });
+                break;
+            }
+            case 'message': {
+                if (!claude) {
+                    safeSend({ type: 'error', message: 'No active session. Send "resume" first.' });
+                    return;
+                }
+                claude.sendMessage(msg.content);
+                break;
+            }
+            case 'stop': {
+                if (claude) {
+                    claude.stop();
+                    claude = null;
+                }
+                break;
+            }
+        }
+    });
+    ws.on('close', () => {
+        console.log('[ws] Client disconnected');
+        if (claude) {
+            claude.stop();
+            claude = null;
+        }
+    });
+});
+server.listen(PORT, () => {
+    console.log(`Server running on http://localhost:${PORT}`);
+    initScheduler();
+    initProviderSync();
+});
+// Graceful shutdown for tsx watch restarts
+for (const sig of ['SIGTERM', 'SIGINT']) {
+    process.on(sig, () => {
+        stopAllJobs();
+        stopProviderSync();
+        closeMcpConnections();
+        closeDb();
+        server.close();
+        process.exit(0);
+    });
+}

package/server/dist/server/src/mcp-server.js ADDED Viewed

@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { getAllTodos, getTodo, createTodo, updateTodo, deleteTodo, } from './services/todoStorage.js';
+const server = new McpServer({
+    name: 'claudit-todos',
+    version: '0.1.0',
+});
+// --- list_todos ---
+server.tool('list_todos', 'List all todos. Optionally filter by status (pending/completed) and priority (low/medium/high).', {
+    status: z.enum(['pending', 'completed', 'all']).optional().describe('Filter by completion status. Default: all'),
+    priority: z.enum(['low', 'medium', 'high']).optional().describe('Filter by priority level'),
+    groupId: z.string().optional().describe('Filter by group ID. Use "ungrouped" for todos without a group.'),
+}, async ({ status, priority, groupId }) => {
+    let todos = getAllTodos();
+    if (status === 'pending')
+        todos = todos.filter(t => !t.completed);
+    else if (status === 'completed')
+        todos = todos.filter(t => t.completed);
+    if (priority)
+        todos = todos.filter(t => t.priority === priority);
+    if (groupId === 'ungrouped')
+        todos = todos.filter(t => !t.groupId);
+    else if (groupId)
+        todos = todos.filter(t => t.groupId === groupId);
+    const summary = todos.map(t => ({
+        id: t.id,
+        title: t.title,
+        description: t.description,
+        completed: t.completed,
+        priority: t.priority,
+        groupId: t.groupId,
+        position: t.position,
+        createdAt: t.createdAt,
+        completedAt: t.completedAt,
+        sessionId: t.sessionId,
+        externalUrl: t.provider?.externalUrl,
+    }));
+    return {
+        content: [{
+                type: 'text',
+                text: todos.length === 0
+                    ? 'No todos found.'
+                    : JSON.stringify(summary, null, 2),
+            }],
+    };
+});
+// --- get_todo ---
+server.tool('get_todo', 'Get full details of a specific todo by ID.', {
+    id: z.string().describe('The todo ID'),
+}, async ({ id }) => {
+    const todo = getTodo(id);
+    if (!todo) {
+        return {
+            content: [{ type: 'text', text: `Todo not found: ${id}` }],
+            isError: true,
+        };
+    }
+    return {
+        content: [{ type: 'text', text: JSON.stringify(todo, null, 2) }],
+    };
+});
+// --- create_todo ---
+server.tool('create_todo', 'Create a new todo item.', {
+    title: z.string().describe('Title of the todo'),
+    description: z.string().optional().describe('Detailed description'),
+    priority: z.enum(['low', 'medium', 'high']).optional().describe('Priority level. Default: medium'),
+    sessionId: z.string().optional().describe('Link to a Claude session ID'),
+    sessionLabel: z.string().optional().describe('Display label for the linked session'),
+    groupId: z.string().optional().describe('Group ID to assign the todo to'),
+}, async ({ title, description, priority, sessionId, sessionLabel, groupId }) => {
+    const todo = createTodo({
+        title,
+        description,
+        completed: false,
+        priority: priority || 'medium',
+        sessionId,
+        sessionLabel,
+        groupId,
+        position: 0, // auto-computed
+    });
+    return {
+        content: [{ type: 'text', text: `Created todo: ${todo.id}\n${JSON.stringify(todo, null, 2)}` }],
+    };
+});
+// --- update_todo ---
+server.tool('update_todo', 'Update an existing todo. Only provided fields will be changed.', {
+    id: z.string().describe('The todo ID to update'),
+    title: z.string().optional().describe('New title'),
+    description: z.string().optional().describe('New description'),
+    completed: z.boolean().optional().describe('Mark as completed (true) or pending (false)'),
+    priority: z.enum(['low', 'medium', 'high']).optional().describe('New priority level'),
+    groupId: z.string().nullable().optional().describe('Group ID to move the todo to (null to ungroup)'),
+}, async ({ id, title, description, completed, priority, groupId }) => {
+    const updates = {};
+    if (title !== undefined)
+        updates.title = title;
+    if (description !== undefined)
+        updates.description = description;
+    if (priority !== undefined)
+        updates.priority = priority;
+    if (groupId !== undefined)
+        updates.groupId = groupId;
+    if (completed !== undefined) {
+        updates.completed = completed;
+        if (completed)
+            updates.completedAt = new Date().toISOString();
+    }
+    const todo = updateTodo(id, updates);
+    if (!todo) {
+        return {
+            content: [{ type: 'text', text: `Todo not found: ${id}` }],
+            isError: true,
+        };
+    }
+    return {
+        content: [{ type: 'text', text: `Updated todo: ${todo.id}\n${JSON.stringify(todo, null, 2)}` }],
+    };
+});
+// --- delete_todo ---
+server.tool('delete_todo', 'Delete a todo by ID.', {
+    id: z.string().describe('The todo ID to delete'),
+}, async ({ id }) => {
+    const deleted = deleteTodo(id);
+    if (!deleted) {
+        return {
+            content: [{ type: 'text', text: `Todo not found: ${id}` }],
+            isError: true,
+        };
+    }
+    return {
+        content: [{ type: 'text', text: `Deleted todo: ${id}` }],
+    };
+});
+// --- Start server ---
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch((err) => {
+    console.error('MCP server error:', err);
+    process.exit(1);
+});

package/server/dist/server/src/routes/cron.js ADDED Viewed

@@ -0,0 +1,101 @@
+import { Router } from 'express';
+import { getAllTasks, getTask, createTask, updateTask, deleteTask, getTaskExecutions, } from '../services/cronStorage.js';
+import { refreshTask, removeTask, runTaskNow } from '../services/cronScheduler.js';
+const router = Router();
+// GET /api/cron — list all tasks
+router.get('/', (_req, res) => {
+    try {
+        res.json(getAllTasks());
+    }
+    catch (err) {
+        console.error('Error fetching cron tasks:', err);
+        res.status(500).json({ error: 'Failed to fetch cron tasks' });
+    }
+});
+// POST /api/cron — create task
+router.post('/', (req, res) => {
+    try {
+        const { name, cronExpression, prompt, enabled, projectPath } = req.body;
+        if (!name || !cronExpression || !prompt) {
+            res.status(400).json({ error: 'name, cronExpression, and prompt are required' });
+            return;
+        }
+        const task = createTask({
+            name,
+            cronExpression,
+            prompt,
+            enabled: enabled ?? true,
+            projectPath,
+        });
+        refreshTask(task.id);
+        res.status(201).json(task);
+    }
+    catch (err) {
+        console.error('Error creating cron task:', err);
+        res.status(500).json({ error: 'Failed to create cron task' });
+    }
+});
+// PUT /api/cron/:id — update task
+router.put('/:id', (req, res) => {
+    try {
+        const task = updateTask(req.params.id, req.body);
+        if (!task) {
+            res.status(404).json({ error: 'Task not found' });
+            return;
+        }
+        refreshTask(task.id);
+        res.json(task);
+    }
+    catch (err) {
+        console.error('Error updating cron task:', err);
+        res.status(500).json({ error: 'Failed to update cron task' });
+    }
+});
+// DELETE /api/cron/:id — delete task
+router.delete('/:id', (req, res) => {
+    try {
+        const ok = deleteTask(req.params.id);
+        if (!ok) {
+            res.status(404).json({ error: 'Task not found' });
+            return;
+        }
+        removeTask(req.params.id);
+        res.json({ success: true });
+    }
+    catch (err) {
+        console.error('Error deleting cron task:', err);
+        res.status(500).json({ error: 'Failed to delete cron task' });
+    }
+});
+// POST /api/cron/:id/run — manual trigger
+router.post('/:id/run', (req, res) => {
+    try {
+        const task = getTask(req.params.id);
+        if (!task) {
+            res.status(404).json({ error: 'Task not found' });
+            return;
+        }
+        runTaskNow(task.id);
+        res.json({ success: true, message: 'Task triggered' });
+    }
+    catch (err) {
+        console.error('Error running cron task:', err);
+        res.status(500).json({ error: 'Failed to run cron task' });
+    }
+});
+// GET /api/cron/:id/executions — execution history
+router.get('/:id/executions', (req, res) => {
+    try {
+        const task = getTask(req.params.id);
+        if (!task) {
+            res.status(404).json({ error: 'Task not found' });
+            return;
+        }
+        res.json(getTaskExecutions(task.id));
+    }
+    catch (err) {
+        console.error('Error fetching executions:', err);
+        res.status(500).json({ error: 'Failed to fetch executions' });
+    }
+});
+export default router;

package/server/dist/server/src/routes/filesystem.js ADDED Viewed

@@ -0,0 +1,71 @@
+import { Router } from 'express';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { execSync } from 'child_process';
+const router = Router();
+/** Get git branch and repo name for a directory */
+function getGitInfo(dirPath) {
+    try {
+        if (!fs.existsSync(path.join(dirPath, '.git')))
+            return null;
+        const branch = execSync('git rev-parse --abbrev-ref HEAD', {
+            cwd: dirPath, encoding: 'utf-8', timeout: 3000,
+        }).trim();
+        // Repo name: top-level directory name of the git repo
+        const topLevel = execSync('git rev-parse --show-toplevel', {
+            cwd: dirPath, encoding: 'utf-8', timeout: 3000,
+        }).trim();
+        const repoName = path.basename(topLevel);
+        return { branch, repoName };
+    }
+    catch {
+        return null;
+    }
+}
+// GET /api/filesystem/list?path=...
+router.get('/list', (req, res) => {
+    try {
+        const targetPath = req.query.path || os.homedir();
+        const resolved = path.resolve(targetPath);
+        if (!fs.existsSync(resolved)) {
+            res.status(400).json({ error: 'Path does not exist' });
+            return;
+        }
+        if (!fs.statSync(resolved).isDirectory()) {
+            res.status(400).json({ error: 'Path is not a directory' });
+            return;
+        }
+        const parentPath = path.dirname(resolved) !== resolved ? path.dirname(resolved) : null;
+        // Check if current dir is a git repo
+        const isGitRepo = fs.existsSync(path.join(resolved, '.git'));
+        const gitInfo = isGitRepo ? getGitInfo(resolved) : null;
+        const dirents = fs.readdirSync(resolved, { withFileTypes: true });
+        const entries = [];
+        for (const d of dirents) {
+            // Skip hidden files and node_modules
+            if (d.name.startsWith('.') || d.name === 'node_modules')
+                continue;
+            if (!d.isDirectory())
+                continue;
+            const entryPath = path.join(resolved, d.name);
+            const entryIsGitRepo = fs.existsSync(path.join(entryPath, '.git'));
+            const entryGitInfo = entryIsGitRepo ? getGitInfo(entryPath) : null;
+            entries.push({
+                name: d.name,
+                path: entryPath,
+                isDirectory: true,
+                isGitRepo: entryIsGitRepo || undefined,
+                gitInfo: entryGitInfo || undefined,
+            });
+        }
+        // Sort alphabetically
+        entries.sort((a, b) => a.name.localeCompare(b.name));
+        res.json({ currentPath: resolved, parentPath, isGitRepo, gitInfo, entries });
+    }
+    catch (err) {
+        console.error('Error listing directory:', err);
+        res.status(500).json({ error: err.message || 'Failed to list directory' });
+    }
+});
+export default router;

package/server/dist/server/src/routes/groups.js ADDED Viewed

@@ -0,0 +1,60 @@
+import { Router } from 'express';
+import { getAllGroups, createGroup, updateGroup, deleteGroup, } from '../services/groupStorage.js';
+const router = Router();
+// GET /api/todo/groups — list all groups
+router.get('/', (_req, res) => {
+    try {
+        res.json(getAllGroups());
+    }
+    catch (err) {
+        console.error('Error fetching groups:', err);
+        res.status(500).json({ error: 'Failed to fetch groups' });
+    }
+});
+// POST /api/todo/groups — create group
+router.post('/', (req, res) => {
+    try {
+        const { name } = req.body;
+        if (!name) {
+            res.status(400).json({ error: 'name is required' });
+            return;
+        }
+        const group = createGroup(name);
+        res.status(201).json(group);
+    }
+    catch (err) {
+        console.error('Error creating group:', err);
+        res.status(500).json({ error: 'Failed to create group' });
+    }
+});
+// PUT /api/todo/groups/:id — update group
+router.put('/:id', (req, res) => {
+    try {
+        const group = updateGroup(req.params.id, req.body);
+        if (!group) {
+            res.status(404).json({ error: 'Group not found' });
+            return;
+        }
+        res.json(group);
+    }
+    catch (err) {
+        console.error('Error updating group:', err);
+        res.status(500).json({ error: 'Failed to update group' });
+    }
+});
+// DELETE /api/todo/groups/:id — delete group
+router.delete('/:id', (req, res) => {
+    try {
+        const ok = deleteGroup(req.params.id);
+        if (!ok) {
+            res.status(404).json({ error: 'Group not found' });
+            return;
+        }
+        res.json({ success: true });
+    }
+    catch (err) {
+        console.error('Error deleting group:', err);
+        res.status(500).json({ error: 'Failed to delete group' });
+    }
+});
+export default router;