A personal agent with a browser, terminal, files, and work that keeps going built with CopilotKit and AG-UI.
TypeScript
import { createHash, randomBytes, randomUUID } from "node:crypto";
import { z } from "zod";
import { decryptSecret, encryptSecret } from "../../../packages/integrations/src/vault.ts";
import type { Config } from "./config.ts";
import type { Store } from "./db.ts";
import { AppError } from "./errors.ts";
const tokenSchema = z.object({
access_token: z.string().min(1),
refresh_token: z.string().optional(),
expires_in: z.number(),
scope: z.string().optional(),
});
interface Tokens {
connectionId: string;
accessToken: string;
refreshToken?: string;
expiresAt: number;
scopes: string[];
account: string;
}
interface OAuthState {
id: string;
owner: string;
expiresAt: number;
verifier: string;
scopes: string[];
generation: string;
}
interface Credential {
id: string;
generation?: string;
connectionId: string | null;
secret: string | null;
}
export class GoogleAuth {
private readonly refreshing = new Map<string, Promise<string>>();
constructor(
private readonly db: Store,
private readonly config: Config,
) {}
configured() {
return Boolean(
this.config.googleClientId && this.config.googleClientSecret && this.config.encryptionKey,
);
}
async tokens(owner: string): Promise<Tokens | null> {
return this.decodeTokens(await this.db.get<Credential>(owner, "credentials", "google"));
}
private decodeTokens(stored: Credential | null): Tokens | null {
if (!stored?.secret) return null;
if (!this.config.encryptionKey)
throw new AppError("TOKEN_ENCRYPTION_KEY is not configured", 503);
return JSON.parse(decryptSecret(stored.secret, this.config.encryptionKey));
}
private async save(owner: string, tokens: Tokens, generation: string) {
if (!this.config.encryptionKey)
throw new AppError("TOKEN_ENCRYPTION_KEY is not configured", 503);
const saved = await this.db.compareAndSwap<Credential>(
owner,
"credentials",
"google",
{ generation },
{
generation: randomUUID(),
connectionId: tokens.connectionId,
secret: encryptSecret(JSON.stringify(tokens), this.config.encryptionKey),
},
);
if (!saved)
throw new AppError("Google sign-in changed or was disconnected. Connect again.", 409);
}
private async rotateGeneration(owner: string, disconnect = false) {
const generation = randomUUID();
for (;;) {
const previous = await this.db.get<Credential>(owner, "credentials", "google");
if (!previous) {
const inserted = await this.db.insertIfAbsent(owner, "credentials", {
id: "google",
generation,
connectionId: null,
secret: null,
});
if (inserted) return { generation, previous: null };
} else {
const updated = await this.db.compareAndSwap<Credential>(
owner,
"credentials",
"google",
{ ...previous },
{
generation,
...(disconnect ? { connectionId: null, secret: null } : {}),
},
);
if (updated) return { generation, previous };
}
}
}
async connect(owner: string, write: boolean) {
if (!this.configured())
throw new AppError(
"Configure GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET and TOKEN_ENCRYPTION_KEY to connect Google",
503,
);
const state = randomBytes(32).toString("base64url"),
verifier = randomBytes(48).toString("base64url");
const { generation, previous } = await this.rotateGeneration(owner);
const existing = this.decodeTokens(previous);
const scopes = Array.from(
new Set([
"https://www.googleapis.com/auth/gmail.readonly",
"https://www.googleapis.com/auth/calendar.events.readonly",
"https://www.googleapis.com/auth/calendar.calendarlist.readonly",
...(existing?.scopes ?? []),
...(write
? [
"https://www.googleapis.com/auth/gmail.send",
"https://www.googleapis.com/auth/calendar.events",
]
: []),
]),
);
await this.db.put("system", "oauth", {
id: state,
owner,
expiresAt: Date.now() + 10 * 60 * 1000,
verifier,
scopes,
generation,
});
const url = new URL("https://accounts.google.com/o/oauth2/v2/auth");
url.search = new URLSearchParams({
client_id: this.config.googleClientId ?? "",
redirect_uri: this.config.googleRedirectUri,
response_type: "code",
scope: scopes.join(" "),
state,
access_type: "offline",
prompt: "consent",
include_granted_scopes: "true",
code_challenge_method: "S256",
code_challenge: createHash("sha256").update(verifier).digest("base64url"),
}).toString();
return { url: url.toString() };
}
async callback(stateId: string, code: string) {
const state = await this.db.take<OAuthState>("system", "oauth", stateId);
if (!state || state.expiresAt < Date.now())
throw new AppError("Google sign-in expired. Connect again.", 400);
const credential = await this.db.get<Credential>(state.owner, "credentials", "google");
if (!state.generation || credential?.generation !== state.generation)
throw new AppError("Google sign-in changed or was disconnected. Connect again.", 409);
const response = await fetch("https://oauth2.googleapis.com/token", {
method: "POST",
headers: { "Content-Type": "application/x-www-form-urlencoded" },
body: new URLSearchParams({
client_id: this.config.googleClientId ?? "",
client_secret: this.config.googleClientSecret ?? "",
redirect_uri: this.config.googleRedirectUri,
grant_type: "authorization_code",
code,
code_verifier: state.verifier,
}),
signal: AbortSignal.timeout(15000),
});
if (!response.ok) throw new AppError("Google could not complete sign-in. Connect again.", 502);
const token = tokenSchema.parse(await response.json());
const profile = await fetch("https://gmail.googleapis.com/gmail/v1/users/me/profile", {
headers: { Authorization: `Bearer ${token.access_token}` },
signal: AbortSignal.timeout(15000),
});
if (!profile.ok)
throw new AppError("Google did not grant Gmail read access. Connect again.", 403);
const { emailAddress } = z.object({ emailAddress: z.email() }).parse(await profile.json());
const previous = await this.tokens(state.owner);
await this.save(
state.owner,
{
connectionId: randomUUID(),
accessToken: token.access_token,
refreshToken:
token.refresh_token ??
(previous?.account === emailAddress ? previous.refreshToken : undefined),
expiresAt: Date.now() + token.expires_in * 1000,
scopes: token.scope?.split(" ") ?? state.scopes,
account: emailAddress,
},
state.generation,
);
}
async accessToken(owner: string, expectedConnectionId?: string): Promise<string> {
const tokens = await this.tokens(owner);
if (!tokens) throw new AppError("Google is disconnected", 409);
if (expectedConnectionId && tokens.connectionId !== expectedConnectionId)
throw new AppError("Google account or connection changed. Prepare a new action.", 409);
if (tokens.expiresAt > Date.now() + 60000) return tokens.accessToken;
const refreshKey = `${owner}:${tokens.connectionId}`;
const pending = this.refreshing.get(refreshKey);
if (pending) return pending;
const task = this.refresh(owner, tokens).finally(() => this.refreshing.delete(refreshKey));
this.refreshing.set(refreshKey, task);
return task;
}
private async refresh(owner: string, tokens: Tokens) {
if (!tokens.refreshToken) throw new AppError("Google session expired. Connect again.", 401);
const response = await fetch("https://oauth2.googleapis.com/token", {
method: "POST",
headers: { "Content-Type": "application/x-www-form-urlencoded" },
body: new URLSearchParams({
client_id: this.config.googleClientId ?? "",
client_secret: this.config.googleClientSecret ?? "",
grant_type: "refresh_token",
refresh_token: tokens.refreshToken,
}),
signal: AbortSignal.timeout(15000),
});
if (!response.ok) throw new AppError("Google session expired. Connect again.", 401);
const token = tokenSchema.parse(await response.json());
const refreshed = {
...tokens,
accessToken: token.access_token,
expiresAt: Date.now() + token.expires_in * 1000,
};
if (!this.config.encryptionKey) throw new AppError("Token encryption is not configured", 503);
const updated = await this.db.updateCredential(
owner,
tokens.connectionId,
encryptSecret(JSON.stringify(refreshed), this.config.encryptionKey),
);
if (!updated)
throw new AppError("Google account changed or was disconnected during refresh", 409);
return token.access_token;
}
async disconnect(owner: string) {
const { previous } = await this.rotateGeneration(owner, true);
const tokens = this.decodeTokens(previous);
if (tokens) {
const response = await fetch("https://oauth2.googleapis.com/revoke", {
method: "POST",
headers: { "Content-Type": "application/x-www-form-urlencoded" },
body: new URLSearchParams({ token: tokens.refreshToken ?? tokens.accessToken }),
signal: AbortSignal.timeout(15000),
});
if (!response.ok && response.status !== 400)
throw new AppError(
"Disconnected locally. Google revocation failed; remove access in your Google account settings.",
502,
);
}
}
}