claudit 0.1.0

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

@@ -0,0 +1,163 @@
+import cron from 'node-cron';
+import { spawn, execFile } from 'child_process';
+import { getAllTasks, getTask, updateTask, createExecution, updateExecution, } from './cronStorage.js';
+import { getAllTodos } from './todoStorage.js';
+import { addManagedSession, renameManagedSession } from './managedSessions.js';
+import { invalidateSessionCache } from './historyIndex.js';
+const scheduledJobs = new Map();
+const MAX_OUTPUT_SIZE = 512 * 1024; // 512 KB limit per stream
+const PRIORITY_ICON = { high: '🔴', medium: '🟡', low: '🟢' };
+function formatTodosForPrompt() {
+    const todos = getAllTodos().filter(t => !t.completed);
+    if (todos.length === 0)
+        return '(No pending todos)';
+    return todos.map((t, i) => {
+        const icon = PRIORITY_ICON[t.priority] || '⚪';
+        let line = `${i + 1}. ${icon} [${t.priority}] ${t.title}`;
+        if (t.description)
+            line += `\n   ${t.description}`;
+        if (t.provider?.externalUrl)
+            line += `\n   Link: ${t.provider.externalUrl}`;
+        return line;
+    }).join('\n');
+}
+function resolvePrompt(prompt) {
+    if (!prompt.includes('{{todos}}'))
+        return prompt;
+    return prompt.replace(/\{\{todos\}\}/g, formatTodosForPrompt());
+}
+function appendCapped(current, chunk) {
+    if (current.length >= MAX_OUTPUT_SIZE)
+        return current;
+    const remaining = MAX_OUTPUT_SIZE - current.length;
+    return current + (chunk.length <= remaining ? chunk : chunk.slice(0, remaining) + '\n[output truncated]');
+}
+function createSessionAsync(taskName, cwd, env) {
+    return new Promise((resolve) => {
+        const initPrompt = `Workflow task: ${taskName} — starting execution.`;
+        const child = execFile('claude', ['-p', '--output-format', 'json', '--max-turns', '1'], { cwd, encoding: 'utf-8', timeout: 60_000, env }, (err, stdout) => {
+            if (err) {
+                console.warn(`[cron] Failed to create session for task ${taskName}, falling back:`, err.message);
+                resolve(undefined);
+                return;
+            }
+            try {
+                const parsed = JSON.parse(stdout);
+                resolve(parsed.session_id || undefined);
+            }
+            catch {
+                resolve(undefined);
+            }
+        });
+        child.stdin?.write(initPrompt);
+        child.stdin?.end();
+    });
+}
+async function executeTask(taskId) {
+    const task = getTask(taskId);
+    if (!task)
+        return;
+    console.log(`[cron] Executing task: ${task.name} (${taskId})`);
+    const resolvedPrompt = resolvePrompt(task.prompt);
+    const cleanEnv = Object.fromEntries(Object.entries(process.env).filter(([k]) => k !== 'CLAUDECODE'));
+    const cwd = task.projectPath || undefined;
+    // Step 1: Create a session asynchronously (non-blocking)
+    const sessionId = await createSessionAsync(task.name, cwd, cleanEnv);
+    if (sessionId) {
+        addManagedSession(sessionId, task.projectPath || '');
+        renameManagedSession(sessionId, `Workflow: ${task.name}`);
+        invalidateSessionCache();
+        console.log(`[cron] Created session ${sessionId} for task ${task.name}`);
+    }
+    const exec = createExecution(taskId, sessionId);
+    // Step 2: Execute the full prompt (resume session if available)
+    const args = sessionId
+        ? ['--session-id', sessionId, '--resume', '-p', '--output-format', 'text', '--dangerously-skip-permissions']
+        : ['-p', '--output-format', 'text', '--dangerously-skip-permissions'];
+    const child = spawn('claude', args, {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        cwd,
+        env: cleanEnv,
+    });
+    let output = '';
+    let errorOutput = '';
+    child.stdout.on('data', (data) => {
+        output = appendCapped(output, data.toString());
+    });
+    child.stderr.on('data', (data) => {
+        errorOutput = appendCapped(errorOutput, data.toString());
+    });
+    child.stdin.write(resolvedPrompt);
+    child.stdin.end();
+    child.on('close', (code) => {
+        const finishedAt = new Date().toISOString();
+        const status = code === 0 ? 'success' : 'error';
+        updateExecution(exec.id, {
+            finishedAt,
+            status,
+            output: output || undefined,
+            error: code !== 0 ? (errorOutput || `Exit code: ${code}`) : undefined,
+        });
+        updateTask(taskId, { lastRun: finishedAt });
+        console.log(`[cron] Task ${task.name} finished with status: ${status}`);
+    });
+    child.on('error', (err) => {
+        updateExecution(exec.id, {
+            finishedAt: new Date().toISOString(),
+            status: 'error',
+            error: err.message,
+        });
+        console.error(`[cron] Task ${task.name} spawn error:`, err.message);
+    });
+}
+function scheduleTask(taskId, cronExpression) {
+    // Remove existing schedule if any
+    unscheduleTask(taskId);
+    if (!cron.validate(cronExpression)) {
+        console.error(`[cron] Invalid cron expression for task ${taskId}: ${cronExpression}`);
+        return;
+    }
+    const job = cron.schedule(cronExpression, () => {
+        executeTask(taskId);
+    });
+    scheduledJobs.set(taskId, job);
+    console.log(`[cron] Scheduled task ${taskId}: ${cronExpression}`);
+}
+function unscheduleTask(taskId) {
+    const existing = scheduledJobs.get(taskId);
+    if (existing) {
+        existing.stop();
+        scheduledJobs.delete(taskId);
+    }
+}
+export function initScheduler() {
+    console.log('[cron] Initializing scheduler...');
+    const tasks = getAllTasks();
+    for (const task of tasks) {
+        if (task.enabled) {
+            scheduleTask(task.id, task.cronExpression);
+        }
+    }
+    console.log(`[cron] Loaded ${tasks.filter(t => t.enabled).length} active tasks`);
+}
+export function refreshTask(taskId) {
+    const task = getTask(taskId);
+    if (!task || !task.enabled) {
+        unscheduleTask(taskId);
+    }
+    else {
+        scheduleTask(taskId, task.cronExpression);
+    }
+}
+export function removeTask(taskId) {
+    unscheduleTask(taskId);
+}
+export function runTaskNow(taskId) {
+    executeTask(taskId);
+}
+export function stopAllJobs() {
+    for (const [id, job] of scheduledJobs) {
+        job.stop();
+    }
+    scheduledJobs.clear();
+}

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

@@ -0,0 +1,154 @@
+import crypto from 'crypto';
+import { db } from './database.js';
+const MAX_EXECUTIONS_PER_TASK = 100;
+// --- Prepared statements: Tasks ---
+const stmtAllTasks = db.prepare('SELECT * FROM cron_tasks');
+const stmtTaskById = db.prepare('SELECT * FROM cron_tasks WHERE id = ?');
+const stmtInsertTask = db.prepare(`
+  INSERT INTO cron_tasks (id, name, cronExpression, prompt, enabled, projectPath, lastRun, nextRun, createdAt)
+  VALUES (@id, @name, @cronExpression, @prompt, @enabled, @projectPath, @lastRun, @nextRun, @createdAt)
+`);
+const stmtDeleteTask = db.prepare('DELETE FROM cron_tasks WHERE id = ?');
+const stmtUpdateTask = db.prepare(`
+  UPDATE cron_tasks SET name = @name, cronExpression = @cronExpression, prompt = @prompt,
+    enabled = @enabled, projectPath = @projectPath, lastRun = @lastRun, nextRun = @nextRun
+  WHERE id = @id
+`);
+// --- Prepared statements: Executions ---
+const stmtExecsByTask = db.prepare('SELECT * FROM cron_executions WHERE taskId = ? ORDER BY startedAt DESC');
+const stmtInsertExec = db.prepare(`
+  INSERT INTO cron_executions (id, taskId, startedAt, finishedAt, status, output, error, sessionId)
+  VALUES (@id, @taskId, @startedAt, @finishedAt, @status, @output, @error, @sessionId)
+`);
+const stmtExecById = db.prepare('SELECT * FROM cron_executions WHERE id = ?');
+const stmtDeleteExec = db.prepare('DELETE FROM cron_executions WHERE id = ?');
+const stmtUpdateExec = db.prepare(`
+  UPDATE cron_executions SET finishedAt = @finishedAt, status = @status, output = @output, error = @error, sessionId = @sessionId
+  WHERE id = @id
+`);
+// Trim: keep latest MAX_EXECUTIONS_PER_TASK, delete the rest
+const stmtTrimExecs = db.prepare(`
+  DELETE FROM cron_executions WHERE taskId = ? AND id NOT IN (
+    SELECT id FROM cron_executions WHERE taskId = ? ORDER BY startedAt DESC LIMIT ?
+  )
+`);
+// --- Row mappers ---
+function rowToTask(row) {
+    const task = {
+        id: row.id,
+        name: row.name,
+        cronExpression: row.cronExpression,
+        prompt: row.prompt,
+        enabled: row.enabled === 1,
+        createdAt: row.createdAt,
+    };
+    if (row.projectPath != null)
+        task.projectPath = row.projectPath;
+    if (row.lastRun != null)
+        task.lastRun = row.lastRun;
+    if (row.nextRun != null)
+        task.nextRun = row.nextRun;
+    return task;
+}
+function taskToParams(task) {
+    return {
+        id: task.id,
+        name: task.name,
+        cronExpression: task.cronExpression,
+        prompt: task.prompt,
+        enabled: task.enabled ? 1 : 0,
+        projectPath: task.projectPath ?? null,
+        lastRun: task.lastRun ?? null,
+        nextRun: task.nextRun ?? null,
+        createdAt: task.createdAt,
+    };
+}
+function rowToExec(row) {
+    const exec = {
+        id: row.id,
+        taskId: row.taskId,
+        startedAt: row.startedAt,
+        status: row.status,
+    };
+    if (row.finishedAt != null)
+        exec.finishedAt = row.finishedAt;
+    if (row.output != null)
+        exec.output = row.output;
+    if (row.error != null)
+        exec.error = row.error;
+    if (row.sessionId != null)
+        exec.sessionId = row.sessionId;
+    return exec;
+}
+// --- Tasks ---
+export function getAllTasks() {
+    return stmtAllTasks.all().map(rowToTask);
+}
+export function getTask(id) {
+    const row = stmtTaskById.get(id);
+    return row ? rowToTask(row) : undefined;
+}
+export function createTask(data) {
+    const task = {
+        ...data,
+        id: crypto.randomUUID(),
+        createdAt: new Date().toISOString(),
+    };
+    stmtInsertTask.run(taskToParams(task));
+    return task;
+}
+export function updateTask(id, updates) {
+    const existing = getTask(id);
+    if (!existing)
+        return null;
+    const merged = { ...existing, ...updates, id };
+    stmtUpdateTask.run(taskToParams(merged));
+    return merged;
+}
+export function deleteTask(id) {
+    // CASCADE will delete related executions
+    const result = stmtDeleteTask.run(id);
+    return result.changes > 0;
+}
+// --- Executions ---
+export function getTaskExecutions(taskId) {
+    return stmtExecsByTask.all(taskId).map(rowToExec);
+}
+export function createExecution(taskId, sessionId) {
+    const exec = {
+        id: crypto.randomUUID(),
+        taskId,
+        startedAt: new Date().toISOString(),
+        status: 'running',
+        sessionId,
+    };
+    stmtInsertExec.run({
+        id: exec.id,
+        taskId: exec.taskId,
+        startedAt: exec.startedAt,
+        finishedAt: null,
+        status: exec.status,
+        output: null,
+        error: null,
+        sessionId: sessionId ?? null,
+    });
+    // Trim old executions
+    stmtTrimExecs.run(taskId, taskId, MAX_EXECUTIONS_PER_TASK);
+    return exec;
+}
+export function updateExecution(id, updates) {
+    const row = stmtExecById.get(id);
+    if (!row)
+        return null;
+    const existing = rowToExec(row);
+    const merged = { ...existing, ...updates, id };
+    stmtUpdateExec.run({
+        id: merged.id,
+        finishedAt: merged.finishedAt ?? null,
+        status: merged.status,
+        output: merged.output ?? null,
+        error: merged.error ?? null,
+        sessionId: merged.sessionId ?? null,
+    });
+    return merged;
+}

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

@@ -0,0 +1,103 @@
+import path from 'path';
+import os from 'os';
+import fs from 'fs';
+import Database from 'better-sqlite3';
+const DATA_DIR = path.join(os.homedir(), '.claudit');
+const DB_PATH = path.join(DATA_DIR, 'claudit.db');
+if (!fs.existsSync(DATA_DIR)) {
+    fs.mkdirSync(DATA_DIR, { recursive: true });
+}
+const db = new Database(DB_PATH);
+// Enable WAL mode for concurrent read/write (MCP + Web server)
+db.pragma('journal_mode = WAL');
+db.pragma('foreign_keys = ON');
+db.pragma('busy_timeout = 5000');
+// --- Schema ---
+db.exec(`
+  CREATE TABLE IF NOT EXISTS todos (
+    id            TEXT PRIMARY KEY,
+    title         TEXT NOT NULL,
+    description   TEXT,
+    completed     INTEGER NOT NULL DEFAULT 0,
+    priority      TEXT NOT NULL DEFAULT 'medium',
+    sessionId     TEXT,
+    sessionLabel  TEXT,
+    createdAt     TEXT NOT NULL,
+    completedAt   TEXT,
+    -- provider fields (NULL when no provider)
+    providerId    TEXT,
+    configId      TEXT,
+    externalId    TEXT,
+    externalUrl   TEXT,
+    lastSyncedAt  TEXT,
+    syncStatus    TEXT,
+    syncError     TEXT
+  );
+
+  CREATE TABLE IF NOT EXISTS cron_tasks (
+    id             TEXT PRIMARY KEY,
+    name           TEXT NOT NULL,
+    cronExpression TEXT NOT NULL,
+    prompt         TEXT NOT NULL,
+    enabled        INTEGER NOT NULL DEFAULT 1,
+    projectPath    TEXT,
+    lastRun        TEXT,
+    nextRun        TEXT,
+    createdAt      TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS cron_executions (
+    id         TEXT PRIMARY KEY,
+    taskId     TEXT NOT NULL REFERENCES cron_tasks(id) ON DELETE CASCADE,
+    startedAt  TEXT NOT NULL,
+    finishedAt TEXT,
+    status     TEXT NOT NULL DEFAULT 'running',
+    output     TEXT,
+    error      TEXT
+  );
+
+  CREATE TABLE IF NOT EXISTS provider_configs (
+    id                  TEXT PRIMARY KEY,
+    providerId          TEXT NOT NULL,
+    name                TEXT NOT NULL,
+    enabled             INTEGER NOT NULL DEFAULT 1,
+    config              TEXT NOT NULL DEFAULT '{}',
+    syncIntervalMinutes INTEGER,
+    lastSyncAt          TEXT,
+    lastSyncError       TEXT,
+    createdAt           TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS managed_sessions (
+    sessionId   TEXT PRIMARY KEY,
+    projectPath TEXT NOT NULL DEFAULT '',
+    displayName TEXT,
+    archived    INTEGER NOT NULL DEFAULT 0,
+    pinned      INTEGER NOT NULL DEFAULT 0,
+    createdAt   TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS todo_groups (
+    id        TEXT PRIMARY KEY,
+    name      TEXT NOT NULL,
+    position  INTEGER NOT NULL DEFAULT 0,
+    createdAt TEXT NOT NULL
+  );
+`);
+// Idempotent ALTER TABLE helper: only swallow "duplicate column" errors
+function addColumnIfNotExists(sql) {
+    try {
+        db.exec(sql);
+    }
+    catch (e) {
+        if (!e.message?.includes('duplicate column'))
+            throw e;
+    }
+}
+addColumnIfNotExists('ALTER TABLE todos ADD COLUMN groupId TEXT REFERENCES todo_groups(id) ON DELETE SET NULL');
+addColumnIfNotExists('ALTER TABLE todos ADD COLUMN position INTEGER NOT NULL DEFAULT 0');
+addColumnIfNotExists('ALTER TABLE cron_executions ADD COLUMN sessionId TEXT');
+export { db };
+export function closeDb() {
+    db.close();
+}

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

@@ -0,0 +1,11 @@
+import { EventEmitter } from 'events';
+class EventBus extends EventEmitter {
+    emitSessionEvent(event) {
+        this.emit('session', event);
+    }
+    onSessionEvent(handler) {
+        this.on('session', handler);
+        return () => this.off('session', handler);
+    }
+}
+export const eventBus = new EventBus();

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

@@ -0,0 +1,52 @@
+import crypto from 'crypto';
+import { db } from './database.js';
+const stmtAll = db.prepare('SELECT * FROM todo_groups ORDER BY position ASC, createdAt ASC');
+const stmtById = db.prepare('SELECT * FROM todo_groups WHERE id = ?');
+const stmtInsert = db.prepare(`
+  INSERT INTO todo_groups (id, name, position, createdAt)
+  VALUES (@id, @name, @position, @createdAt)
+`);
+const stmtUpdate = db.prepare('UPDATE todo_groups SET name = ?, position = ? WHERE id = ?');
+const stmtDelete = db.prepare('DELETE FROM todo_groups WHERE id = ?');
+const stmtMaxPosition = db.prepare('SELECT COALESCE(MAX(position), 0) as maxPos FROM todo_groups');
+function rowToGroup(row) {
+    return {
+        id: row.id,
+        name: row.name,
+        position: row.position,
+        createdAt: row.createdAt,
+    };
+}
+export function getAllGroups() {
+    return stmtAll.all().map(rowToGroup);
+}
+export function getGroup(id) {
+    const row = stmtById.get(id);
+    return row ? rowToGroup(row) : undefined;
+}
+export function createGroup(name) {
+    const maxPos = stmtMaxPosition.get()?.maxPos ?? 0;
+    const group = {
+        id: crypto.randomUUID(),
+        name,
+        position: maxPos + 1000,
+        createdAt: new Date().toISOString(),
+    };
+    stmtInsert.run(group);
+    return group;
+}
+export function updateGroup(id, updates) {
+    const existing = getGroup(id);
+    if (!existing)
+        return null;
+    const merged = {
+        ...existing,
+        ...updates,
+    };
+    stmtUpdate.run(merged.name, merged.position, id);
+    return merged;
+}
+export function deleteGroup(id) {
+    const result = stmtDelete.run(id);
+    return result.changes > 0;
+}

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

@@ -0,0 +1,100 @@
+import { getManagedSessionMap, getArchivedSessionIds, getPinnedSessionIds } from './managedSessions.js';
+import { getActivePtySessions } from './ptyManager.js';
+import { scanProjectSessions } from './sessionScanner.js';
+let cache = null;
+const CACHE_TTL = 30_000; // 30 seconds
+/** Invalidate the session cache (e.g. after creating a new session) */
+export function invalidateSessionCache() {
+    cache = null;
+}
+/** Get sessions grouped by project, with optional search filter */
+export function getSessionIndex(query, hideEmpty, managedOnly, includeArchived) {
+    if (cache && Date.now() - cache.timestamp < CACHE_TTL) {
+        return filterGroups(overlayRunningStatus(cache.data), query, hideEmpty, managedOnly, includeArchived);
+    }
+    const summaries = scanProjectSessions();
+    // Group by project
+    const groupMap = new Map();
+    for (const s of summaries) {
+        let group = groupMap.get(s.projectHash);
+        if (!group) {
+            group = { projectPath: s.projectPath, projectHash: s.projectHash, sessions: [] };
+            groupMap.set(s.projectHash, group);
+        }
+        group.sessions.push(s);
+    }
+    // Sort sessions within each group by timestamp desc
+    const groups = Array.from(groupMap.values());
+    for (const g of groups) {
+        g.sessions.sort((a, b) => b.timestamp - a.timestamp);
+    }
+    // Sort groups by most recent session
+    groups.sort((a, b) => {
+        const aTime = a.sessions[0]?.timestamp ?? 0;
+        const bTime = b.sessions[0]?.timestamp ?? 0;
+        return bTime - aTime;
+    });
+    cache = { data: groups, timestamp: Date.now() };
+    return filterGroups(overlayPinnedStatus(overlayRunningStatus(groups)), query, hideEmpty, managedOnly, includeArchived);
+}
+/** Overlay running status from active PTY sessions (not cached) */
+function overlayRunningStatus(groups) {
+    const active = getActivePtySessions();
+    if (active.size === 0)
+        return groups;
+    return groups.map(g => ({
+        ...g,
+        sessions: g.sessions.map(s => active.has(s.sessionId) ? { ...s, status: 'running' } : s),
+    }));
+}
+/** Overlay pinned status and sort pinned sessions first within each group */
+function overlayPinnedStatus(groups) {
+    const pinned = getPinnedSessionIds();
+    if (pinned.size === 0)
+        return groups;
+    return groups.map(g => {
+        const sessions = g.sessions.map(s => pinned.has(s.sessionId) ? { ...s, pinned: true } : s);
+        sessions.sort((a, b) => {
+            if (a.pinned && !b.pinned)
+                return -1;
+            if (!a.pinned && b.pinned)
+                return 1;
+            return 0; // preserve existing order within same pin status
+        });
+        return { ...g, sessions };
+    });
+}
+function filterGroups(groups, query, hideEmpty, managedOnly, includeArchived) {
+    let managedSet = null;
+    if (managedOnly) {
+        managedSet = new Set(getManagedSessionMap().keys());
+    }
+    const archivedIds = getArchivedSessionIds();
+    return groups
+        .map(g => ({
+        ...g,
+        sessions: g.sessions.filter(s => {
+            if (includeArchived) {
+                if (!archivedIds.has(s.sessionId))
+                    return false;
+            }
+            else {
+                if (archivedIds.has(s.sessionId))
+                    return false;
+            }
+            if (hideEmpty && s.messageCount === 0)
+                return false;
+            if (managedSet && !managedSet.has(s.sessionId))
+                return false;
+            if (query) {
+                const q = query.toLowerCase();
+                return (s.lastMessage.toLowerCase().includes(q) ||
+                    s.projectPath.toLowerCase().includes(q) ||
+                    s.sessionId.includes(q) ||
+                    (s.displayName?.toLowerCase().includes(q) ?? false));
+            }
+            return true;
+        }),
+    }))
+        .filter(g => g.sessions.length > 0);
+}

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

@@ -0,0 +1,41 @@
+import fs from 'fs';
+import path from 'path';
+import crypto from 'crypto';
+/**
+ * Generic JSON file store with atomic writes (temp file + rename).
+ */
+export class JsonStore {
+    filePath;
+    fallback;
+    constructor(filePath, fallback) {
+        this.filePath = filePath;
+        this.fallback = fallback;
+    }
+    read() {
+        try {
+            if (fs.existsSync(this.filePath)) {
+                return JSON.parse(fs.readFileSync(this.filePath, 'utf-8'));
+            }
+        }
+        catch {
+            // corrupt file — return fallback
+        }
+        return this.fallback;
+    }
+    write(data) {
+        const dir = path.dirname(this.filePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        const tmp = path.join(dir, `.tmp-${crypto.randomUUID()}`);
+        fs.writeFileSync(tmp, JSON.stringify(data, null, 2), 'utf-8');
+        fs.renameSync(tmp, this.filePath);
+    }
+    /** Read, apply mutation, write back atomically. Returns the mutator's return value. */
+    update(fn) {
+        const data = this.read();
+        const result = fn(data);
+        this.write(data);
+        return result;
+    }
+}