agor-live 0.3.7

package/dist/daemon/adapters/drizzle.d.ts

@@ -0,0 +1,114 @@
+import { Params, Paginated, Id, NullableId } from '@agor/core/types';
+
+/**
+ * Custom Drizzle Adapter for FeathersJS
+ *
+ * Lightweight adapter that bridges FeathersJS service interface with Drizzle ORM.
+ * Uses the repository pattern from @agor/core/db for type-safe database operations.
+ */
+
+/**
+ * Query operators supported by the adapter
+ */
+interface Query {
+    $limit?: number;
+    $skip?: number;
+    $sort?: Record<string, 1 | -1>;
+    $select?: string[];
+    [key: string]: any;
+}
+/**
+ * Pagination configuration
+ */
+interface PaginationOptions {
+    default?: number;
+    max?: number;
+}
+/**
+ * Adapter options
+ */
+interface DrizzleAdapterOptions {
+    /**
+     * Name of the ID field (default: 'id')
+     */
+    id?: string;
+    /**
+     * Pagination configuration
+     */
+    paginate?: PaginationOptions;
+    /**
+     * Allow multi-record operations (patch/remove without ID)
+     */
+    multi?: boolean | string[];
+}
+/**
+ * Repository interface that the adapter expects
+ */
+interface Repository<T> {
+    create(data: Partial<T>): Promise<T>;
+    findById(id: string): Promise<T | null>;
+    findAll(): Promise<T[]>;
+    update(id: string, updates: Partial<T>): Promise<T>;
+    delete(id: string): Promise<void>;
+    count?(): Promise<number>;
+}
+/**
+ * Drizzle Service Adapter
+ *
+ * Implements FeathersJS service methods using a Drizzle repository.
+ * Emits events for real-time WebSocket broadcasting.
+ */
+declare class DrizzleService<T = any, D = Partial<T>, P extends Params = Params> {
+    private repository;
+    id: string;
+    paginate?: PaginationOptions;
+    multi: boolean | string[];
+    emit?: (event: string, ...args: any[]) => boolean;
+    constructor(repository: Repository<T>, options?: DrizzleAdapterOptions);
+    /**
+     * Extract query parameters from params
+     */
+    private getQuery;
+    /**
+     * Apply filters to data array (client-side filtering)
+     */
+    private filterData;
+    /**
+     * Sort data array
+     */
+    private sortData;
+    /**
+     * Select specific fields from data
+     */
+    private selectFields;
+    /**
+     * Apply pagination to data
+     */
+    private paginateData;
+    /**
+     * Find records
+     */
+    find(params?: P): Promise<Paginated<T> | T[]>;
+    /**
+     * Get a single record by ID
+     */
+    get(id: Id, _params?: P): Promise<T>;
+    /**
+     * Create one or more records
+     */
+    create(data: D | D[], params?: P): Promise<T | T[]>;
+    /**
+     * Update a record (complete replacement)
+     */
+    update(id: Id, data: D, params?: P): Promise<T>;
+    /**
+     * Patch a record (partial update)
+     */
+    patch(id: NullableId, data: D, params?: P): Promise<T | T[]>;
+    /**
+     * Remove one or more records
+     */
+    remove(id: NullableId, params?: P): Promise<T | T[]>;
+}
+
+export { type DrizzleAdapterOptions, DrizzleService, type PaginationOptions, type Query, type Repository };

package/dist/daemon/adapters/drizzle.js

@@ -0,0 +1,219 @@
+// 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;
+  }
+};
+export {
+  DrizzleService
+};

package/dist/daemon/declarations.d.ts

@@ -0,0 +1,101 @@
+import { ExpressApplication, Service } from '@agor/core/feathers';
+import { AuthenticatedUser as AuthenticatedUser$1, AuthenticatedParams as AuthenticatedParams$1, CreateHookContext as CreateHookContext$1, HookContext as HookContext$1, Session, Params, Task, Repo, Board, Message, Worktree, WorktreeID } from '@agor/core/types';
+
+/**
+ * FeathersJS Type Declarations for Agor Daemon
+ *
+ * Provides proper TypeScript types for:
+ * - Hook contexts with authentication
+ * - Service implementations with custom methods
+ * - Application instance
+ */
+
+type AuthenticatedUser = AuthenticatedUser$1;
+type AuthenticatedParams = AuthenticatedParams$1;
+type CreateHookContext<T = unknown> = CreateHookContext$1<T>;
+type HookContext<T = unknown> = HookContext$1<T>;
+/**
+ * Application type for the daemon
+ */
+type Application = ExpressApplication;
+/**
+ * Sessions service with custom methods (server-side implementation)
+ * This matches the SessionRepository methods exposed via the service adapter
+ */
+interface SessionsServiceImpl extends Service<Session, Partial<Session>, Params> {
+    fork(id: string, data: {
+        prompt: string;
+        task_id?: string;
+    }, params?: Params): Promise<Session>;
+    spawn(id: string, data: {
+        prompt: string;
+        title?: string;
+        agentic_tool?: Session['agentic_tool'];
+        task_id?: string;
+    }, params?: Params): Promise<Session>;
+    getGenealogy(id: string, params?: Params): Promise<unknown>;
+    on(event: string, handler: (...args: any[]) => void): this;
+    removeListener(event: string, handler: (...args: any[]) => void): this;
+}
+/**
+ * Tasks service with custom methods (server-side implementation)
+ */
+interface TasksServiceImpl extends Service<Task, Partial<Task>, Params> {
+    createMany(data: Array<Partial<Task>>): Promise<Task[]>;
+    complete(id: string, data: {
+        git_state?: {
+            sha_at_end?: string;
+            commit_message?: string;
+        };
+    }, params?: Params): Promise<Task>;
+    fail(id: string, data: {
+        error?: string;
+    }, params?: Params): Promise<Task>;
+}
+/**
+ * Repos service with custom methods (server-side implementation)
+ */
+interface ReposServiceImpl extends Service<Repo, Partial<Repo>, Params> {
+    cloneRepository(data: {
+        url: string;
+        name?: string;
+        destination?: string;
+    }, params?: Params): Promise<Repo>;
+    createWorktree(id: string, data: {
+        name: string;
+        ref: string;
+        createBranch?: boolean;
+    }, params?: Params): Promise<Repo>;
+    removeWorktree(id: string, name: string, params?: Params): Promise<Repo>;
+}
+/**
+ * Boards service with custom methods (server-side implementation)
+ */
+interface BoardsServiceImpl extends Service<Board, Partial<Board>, Params> {
+    addSession(boardId: string, sessionId: string, params?: Params): Promise<Board>;
+    removeSession(boardId: string, sessionId: string, params?: Params): Promise<Board>;
+    upsertBoardObject(boardId: string, objectId: string, objectData: unknown, params?: Params): Promise<Board>;
+    removeBoardObject(boardId: string, objectId: string, params?: Params): Promise<Board>;
+    batchUpsertBoardObjects(boardId: string, objects: unknown[], params?: Params): Promise<Board>;
+    deleteZone(boardId: string, zoneId: string, deleteAssociatedSessions: boolean, params?: Params): Promise<{
+        board: Board;
+        affectedSessions: string[];
+    }>;
+}
+/**
+ * Messages service with custom methods (server-side implementation)
+ */
+interface MessagesServiceImpl extends Service<Message, Partial<Message>, Params> {
+    createMany(data: Array<Partial<Message>>): Promise<Message[]>;
+}
+/**
+ * Worktrees service with custom methods (server-side implementation)
+ */
+interface WorktreesServiceImpl extends Service<Worktree, Partial<Worktree>, Params> {
+    startEnvironment(id: WorktreeID, params?: Params): Promise<Worktree>;
+    stopEnvironment(id: WorktreeID, params?: Params): Promise<Worktree>;
+    restartEnvironment(id: WorktreeID, params?: Params): Promise<Worktree>;
+    checkHealth(id: WorktreeID, params?: Params): Promise<Worktree>;
+}
+
+export type { Application, AuthenticatedParams, AuthenticatedUser, BoardsServiceImpl, CreateHookContext, HookContext, MessagesServiceImpl, ReposServiceImpl, SessionsServiceImpl, TasksServiceImpl, WorktreesServiceImpl };

package/dist/daemon/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }