agor-live 0.3.7

package/dist/daemon/services/boards.d.ts

@@ -0,0 +1,64 @@
+import { Database } from '@agor/core/db';
+import { QueryParams, Board, BoardObject } from '@agor/core/types';
+import { DrizzleService } from '../adapters/drizzle.js';
+
+/**
+ * Boards Service
+ *
+ * Provides REST + WebSocket API for board management.
+ * Uses DrizzleService adapter with BoardRepository.
+ */
+
+/**
+ * Board service params
+ */
+type BoardParams = QueryParams<{
+    slug?: string;
+    name?: string;
+}>;
+/**
+ * Extended boards service with custom methods
+ */
+declare class BoardsService extends DrizzleService<Board, Partial<Board>, BoardParams> {
+    private boardRepo;
+    constructor(db: Database);
+    /**
+     * Custom method: Find board by slug
+     */
+    findBySlug(slug: string, _params?: BoardParams): Promise<Board | null>;
+    /**
+     * DEPRECATED: Add session to board
+     * Use board-objects service instead
+     */
+    addSession(_id: string, _sessionId: string, _params?: BoardParams): Promise<Board>;
+    /**
+     * DEPRECATED: Remove session from board
+     * Use board-objects service instead
+     */
+    removeSession(_id: string, _sessionId: string, _params?: BoardParams): Promise<Board>;
+    /**
+     * Custom method: Atomically add or update a board object
+     */
+    upsertBoardObject(boardId: string, objectId: string, objectData: BoardObject, _params?: BoardParams): Promise<Board>;
+    /**
+     * Custom method: Atomically remove a board object
+     */
+    removeBoardObject(boardId: string, objectId: string, _params?: BoardParams): Promise<Board>;
+    /**
+     * Custom method: Batch upsert board objects
+     */
+    batchUpsertBoardObjects(boardId: string, objects: Record<string, BoardObject>, _params?: BoardParams): Promise<Board>;
+    /**
+     * Custom method: Delete a zone and handle associated sessions
+     */
+    deleteZone(boardId: string, objectId: string, deleteAssociatedSessions: boolean, _params?: BoardParams): Promise<{
+        board: Board;
+        affectedSessions: string[];
+    }>;
+}
+/**
+ * Service factory function
+ */
+declare function createBoardsService(db: Database): BoardsService;
+
+export { type BoardParams, BoardsService, createBoardsService };

package/dist/daemon/services/boards.js

@@ -0,0 +1,286 @@
+// src/services/boards.ts
+import { BoardRepository } from "@agor/core/db";
+
+// src/adapters/drizzle.ts
+var DrizzleService = class {
+  constructor(repository, options = {}) {
+    this.repository = repository;
+    this.id = options.id ?? "id";
+    this.paginate = options.paginate;
+    this.multi = options.multi ?? false;
+  }
+  id;
+  paginate;
+  multi;
+  // Event emitter for FeathersJS (will be injected by framework)
+  // biome-ignore lint/suspicious/noExplicitAny: FeathersJS event system
+  emit;
+  /**
+   * Extract query parameters from params
+   */
+  getQuery(params) {
+    return params?.query ?? {};
+  }
+  /**
+   * Apply filters to data array (client-side filtering)
+   */
+  filterData(data, query) {
+    let filtered = [...data];
+    for (const [key, value] of Object.entries(query)) {
+      if (key.startsWith("$")) continue;
+      filtered = filtered.filter((item) => {
+        if (typeof value === "object" && value !== null) {
+          for (const [op, opValue] of Object.entries(value)) {
+            switch (op) {
+              case "$in":
+                return Array.isArray(opValue) && opValue.includes(item[key]);
+              case "$nin":
+                return Array.isArray(opValue) && !opValue.includes(item[key]);
+              case "$ne":
+                return item[key] !== opValue;
+              case "$gt":
+                return item[key] > opValue;
+              case "$gte":
+                return item[key] >= opValue;
+              case "$lt":
+                return item[key] < opValue;
+              case "$lte":
+                return item[key] <= opValue;
+            }
+          }
+        }
+        return item[key] === value;
+      });
+    }
+    return filtered;
+  }
+  /**
+   * Sort data array
+   */
+  sortData(data, sortSpec) {
+    if (!sortSpec) return data;
+    const sorted = [...data];
+    const entries = Object.entries(sortSpec);
+    sorted.sort((a, b) => {
+      for (const [field, direction] of entries) {
+        const aVal = a[field];
+        const bVal = b[field];
+        if (aVal < bVal) return direction === 1 ? -1 : 1;
+        if (aVal > bVal) return direction === 1 ? 1 : -1;
+      }
+      return 0;
+    });
+    return sorted;
+  }
+  /**
+   * Select specific fields from data
+   */
+  selectFields(data, fields) {
+    if (!fields || fields.length === 0) return data;
+    return data.map((item) => {
+      const selected = {};
+      for (const field of fields) {
+        if (field in item) {
+          selected[field] = item[field];
+        }
+      }
+      return selected;
+    });
+  }
+  /**
+   * Apply pagination to data
+   */
+  paginateData(data, query, total) {
+    const limit = query.$limit ?? this.paginate?.default ?? data.length;
+    const skip = query.$skip ?? 0;
+    if (!this.paginate) {
+      return data;
+    }
+    const maxLimit = this.paginate.max ?? 1e3;
+    const actualLimit = Math.min(limit, maxLimit);
+    const paginated = data.slice(skip, skip + actualLimit);
+    return {
+      total,
+      limit: actualLimit,
+      skip,
+      data: paginated
+    };
+  }
+  /**
+   * Find records
+   */
+  async find(params) {
+    const query = this.getQuery(params);
+    let data = await this.repository.findAll();
+    const total = data.length;
+    data = this.filterData(data, query);
+    data = this.sortData(data, query.$sort);
+    const selected = this.selectFields(data, query.$select);
+    return this.paginateData(selected, query, total);
+  }
+  /**
+   * Get a single record by ID
+   */
+  async get(id, _params) {
+    const result = await this.repository.findById(String(id));
+    if (!result) {
+      throw new Error(`No record found for id '${id}'`);
+    }
+    return result;
+  }
+  /**
+   * Create one or more records
+   */
+  async create(data, params) {
+    if (Array.isArray(data)) {
+      const results = await Promise.all(
+        data.map((item) => this.repository.create(item))
+      );
+      for (const result2 of results) {
+        this.emit?.("created", result2, params);
+      }
+      return results;
+    }
+    const result = await this.repository.create(data);
+    console.log("\u{1F514} [DrizzleService] Emitting created event, emit function exists:", !!this.emit);
+    this.emit?.("created", result, params);
+    return result;
+  }
+  /**
+   * Update a record (complete replacement)
+   */
+  async update(id, data, params) {
+    const existing = await this.get(id, params);
+    if (!existing) {
+      throw new Error(`No record found for id '${id}'`);
+    }
+    const result = await this.repository.update(String(id), data);
+    this.emit?.("updated", result, params);
+    this.emit?.("patched", result, params);
+    return result;
+  }
+  /**
+   * Patch a record (partial update)
+   */
+  async patch(id, data, params) {
+    if (id === null) {
+      if (!this.multi) {
+        throw new Error("Multi-patch is not enabled");
+      }
+      const query = this.getQuery(params);
+      let records = await this.repository.findAll();
+      records = this.filterData(records, query);
+      const results = await Promise.all(
+        records.map(
+          (record) => this.repository.update(
+            record[this.id],
+            data
+          )
+        )
+      );
+      for (const result2 of results) {
+        this.emit?.("patched", result2, params);
+      }
+      return results;
+    }
+    const existing = await this.get(id, params);
+    if (!existing) {
+      throw new Error(`No record found for id '${id}'`);
+    }
+    const result = await this.repository.update(String(id), data);
+    this.emit?.("patched", result, params);
+    return result;
+  }
+  /**
+   * Remove one or more records
+   */
+  async remove(id, params) {
+    if (id === null) {
+      if (!this.multi) {
+        throw new Error("Multi-remove is not enabled");
+      }
+      const query = this.getQuery(params);
+      let records = await this.repository.findAll();
+      records = this.filterData(records, query);
+      await Promise.all(records.map((record) => this.repository.delete(record[this.id])));
+      for (const record of records) {
+        this.emit?.("removed", record, params);
+      }
+      return records;
+    }
+    const existing = await this.get(id, params);
+    if (!existing) {
+      throw new Error(`No record found for id '${id}'`);
+    }
+    await this.repository.delete(String(id));
+    this.emit?.("removed", existing, params);
+    return existing;
+  }
+};
+
+// src/services/boards.ts
+var BoardsService = class extends DrizzleService {
+  boardRepo;
+  constructor(db) {
+    const boardRepo = new BoardRepository(db);
+    super(boardRepo, {
+      id: "board_id",
+      paginate: {
+        default: 50,
+        max: 100
+      }
+    });
+    this.boardRepo = boardRepo;
+  }
+  /**
+   * Custom method: Find board by slug
+   */
+  async findBySlug(slug, _params) {
+    return this.boardRepo.findBySlug(slug);
+  }
+  /**
+   * DEPRECATED: Add session to board
+   * Use board-objects service instead
+   */
+  async addSession(_id, _sessionId, _params) {
+    throw new Error("addSession is deprecated - use board-objects service");
+  }
+  /**
+   * DEPRECATED: Remove session from board
+   * Use board-objects service instead
+   */
+  async removeSession(_id, _sessionId, _params) {
+    throw new Error("removeSession is deprecated - use board-objects service");
+  }
+  /**
+   * Custom method: Atomically add or update a board object
+   */
+  async upsertBoardObject(boardId, objectId, objectData, _params) {
+    return this.boardRepo.upsertBoardObject(boardId, objectId, objectData);
+  }
+  /**
+   * Custom method: Atomically remove a board object
+   */
+  async removeBoardObject(boardId, objectId, _params) {
+    return this.boardRepo.removeBoardObject(boardId, objectId);
+  }
+  /**
+   * Custom method: Batch upsert board objects
+   */
+  async batchUpsertBoardObjects(boardId, objects, _params) {
+    return this.boardRepo.batchUpsertBoardObjects(boardId, objects);
+  }
+  /**
+   * Custom method: Delete a zone and handle associated sessions
+   */
+  async deleteZone(boardId, objectId, deleteAssociatedSessions, _params) {
+    return this.boardRepo.deleteZone(boardId, objectId, deleteAssociatedSessions);
+  }
+};
+function createBoardsService(db) {
+  return new BoardsService(db);
+}
+export {
+  BoardsService,
+  createBoardsService
+};

package/dist/daemon/services/config.d.ts

@@ -0,0 +1,35 @@
+import { AgorConfig } from '@agor/core/config';
+import { Params } from '@agor/core/types';
+
+/**
+ * Config Service
+ *
+ * Provides REST + WebSocket API for configuration management.
+ * Wraps @agor/core/config functions for UI access.
+ */
+
+/**
+ * Config service class
+ */
+declare class ConfigService {
+    /**
+     * Get full config (masked)
+     */
+    find(_params?: Params): Promise<AgorConfig>;
+    /**
+     * Get specific config section or value
+     */
+    get(id: string, _params?: Params): Promise<unknown>;
+    /**
+     * Update config values
+     *
+     * SECURITY: Only allow updating credentials section from UI
+     */
+    patch(_id: null, data: Partial<AgorConfig>, _params?: Params): Promise<AgorConfig>;
+}
+/**
+ * Service factory function
+ */
+declare function createConfigService(): ConfigService;
+
+export { ConfigService, createConfigService };

package/dist/daemon/services/config.js

@@ -0,0 +1,68 @@
+// src/services/config.ts
+import { loadConfig, saveConfig } from "@agor/core/config";
+function maskApiKey(key) {
+  if (!key || typeof key !== "string") return void 0;
+  if (key.length <= 10) return "***";
+  return `${key.substring(0, 10)}...`;
+}
+function maskCredentials(config) {
+  if (!config.credentials) return config;
+  return {
+    ...config,
+    credentials: {
+      ANTHROPIC_API_KEY: maskApiKey(config.credentials.ANTHROPIC_API_KEY),
+      OPENAI_API_KEY: maskApiKey(config.credentials.OPENAI_API_KEY),
+      GEMINI_API_KEY: maskApiKey(config.credentials.GEMINI_API_KEY),
+      CURSOR_API_KEY: maskApiKey(config.credentials.CURSOR_API_KEY)
+    }
+  };
+}
+var ConfigService = class {
+  /**
+   * Get full config (masked)
+   */
+  async find(_params) {
+    const config = await loadConfig();
+    return maskCredentials(config);
+  }
+  /**
+   * Get specific config section or value
+   */
+  async get(id, _params) {
+    const config = await loadConfig();
+    const masked = maskCredentials(config);
+    const parts = id.split(".");
+    let value = masked;
+    for (const part of parts) {
+      if (value && typeof value === "object" && part in value) {
+        value = value[part];
+      } else {
+        return void 0;
+      }
+    }
+    return value;
+  }
+  /**
+   * Update config values
+   *
+   * SECURITY: Only allow updating credentials section from UI
+   */
+  async patch(_id, data, _params) {
+    const config = await loadConfig();
+    if (data.credentials) {
+      config.credentials = {
+        ...config.credentials,
+        ...data.credentials
+      };
+    }
+    await saveConfig(config);
+    return maskCredentials(config);
+  }
+};
+function createConfigService() {
+  return new ConfigService();
+}
+export {
+  ConfigService,
+  createConfigService
+};

package/dist/daemon/services/context.d.ts

@@ -0,0 +1,55 @@
+import { WorktreeRepository } from '@agor/core/db';
+import { QueryParams, ServiceMethods, ContextFileListItem, ContextFileDetail, Id } from '@agor/core/types';
+
+/**
+ * Context Service
+ *
+ * Provides read-only REST + WebSocket API for browsing markdown files in worktree context/ directories.
+ * Does not use database - reads directly from filesystem.
+ *
+ * Configuration:
+ * - Scans context/ folder from worktree path when worktree_id is provided
+ * - Recursively finds all .md files in context/ and subdirectories
+ */
+
+/**
+ * Context service params (read-only, no create/update/delete)
+ */
+type ContextParams = QueryParams<{
+    worktree_id?: string;
+}>;
+/**
+ * Context service - read-only filesystem browser for worktree concept files
+ */
+declare class ContextService implements Pick<ServiceMethods<ContextFileListItem | ContextFileDetail>, 'find' | 'get' | 'setup' | 'teardown'> {
+    private worktreeRepo;
+    constructor(worktreeRepo: WorktreeRepository);
+    /**
+     * Find all markdown files (GET /context?worktree_id=xxx)
+     * Returns lightweight list items without content
+     */
+    find(params?: ContextParams): Promise<ContextFileListItem[]>;
+    /**
+     * Get specific markdown file (GET /context/:path?worktree_id=xxx)
+     * Returns full details with content
+     *
+     * @param id - Relative path from worktree root (e.g., "context/concepts/core.md", "CLAUDE.md")
+     */
+    get(id: Id, params?: ContextParams): Promise<ContextFileDetail>;
+    /**
+     * Recursively scan directory for markdown files
+     */
+    private scanDirectory;
+    /**
+     * Extract title from markdown content (first H1) or fallback to filename
+     */
+    private extractTitle;
+    setup(): Promise<void>;
+    teardown(): Promise<void>;
+}
+/**
+ * Service factory function
+ */
+declare function createContextService(worktreeRepo: WorktreeRepository): ContextService;
+
+export { type ContextParams, ContextService, createContextService };

package/dist/daemon/services/context.js

@@ -0,0 +1,113 @@
+// src/services/context.ts
+import { readdir, readFile, stat } from "fs/promises";
+import { join } from "path";
+var ContextService = class {
+  worktreeRepo;
+  constructor(worktreeRepo) {
+    this.worktreeRepo = worktreeRepo;
+  }
+  /**
+   * Find all markdown files (GET /context?worktree_id=xxx)
+   * Returns lightweight list items without content
+   */
+  async find(params) {
+    const worktreeId = params?.query?.worktree_id;
+    if (!worktreeId) {
+      throw new Error("worktree_id query parameter is required");
+    }
+    const worktree = await this.worktreeRepo.findById(worktreeId);
+    if (!worktree) {
+      throw new Error(`Worktree not found: ${worktreeId}`);
+    }
+    console.log("[Context Service] Worktree:", {
+      worktree_id: worktree.worktree_id,
+      name: worktree.name,
+      path: worktree.path
+    });
+    const files = [];
+    await this.scanDirectory(worktree.path, "context", files);
+    console.log("[Context Service] Found files:", files.length);
+    return files;
+  }
+  /**
+   * Get specific markdown file (GET /context/:path?worktree_id=xxx)
+   * Returns full details with content
+   *
+   * @param id - Relative path from worktree root (e.g., "context/concepts/core.md", "CLAUDE.md")
+   */
+  async get(id, params) {
+    const worktreeId = params?.query?.worktree_id;
+    if (!worktreeId) {
+      throw new Error("worktree_id query parameter is required");
+    }
+    const worktree = await this.worktreeRepo.findById(worktreeId);
+    if (!worktree) {
+      throw new Error(`Worktree not found: ${worktreeId}`);
+    }
+    const relativePath = id.toString();
+    const fullPath = join(worktree.path, relativePath);
+    try {
+      const content = await readFile(fullPath, "utf-8");
+      const stats = await stat(fullPath);
+      const title = this.extractTitle(content, relativePath);
+      return {
+        path: relativePath,
+        title,
+        size: stats.size,
+        lastModified: stats.mtime.toISOString(),
+        content
+      };
+    } catch (error) {
+      throw new Error(`Failed to read context file: ${error}`);
+    }
+  }
+  /**
+   * Recursively scan directory for markdown files
+   */
+  async scanDirectory(basePath, relativePath, files) {
+    const dirPath = join(basePath, relativePath);
+    try {
+      const entries = await readdir(dirPath, { withFileTypes: true });
+      for (const entry of entries) {
+        const entryRelPath = relativePath ? join(relativePath, entry.name) : entry.name;
+        if (entry.isDirectory()) {
+          await this.scanDirectory(basePath, entryRelPath, files);
+        } else if (entry.isFile() && entry.name.endsWith(".md")) {
+          const fullPath = join(dirPath, entry.name);
+          const stats = await stat(fullPath);
+          const content = await readFile(fullPath, "utf-8");
+          const title = this.extractTitle(content, entryRelPath);
+          files.push({
+            path: entryRelPath,
+            title,
+            size: stats.size,
+            lastModified: stats.mtime.toISOString()
+          });
+        }
+      }
+    } catch (_error) {
+    }
+  }
+  /**
+   * Extract title from markdown content (first H1) or fallback to filename
+   */
+  extractTitle(content, relativePath) {
+    const h1Match = content.match(/^#\s+(.+)$/m);
+    if (h1Match) {
+      return h1Match[1].trim();
+    }
+    const filename = relativePath.split("/").pop() || relativePath;
+    return filename.replace(/\.md$/, "");
+  }
+  async setup() {
+  }
+  async teardown() {
+  }
+};
+function createContextService(worktreeRepo) {
+  return new ContextService(worktreeRepo);
+}
+export {
+  ContextService,
+  createContextService
+};

package/dist/daemon/services/health-monitor.d.ts

@@ -0,0 +1,58 @@
+import * as _agor_core from '@agor/core';
+import { Application } from '@agor/core/feathers';
+
+/**
+ * Health Monitor - Singleton service for periodic health checks
+ */
+declare class HealthMonitor {
+    private app;
+    private intervals;
+    private isShuttingDown;
+    constructor(app: Application);
+    /**
+     * Set up WebSocket listeners for worktree changes
+     */
+    private setupWorktreeListeners;
+    /**
+     * Handle worktree state changes
+     */
+    private handleWorktreeUpdate;
+    /**
+     * Start monitoring a worktree's health
+     */
+    private startMonitoring;
+    /**
+     * Stop monitoring a worktree's health
+     */
+    private stopMonitoring;
+    /**
+     * Perform health check for a specific worktree
+     */
+    private checkHealth;
+    /**
+     * Initialize monitoring for all currently running worktrees
+     *
+     * Called on daemon startup to resume monitoring existing environments
+     */
+    initialize(): Promise<void>;
+    /**
+     * Cleanup all monitoring intervals
+     *
+     * Called on daemon shutdown
+     */
+    cleanup(): void;
+    /**
+     * Get monitoring status (for debugging)
+     */
+    getStatus(): {
+        isShuttingDown: boolean;
+        monitoredWorktrees: _agor_core.UUID[];
+        monitoringCount: number;
+    };
+}
+/**
+ * Create and initialize Health Monitor service
+ */
+declare function createHealthMonitor(app: Application): Promise<HealthMonitor>;
+
+export { HealthMonitor, createHealthMonitor };