circuschief 0.1.0

package/packages/server/src/db/CanvasItemRepository.js

@@ -0,0 +1,315 @@
+import { BaseRepository } from './BaseRepository.js';
+import { databaseManager } from './DatabaseManager.js';
+
+/**
+ * Canvas item repository class
+ */
+export class CanvasItemRepository extends BaseRepository {
+  constructor() {
+    super('canvas_items', CanvasItemRepository.#mapCanvasItem);
+  }
+
+  static #mapCanvasItem(row) {
+    // Parse JSON data for json type
+    let data = row.data;
+    if (row.type === 'json' && typeof data === 'string') {
+      try {
+        data = JSON.parse(data);
+      } catch (e) {
+        // If parsing fails, keep as string
+      }
+    }
+
+    return {
+      id: row.id,
+      sessionId: row.session_id,
+      type: row.type,
+      content: row.content,
+      data,
+      mimeType: row.mime_type,
+      filename: row.filename,
+      width: row.width,
+      height: row.height,
+      deletedAt: row.deleted_at,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+    };
+  }
+
+  create(sessionId, data) {
+    const id = databaseManager.generateId();
+    const now = Date.now();
+
+    // Serialize data field to JSON if it's an object
+    let dataValue = data.data || null;
+    if (dataValue !== null && typeof dataValue === 'object') {
+      dataValue = JSON.stringify(dataValue);
+    }
+
+    this.db
+      .prepare(
+        `INSERT INTO canvas_items (id, session_id, type, content, data, mime_type, filename, width, height, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+      )
+      .run(
+        id,
+        sessionId,
+        data.type,
+        data.content || null,
+        dataValue,
+        data.mimeType || null,
+        data.filename || null,
+        data.width || null,
+        data.height || null,
+        now,
+        now
+      );
+    return this.getById(id);
+  }
+
+  getBySessionId(sessionId) {
+    const rows = this.db
+      .prepare('SELECT * FROM canvas_items WHERE session_id = ? AND deleted_at IS NULL ORDER BY created_at DESC')
+      .all(sessionId);
+    return this.mapAll(rows);
+  }
+
+  /**
+   * Get only the latest version of each file for a session (for agent-facing API)
+   * Returns one item per unique filename, always the newest version
+   * @param {string} sessionId
+   * @returns {Array} Array of latest canvas items (one per filename)
+   */
+  getLatestVersionsBySessionId(sessionId) {
+    // Use a subquery to get the max rowid (which is unique and auto-incrementing) for each filename
+    // rowid is more reliable than created_at since items can have identical timestamps
+    const rows = this.db
+      .prepare(
+        `SELECT ci.*
+         FROM canvas_items ci
+         INNER JOIN (
+           SELECT filename, MAX(rowid) as max_rowid
+           FROM canvas_items
+           WHERE session_id = ? AND deleted_at IS NULL
+           GROUP BY filename
+         ) latest ON ci.filename = latest.filename AND ci.rowid = latest.max_rowid
+         WHERE ci.session_id = ? AND ci.deleted_at IS NULL
+         ORDER BY ci.created_at DESC`
+      )
+      .all(sessionId, sessionId);
+    return this.mapAll(rows);
+  }
+
+  /**
+   * Get all versions of a file by filename, ordered newest first
+   * @param {string} sessionId
+   * @param {string} filename
+   * @returns {Array} Array of canvas items with matching filename
+   */
+  getAllVersionsByFilename(sessionId, filename) {
+    const rows = this.db
+      .prepare(
+        `SELECT * FROM canvas_items
+         WHERE session_id = ? AND filename = ? AND deleted_at IS NULL
+         ORDER BY created_at DESC, rowid DESC`
+      )
+      .all(sessionId, filename);
+    return this.mapAll(rows);
+  }
+
+  /**
+   * Get only deleted items for trash view
+   * @param {string} sessionId
+   * @returns {Array} Array of deleted canvas items
+   */
+  getDeletedBySessionId(sessionId) {
+    const rows = this.db
+      .prepare('SELECT * FROM canvas_items WHERE session_id = ? AND deleted_at IS NOT NULL ORDER BY deleted_at DESC')
+      .all(sessionId);
+    return this.mapAll(rows);
+  }
+
+  /**
+   * Soft delete: set deleted_at timestamp
+   * @param {string} itemId
+   * @returns {Object} The updated item
+   */
+  softDelete(itemId) {
+    const now = Date.now();
+    this.db
+      .prepare('UPDATE canvas_items SET deleted_at = ? WHERE id = ?')
+      .run(now, itemId);
+    return this.getById(itemId);
+  }
+
+  /**
+   * Recover: clear deleted_at timestamp
+   * @param {string} itemId
+   * @returns {Object} The recovered item
+   */
+  recover(itemId) {
+    const now = Date.now();
+    this.db
+      .prepare('UPDATE canvas_items SET deleted_at = NULL, updated_at = ? WHERE id = ?')
+      .run(now, itemId);
+    return this.getById(itemId);
+  }
+
+  /**
+   * Recover all versions of a file
+   * @param {string} sessionId
+   * @param {string} filename
+   */
+  recoverByFilename(sessionId, filename) {
+    const now = Date.now();
+    this.db
+      .prepare('UPDATE canvas_items SET deleted_at = NULL, updated_at = ? WHERE session_id = ? AND filename = ? AND deleted_at IS NOT NULL')
+      .run(now, sessionId, filename);
+  }
+
+  /**
+   * Permanent delete (for emptying trash)
+   * @param {string} itemId
+   */
+  permanentDelete(itemId) {
+    this.db.prepare('DELETE FROM canvas_items WHERE id = ?').run(itemId);
+  }
+
+  /**
+   * Expand item IDs to include all versions sharing the same filename.
+   * For each given ID, finds the item's filename + session, then collects
+   * all items with that filename in that session.
+   * @param {string[]} itemIds - Array of item IDs
+   * @param {object} options
+   * @param {boolean} [options.deletedOnly] - Only include deleted items (for trash operations)
+   * @param {boolean} [options.activeOnly] - Only include active (non-deleted) items
+   * @returns {string[]} Expanded array of item IDs (deduplicated)
+   */
+  expandToAllVersions(itemIds, { deletedOnly = false, activeOnly = false } = {}) {
+    if (!itemIds || itemIds.length === 0) return [];
+
+    const allIds = new Set();
+
+    for (const itemId of itemIds) {
+      const item = this.getById(itemId);
+      if (!item || !item.filename) {
+        allIds.add(itemId);
+        continue;
+      }
+
+      let filter = 'session_id = ? AND filename = ?';
+      if (deletedOnly) filter += ' AND deleted_at IS NOT NULL';
+      if (activeOnly) filter += ' AND deleted_at IS NULL';
+
+      const siblings = this.db
+        .prepare(`SELECT id FROM canvas_items WHERE ${filter}`)
+        .all(item.sessionId, item.filename);
+
+      for (const sibling of siblings) {
+        allIds.add(sibling.id);
+      }
+    }
+
+    return [...allIds];
+  }
+
+  /**
+   * Duplicates all canvas items from one session to another.
+   * Only copies non-deleted items.
+   * @param {string} sourceSessionId - Source session ID
+   * @param {string} targetSessionId - Target session ID
+   */
+  /**
+   * Update the content of an existing canvas item in-place
+   * @param {string} itemId
+   * @param {string} content
+   * @returns {Object|undefined} The updated item, or undefined if not found
+   */
+  updateContent(itemId, content) {
+    const now = Date.now();
+    const result = this.db
+      .prepare('UPDATE canvas_items SET content = ?, updated_at = ? WHERE id = ?')
+      .run(content, now, itemId);
+    if (result.changes === 0) return undefined;
+    return this.getById(itemId);
+  }
+
+  duplicateForSession(sourceSessionId, targetSessionId) {
+    const items = this.getBySessionId(sourceSessionId);
+
+    for (const item of items) {
+      this.create(targetSessionId, {
+        type: item.type,
+        content: item.content,
+        data: item.data,
+        mimeType: item.mimeType,
+        filename: item.filename,
+        width: item.width,
+        height: item.height,
+      });
+    }
+  }
+
+  /**
+   * Soft delete multiple items atomically
+   * @param {string[]} itemIds - Array of item IDs to soft delete
+   * @returns {number} Count of items actually deleted
+   */
+  softDeleteBatch(itemIds) {
+    if (!itemIds || itemIds.length === 0) {
+      return 0;
+    }
+
+    const now = Date.now();
+    const placeholders = itemIds.map(() => '?').join(',');
+
+    const updateStmt = this.db.prepare(
+      `UPDATE canvas_items SET deleted_at = ? WHERE id IN (${placeholders}) AND deleted_at IS NULL`
+    );
+
+    const result = updateStmt.run(now, ...itemIds);
+    return result.changes || 0;
+  }
+
+  /**
+   * Recover multiple items atomically
+   * @param {string[]} itemIds - Array of item IDs to recover
+   * @returns {number} Count of items actually recovered
+   */
+  recoverBatch(itemIds) {
+    if (!itemIds || itemIds.length === 0) {
+      return 0;
+    }
+
+    const now = Date.now();
+    const placeholders = itemIds.map(() => '?').join(',');
+
+    const updateStmt = this.db.prepare(
+      `UPDATE canvas_items SET deleted_at = NULL, updated_at = ? WHERE id IN (${placeholders}) AND deleted_at IS NOT NULL`
+    );
+
+    const result = updateStmt.run(now, ...itemIds);
+    return result.changes || 0;
+  }
+
+  /**
+   * Permanently delete multiple items atomically
+   * @param {string[]} itemIds - Array of item IDs to permanently delete (must be from trash)
+   * @returns {number} Count of items actually deleted
+   */
+  permanentDeleteBatch(itemIds) {
+    if (!itemIds || itemIds.length === 0) {
+      return 0;
+    }
+
+    // Only allow permanent deletion of items that are in trash (deleted_at IS NOT NULL)
+    const placeholders = itemIds.map(() => '?').join(',');
+
+    const deleteStmt = this.db.prepare(
+      `DELETE FROM canvas_items WHERE id IN (${placeholders}) AND deleted_at IS NOT NULL`
+    );
+
+    const result = deleteStmt.run(...itemIds);
+    return result.changes || 0;
+  }
+}

package/packages/server/src/db/CommandButtonRepository.js

@@ -0,0 +1,75 @@
+import { BaseRepository } from './BaseRepository.js';
+import { databaseManager } from './DatabaseManager.js';
+
+/**
+ * Command button repository class
+ */
+export class CommandButtonRepository extends BaseRepository {
+  constructor() {
+    super('command_buttons', CommandButtonRepository.#mapButton);
+  }
+
+  static #mapButton(row) {
+    return {
+      id: row.id,
+      projectId: row.project_id,
+      label: row.label,
+      command: row.command,
+      sortOrder: row.sort_order,
+      showOnList: row.show_on_list === 1,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+    };
+  }
+
+  create({ projectId, label, command, sortOrder = 0, showOnList = false }) {
+    const id = databaseManager.generateId();
+    const now = Date.now();
+    this.db
+      .prepare(
+        `INSERT INTO command_buttons (id, project_id, label, command, sort_order, show_on_list, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`
+      )
+      .run(id, projectId, label, command, sortOrder, showOnList ? 1 : 0, now, now);
+    return this.getById(id);
+  }
+
+  getByProjectId(projectId) {
+    const rows = this.db
+      .prepare('SELECT * FROM command_buttons WHERE project_id = ? ORDER BY sort_order ASC, created_at ASC')
+      .all(projectId);
+    return this.mapAll(rows);
+  }
+
+  update(id, data) {
+    const updates = [];
+    const values = [];
+
+    if (data.label !== undefined) {
+      updates.push('label = ?');
+      values.push(data.label);
+    }
+    if (data.command !== undefined) {
+      updates.push('command = ?');
+      values.push(data.command);
+    }
+    if (data.sortOrder !== undefined) {
+      updates.push('sort_order = ?');
+      values.push(data.sortOrder);
+    }
+    if (data.showOnList !== undefined) {
+      updates.push('show_on_list = ?');
+      values.push(data.showOnList ? 1 : 0);
+    }
+
+    if (updates.length === 0) return this.getById(id);
+
+    updates.push('updated_at = ?');
+    values.push(Date.now());
+    values.push(id);
+
+    this.db.prepare(`UPDATE command_buttons SET ${updates.join(', ')} WHERE id = ?`).run(...values);
+
+    return this.getById(id);
+  }
+}

package/packages/server/src/db/CommandRunRepository.js

@@ -0,0 +1,219 @@
+import { BaseRepository } from './BaseRepository.js';
+
+/**
+ * Command run repository class for persisting command execution history
+ */
+export class CommandRunRepository extends BaseRepository {
+  constructor() {
+    super('command_runs', CommandRunRepository.#mapRun);
+  }
+
+  static #mapRun(row) {
+    return {
+      id: row.id,
+      sessionId: row.session_id,
+      buttonId: row.button_id,
+      status: row.status,
+      output: row.output || '',
+      exitCode: row.exit_code,
+      startedAt: row.started_at,
+      completedAt: row.completed_at,
+    };
+  }
+
+  create({ id, sessionId, buttonId }) {
+    const now = Date.now();
+    this.db
+      .prepare(
+        `INSERT INTO command_runs (id, session_id, button_id, status, output, started_at)
+         VALUES (?, ?, ?, 'running', '', ?)`
+      )
+      .run(id, sessionId, buttonId, now);
+    return this.getById(id);
+  }
+
+  /**
+   * Append text to run output (buffered for performance)
+   */
+  appendOutput(runId, text) {
+    if (!text) return;
+    this.db
+      .prepare(`UPDATE command_runs SET output = output || ? WHERE id = ?`)
+      .run(text, runId);
+  }
+
+  /**
+   * Mark run as completed with exit code and final output
+   */
+  complete(runId, exitCode, finalOutput) {
+    const status = exitCode === 0 ? 'success' : 'error';
+    const now = Date.now();
+    this.db
+      .prepare(
+        `UPDATE command_runs SET status = ?, output = ?, exit_code = ?, completed_at = ? WHERE id = ?`
+      )
+      .run(status, finalOutput, exitCode, now, runId);
+  }
+
+  /**
+   * Mark run as killed
+   */
+  markKilled(runId, finalOutput) {
+    const now = Date.now();
+    this.db
+      .prepare(
+        `UPDATE command_runs SET status = 'killed', output = ?, completed_at = ? WHERE id = ?`
+      )
+      .run(finalOutput, now, runId);
+  }
+
+  /**
+   * Get all runs for a session (both running and recent completed)
+   */
+  getBySessionId(sessionId) {
+    const rows = this.db
+      .prepare('SELECT * FROM command_runs WHERE session_id = ? ORDER BY started_at DESC')
+      .all(sessionId);
+    return this.mapAll(rows);
+  }
+
+  /**
+   * Get runs for a session from last X milliseconds (recent runs)
+   * If includeRunning is true, also include running commands regardless of age
+   */
+  getRecentBySessionId(sessionId, windowMs = 3600000, includeRunning = true) {
+    const cutoffTime = Date.now() - windowMs;
+    let query = `SELECT * FROM command_runs WHERE session_id = ?`;
+
+    if (includeRunning) {
+      query += ` AND (started_at > ? OR status = 'running')`;
+    } else {
+      query += ` AND started_at > ?`;
+    }
+
+    query += ` ORDER BY started_at DESC`;
+
+    const rows = this.db.prepare(query).all(sessionId, cutoffTime);
+    return this.mapAll(rows);
+  }
+
+  /**
+   * Get a single run by ID
+   */
+  getById(id) {
+    const row = this.db.prepare('SELECT * FROM command_runs WHERE id = ?').get(id);
+    return this.map(row);
+  }
+
+  /**
+   * Get most recent run for a button
+   */
+  getLastRunForButton(buttonId) {
+    const row = this.db
+      .prepare('SELECT * FROM command_runs WHERE button_id = ? ORDER BY started_at DESC LIMIT 1')
+      .get(buttonId);
+    return this.map(row);
+  }
+
+  /**
+   * Delete runs older than specified milliseconds
+   */
+  deleteOlderThan(ageMs) {
+    const cutoffTime = Date.now() - ageMs;
+    const result = this.db
+      .prepare('DELETE FROM command_runs WHERE completed_at < ?')
+      .run(cutoffTime);
+    return result.changes;
+  }
+
+  /**
+   * Delete a single run by ID
+   * @param {string} id - Run ID
+   * @returns {number} Number of rows deleted (0 or 1)
+   */
+  deleteById(id) {
+    const result = this.db.prepare('DELETE FROM command_runs WHERE id = ?').run(id);
+    return result.changes;
+  }
+
+  /**
+   * Delete all non-running runs for a button within a session.
+   * Returns info about deleted runs (needed for WebSocket broadcasting).
+   * @param {string} buttonId - Button ID
+   * @param {string} sessionId - Session ID
+   * @returns {{ deletedCount: number, deletedRuns: Array<{ id: string, buttonId: string }> }}
+   */
+  deleteByButtonAndSession(buttonId, sessionId) {
+    const deleteRuns = this.db.transaction(() => {
+      // First get the IDs of runs we'll delete (for broadcasting)
+      const runs = this.db
+        .prepare('SELECT id, button_id FROM command_runs WHERE button_id = ? AND session_id = ? AND status != ?')
+        .all(buttonId, sessionId, 'running');
+
+      const result = this.db
+        .prepare('DELETE FROM command_runs WHERE button_id = ? AND session_id = ? AND status != ?')
+        .run(buttonId, sessionId, 'running');
+
+      return {
+        deletedCount: result.changes,
+        deletedRuns: runs.map(r => ({ id: r.id, buttonId: r.button_id })),
+      };
+    });
+
+    return deleteRuns();
+  }
+
+  /**
+   * Delete all runs for a session (useful for testing or cleanup)
+   */
+  deleteBySessionId(sessionId) {
+    const result = this.db
+      .prepare('DELETE FROM command_runs WHERE session_id = ?')
+      .run(sessionId);
+    return result.changes;
+  }
+
+  /**
+   * Get the latest run for each (session_id, button_id) combination within a project
+   * Returns the most recent run per button per session regardless of age
+   */
+  getLatestRunsForProject(projectId) {
+    const rows = this.db
+      .prepare(
+        `SELECT *
+         FROM (
+           SELECT cr.id, cr.session_id, cr.button_id, cr.status, cr.exit_code, cr.started_at, cr.completed_at,
+             ROW_NUMBER() OVER (PARTITION BY cr.session_id, cr.button_id ORDER BY COALESCE(cr.completed_at, cr.started_at) DESC, cr.id DESC) as rn
+           FROM command_runs cr
+           INNER JOIN sessions s ON cr.session_id = s.id
+           WHERE s.project_id = ?
+         )
+         WHERE rn = 1
+         ORDER BY COALESCE(completed_at, started_at) DESC, id DESC`
+      )
+      .all(projectId);
+    return this.mapAll(rows);
+  }
+
+  /**
+   * Get the latest run for each button in a session (one per button)
+   * @param {string} sessionId - Session ID
+   * @returns {Array} Array of CommandRun objects
+   */
+  getLatestRunsForSession(sessionId) {
+    const rows = this.db
+      .prepare(
+        `SELECT *
+         FROM (
+           SELECT cr.id, cr.session_id, cr.button_id, cr.status, cr.exit_code, cr.output, cr.started_at, cr.completed_at,
+             ROW_NUMBER() OVER (PARTITION BY cr.button_id ORDER BY COALESCE(cr.completed_at, cr.started_at) DESC, cr.id DESC) as rn
+           FROM command_runs cr
+           WHERE cr.session_id = ?
+         )
+         WHERE rn = 1
+         ORDER BY COALESCE(completed_at, started_at) DESC, id DESC`
+      )
+      .all(sessionId);
+    return this.mapAll(rows);
+  }
+}