npm - @elizaos/agent - Versions diffs - 2.0.0-alpha.98 → 2.0.0-beta.2 - Mend

@elizaos/agent 2.0.0-alpha.98 → 2.0.0-beta.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1227) hide show

package/packages/agent/src/auth/vendor/pi-oauth/openai-codex-login.js ADDED Viewed

@@ -0,0 +1,343 @@
+/**
+ * OpenAI Codex (ChatGPT OAuth) — local callback on :1455 + PKCE.
+ * Inlined OAuth flow (MIT) — vendored to avoid a runtime dependency.
+ */
+let _randomBytes = null;
+let _http = null;
+if (typeof process !== "undefined" &&
+    (process.versions?.node || process.versions?.bun)) {
+    void import("node:crypto").then((m) => {
+        _randomBytes = m.randomBytes;
+    });
+    void import("node:http").then((m) => {
+        _http = m;
+    });
+}
+import { logger } from "@elizaos/core";
+import { generatePKCE } from "./pkce.js";
+const CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+const AUTHORIZE_URL = "https://auth.openai.com/oauth/authorize";
+const TOKEN_URL = "https://auth.openai.com/oauth/token";
+const REDIRECT_URI = "http://localhost:1455/auth/callback";
+const SCOPE = "openid profile email offline_access";
+const JWT_CLAIM_PATH = "https://api.openai.com/auth";
+const SUCCESS_HTML = `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Authentication successful</title>
+</head>
+<body>
+  <p>Authentication successful. Return to your terminal to continue.</p>
+</body>
+</html>`;
+function createState() {
+    if (!_randomBytes) {
+        throw new Error("OpenAI Codex OAuth is only available in Node.js environments");
+    }
+    return _randomBytes(16).toString("hex");
+}
+function parseAuthorizationInput(input) {
+    const value = input.trim();
+    if (!value)
+        return {};
+    try {
+        const url = new URL(value);
+        return {
+            code: url.searchParams.get("code") ?? undefined,
+            state: url.searchParams.get("state") ?? undefined,
+        };
+    }
+    catch {
+        /* not a URL */
+    }
+    if (value.includes("#")) {
+        const [code, state] = value.split("#", 2);
+        return { code, state };
+    }
+    if (value.includes("code=")) {
+        const params = new URLSearchParams(value);
+        return {
+            code: params.get("code") ?? undefined,
+            state: params.get("state") ?? undefined,
+        };
+    }
+    return { code: value };
+}
+function decodeJwt(token) {
+    try {
+        const parts = token.split(".");
+        if (parts.length !== 3)
+            return null;
+        const payload = parts[1] ?? "";
+        const decoded = atob(payload);
+        return JSON.parse(decoded);
+    }
+    catch {
+        return null;
+    }
+}
+async function exchangeAuthorizationCode(code, verifier, redirectUri = REDIRECT_URI) {
+    const response = await fetch(TOKEN_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({
+            grant_type: "authorization_code",
+            client_id: CLIENT_ID,
+            code,
+            code_verifier: verifier,
+            redirect_uri: redirectUri,
+        }),
+    });
+    if (!response.ok) {
+        const text = await response.text().catch(() => "");
+        logger.error(`[openai-codex] code->token failed: ${response.status} ${text}`);
+        return { type: "failed" };
+    }
+    const json = (await response.json());
+    if (!json.access_token ||
+        !json.refresh_token ||
+        typeof json.expires_in !== "number") {
+        logger.error(`[openai-codex] token response missing fields: ${JSON.stringify(json)}`);
+        return { type: "failed" };
+    }
+    return {
+        type: "success",
+        access: json.access_token,
+        refresh: json.refresh_token,
+        expires: Date.now() + json.expires_in * 1000,
+    };
+}
+async function refreshAccessToken(refreshToken) {
+    try {
+        const response = await fetch(TOKEN_URL, {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: new URLSearchParams({
+                grant_type: "refresh_token",
+                refresh_token: refreshToken,
+                client_id: CLIENT_ID,
+            }),
+        });
+        if (!response.ok) {
+            const text = await response.text().catch(() => "");
+            logger.error(`[openai-codex] Token refresh failed: ${response.status} ${text}`);
+            return { type: "failed" };
+        }
+        const json = (await response.json());
+        if (!json.access_token ||
+            !json.refresh_token ||
+            typeof json.expires_in !== "number") {
+            logger.error(`[openai-codex] Token refresh response missing fields: ${JSON.stringify(json)}`);
+            return { type: "failed" };
+        }
+        return {
+            type: "success",
+            access: json.access_token,
+            refresh: json.refresh_token,
+            expires: Date.now() + json.expires_in * 1000,
+        };
+    }
+    catch (error) {
+        logger.error(`[openai-codex] Token refresh error: ${String(error)}`);
+        return { type: "failed" };
+    }
+}
+async function createAuthorizationFlow(originator = "pi") {
+    const { verifier, challenge } = await generatePKCE();
+    const state = createState();
+    const url = new URL(AUTHORIZE_URL);
+    url.searchParams.set("response_type", "code");
+    url.searchParams.set("client_id", CLIENT_ID);
+    url.searchParams.set("redirect_uri", REDIRECT_URI);
+    url.searchParams.set("scope", SCOPE);
+    url.searchParams.set("code_challenge", challenge);
+    url.searchParams.set("code_challenge_method", "S256");
+    url.searchParams.set("state", state);
+    url.searchParams.set("id_token_add_organizations", "true");
+    url.searchParams.set("codex_cli_simplified_flow", "true");
+    url.searchParams.set("originator", originator);
+    return { verifier, state, url: url.toString() };
+}
+function startLocalOAuthServer(state) {
+    if (!_http) {
+        throw new Error("OpenAI Codex OAuth is only available in Node.js environments");
+    }
+    let lastCode = null;
+    let cancelled = false;
+    const server = _http.createServer((req, res) => {
+        try {
+            const url = new URL(req.url || "", "http://localhost");
+            if (url.pathname !== "/auth/callback") {
+                res.statusCode = 404;
+                res.end("Not found");
+                return;
+            }
+            if (url.searchParams.get("state") !== state) {
+                res.statusCode = 400;
+                res.end("State mismatch");
+                return;
+            }
+            const code = url.searchParams.get("code");
+            if (!code) {
+                res.statusCode = 400;
+                res.end("Missing authorization code");
+                return;
+            }
+            res.statusCode = 200;
+            res.setHeader("Content-Type", "text/html; charset=utf-8");
+            res.end(SUCCESS_HTML);
+            lastCode = code;
+        }
+        catch {
+            res.statusCode = 500;
+            res.end("Internal error");
+        }
+    });
+    return new Promise((resolve) => {
+        server
+            .listen(1455, "127.0.0.1", () => {
+            resolve({
+                close: () => server.close(),
+                cancelWait: () => {
+                    cancelled = true;
+                },
+                waitForCode: async () => {
+                    const sleep = () => new Promise((r) => setTimeout(r, 100));
+                    for (let i = 0; i < 600; i += 1) {
+                        if (lastCode)
+                            return { code: lastCode };
+                        if (cancelled)
+                            return null;
+                        await sleep();
+                    }
+                    return null;
+                },
+            });
+        })
+            .on("error", (err) => {
+            logger.error(`[openai-codex] Failed to bind http://127.0.0.1:1455 (${err.code}) Falling back to manual paste.`);
+            resolve({
+                close: () => {
+                    try {
+                        server.close();
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                },
+                cancelWait: () => { },
+                waitForCode: async () => null,
+            });
+        });
+    });
+}
+function getAccountId(accessToken) {
+    const payload = decodeJwt(accessToken);
+    const auth = payload?.[JWT_CLAIM_PATH];
+    const accountId = auth?.chatgpt_account_id;
+    return typeof accountId === "string" && accountId.length > 0
+        ? accountId
+        : null;
+}
+export async function loginOpenAICodex(options) {
+    const { verifier, state, url } = await createAuthorizationFlow(options.originator);
+    const server = await startLocalOAuthServer(state);
+    options.onAuth({
+        url,
+        instructions: "A browser window should open. Complete login to finish.",
+    });
+    let code;
+    try {
+        if (options.onManualCodeInput) {
+            let manualCode;
+            let manualError;
+            const manualPromise = options
+                .onManualCodeInput()
+                .then((input) => {
+                manualCode = input;
+                server.cancelWait();
+            })
+                .catch((err) => {
+                manualError = err instanceof Error ? err : new Error(String(err));
+                server.cancelWait();
+            });
+            const result = await server.waitForCode();
+            if (manualError)
+                throw manualError;
+            if (result?.code) {
+                code = result.code;
+            }
+            else if (manualCode) {
+                const parsed = parseAuthorizationInput(manualCode);
+                if (parsed.state && parsed.state !== state) {
+                    throw new Error("State mismatch");
+                }
+                code = parsed.code;
+            }
+            if (!code) {
+                await manualPromise;
+                if (manualError)
+                    throw manualError;
+                if (manualCode) {
+                    const parsed = parseAuthorizationInput(manualCode);
+                    if (parsed.state && parsed.state !== state) {
+                        throw new Error("State mismatch");
+                    }
+                    code = parsed.code;
+                }
+            }
+        }
+        else {
+            const result = await server.waitForCode();
+            if (result?.code)
+                code = result.code;
+        }
+        if (!code) {
+            const input = await options.onPrompt({
+                message: "Paste the authorization code (or full redirect URL):",
+            });
+            const parsed = parseAuthorizationInput(input);
+            if (parsed.state && parsed.state !== state) {
+                throw new Error("State mismatch");
+            }
+            code = parsed.code;
+        }
+        if (!code)
+            throw new Error("Missing authorization code");
+        const tokenResult = await exchangeAuthorizationCode(code, verifier);
+        if (tokenResult.type !== "success") {
+            throw new Error("Token exchange failed");
+        }
+        const accountId = getAccountId(tokenResult.access);
+        if (!accountId) {
+            throw new Error("Failed to extract accountId from token");
+        }
+        return {
+            access: tokenResult.access,
+            refresh: tokenResult.refresh,
+            expires: tokenResult.expires,
+            accountId,
+        };
+    }
+    finally {
+        server.close();
+    }
+}
+export async function refreshOpenAICodexToken(refreshToken) {
+    const result = await refreshAccessToken(refreshToken);
+    if (result.type !== "success") {
+        throw new Error("Failed to refresh OpenAI Codex token");
+    }
+    const accountId = getAccountId(result.access);
+    if (!accountId) {
+        throw new Error("Failed to extract accountId from token");
+    }
+    return {
+        access: result.access,
+        refresh: result.refresh,
+        expires: result.expires,
+        accountId,
+    };
+}

package/packages/agent/src/auth/vendor/pi-oauth/pkce.d.ts ADDED Viewed

@@ -0,0 +1,9 @@
+/**
+ * PKCE utilities using Web Crypto API (Node.js 20+ / Bun).
+ * Inlined PKCE helpers (MIT) — vendored to avoid a runtime dependency.
+ */
+export declare function generatePKCE(): Promise<{
+    verifier: string;
+    challenge: string;
+}>;
+//# sourceMappingURL=pkce.d.ts.map

package/packages/agent/src/auth/vendor/pi-oauth/pkce.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"pkce.d.ts","sourceRoot":"","sources":["../../../../../../../src/auth/vendor/pi-oauth/pkce.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAUH,wBAAsB,YAAY,IAAI,OAAO,CAAC;IAC5C,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC,CASD"}

package/packages/agent/src/auth/vendor/pi-oauth/pkce.js ADDED Viewed

@@ -0,0 +1,21 @@
+/**
+ * PKCE utilities using Web Crypto API (Node.js 20+ / Bun).
+ * Inlined PKCE helpers (MIT) — vendored to avoid a runtime dependency.
+ */
+function base64urlEncode(bytes) {
+    let binary = "";
+    for (const byte of bytes) {
+        binary += String.fromCharCode(byte);
+    }
+    return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+export async function generatePKCE() {
+    const verifierBytes = new Uint8Array(32);
+    crypto.getRandomValues(verifierBytes);
+    const verifier = base64urlEncode(verifierBytes);
+    const encoder = new TextEncoder();
+    const data = encoder.encode(verifier);
+    const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+    const challenge = base64urlEncode(new Uint8Array(hashBuffer));
+    return { verifier, challenge };
+}

package/packages/agent/src/autonomy/index.d.ts ADDED Viewed

@@ -0,0 +1,48 @@
+import type { StreamEventEnvelope } from "../api/server-types.ts";
+export type AutonomyRunHealthStatus = "ok" | "gap_detected" | "recovered" | "partial";
+export interface AutonomyRunHealth {
+    runId: string;
+    status: AutonomyRunHealthStatus;
+    lastSeq: number | null;
+    missingSeqs: number[];
+    gapCount: number;
+    lastGapAt?: number;
+    recoveredAt?: number;
+    partialAt?: number;
+}
+export type AutonomyRunHealthMap = Record<string, AutonomyRunHealth>;
+export interface AutonomyEventStore {
+    eventsById: Record<string, StreamEventEnvelope>;
+    eventOrder: string[];
+    runIndex: Record<string, Record<number, string>>;
+    watermark: string | null;
+}
+export interface MergeAutonomyEventsOptions {
+    existingEvents?: StreamEventEnvelope[];
+    store?: AutonomyEventStore;
+    incomingEvents: StreamEventEnvelope[];
+    runHealthByRunId: AutonomyRunHealthMap;
+    maxEvents?: number;
+    replay?: boolean;
+}
+export interface MergeAutonomyEventsResult {
+    store: AutonomyEventStore;
+    events: StreamEventEnvelope[];
+    latestEventId: string | null;
+    runHealthByRunId: AutonomyRunHealthMap;
+    insertedCount: number;
+    duplicateCount: number;
+    runsWithNewGaps: string[];
+    runsRecovered: string[];
+    hasUnresolvedGaps: boolean;
+}
+export interface AutonomyGapReplayRequest {
+    runId: string;
+    fromSeq: number;
+    missingSeqs: number[];
+}
+export declare function buildAutonomyGapReplayRequests(runHealthByRunId: AutonomyRunHealthMap, store: AutonomyEventStore): AutonomyGapReplayRequest[];
+export declare function hasPendingAutonomyGaps(runHealthByRunId: AutonomyRunHealthMap): boolean;
+export declare function markPendingAutonomyGapsPartial(runHealthByRunId: AutonomyRunHealthMap, ts?: number): AutonomyRunHealthMap;
+export declare function mergeAutonomyEvents({ existingEvents, store, incomingEvents, runHealthByRunId, maxEvents, replay, }: MergeAutonomyEventsOptions): MergeAutonomyEventsResult;
+//# sourceMappingURL=index.d.ts.map

package/packages/agent/src/autonomy/index.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/autonomy/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAElE,MAAM,MAAM,uBAAuB,GAC/B,IAAI,GACJ,cAAc,GACd,WAAW,GACX,SAAS,CAAC;AAEd,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,uBAAuB,CAAC;IAChC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;AAErE,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IAChD,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACjD,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED,MAAM,WAAW,0BAA0B;IACzC,cAAc,CAAC,EAAE,mBAAmB,EAAE,CAAC;IACvC,KAAK,CAAC,EAAE,kBAAkB,CAAC;IAC3B,cAAc,EAAE,mBAAmB,EAAE,CAAC;IACtC,gBAAgB,EAAE,oBAAoB,CAAC;IACvC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,yBAAyB;IACxC,KAAK,EAAE,kBAAkB,CAAC;IAC1B,MAAM,EAAE,mBAAmB,EAAE,CAAC;IAC9B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,gBAAgB,EAAE,oBAAoB,CAAC;IACvC,aAAa,EAAE,MAAM,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,iBAAiB,EAAE,OAAO,CAAC;CAC5B;AAuQD,MAAM,WAAW,wBAAwB;IACvC,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AAED,wBAAgB,8BAA8B,CAC5C,gBAAgB,EAAE,oBAAoB,EACtC,KAAK,EAAE,kBAAkB,GACxB,wBAAwB,EAAE,CAkB5B;AAED,wBAAgB,sBAAsB,CACpC,gBAAgB,EAAE,oBAAoB,GACrC,OAAO,CAIT;AAED,wBAAgB,8BAA8B,CAC5C,gBAAgB,EAAE,oBAAoB,EACtC,EAAE,SAAa,GACd,oBAAoB,CAQtB;AAED,wBAAgB,mBAAmB,CAAC,EAClC,cAAc,EACd,KAAK,EACL,cAAc,EACd,gBAAgB,EAChB,SAA8B,EAC9B,MAAc,GACf,EAAE,0BAA0B,GAAG,yBAAyB,CA+HxD"}