agor-live 0.3.7

package/dist/daemon/services/users.js

@@ -0,0 +1,177 @@
+// src/services/users.ts
+import { generateId } from "@agor/core";
+import { compare, eq, hash, users } from "@agor/core/db";
+var UsersService = class {
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * Find all users (supports filtering by email for authentication)
+   */
+  async find(params) {
+    const email = params?.query?.email;
+    const includePassword = !!email;
+    let rows;
+    if (email) {
+      const row = await this.db.select().from(users).where(eq(users.email, email)).get();
+      rows = row ? [row] : [];
+    } else {
+      rows = await this.db.select().from(users).all();
+    }
+    const results = rows.map((row) => this.rowToUser(row, includePassword));
+    return {
+      total: results.length,
+      limit: results.length,
+      skip: 0,
+      data: results
+    };
+  }
+  /**
+   * Get user by ID
+   */
+  async get(id, _params) {
+    const row = await this.db.select().from(users).where(eq(users.user_id, id)).get();
+    if (!row) {
+      throw new Error(`User not found: ${id}`);
+    }
+    return this.rowToUser(row);
+  }
+  /**
+   * Create new user
+   */
+  async create(data, _params) {
+    const existing = await this.db.select().from(users).where(eq(users.email, data.email)).get();
+    if (existing) {
+      throw new Error(`User with email ${data.email} already exists`);
+    }
+    const hashedPassword = await hash(data.password, 10);
+    const now = /* @__PURE__ */ new Date();
+    const user_id = generateId();
+    const role = data.role || "member";
+    const defaultEmoji = role === "admin" ? "\u2B50" : "\u{1F464}";
+    const row = await this.db.insert(users).values({
+      user_id,
+      email: data.email,
+      password: hashedPassword,
+      name: data.name,
+      emoji: data.emoji || defaultEmoji,
+      role,
+      created_at: now,
+      updated_at: now,
+      data: {
+        preferences: {}
+      }
+    }).returning().get();
+    return this.rowToUser(row);
+  }
+  /**
+   * Update user
+   */
+  async patch(id, data, _params) {
+    const now = /* @__PURE__ */ new Date();
+    const updates = { updated_at: now };
+    if (data.password) {
+      updates.password = await hash(data.password, 10);
+    }
+    if (data.email) updates.email = data.email;
+    if (data.name) updates.name = data.name;
+    if (data.emoji !== void 0) updates.emoji = data.emoji;
+    if (data.role) updates.role = data.role;
+    if (data.onboarding_completed !== void 0)
+      updates.onboarding_completed = data.onboarding_completed;
+    if (data.avatar || data.preferences) {
+      const current = await this.get(id);
+      updates.data = {
+        avatar: data.avatar ?? current.avatar,
+        preferences: data.preferences ?? current.preferences
+      };
+    }
+    const row = await this.db.update(users).set(updates).where(eq(users.user_id, id)).returning().get();
+    if (!row) {
+      throw new Error(`User not found: ${id}`);
+    }
+    return this.rowToUser(row);
+  }
+  /**
+   * Delete user
+   */
+  async remove(id, _params) {
+    const user = await this.get(id);
+    await this.db.delete(users).where(eq(users.user_id, id)).run();
+    return user;
+  }
+  /**
+   * Find user by email (for authentication)
+   */
+  async findByEmail(email) {
+    const row = await this.db.select().from(users).where(eq(users.email, email)).get();
+    return row ? this.rowToUser(row) : null;
+  }
+  /**
+   * Verify password
+   */
+  async verifyPassword(user, password) {
+    const row = await this.db.select().from(users).where(eq(users.user_id, user.user_id)).get();
+    if (!row) return false;
+    return compare(password, row.password);
+  }
+  /**
+   * Convert database row to User type
+   *
+   * @param row - Database row
+   * @param includePassword - Include password field (for authentication only)
+   */
+  rowToUser(row, includePassword = false) {
+    const data = row.data;
+    const user = {
+      user_id: row.user_id,
+      email: row.email,
+      name: row.name ?? void 0,
+      emoji: row.emoji ?? void 0,
+      role: row.role,
+      avatar: data.avatar,
+      preferences: data.preferences,
+      onboarding_completed: !!row.onboarding_completed,
+      created_at: row.created_at,
+      updated_at: row.updated_at ?? void 0
+    };
+    if (includePassword) {
+      user.password = row.password;
+    }
+    return user;
+  }
+};
+var UsersServiceWithAuth = class extends UsersService {
+  /**
+   * Override get to include password for authentication
+   * (FeathersJS LocalStrategy needs this)
+   */
+  async getWithPassword(id) {
+    const row = await this.db.select().from(users).where(eq(users.user_id, id)).get();
+    if (!row) {
+      throw new Error(`User not found: ${id}`);
+    }
+    const data = row.data;
+    return {
+      user_id: row.user_id,
+      email: row.email,
+      password: row.password,
+      // Include for authentication
+      name: row.name ?? void 0,
+      emoji: row.emoji ?? void 0,
+      role: row.role,
+      avatar: data.avatar,
+      preferences: data.preferences,
+      onboarding_completed: !!row.onboarding_completed,
+      created_at: row.created_at,
+      updated_at: row.updated_at ?? void 0
+    };
+  }
+};
+function createUsersService(db) {
+  return new UsersServiceWithAuth(db);
+}
+export {
+  UsersService,
+  createUsersService
+};

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

@@ -0,0 +1,98 @@
+import * as _agor_core from '@agor/core';
+import { Database } from '@agor/core/db';
+import { Application } from '@agor/core/feathers';
+import { QueryParams, UUID, Worktree, WorktreeID } from '@agor/core/types';
+import { DrizzleService } from '../adapters/drizzle.js';
+
+/**
+ * Worktree service params
+ */
+type WorktreeParams = QueryParams<{
+    repo_id?: UUID;
+    name?: string;
+    ref?: string;
+    deleteFromFilesystem?: boolean;
+}>;
+/**
+ * Extended worktrees service with custom methods
+ */
+declare class WorktreesService extends DrizzleService<Worktree, Partial<Worktree>, WorktreeParams> {
+    private worktreeRepo;
+    private app;
+    private processes;
+    constructor(db: Database, app: Application);
+    /**
+     * Override patch to handle board_objects when board_id changes
+     */
+    patch(id: WorktreeID, data: Partial<Worktree>, params?: WorktreeParams): Promise<Worktree>;
+    /**
+     * Override find to support repo_id filter
+     */
+    find(params?: WorktreeParams): Promise<Worktree[] | _agor_core.Paginated<Worktree>>;
+    /**
+     * Override remove to support filesystem deletion
+     */
+    remove(id: WorktreeID, params?: WorktreeParams): Promise<Worktree>;
+    /**
+     * Custom method: Find worktree by repo_id and name
+     */
+    findByRepoAndName(repoId: UUID, name: string, _params?: WorktreeParams): Promise<Worktree | null>;
+    /**
+     * Custom method: Add session to worktree
+     */
+    addSession(id: WorktreeID, sessionId: UUID, params?: WorktreeParams): Promise<Worktree>;
+    /**
+     * Custom method: Remove session from worktree
+     */
+    removeSession(id: WorktreeID, sessionId: UUID, params?: WorktreeParams): Promise<Worktree>;
+    /**
+     * Custom method: Add worktree to board
+     *
+     * Phase 0: Sets board_id on worktree
+     * Phase 1: Will also create board_object entry for positioning
+     */
+    addToBoard(id: WorktreeID, boardId: UUID, params?: WorktreeParams): Promise<Worktree>;
+    /**
+     * Custom method: Remove worktree from board
+     *
+     * Phase 0: Clears board_id on worktree
+     * Phase 1: Will also remove board_object entry
+     */
+    removeFromBoard(id: WorktreeID, params?: WorktreeParams): Promise<Worktree>;
+    /**
+     * Custom method: Update environment status
+     */
+    updateEnvironment(id: WorktreeID, environmentUpdate: Partial<Worktree['environment_instance']>, params?: WorktreeParams): Promise<Worktree>;
+    /**
+     * Custom method: Start environment
+     */
+    startEnvironment(id: WorktreeID, params?: WorktreeParams): Promise<Worktree>;
+    /**
+     * Custom method: Stop environment
+     */
+    stopEnvironment(id: WorktreeID, params?: WorktreeParams): Promise<Worktree>;
+    /**
+     * Custom method: Restart environment
+     */
+    restartEnvironment(id: WorktreeID, params?: WorktreeParams): Promise<Worktree>;
+    /**
+     * Custom method: Check health
+     */
+    checkHealth(id: WorktreeID, params?: WorktreeParams): Promise<Worktree>;
+    /**
+     * Custom method: Recompute access URLs for a running environment
+     *
+     * Called when repo environment_config is updated to refresh URLs without restart
+     */
+    recomputeAccessUrls(id: WorktreeID, params?: WorktreeParams): Promise<Worktree>;
+    /**
+     * Build template context for Handlebars rendering
+     */
+    private buildTemplateContext;
+}
+/**
+ * Service factory function
+ */
+declare function createWorktreesService(db: Database, app: Application): WorktreesService;
+
+export { type WorktreeParams, WorktreesService, createWorktreesService };