Skip to content

armgit / qm

Public Imported from GitHub
0

Multiplayer agent harness for work.

6.4 KB
Raw Blame
import type { DerivedOAuthAuth, Keychain } from "../credentials/keychain.ts";
import type { ModelProvider } from "./pi-models.ts";

type UserCredentialKind = "apikey" | "oauth";

export interface UserOAuthTokens {
  accessToken: string;
  refreshToken?: string;
  idToken?: string;
  accountId?: string;
  expiresAt?: number;
}

/** Connection summary. Never carries token material. */
export interface UserModelCredential {
  provider: ModelProvider;
  kind: UserCredentialKind;
  apiKey?: string;
  oauth?: { accountId?: string; expiresAt?: number; needsReconnect?: boolean };
  updatedAt: number;
}

interface UserCredentialConnection {
  provider: ModelProvider;
  kind: UserCredentialKind;
}

export interface UserModelCredentialStore {
  get(userId: string, provider: ModelProvider): Promise<UserModelCredential | null>;
  connections(userId: string): Promise<UserCredentialConnection[]>;
  setApiKey(userId: string, provider: ModelProvider, apiKey: string): Promise<void>;
  setOAuth(userId: string, provider: ModelProvider, tokens: UserOAuthTokens): Promise<void>;
  /**
   * Fresh derived material for the user's subscription login (access + id
   * token + account id) — refreshed inside the keychain (single-flight, CAS)
   * when stale. The refresh token never leaves the keychain record.
   */
  derivedOAuth(userId: string, provider: ModelProvider): Promise<DerivedOAuthAuth | null>;
  delete(userId: string, provider: ModelProvider): Promise<void>;
}

const PROVIDERS: ModelProvider[] = ["anthropic", "openai"];
const ORIGIN = "individual-model-auth";
/**
 * OAuth logins are keyed by the provider's auth host, so the keychain's own
 * connector-token machinery (encryption, expiry margin, single-flight refresh
 * via the wired refresh dispatch) covers them with no parallel implementation.
 */
const AI_OAUTH_HOSTS: Record<"anthropic" | "openai", string> = {
  anthropic: "claude.ai",
  openai: "auth.openai.com",
};
/** Segregates AI subscription logins from any other connector use of the same host. */
const AI_ACCOUNT_TYPE = "individual-model";

function serviceFor(provider: ModelProvider): string {
  return `model-${provider}`;
}

function oauthHostFor(provider: ModelProvider): string | null {
  return provider === "anthropic" || provider === "openai" ? AI_OAUTH_HOSTS[provider] : null;
}

/**
 * Per-user AI-account custody, backed by the org keychain — NOT a parallel
 * secret store.
 *
 * - Subscription (OAuth) logins are keychain connector tokens: the keychain
 *   encrypts them, tracks expiry, and refreshes them centrally; callers only
 *   ever receive derived material without the refresh token.
 * - API keys are ordinary keychain credentials owned by the user (service
 *   `model-<provider>`, origin `individual-model-auth`), so admin visibility
 *   and "remove my credentials" apply.
 */
export function createUserModelCredentialStore(input: { keychain: Keychain }): UserModelCredentialStore {
  const { keychain } = input;

  async function findApiKey(userId: string, provider: ModelProvider) {
    const all = await keychain.listByOwner(userId);
    return all.find((c) => c.service === serviceFor(provider) && c.origin === ORIGIN) ?? null;
  }

  async function oauthCredential(userId: string, provider: ModelProvider): Promise<UserModelCredential | null> {
    const host = oauthHostFor(provider);
    if (!host) return null;
    const status = await keychain.connectorTokenStatus(host, userId, AI_ACCOUNT_TYPE);
    if (!status.connected) return null;
    return {
      provider,
      kind: "oauth",
      oauth: {
        ...(status.expiresAt !== undefined ? { expiresAt: status.expiresAt } : {}),
        ...(status.needsReconnect ? { needsReconnect: true } : {}),
      },
      updatedAt: 0,
    };
  }

  async function apiKeyCredential(userId: string, provider: ModelProvider): Promise<UserModelCredential | null> {
    const meta = await findApiKey(userId, provider);
    if (!meta) return null;
    const apiKey = await keychain.readOwnSecret(userId, meta.id);
    if (!apiKey) return null;
    return { provider, kind: "apikey", apiKey, updatedAt: meta.updatedAt };
  }

  return {
    async get(userId, provider) {
      return (await oauthCredential(userId, provider)) ?? (await apiKeyCredential(userId, provider));
    },

    async connections(userId) {
      const found: UserCredentialConnection[] = [];
      for (const provider of PROVIDERS) {
        const cred = (await oauthCredential(userId, provider)) ?? (await apiKeyCredential(userId, provider));
        if (cred) found.push({ provider, kind: cred.kind });
      }
      return found;
    },

    async setApiKey(userId, provider, apiKey) {
      const secret = apiKey.trim();
      if (!secret) throw new Error("API key is required");
      // One connection per provider: an API key replaces a subscription login.
      const host = oauthHostFor(provider);
      if (host) await keychain.deleteConnectorToken(host, userId, AI_ACCOUNT_TYPE);
      await keychain.save({ ownerId: userId, service: serviceFor(provider), secret, origin: ORIGIN });
    },

    async setOAuth(userId, provider, tokens) {
      if (!tokens.accessToken?.trim()) throw new Error("access token is required");
      const host = oauthHostFor(provider);
      if (!host) throw new Error(`no subscription login host for provider ${provider}`);
      await keychain.setConnectorToken(
        host,
        userId,
        {
          accessToken: tokens.accessToken,
          ...(tokens.refreshToken ? { refreshToken: tokens.refreshToken } : {}),
          ...(tokens.idToken ? { idToken: tokens.idToken } : {}),
          ...(tokens.accountId ? { accountId: tokens.accountId } : {}),
          ...(tokens.expiresAt !== undefined ? { expiresAt: tokens.expiresAt } : {}),
        },
        AI_ACCOUNT_TYPE,
      );
      // One connection per provider: a subscription login replaces an API key.
      const apiKeyMeta = await findApiKey(userId, provider);
      if (apiKeyMeta) await keychain.remove(userId, apiKeyMeta.id);
    },

    async derivedOAuth(userId, provider) {
      const host = oauthHostFor(provider);
      if (!host) return null;
      return keychain.connectorDerivedAuth(host, userId, AI_ACCOUNT_TYPE);
    },

    async delete(userId, provider) {
      const host = oauthHostFor(provider);
      if (host) await keychain.deleteConnectorToken(host, userId, AI_ACCOUNT_TYPE);
      const meta = await findApiKey(userId, provider);
      if (meta) await keychain.remove(userId, meta.id);
    },
  };
}