Skip to content

Open-source AI coworkers that each get a computer of their own: a browser, files and tools, with every action decided before it happens and recorded after. Bring any AG-UI agent.

6.7 KB
Raw Blame
import { randomUUID } from "node:crypto";
import { and, asc, desc, eq, inArray, sql } from "drizzle-orm";
import type { Database } from "../db/client";
import { savedLogins, signInRequests } from "../db/schema/passwords";
import type {
  PasswordStore,
  SavedLoginRecord,
  SignInRequestRecord,
} from "./types";

function requestRow(
  row: typeof signInRequests.$inferSelect,
): SignInRequestRecord {
  return {
    ...row,
    continuation: (row.continuation as Record<string, unknown> | null) ?? null,
  };
}

/** The Postgres store. Every read and write is scoped by the owner, so a request id alone is nothing. */
export function createPasswordStore(database: Database): PasswordStore {
  return {
    async createRequest(input) {
      const [row] = await database
        .insert(signInRequests)
        .values({
          ...input,
          continuation: input.continuation ?? null,
          status: "pending",
        })
        .returning();
      if (!row) throw new Error("The sign-in request was not recorded.");
      return requestRow(row);
    },
    async request(ownerUserId, id) {
      const [row] = await database
        .select()
        .from(signInRequests)
        .where(
          and(
            eq(signInRequests.ownerUserId, ownerUserId),
            eq(signInRequests.id, id),
          ),
        )
        .limit(1);
      return row ? requestRow(row) : null;
    },
    async pendingRequests(ownerUserId) {
      const rows = await database
        .select()
        .from(signInRequests)
        .where(
          and(
            eq(signInRequests.ownerUserId, ownerUserId),
            inArray(signInRequests.status, [
              "pending",
              "code_required",
              "taken_over",
            ]),
            sql`${signInRequests.expiresAt} > now()`,
          ),
        )
        .orderBy(desc(signInRequests.createdAt))
        .limit(50);
      return rows.map(requestRow);
    },
    async transition(ownerUserId, id, from, to) {
      const [row] = await database
        .update(signInRequests)
        .set(to)
        .where(
          and(
            eq(signInRequests.ownerUserId, ownerUserId),
            eq(signInRequests.id, id),
            inArray(signInRequests.status, [...from]),
          ),
        )
        .returning();
      return row ? requestRow(row) : null;
    },
    async logins(ownerUserId, origin) {
      return database
        .select()
        .from(savedLogins)
        .where(
          and(
            eq(savedLogins.ownerUserId, ownerUserId),
            ...(origin ? [eq(savedLogins.origin, origin)] : []),
          ),
        )
        .orderBy(asc(savedLogins.origin), asc(savedLogins.username));
    },
    async login(ownerUserId, id) {
      const [row] = await database
        .select()
        .from(savedLogins)
        .where(
          and(eq(savedLogins.ownerUserId, ownerUserId), eq(savedLogins.id, id)),
        )
        .limit(1);
      return row ?? null;
    },
    async saveLogin(input) {
      const now = new Date();
      const [row] = await database
        .insert(savedLogins)
        .values({ id: randomUUID(), ...input })
        .onConflictDoUpdate({
          target: [
            savedLogins.ownerUserId,
            savedLogins.origin,
            savedLogins.username,
          ],
          set: { encryptedPassword: input.encryptedPassword, updatedAt: now },
        })
        .returning();
      if (!row) throw new Error("The login was not saved.");
      return row;
    },
    async touchLogin(ownerUserId, id) {
      await database
        .update(savedLogins)
        .set({ lastUsedAt: new Date() })
        .where(
          and(eq(savedLogins.ownerUserId, ownerUserId), eq(savedLogins.id, id)),
        );
    },
    async deleteLogin(ownerUserId, id) {
      const rows = await database
        .delete(savedLogins)
        .where(
          and(eq(savedLogins.ownerUserId, ownerUserId), eq(savedLogins.id, id)),
        )
        .returning({ id: savedLogins.id });
      return rows.length > 0;
    },
  };
}

/** The same contract in memory, for tests and for a deployment wired without a database. */
export function createMemoryPasswordStore(): PasswordStore & {
  requests: Map<string, SignInRequestRecord>;
  saved: Map<string, SavedLoginRecord>;
} {
  const requests = new Map<string, SignInRequestRecord>();
  const saved = new Map<string, SavedLoginRecord>();
  return {
    requests,
    saved,
    async createRequest(input) {
      const record: SignInRequestRecord = {
        ...input,
        status: "pending",
        method: null,
        outcome: null,
        controlRequestId: null,
        createdAt: new Date(),
        resolvedAt: null,
        fillingUntil: null,
      };
      requests.set(record.id, record);
      return { ...record };
    },
    async request(ownerUserId, id) {
      const row = requests.get(id);
      return row && row.ownerUserId === ownerUserId ? { ...row } : null;
    },
    async pendingRequests(ownerUserId) {
      return [...requests.values()].filter(
        (row) =>
          row.ownerUserId === ownerUserId &&
          ["pending", "code_required", "taken_over"].includes(row.status) &&
          row.expiresAt > new Date(),
      );
    },
    async transition(ownerUserId, id, from, to) {
      const row = requests.get(id);
      if (!row || row.ownerUserId !== ownerUserId || !from.includes(row.status))
        return null;
      Object.assign(row, to);
      return { ...row };
    },
    async logins(ownerUserId, origin) {
      return [...saved.values()].filter(
        (row) =>
          row.ownerUserId === ownerUserId && (!origin || row.origin === origin),
      );
    },
    async login(ownerUserId, id) {
      const row = saved.get(id);
      return row && row.ownerUserId === ownerUserId ? { ...row } : null;
    },
    async saveLogin(input) {
      const existing = [...saved.values()].find(
        (row) =>
          row.ownerUserId === input.ownerUserId &&
          row.origin === input.origin &&
          row.username === input.username,
      );
      if (existing) {
        existing.encryptedPassword = input.encryptedPassword;
        existing.updatedAt = new Date();
        return { ...existing };
      }
      const record: SavedLoginRecord = {
        id: randomUUID(),
        ...input,
        createdAt: new Date(),
        updatedAt: new Date(),
        lastUsedAt: null,
      };
      saved.set(record.id, record);
      return { ...record };
    },
    async touchLogin(ownerUserId, id) {
      const row = saved.get(id);
      if (row && row.ownerUserId === ownerUserId) row.lastUsedAt = new Date();
    },
    async deleteLogin(ownerUserId, id) {
      const row = saved.get(id);
      if (!row || row.ownerUserId !== ownerUserId) return false;
      saved.delete(id);
      return true;
    },
  };
}