claudit 0.1.0

package/server/dist/server/src/routes/sessions.js

@@ -0,0 +1,206 @@
+import { Router } from 'express';
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { getSessionIndex, invalidateSessionCache } from '../services/historyIndex.js';
+import { parseSession } from '../services/sessionParser.js';
+import { addManagedSession, renameManagedSession, archiveManagedSession, removeManagedSession, pinManagedSession } from '../services/managedSessions.js';
+import { eventBus } from '../services/eventBus.js';
+const router = Router();
+// GET /api/sessions?q=keyword&hideEmpty=true&managedOnly=true
+router.get('/', (req, res) => {
+    try {
+        const query = req.query.q;
+        const hideEmpty = req.query.hideEmpty === 'true';
+        const managedOnly = req.query.managedOnly === 'true';
+        const groups = getSessionIndex(query, hideEmpty, managedOnly);
+        res.json(groups);
+    }
+    catch (err) {
+        console.error('Error fetching sessions:', err);
+        res.status(500).json({ error: 'Failed to fetch sessions' });
+    }
+});
+// POST /api/sessions/new — create a fresh claude session
+router.post('/new', (req, res) => {
+    try {
+        const { projectPath, worktree, displayName, initialPrompt } = req.body;
+        if (!projectPath || typeof projectPath !== 'string') {
+            res.status(400).json({ error: 'projectPath is required' });
+            return;
+        }
+        if (!fs.existsSync(projectPath)) {
+            res.status(400).json({ error: 'projectPath does not exist' });
+            return;
+        }
+        let actualProjectPath = projectPath;
+        // Handle git worktree creation
+        if (worktree?.branchName) {
+            const gitDir = path.join(projectPath, '.git');
+            if (!fs.existsSync(gitDir)) {
+                res.status(400).json({ error: 'Source path is not a git repository' });
+                return;
+            }
+            const worktreePath = path.join(path.dirname(projectPath), `${path.basename(projectPath)}-${worktree.branchName}`);
+            try {
+                execSync(`git worktree add ${JSON.stringify(worktreePath)} -b ${JSON.stringify(worktree.branchName)}`, {
+                    cwd: projectPath, encoding: 'utf-8', timeout: 15_000,
+                });
+            }
+            catch {
+                // Branch may already exist — try without -b
+                try {
+                    execSync(`git worktree add ${JSON.stringify(worktreePath)} ${JSON.stringify(worktree.branchName)}`, {
+                        cwd: projectPath, encoding: 'utf-8', timeout: 15_000,
+                    });
+                }
+                catch (e) {
+                    res.status(500).json({ error: `Failed to create worktree: ${e.message}` });
+                    return;
+                }
+            }
+            actualProjectPath = worktreePath;
+        }
+        // Run claude with the initial prompt to create a session
+        const prompt = (typeof initialPrompt === 'string' && initialPrompt.trim())
+            ? initialPrompt.trim()
+            : 'hello';
+        const cleanEnv = Object.fromEntries(Object.entries(process.env).filter(([k]) => k !== 'CLAUDECODE'));
+        const escapedPrompt = prompt.replace(/'/g, "'\\''");
+        const result = execSync(`claude -p --output-format json --max-turns 1 '${escapedPrompt}'`, { cwd: actualProjectPath, encoding: 'utf-8', timeout: 60_000, env: cleanEnv });
+        // Parse the JSON result to get the session ID
+        const parsed = JSON.parse(result);
+        const sessionId = parsed.session_id;
+        if (!sessionId) {
+            res.status(500).json({ error: 'Failed to get session ID from claude output' });
+            return;
+        }
+        // Compute project hash
+        const projectHash = actualProjectPath.replace(/\//g, '-');
+        // Record in managed store
+        addManagedSession(sessionId, actualProjectPath);
+        if (displayName) {
+            renameManagedSession(sessionId, displayName);
+        }
+        // Invalidate cache so the new session shows up
+        invalidateSessionCache();
+        eventBus.emitSessionEvent({ type: 'session:created', sessionId });
+        res.json({ sessionId, projectPath: actualProjectPath, projectHash });
+    }
+    catch (err) {
+        console.error('Error creating session:', err);
+        res.status(500).json({ error: err.message || 'Failed to create session' });
+    }
+});
+// GET /api/sessions/archived — return archived sessions
+router.get('/archived', (req, res) => {
+    try {
+        const groups = getSessionIndex(undefined, false, false, true);
+        const count = groups.reduce((sum, g) => sum + g.sessions.length, 0);
+        res.json({ count, groups });
+    }
+    catch (err) {
+        console.error('Error fetching archived sessions:', err);
+        res.status(500).json({ error: 'Failed to fetch archived sessions' });
+    }
+});
+// PATCH /api/sessions/:sessionId/pin — pin or unpin a session
+router.patch('/:sessionId/pin', (req, res) => {
+    try {
+        const { sessionId } = req.params;
+        const { pinned } = req.body;
+        if (typeof pinned !== 'boolean') {
+            res.status(400).json({ error: 'pinned (boolean) is required' });
+            return;
+        }
+        pinManagedSession(sessionId, pinned);
+        invalidateSessionCache();
+        eventBus.emitSessionEvent({ type: 'session:updated', sessionId });
+        res.json({ ok: true });
+    }
+    catch (err) {
+        console.error('Error pinning session:', err);
+        res.status(500).json({ error: err.message || 'Failed to pin session' });
+    }
+});
+// PATCH /api/sessions/:sessionId/archive — archive or unarchive a session
+router.patch('/:sessionId/archive', (req, res) => {
+    try {
+        const { sessionId } = req.params;
+        const { archived } = req.body;
+        if (typeof archived !== 'boolean') {
+            res.status(400).json({ error: 'archived (boolean) is required' });
+            return;
+        }
+        archiveManagedSession(sessionId, archived);
+        invalidateSessionCache();
+        eventBus.emitSessionEvent({ type: 'session:archived', sessionId });
+        res.json({ ok: true });
+    }
+    catch (err) {
+        console.error('Error archiving session:', err);
+        res.status(500).json({ error: err.message || 'Failed to archive session' });
+    }
+});
+// PATCH /api/sessions/:sessionId/name — rename a session
+router.patch('/:sessionId/name', (req, res) => {
+    try {
+        const { sessionId } = req.params;
+        const { name } = req.body;
+        if (typeof name !== 'string') {
+            res.status(400).json({ error: 'name is required' });
+            return;
+        }
+        let entry = renameManagedSession(sessionId, name);
+        if (!entry) {
+            // Session not in managed store — add it so we can still rename
+            addManagedSession(sessionId, '');
+            entry = renameManagedSession(sessionId, name);
+        }
+        // Invalidate cache so the new name shows up
+        invalidateSessionCache();
+        eventBus.emitSessionEvent({ type: 'session:updated', sessionId });
+        res.json({ ok: true });
+    }
+    catch (err) {
+        console.error('Error renaming session:', err);
+        res.status(500).json({ error: err.message || 'Failed to rename session' });
+    }
+});
+// DELETE /api/sessions/:projectHash/:sessionId — delete session file and managed entry
+router.delete('/:projectHash/:sessionId', (req, res) => {
+    try {
+        const { projectHash, sessionId } = req.params;
+        const sessionFile = path.join(os.homedir(), '.claude', 'projects', projectHash, `${sessionId}.jsonl`);
+        if (fs.existsSync(sessionFile)) {
+            fs.unlinkSync(sessionFile);
+        }
+        removeManagedSession(sessionId);
+        invalidateSessionCache();
+        eventBus.emitSessionEvent({ type: 'session:deleted', sessionId });
+        res.json({ ok: true });
+    }
+    catch (err) {
+        console.error('Error deleting session:', err);
+        res.status(500).json({ error: err.message || 'Failed to delete session' });
+    }
+});
+// GET /api/sessions/:projectHash/:sessionId
+router.get('/:projectHash/:sessionId', (req, res) => {
+    try {
+        const { projectHash, sessionId } = req.params;
+        const detail = parseSession(projectHash, sessionId);
+        res.json(detail);
+    }
+    catch (err) {
+        console.error('Error parsing session:', err);
+        if (err.message?.includes('not found')) {
+            res.status(404).json({ error: 'Session not found' });
+        }
+        else {
+            res.status(500).json({ error: 'Failed to parse session' });
+        }
+    }
+});
+export default router;

package/server/dist/server/src/routes/todo.js

@@ -0,0 +1,93 @@
+import { Router } from 'express';
+import { getAllTodos, getTodo, createTodo, updateTodo, deleteTodo, reorderTodos, } from '../services/todoStorage.js';
+import { pushCompletion } from '../services/todoSyncEngine.js';
+const router = Router();
+// GET /api/todo — list all todos
+router.get('/', (_req, res) => {
+    try {
+        res.json(getAllTodos());
+    }
+    catch (err) {
+        console.error('Error fetching todos:', err);
+        res.status(500).json({ error: 'Failed to fetch todos' });
+    }
+});
+// POST /api/todo — create todo
+router.post('/', (req, res) => {
+    try {
+        const { title, description, priority, sessionId, sessionLabel, groupId } = req.body;
+        if (!title) {
+            res.status(400).json({ error: 'title is required' });
+            return;
+        }
+        const todo = createTodo({
+            title,
+            description,
+            completed: false,
+            priority: priority ?? 'medium',
+            sessionId,
+            sessionLabel,
+            groupId,
+            position: 0, // will be auto-computed by createTodo
+        });
+        res.status(201).json(todo);
+    }
+    catch (err) {
+        console.error('Error creating todo:', err);
+        res.status(500).json({ error: 'Failed to create todo' });
+    }
+});
+// PUT /api/todo/reorder — batch reorder todos
+router.put('/reorder', (req, res) => {
+    try {
+        const { items } = req.body;
+        if (!Array.isArray(items)) {
+            res.status(400).json({ error: 'items array is required' });
+            return;
+        }
+        reorderTodos(items);
+        res.json({ success: true });
+    }
+    catch (err) {
+        console.error('Error reordering todos:', err);
+        res.status(500).json({ error: 'Failed to reorder todos' });
+    }
+});
+// PUT /api/todo/:id — update todo
+router.put('/:id', (req, res) => {
+    try {
+        const before = getTodo(req.params.id);
+        const todo = updateTodo(req.params.id, req.body);
+        if (!todo) {
+            res.status(404).json({ error: 'Todo not found' });
+            return;
+        }
+        // If a provider-linked todo was just completed, push completion async
+        if (todo.provider && todo.completed && before && !before.completed) {
+            pushCompletion(todo).catch(err => {
+                console.error('Failed to push completion:', err);
+            });
+        }
+        res.json(todo);
+    }
+    catch (err) {
+        console.error('Error updating todo:', err);
+        res.status(500).json({ error: 'Failed to update todo' });
+    }
+});
+// DELETE /api/todo/:id — delete todo
+router.delete('/:id', (req, res) => {
+    try {
+        const ok = deleteTodo(req.params.id);
+        if (!ok) {
+            res.status(404).json({ error: 'Todo not found' });
+            return;
+        }
+        res.json({ success: true });
+    }
+    catch (err) {
+        console.error('Error deleting todo:', err);
+        res.status(500).json({ error: 'Failed to delete todo' });
+    }
+});
+export default router;

package/server/dist/server/src/routes/todoProviders.js

@@ -0,0 +1,179 @@
+import { Router } from 'express';
+import { getAllProviders, getProvider } from '../services/providers/registry.js';
+import { getAllConfigs, getConfig, createConfig, updateConfig, deleteConfig, } from '../services/providerConfigStorage.js';
+import { syncProvider, syncAllProviders } from '../services/todoSyncEngine.js';
+const router = Router();
+// GET /api/todo/providers — list provider types
+router.get('/', (_req, res) => {
+    try {
+        const providers = getAllProviders().map(p => ({
+            id: p.id,
+            displayName: p.displayName,
+            configSchema: p.configSchema,
+        }));
+        res.json(providers);
+    }
+    catch (err) {
+        console.error('Error listing providers:', err);
+        res.status(500).json({ error: 'Failed to list providers' });
+    }
+});
+/**
+ * Redact secret fields from a config object.
+ */
+function redactSecrets(providerId, config) {
+    const provider = getProvider(providerId);
+    if (!provider)
+        return config;
+    const secretKeys = new Set(provider.configSchema.filter(f => f.secret).map(f => f.key));
+    const redacted = {};
+    for (const [key, value] of Object.entries(config)) {
+        redacted[key] = secretKeys.has(key) && typeof value === 'string' && value
+            ? '••••••••'
+            : value;
+    }
+    return redacted;
+}
+// GET /api/todo/providers/configs — list all configs (secrets redacted)
+router.get('/configs', (_req, res) => {
+    try {
+        const configs = getAllConfigs().map(c => ({
+            ...c,
+            config: redactSecrets(c.providerId, c.config),
+        }));
+        res.json(configs);
+    }
+    catch (err) {
+        console.error('Error listing configs:', err);
+        res.status(500).json({ error: 'Failed to list configs' });
+    }
+});
+// POST /api/todo/providers/configs — create config
+router.post('/configs', async (req, res) => {
+    try {
+        const { providerId, name, enabled, config: providerConfig, syncIntervalMinutes } = req.body;
+        if (!providerId || !name) {
+            res.status(400).json({ error: 'providerId and name are required' });
+            return;
+        }
+        const provider = getProvider(providerId);
+        if (!provider) {
+            res.status(400).json({ error: `Unknown provider: ${providerId}` });
+            return;
+        }
+        // Validate config if provider supports it
+        if (provider.validateConfig) {
+            const validationError = await provider.validateConfig(providerConfig || {});
+            if (validationError) {
+                res.status(400).json({ error: validationError });
+                return;
+            }
+        }
+        const created = createConfig({
+            providerId,
+            name,
+            enabled: enabled ?? true,
+            config: providerConfig || {},
+            syncIntervalMinutes: syncIntervalMinutes ?? 0,
+        });
+        res.status(201).json({
+            ...created,
+            config: redactSecrets(created.providerId, created.config),
+        });
+    }
+    catch (err) {
+        console.error('Error creating config:', err);
+        res.status(500).json({ error: 'Failed to create config' });
+    }
+});
+// PUT /api/todo/providers/configs/:id — update config
+router.put('/configs/:id', async (req, res) => {
+    try {
+        const existing = getConfig(req.params.id);
+        if (!existing) {
+            res.status(404).json({ error: 'Config not found' });
+            return;
+        }
+        // If config fields are being updated, merge with existing (don't overwrite secrets with redacted values)
+        let newConfig = req.body.config;
+        if (newConfig) {
+            const provider = getProvider(existing.providerId);
+            if (provider) {
+                const secretKeys = new Set(provider.configSchema.filter(f => f.secret).map(f => f.key));
+                const merged = { ...existing.config };
+                for (const [key, value] of Object.entries(newConfig)) {
+                    // Skip redacted placeholder values for secret fields
+                    if (secretKeys.has(key) && value === '••••••••')
+                        continue;
+                    merged[key] = value;
+                }
+                newConfig = merged;
+            }
+        }
+        const updates = {};
+        if (req.body.name !== undefined)
+            updates.name = req.body.name;
+        if (req.body.enabled !== undefined)
+            updates.enabled = req.body.enabled;
+        if (newConfig !== undefined)
+            updates.config = newConfig;
+        if (req.body.syncIntervalMinutes !== undefined)
+            updates.syncIntervalMinutes = req.body.syncIntervalMinutes;
+        const updated = updateConfig(req.params.id, updates);
+        if (!updated) {
+            res.status(404).json({ error: 'Config not found' });
+            return;
+        }
+        res.json({
+            ...updated,
+            config: redactSecrets(updated.providerId, updated.config),
+        });
+    }
+    catch (err) {
+        console.error('Error updating config:', err);
+        res.status(500).json({ error: 'Failed to update config' });
+    }
+});
+// DELETE /api/todo/providers/configs/:id — delete config
+router.delete('/configs/:id', (req, res) => {
+    try {
+        const ok = deleteConfig(req.params.id);
+        if (!ok) {
+            res.status(404).json({ error: 'Config not found' });
+            return;
+        }
+        res.json({ success: true });
+    }
+    catch (err) {
+        console.error('Error deleting config:', err);
+        res.status(500).json({ error: 'Failed to delete config' });
+    }
+});
+// POST /api/todo/providers/configs/:id/sync — manual sync one config
+router.post('/configs/:id/sync', async (req, res) => {
+    try {
+        const config = getConfig(req.params.id);
+        if (!config) {
+            res.status(404).json({ error: 'Config not found' });
+            return;
+        }
+        const result = await syncProvider(config);
+        res.json(result);
+    }
+    catch (err) {
+        console.error('Error syncing provider:', err);
+        res.status(500).json({ error: 'Failed to sync provider' });
+    }
+});
+// POST /api/todo/providers/sync-all — manual sync all enabled configs
+router.post('/sync-all', async (_req, res) => {
+    try {
+        const results = await syncAllProviders();
+        res.json(results);
+    }
+    catch (err) {
+        console.error('Error syncing all providers:', err);
+        res.status(500).json({ error: 'Failed to sync providers' });
+    }
+});
+export default router;

package/server/dist/server/src/services/claudeProcess.js

@@ -0,0 +1,220 @@
+import { spawn, execSync } from 'child_process';
+import fs from 'fs';
+import os from 'os';
+import { EventEmitter } from 'events';
+// Resolve claude binary path at startup so spawn can find it
+const CLAUDE_BIN = (() => {
+    try {
+        return execSync('which claude', { encoding: 'utf-8' }).trim();
+    }
+    catch {
+        return 'claude'; // fallback
+    }
+})();
+console.log(`[claude] Binary path: ${CLAUDE_BIN}`);
+export class ClaudeProcess extends EventEmitter {
+    proc = null;
+    sessionId;
+    projectPath;
+    stdoutBuffer = '';
+    stderrBuffer = '';
+    lastTextLength = 0;
+    lastThinkingLength = 0;
+    lastMessageId = '';
+    sentToolUseIds = new Set();
+    userMessageSent = false;
+    pendingMessage = null;
+    constructor(sessionId, projectPath) {
+        super();
+        this.sessionId = sessionId;
+        this.projectPath = projectPath;
+    }
+    resetTracking() {
+        this.lastTextLength = 0;
+        this.lastThinkingLength = 0;
+        this.lastMessageId = '';
+        this.sentToolUseIds.clear();
+        this.stdoutBuffer = '';
+        this.stderrBuffer = '';
+    }
+    _spawnProcess(onClose) {
+        const cwd = fs.existsSync(this.projectPath) ? this.projectPath : os.homedir();
+        console.log(`[claude] Spawning CLI: resume=${this.sessionId} cwd=${cwd}`);
+        const proc = spawn(CLAUDE_BIN, [
+            '--resume', this.sessionId,
+            '-p',
+            '--output-format', 'stream-json',
+            '--input-format', 'stream-json',
+            '--verbose',
+        ], {
+            cwd,
+            env: Object.fromEntries(Object.entries(process.env).filter(([k]) => k !== 'CLAUDECODE')),
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        proc.stdout?.on('data', (data) => {
+            this.processStreamData(data, 'stdout');
+        });
+        proc.stderr?.on('data', (data) => {
+            this.processStreamData(data, 'stderr');
+        });
+        proc.on('close', onClose);
+        proc.on('error', (err) => {
+            console.error(`[claude] Process error: ${err.message}`);
+            this.emit('error', err.message);
+            this.proc = null;
+        });
+        return proc;
+    }
+    start() {
+        this.proc = this._spawnProcess((code) => {
+            console.log(`[claude] Process exited with code ${code}`);
+            this.proc = null;
+            if (this.userMessageSent) {
+                this.emit('done');
+            }
+            else if (this.pendingMessage) {
+                console.log('[claude] Process exited during resume, restarting for pending message...');
+                const msg = this.pendingMessage;
+                this.pendingMessage = null;
+                this.restart(msg);
+            }
+        });
+    }
+    /** Restart the process and send a message once ready */
+    restart(content) {
+        this.userMessageSent = true;
+        this.resetTracking();
+        this.proc = this._spawnProcess((code) => {
+            console.log(`[claude] Restarted process exited with code ${code}`);
+            this.emit('done');
+            this.proc = null;
+        });
+        // Write the user message to stdin
+        const msg = JSON.stringify({
+            type: 'user',
+            message: { role: 'user', content },
+        }) + '\n';
+        console.log(`[claude] Sending to restarted stdin: ${msg.trim().slice(0, 200)}`);
+        this.proc.stdin?.write(msg);
+    }
+    processStreamData(data, source) {
+        const bufferKey = source === 'stdout' ? 'stdoutBuffer' : 'stderrBuffer';
+        this[bufferKey] += data.toString();
+        const lines = this[bufferKey].split('\n');
+        this[bufferKey] = lines.pop() || '';
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const parsed = JSON.parse(line);
+                this.handleStreamEvent(parsed);
+            }
+            catch {
+                if (source === 'stderr') {
+                    const text = line.trim();
+                    if (text.includes('Error') || text.includes('error')) {
+                        console.error(`[claude] stderr text: ${text.slice(0, 300)}`);
+                        this.emit('error', text);
+                    }
+                }
+            }
+        }
+    }
+    handleStreamEvent(event) {
+        switch (event.type) {
+            case 'system':
+                this.emit('ready');
+                break;
+            case 'assistant': {
+                if (!this.userMessageSent)
+                    break;
+                const msg = event.message;
+                if (!msg?.content)
+                    break;
+                const messageId = msg.id || '';
+                if (messageId !== this.lastMessageId) {
+                    this.lastMessageId = messageId;
+                    this.lastTextLength = 0;
+                    this.lastThinkingLength = 0;
+                }
+                let fullText = '';
+                let fullThinking = '';
+                for (const block of msg.content) {
+                    if (block.type === 'text' && block.text) {
+                        fullText += block.text;
+                    }
+                    else if (block.type === 'thinking' && block.thinking) {
+                        fullThinking += block.thinking;
+                    }
+                    else if (block.type === 'tool_use' && !this.sentToolUseIds.has(block.id)) {
+                        this.sentToolUseIds.add(block.id);
+                        this.emit('tool_use', {
+                            name: block.name,
+                            id: block.id,
+                            input: block.input || {},
+                        });
+                    }
+                }
+                if (fullThinking.length > this.lastThinkingLength) {
+                    const delta = fullThinking.slice(this.lastThinkingLength);
+                    this.lastThinkingLength = fullThinking.length;
+                    this.emit('assistant_thinking', delta);
+                }
+                if (fullText.length > this.lastTextLength) {
+                    const delta = fullText.slice(this.lastTextLength);
+                    this.lastTextLength = fullText.length;
+                    this.emit('assistant_text', delta);
+                }
+                break;
+            }
+            case 'result':
+                if (!this.userMessageSent) {
+                    console.log('[claude] Ignoring initial resume result');
+                    break;
+                }
+                if (event.result && typeof event.result === 'string' && this.lastTextLength === 0) {
+                    this.emit('assistant_text', event.result);
+                }
+                console.log(`[claude] Result: subtype=${event.subtype} result=${String(event.result).slice(0, 100)}`);
+                this.emit('done');
+                break;
+            case 'user':
+                break;
+            default:
+                break;
+        }
+    }
+    sendMessage(content) {
+        if (!this.proc?.stdin?.writable) {
+            console.log('[claude] Process not running, restarting for message...');
+            this.restart(content);
+            return;
+        }
+        this.userMessageSent = true;
+        this.lastTextLength = 0;
+        this.lastThinkingLength = 0;
+        this.lastMessageId = '';
+        this.sentToolUseIds.clear();
+        const msg = JSON.stringify({
+            type: 'user',
+            message: { role: 'user', content },
+        }) + '\n';
+        console.log(`[claude] Sending to stdin: ${msg.trim().slice(0, 200)}`);
+        this.proc.stdin.write(msg);
+    }
+    isAlive() {
+        return this.proc !== null && !this.proc.killed;
+    }
+    stop() {
+        if (this.proc) {
+            console.log('[claude] Stopping process');
+            this.proc.kill('SIGTERM');
+            setTimeout(() => {
+                if (this.proc) {
+                    this.proc.kill('SIGKILL');
+                    this.proc = null;
+                }
+            }, 3000);
+        }
+    }
+}