@psnext/slingcli 2.4.20260507-3 → 2.4.20260509-2

package/node_modules/@mariozechner/pi-agent-core/node_modules/@mariozechner/pi-ai/dist/utils/oauth/openai-codex.js

@@ -1,374 +0,0 @@
-/**
- * OpenAI Codex (ChatGPT OAuth) flow
- *
- * NOTE: This module uses Node.js crypto and http for the OAuth callback.
- * It is only intended for CLI use, not browser environments.
- */
-// NEVER convert to top-level imports - breaks browser/Vite builds (web-ui)
-let _randomBytes = null;
-let _http = null;
-if (typeof process !== "undefined" && (process.versions?.node || process.versions?.bun)) {
-    import("node:crypto").then((m) => {
-        _randomBytes = m.randomBytes;
-    });
-    import("node:http").then((m) => {
-        _http = m;
-    });
-}
-import { oauthErrorHtml, oauthSuccessHtml } from "./oauth-page.js";
-import { generatePKCE } from "./pkce.js";
-const CALLBACK_HOST = process.env.PI_OAUTH_CALLBACK_HOST || "127.0.0.1";
-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";
-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(() => "");
-        console.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") {
-        console.error("[openai-codex] token response missing fields:", 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(() => "");
-            console.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") {
-            console.error("[openai-codex] Token refresh response missing fields:", json);
-            return { type: "failed" };
-        }
-        return {
-            type: "success",
-            access: json.access_token,
-            refresh: json.refresh_token,
-            expires: Date.now() + json.expires_in * 1000,
-        };
-    }
-    catch (error) {
-        console.error("[openai-codex] Token refresh error:", 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 settleWait;
-    const waitForCodePromise = new Promise((resolve) => {
-        let settled = false;
-        settleWait = (value) => {
-            if (settled)
-                return;
-            settled = true;
-            resolve(value);
-        };
-    });
-    const server = _http.createServer((req, res) => {
-        try {
-            const url = new URL(req.url || "", "http://localhost");
-            if (url.pathname !== "/auth/callback") {
-                res.statusCode = 404;
-                res.setHeader("Content-Type", "text/html; charset=utf-8");
-                res.end(oauthErrorHtml("Callback route not found."));
-                return;
-            }
-            if (url.searchParams.get("state") !== state) {
-                res.statusCode = 400;
-                res.setHeader("Content-Type", "text/html; charset=utf-8");
-                res.end(oauthErrorHtml("State mismatch."));
-                return;
-            }
-            const code = url.searchParams.get("code");
-            if (!code) {
-                res.statusCode = 400;
-                res.setHeader("Content-Type", "text/html; charset=utf-8");
-                res.end(oauthErrorHtml("Missing authorization code."));
-                return;
-            }
-            res.statusCode = 200;
-            res.setHeader("Content-Type", "text/html; charset=utf-8");
-            res.end(oauthSuccessHtml("OpenAI authentication completed. You can close this window."));
-            settleWait?.({ code });
-        }
-        catch {
-            res.statusCode = 500;
-            res.setHeader("Content-Type", "text/html; charset=utf-8");
-            res.end(oauthErrorHtml("Internal error while processing OAuth callback."));
-        }
-    });
-    return new Promise((resolve) => {
-        server
-            .listen(1455, CALLBACK_HOST, () => {
-            resolve({
-                close: () => server.close(),
-                cancelWait: () => {
-                    settleWait?.(null);
-                },
-                waitForCode: () => waitForCodePromise,
-            });
-        })
-            .on("error", (err) => {
-            console.error(`[openai-codex] Failed to bind http://${CALLBACK_HOST}:1455 (`, err.code, ") Falling back to manual paste.");
-            settleWait?.(null);
-            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;
-}
-/**
- * Login with OpenAI Codex OAuth
- *
- * @param options.onAuth - Called with URL and instructions when auth starts
- * @param options.onPrompt - Called to prompt user for manual code paste (fallback if no onManualCodeInput)
- * @param options.onProgress - Optional progress messages
- * @param options.onManualCodeInput - Optional promise that resolves with user-pasted code.
- *                                    Races with browser callback - whichever completes first wins.
- *                                    Useful for showing paste input immediately alongside browser flow.
- * @param options.originator - OAuth originator parameter (defaults to "pi")
- */
-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) {
-            // Race between browser callback and manual input
-            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 manual input was cancelled, throw that error
-            if (manualError) {
-                throw manualError;
-            }
-            if (result?.code) {
-                // Browser callback won
-                code = result.code;
-            }
-            else if (manualCode) {
-                // Manual input won (or callback timed out and user had entered code)
-                const parsed = parseAuthorizationInput(manualCode);
-                if (parsed.state && parsed.state !== state) {
-                    throw new Error("State mismatch");
-                }
-                code = parsed.code;
-            }
-            // If still no code, wait for manual promise to complete and try that
-            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 {
-            // Original flow: wait for callback, then prompt if needed
-            const result = await server.waitForCode();
-            if (result?.code) {
-                code = result.code;
-            }
-        }
-        // Fallback to onPrompt if still no 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();
-    }
-}
-/**
- * Refresh OpenAI Codex OAuth token
- */
-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,
-    };
-}
-export const openaiCodexOAuthProvider = {
-    id: "openai-codex",
-    name: "ChatGPT Plus/Pro (Codex Subscription)",
-    usesCallbackServer: true,
-    async login(callbacks) {
-        return loginOpenAICodex({
-            onAuth: callbacks.onAuth,
-            onPrompt: callbacks.onPrompt,
-            onProgress: callbacks.onProgress,
-            onManualCodeInput: callbacks.onManualCodeInput,
-        });
-    },
-    async refreshToken(credentials) {
-        return refreshOpenAICodexToken(credentials.refresh);
-    },
-    getApiKey(credentials) {
-        return credentials.access;
-    },
-};
-//# sourceMappingURL=openai-codex.js.map

package/node_modules/@mariozechner/pi-ai/dist/api-registry.js

@@ -1,44 +0,0 @@
-const apiProviderRegistry = new Map();
-function wrapStream(api, stream) {
-    return (model, context, options) => {
-        if (model.api !== api) {
-            throw new Error(`Mismatched api: ${model.api} expected ${api}`);
-        }
-        return stream(model, context, options);
-    };
-}
-function wrapStreamSimple(api, streamSimple) {
-    return (model, context, options) => {
-        if (model.api !== api) {
-            throw new Error(`Mismatched api: ${model.api} expected ${api}`);
-        }
-        return streamSimple(model, context, options);
-    };
-}
-export function registerApiProvider(provider, sourceId) {
-    apiProviderRegistry.set(provider.api, {
-        provider: {
-            api: provider.api,
-            stream: wrapStream(provider.api, provider.stream),
-            streamSimple: wrapStreamSimple(provider.api, provider.streamSimple),
-        },
-        sourceId,
-    });
-}
-export function getApiProvider(api) {
-    return apiProviderRegistry.get(api)?.provider;
-}
-export function getApiProviders() {
-    return Array.from(apiProviderRegistry.values(), (entry) => entry.provider);
-}
-export function unregisterApiProviders(sourceId) {
-    for (const [api, entry] of apiProviderRegistry.entries()) {
-        if (entry.sourceId === sourceId) {
-            apiProviderRegistry.delete(api);
-        }
-    }
-}
-export function clearApiProviders() {
-    apiProviderRegistry.clear();
-}
-//# sourceMappingURL=api-registry.js.map

package/node_modules/@mariozechner/pi-ai/dist/bedrock-provider.js

@@ -1,6 +0,0 @@
-import { streamBedrock, streamSimpleBedrock } from "./providers/amazon-bedrock.js";
-export const bedrockProviderModule = {
-    streamBedrock,
-    streamSimpleBedrock,
-};
-//# sourceMappingURL=bedrock-provider.js.map

package/node_modules/@mariozechner/pi-ai/dist/models.js

@@ -1,71 +0,0 @@
-import { MODELS } from "./models.generated.js";
-const modelRegistry = new Map();
-// Initialize registry from MODELS on module load
-for (const [provider, models] of Object.entries(MODELS)) {
-    const providerModels = new Map();
-    for (const [id, model] of Object.entries(models)) {
-        providerModels.set(id, model);
-    }
-    modelRegistry.set(provider, providerModels);
-}
-export function getModel(provider, modelId) {
-    const providerModels = modelRegistry.get(provider);
-    return providerModels?.get(modelId);
-}
-export function getProviders() {
-    return Array.from(modelRegistry.keys());
-}
-export function getModels(provider) {
-    const models = modelRegistry.get(provider);
-    return models ? Array.from(models.values()) : [];
-}
-export function calculateCost(model, usage) {
-    usage.cost.input = (model.cost.input / 1000000) * usage.input;
-    usage.cost.output = (model.cost.output / 1000000) * usage.output;
-    usage.cost.cacheRead = (model.cost.cacheRead / 1000000) * usage.cacheRead;
-    usage.cost.cacheWrite = (model.cost.cacheWrite / 1000000) * usage.cacheWrite;
-    usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
-    return usage.cost;
-}
-const EXTENDED_THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh"];
-export function getSupportedThinkingLevels(model) {
-    if (!model.reasoning)
-        return ["off"];
-    return EXTENDED_THINKING_LEVELS.filter((level) => {
-        const mapped = model.thinkingLevelMap?.[level];
-        if (mapped === null)
-            return false;
-        if (level === "xhigh")
-            return mapped !== undefined;
-        return true;
-    });
-}
-export function clampThinkingLevel(model, level) {
-    const availableLevels = getSupportedThinkingLevels(model);
-    if (availableLevels.includes(level))
-        return level;
-    const requestedIndex = EXTENDED_THINKING_LEVELS.indexOf(level);
-    if (requestedIndex === -1)
-        return availableLevels[0] ?? "off";
-    for (let i = requestedIndex; i < EXTENDED_THINKING_LEVELS.length; i++) {
-        const candidate = EXTENDED_THINKING_LEVELS[i];
-        if (availableLevels.includes(candidate))
-            return candidate;
-    }
-    for (let i = requestedIndex - 1; i >= 0; i--) {
-        const candidate = EXTENDED_THINKING_LEVELS[i];
-        if (availableLevels.includes(candidate))
-            return candidate;
-    }
-    return availableLevels[0] ?? "off";
-}
-/**
- * Check if two models are equal by comparing both their id and provider.
- * Returns false if either model is null or undefined.
- */
-export function modelsAreEqual(a, b) {
-    if (!a || !b)
-        return false;
-    return a.id === b.id && a.provider === b.provider;
-}
-//# sourceMappingURL=models.js.map

package/node_modules/@mariozechner/pi-ai/dist/oauth.js

@@ -1,2 +0,0 @@
-export * from "./utils/oauth/index.js";
-//# sourceMappingURL=oauth.js.map