Multiplayer agent harness for work.
import type { ModelProvider } from "../../model/pi-models.ts";
import { completeClaudeLogin, startClaudeLogin } from "../../model/subscription-oauth.ts";
import { createCodexDeviceLogin } from "../../model/codex-device-login.ts";
import { errMessage } from "../../util/errors.ts";
import { sendJson } from "../http.ts";
import { validateProviderApiKey } from "./admin/model-providers.ts";
import { withActor, type ApiCtx, type Route } from "./route.ts";
import { audit } from "./shared.ts";
function caller(ctx: ApiCtx): string | null {
return ctx.actor?.p ?? null;
}
function bodyObj(ctx: ApiCtx): Record<string, unknown> {
return typeof ctx.body === "object" && ctx.body !== null ? (ctx.body as Record<string, unknown>) : {};
}
function connectProvider(raw: unknown): ModelProvider | null {
if (raw === "anthropic" || raw === "claude") return "anthropic";
if (raw === "openai" || raw === "chatgpt" || raw === "codex") return "openai";
return null;
}
async function getStatus(ctx: ApiCtx): Promise<void> {
const principal = caller(ctx);
if (!principal) return sendJson(ctx.res, 401, { error: "unauthorized" });
const required = (await ctx.deps.config?.getIndividualModelAuthDurable()) ?? false;
const connections = (await ctx.deps.userModelCredentials?.connections(principal)) ?? [];
const individualModelAuth = (await ctx.deps.config?.getIndividualModelAuthDurable(principal)) ?? false;
const account = (await ctx.deps.config?.getModelAccountDurable(principal)) ?? "company";
return sendJson(ctx.res, 200, { individualModelAuth, required, account, connections });
}
async function setAccount(ctx: ApiCtx): Promise<void> {
const principal = caller(ctx);
if (!principal) return sendJson(ctx.res, 401, { error: "unauthorized" });
if (!ctx.deps.config || !ctx.deps.userModelCredentials) return sendJson(ctx.res, 404, { error: "not_found" });
const account = bodyObj(ctx).account;
if (account !== "personal" && account !== "company") return sendJson(ctx.res, 400, { error: "bad_request" });
if (account === "company" && (await ctx.deps.config.getIndividualModelAuthDurable())) {
return sendJson(ctx.res, 403, { error: "Your organization requires a personal AI account." });
}
if (account === "personal" && !(await ctx.deps.userModelCredentials.connections(principal)).length) {
return sendJson(ctx.res, 409, { error: "Connect an AI account first." });
}
const provider = bodyObj(ctx).provider;
if (provider !== undefined && provider !== "anthropic" && provider !== "openai")
return sendJson(ctx.res, 400, { error: "bad_request" });
if (
account === "personal" &&
provider &&
!(await ctx.deps.userModelCredentials.connections(principal)).some((c) => c.provider === provider)
) {
return sendJson(ctx.res, 409, { error: "Connect this AI account first." });
}
await ctx.deps.config.setPersonalModelAuth(principal, account === "personal", provider);
audit(ctx.deps, {
principalId: principal,
action: "user-model-auth.account",
resource: account,
scopeLabel: principal,
});
return getStatus(ctx);
}
async function disconnect(ctx: ApiCtx): Promise<void> {
const principal = caller(ctx);
if (!principal) return sendJson(ctx.res, 401, { error: "unauthorized" });
if (!ctx.deps.userModelCredentials) return sendJson(ctx.res, 404, { error: "not_found" });
const provider = connectProvider(bodyObj(ctx).provider);
if (!provider) return sendJson(ctx.res, 400, { error: "bad_request", message: "provider must be claude or chatgpt" });
await ctx.deps.userModelCredentials.delete(principal, provider);
audit(ctx.deps, {
principalId: principal,
action: "user-model-auth.disconnect",
resource: provider,
scopeLabel: principal,
});
return sendJson(ctx.res, 200, { ok: true });
}
async function putApiKey(ctx: ApiCtx): Promise<void> {
const principal = caller(ctx);
if (!principal) return sendJson(ctx.res, 401, { error: "unauthorized" });
if (!ctx.deps.userModelCredentials) return sendJson(ctx.res, 404, { error: "not_found" });
const body = bodyObj(ctx);
const provider = connectProvider(body.provider);
const apiKey = typeof body.apiKey === "string" ? body.apiKey.trim() : "";
if (!provider) return sendJson(ctx.res, 400, { error: "bad_request", message: "provider must be claude or chatgpt" });
if (!apiKey) return sendJson(ctx.res, 400, { error: "bad_request", message: "API key is required" });
if (!(await validateProviderApiKey(ctx, provider, apiKey))) {
return sendJson(ctx.res, 400, { error: "invalid_api_key", message: `${provider} rejected this API key` });
}
await ctx.deps.userModelCredentials.setApiKey(principal, provider, apiKey);
audit(ctx.deps, {
principalId: principal,
action: "user-model-auth.api-key",
resource: provider,
scopeLabel: principal,
});
return sendJson(ctx.res, 200, { ok: true });
}
const codexDeviceLogin = createCodexDeviceLogin();
async function chatgptStart(ctx: ApiCtx): Promise<void> {
if (!caller(ctx)) return sendJson(ctx.res, 401, { error: "unauthorized" });
try {
const prompt = await codexDeviceLogin.start();
return sendJson(ctx.res, 200, prompt);
} catch (e) {
return sendJson(ctx.res, 502, { error: "oauth_start_failed", message: errMessage(e) });
}
}
async function chatgptPoll(ctx: ApiCtx): Promise<void> {
const principal = caller(ctx);
if (!principal) return sendJson(ctx.res, 401, { error: "unauthorized" });
if (!ctx.deps.userModelCredentials) return sendJson(ctx.res, 404, { error: "not_found" });
const body = bodyObj(ctx);
const deviceAuthId = typeof body.deviceAuthId === "string" ? body.deviceAuthId : "";
if (!deviceAuthId) return sendJson(ctx.res, 400, { error: "bad_request" });
try {
const result = await codexDeviceLogin.poll(deviceAuthId);
if (result === "pending") return sendJson(ctx.res, 200, { status: "pending" });
await ctx.deps.userModelCredentials.setOAuth(principal, "openai", result);
audit(ctx.deps, {
principalId: principal,
action: "user-model-auth.oauth",
resource: "openai",
scopeLabel: principal,
});
return sendJson(ctx.res, 200, { status: "connected" });
} catch (e) {
return sendJson(ctx.res, 502, { error: "oauth_poll_failed", message: errMessage(e) });
}
}
async function claudeStart(ctx: ApiCtx): Promise<void> {
if (!caller(ctx)) return sendJson(ctx.res, 401, { error: "unauthorized" });
return sendJson(ctx.res, 200, startClaudeLogin());
}
async function claudeComplete(ctx: ApiCtx): Promise<void> {
const principal = caller(ctx);
if (!principal) return sendJson(ctx.res, 401, { error: "unauthorized" });
if (!ctx.deps.userModelCredentials) return sendJson(ctx.res, 404, { error: "not_found" });
const body = bodyObj(ctx);
const code = typeof body.code === "string" ? body.code : "";
const verifier = typeof body.verifier === "string" ? body.verifier : "";
if (!code || !verifier) return sendJson(ctx.res, 400, { error: "bad_request" });
try {
const tokens = await completeClaudeLogin(code, verifier);
await ctx.deps.userModelCredentials.setOAuth(principal, "anthropic", tokens);
audit(ctx.deps, {
principalId: principal,
action: "user-model-auth.oauth",
resource: "anthropic",
scopeLabel: principal,
});
return sendJson(ctx.res, 200, { ok: true });
} catch (e) {
return sendJson(ctx.res, 502, { error: "oauth_complete_failed", message: errMessage(e) });
}
}
export const userModelAuthRoutes: ReadonlyArray<Route<ApiCtx>> = [
{ method: "GET", path: "/v1/user-model-auth/status", actor: "query.principalId", auth: "source", handle: getStatus },
...withActor("body.principalId", [
{ method: "POST", path: "/v1/user-model-auth/account", auth: "source", handle: setAccount },
{ method: "POST", path: "/v1/user-model-auth/api-key", auth: "source", handle: putApiKey },
{ method: "POST", path: "/v1/user-model-auth/disconnect", auth: "source", handle: disconnect },
{ method: "POST", path: "/v1/user-model-auth/chatgpt/start", auth: "source", handle: chatgptStart },
{ method: "POST", path: "/v1/user-model-auth/chatgpt/poll", auth: "source", handle: chatgptPoll },
{ method: "POST", path: "/v1/user-model-auth/claude/start", auth: "source", handle: claudeStart },
{ method: "POST", path: "/v1/user-model-auth/claude/complete", auth: "source", handle: claudeComplete },
]),
];