cowork-os 0.3.21

package/dist/electron/electron/agents/TaskSubscriptionRepository.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskSubscriptionRepository = void 0;
+const uuid_1 = require("uuid");
+/**
+ * Repository for managing task subscriptions
+ * Agents subscribed to a task receive notifications when new activities occur
+ */
+class TaskSubscriptionRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    /**
+     * Subscribe an agent to a task
+     * If already subscribed, returns existing subscription
+     */
+    subscribe(taskId, agentRoleId, reason) {
+        // Check if already subscribed
+        const existing = this.findByTaskAndAgent(taskId, agentRoleId);
+        if (existing) {
+            return existing;
+        }
+        const now = Date.now();
+        const subscription = {
+            id: (0, uuid_1.v4)(),
+            taskId,
+            agentRoleId,
+            subscriptionReason: reason,
+            subscribedAt: now,
+        };
+        const stmt = this.db.prepare(`
+      INSERT INTO task_subscriptions (
+        id, task_id, agent_role_id, subscription_reason, subscribed_at
+      ) VALUES (?, ?, ?, ?, ?)
+    `);
+        stmt.run(subscription.id, subscription.taskId, subscription.agentRoleId, subscription.subscriptionReason, subscription.subscribedAt);
+        return subscription;
+    }
+    /**
+     * Auto-subscribe an agent to a task (convenience method)
+     * Used when agent comments, gets mentioned, or gets assigned
+     */
+    autoSubscribe(taskId, agentRoleId, reason) {
+        return this.subscribe(taskId, agentRoleId, reason);
+    }
+    /**
+     * Unsubscribe an agent from a task
+     */
+    unsubscribe(taskId, agentRoleId) {
+        const stmt = this.db.prepare('DELETE FROM task_subscriptions WHERE task_id = ? AND agent_role_id = ?');
+        const result = stmt.run(taskId, agentRoleId);
+        return result.changes > 0;
+    }
+    /**
+     * Find a subscription by task and agent
+     */
+    findByTaskAndAgent(taskId, agentRoleId) {
+        const stmt = this.db.prepare('SELECT * FROM task_subscriptions WHERE task_id = ? AND agent_role_id = ?');
+        const row = stmt.get(taskId, agentRoleId);
+        return row ? this.mapRowToSubscription(row) : undefined;
+    }
+    /**
+     * Find a subscription by ID
+     */
+    findById(id) {
+        const stmt = this.db.prepare('SELECT * FROM task_subscriptions WHERE id = ?');
+        const row = stmt.get(id);
+        return row ? this.mapRowToSubscription(row) : undefined;
+    }
+    /**
+     * Get all subscribers for a task
+     */
+    getSubscribers(taskId) {
+        const stmt = this.db.prepare('SELECT * FROM task_subscriptions WHERE task_id = ? ORDER BY subscribed_at ASC');
+        const rows = stmt.all(taskId);
+        return rows.map((row) => this.mapRowToSubscription(row));
+    }
+    /**
+     * Get subscriber count for a task
+     */
+    getSubscriberCount(taskId) {
+        const stmt = this.db.prepare('SELECT COUNT(*) as count FROM task_subscriptions WHERE task_id = ?');
+        const result = stmt.get(taskId);
+        return result.count;
+    }
+    /**
+     * Get all subscriptions for an agent
+     */
+    getSubscriptionsForAgent(agentRoleId) {
+        const stmt = this.db.prepare('SELECT * FROM task_subscriptions WHERE agent_role_id = ? ORDER BY subscribed_at DESC');
+        const rows = stmt.all(agentRoleId);
+        return rows.map((row) => this.mapRowToSubscription(row));
+    }
+    /**
+     * List subscriptions with optional filtering
+     */
+    list(query) {
+        const conditions = [];
+        const params = [];
+        if (query.taskId) {
+            conditions.push('task_id = ?');
+            params.push(query.taskId);
+        }
+        if (query.agentRoleId) {
+            conditions.push('agent_role_id = ?');
+            params.push(query.agentRoleId);
+        }
+        let sql = 'SELECT * FROM task_subscriptions';
+        if (conditions.length > 0) {
+            sql += ` WHERE ${conditions.join(' AND ')}`;
+        }
+        sql += ' ORDER BY subscribed_at DESC';
+        if (query.limit) {
+            sql += ` LIMIT ${query.limit}`;
+            if (query.offset) {
+                sql += ` OFFSET ${query.offset}`;
+            }
+        }
+        const stmt = this.db.prepare(sql);
+        const rows = stmt.all(...params);
+        return rows.map((row) => this.mapRowToSubscription(row));
+    }
+    /**
+     * Delete all subscriptions for a task
+     */
+    deleteByTask(taskId) {
+        const stmt = this.db.prepare('DELETE FROM task_subscriptions WHERE task_id = ?');
+        const result = stmt.run(taskId);
+        return result.changes;
+    }
+    /**
+     * Delete all subscriptions for an agent
+     */
+    deleteByAgent(agentRoleId) {
+        const stmt = this.db.prepare('DELETE FROM task_subscriptions WHERE agent_role_id = ?');
+        const result = stmt.run(agentRoleId);
+        return result.changes;
+    }
+    /**
+     * Check if an agent is subscribed to a task
+     */
+    isSubscribed(taskId, agentRoleId) {
+        const stmt = this.db.prepare('SELECT 1 FROM task_subscriptions WHERE task_id = ? AND agent_role_id = ? LIMIT 1');
+        const result = stmt.get(taskId, agentRoleId);
+        return !!result;
+    }
+    /**
+     * Get agent role IDs subscribed to a task (for efficient notification)
+     */
+    getSubscriberIds(taskId) {
+        const stmt = this.db.prepare('SELECT agent_role_id FROM task_subscriptions WHERE task_id = ?');
+        const rows = stmt.all(taskId);
+        return rows.map((row) => row.agent_role_id);
+    }
+    /**
+     * Map database row to TaskSubscription object
+     */
+    mapRowToSubscription(row) {
+        return {
+            id: row.id,
+            taskId: row.task_id,
+            agentRoleId: row.agent_role_id,
+            subscriptionReason: row.subscription_reason,
+            subscribedAt: row.subscribed_at,
+        };
+    }
+}
+exports.TaskSubscriptionRepository = TaskSubscriptionRepository;

package/dist/electron/electron/agents/WorkingStateRepository.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkingStateRepository = void 0;
+const uuid_1 = require("uuid");
+/**
+ * Repository for managing agent working state in the database
+ */
+class WorkingStateRepository {
+    constructor(db) {
+        this.db = db;
+    }
+    /**
+     * Get a working state by ID
+     */
+    findById(id) {
+        const stmt = this.db.prepare('SELECT * FROM agent_working_state WHERE id = ?');
+        const row = stmt.get(id);
+        return row ? this.mapRowToState(row) : undefined;
+    }
+    /**
+     * Get the current working state for an agent in a workspace
+     */
+    getCurrent(query) {
+        let sql = `
+      SELECT * FROM agent_working_state
+      WHERE agent_role_id = ?
+        AND workspace_id = ?
+        AND is_current = 1
+    `;
+        const params = [query.agentRoleId, query.workspaceId];
+        if (query.taskId) {
+            sql += ' AND task_id = ?';
+            params.push(query.taskId);
+        }
+        else {
+            sql += ' AND task_id IS NULL';
+        }
+        if (query.stateType) {
+            sql += ' AND state_type = ?';
+            params.push(query.stateType);
+        }
+        sql += ' ORDER BY updated_at DESC LIMIT 1';
+        const stmt = this.db.prepare(sql);
+        const row = stmt.get(...params);
+        return row ? this.mapRowToState(row) : undefined;
+    }
+    /**
+     * Get all current working states for an agent in a workspace
+     */
+    getAllCurrent(agentRoleId, workspaceId) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM agent_working_state
+      WHERE agent_role_id = ? AND workspace_id = ? AND is_current = 1
+      ORDER BY state_type, updated_at DESC
+    `);
+        const rows = stmt.all(agentRoleId, workspaceId);
+        return rows.map((row) => this.mapRowToState(row));
+    }
+    /**
+     * Update or create a working state
+     */
+    update(request) {
+        const now = Date.now();
+        // Mark existing current states as not current
+        const updateStmt = this.db.prepare(`
+      UPDATE agent_working_state
+      SET is_current = 0, updated_at = ?
+      WHERE agent_role_id = ?
+        AND workspace_id = ?
+        AND state_type = ?
+        AND is_current = 1
+        ${request.taskId ? 'AND task_id = ?' : 'AND task_id IS NULL'}
+    `);
+        const updateParams = [now, request.agentRoleId, request.workspaceId, request.stateType];
+        if (request.taskId) {
+            updateParams.push(request.taskId);
+        }
+        updateStmt.run(...updateParams);
+        // Create new state
+        const state = {
+            id: (0, uuid_1.v4)(),
+            agentRoleId: request.agentRoleId,
+            workspaceId: request.workspaceId,
+            taskId: request.taskId,
+            stateType: request.stateType,
+            content: request.content,
+            fileReferences: request.fileReferences,
+            isCurrent: true,
+            createdAt: now,
+            updatedAt: now,
+        };
+        const insertStmt = this.db.prepare(`
+      INSERT INTO agent_working_state
+        (id, agent_role_id, workspace_id, task_id, state_type, content, file_references, is_current, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, 1, ?, ?)
+    `);
+        insertStmt.run(state.id, state.agentRoleId, state.workspaceId, state.taskId || null, state.stateType, state.content, state.fileReferences ? JSON.stringify(state.fileReferences) : null, state.createdAt, state.updatedAt);
+        return state;
+    }
+    /**
+     * Get working state history for an agent
+     */
+    getHistory(query) {
+        const limit = query.limit || 50;
+        const offset = query.offset || 0;
+        const stmt = this.db.prepare(`
+      SELECT * FROM agent_working_state
+      WHERE agent_role_id = ? AND workspace_id = ?
+      ORDER BY updated_at DESC
+      LIMIT ? OFFSET ?
+    `);
+        const rows = stmt.all(query.agentRoleId, query.workspaceId, limit, offset);
+        return rows.map((row) => this.mapRowToState(row));
+    }
+    /**
+     * Get all working states for a specific task
+     */
+    listForTask(taskId) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM agent_working_state
+      WHERE task_id = ?
+      ORDER BY updated_at DESC
+    `);
+        const rows = stmt.all(taskId);
+        return rows.map((row) => this.mapRowToState(row));
+    }
+    /**
+     * Restore a previous working state as current
+     */
+    restore(id) {
+        const state = this.findById(id);
+        if (!state)
+            return undefined;
+        const now = Date.now();
+        // Mark all states of this type/agent/workspace as not current
+        const updateStmt = this.db.prepare(`
+      UPDATE agent_working_state
+      SET is_current = 0, updated_at = ?
+      WHERE agent_role_id = ?
+        AND workspace_id = ?
+        AND state_type = ?
+        AND is_current = 1
+        ${state.taskId ? 'AND task_id = ?' : 'AND task_id IS NULL'}
+    `);
+        const updateParams = [now, state.agentRoleId, state.workspaceId, state.stateType];
+        if (state.taskId) {
+            updateParams.push(state.taskId);
+        }
+        updateStmt.run(...updateParams);
+        // Mark the target state as current
+        const restoreStmt = this.db.prepare(`
+      UPDATE agent_working_state SET is_current = 1, updated_at = ? WHERE id = ?
+    `);
+        restoreStmt.run(now, id);
+        return { ...state, isCurrent: true, updatedAt: now };
+    }
+    /**
+     * Delete a working state
+     */
+    delete(id) {
+        const stmt = this.db.prepare('DELETE FROM agent_working_state WHERE id = ?');
+        const result = stmt.run(id);
+        return result.changes > 0;
+    }
+    /**
+     * Delete all working states for an agent in a workspace
+     */
+    deleteByAgentAndWorkspace(agentRoleId, workspaceId) {
+        const stmt = this.db.prepare('DELETE FROM agent_working_state WHERE agent_role_id = ? AND workspace_id = ?');
+        const result = stmt.run(agentRoleId, workspaceId);
+        return result.changes;
+    }
+    /**
+     * Delete all working states for a task
+     */
+    deleteByTask(taskId) {
+        const stmt = this.db.prepare('DELETE FROM agent_working_state WHERE task_id = ?');
+        const result = stmt.run(taskId);
+        return result.changes;
+    }
+    /**
+     * Clean up old non-current states (keep last N per agent/workspace)
+     */
+    cleanupOldStates(keepCount = 50) {
+        // Get all agent/workspace combinations with more than keepCount states
+        const countStmt = this.db.prepare(`
+      SELECT agent_role_id, workspace_id, COUNT(*) as total
+      FROM agent_working_state
+      WHERE is_current = 0
+      GROUP BY agent_role_id, workspace_id
+      HAVING total > ?
+    `);
+        const groups = countStmt.all(keepCount);
+        let totalDeleted = 0;
+        for (const group of groups) {
+            // Delete oldest states beyond keepCount
+            const deleteStmt = this.db.prepare(`
+        DELETE FROM agent_working_state
+        WHERE id IN (
+          SELECT id FROM agent_working_state
+          WHERE agent_role_id = ? AND workspace_id = ? AND is_current = 0
+          ORDER BY updated_at ASC
+          LIMIT ?
+        )
+      `);
+            const result = deleteStmt.run(group.agent_role_id, group.workspace_id, group.total - keepCount);
+            totalDeleted += result.changes;
+        }
+        return totalDeleted;
+    }
+    /**
+     * Map database row to AgentWorkingState object
+     */
+    mapRowToState(row) {
+        return {
+            id: row.id,
+            agentRoleId: row.agent_role_id,
+            workspaceId: row.workspace_id,
+            taskId: row.task_id || undefined,
+            stateType: row.state_type,
+            content: row.content,
+            fileReferences: row.file_references ? JSON.parse(row.file_references) : undefined,
+            isCurrent: row.is_current === 1,
+            createdAt: row.created_at,
+            updatedAt: row.updated_at,
+        };
+    }
+}
+exports.WorkingStateRepository = WorkingStateRepository;