@push.rocks/smartai 2.3.0 → 4.0.1

package/dist_ts_openai_chatgpt_auth/index.js

@@ -0,0 +1,249 @@
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { parseOpenAiChatGptTokenInfo, refreshOpenAiChatGptTokenData, } from '../dist_ts/smartai.auth.openai.js';
+const defaultSources = ['smartai', 'opencode', 'codex'];
+const refreshWindowMs = 5 * 60 * 1000;
+export const getDefaultOpenAiChatGptAuthPath = (source, homeDir = os.homedir()) => {
+    switch (source) {
+        case 'smartai':
+            return path.join(homeDir, '.git.zone', 'ide', 'openai-chatgpt-auth.json');
+        case 'opencode':
+            return path.join(homeDir, '.local', 'share', 'opencode', 'auth.json');
+        case 'codex':
+            return path.join(homeDir, '.codex', 'auth.json');
+        default:
+            throw new Error(`Unsupported OpenAI ChatGPT auth source: ${source}`);
+    }
+};
+export const normalizeOpenAiChatGptAuth = (input, format = 'auto') => {
+    if (format === 'auto') {
+        return normalizeOpenAiChatGptAuth(input, 'smartai')
+            ?? normalizeOpenAiChatGptAuth(input, 'opencode')
+            ?? normalizeOpenAiChatGptAuth(input, 'codex');
+    }
+    if (!isRecord(input))
+        return undefined;
+    if (format === 'opencode') {
+        return normalizeOpenCodeAuth(input);
+    }
+    return normalizeTokenObject(isRecord(input.tokens) ? input.tokens : input);
+};
+export const readOpenAiChatGptAuthFile = async (filePath, format = 'auto') => {
+    const parsed = JSON.parse(await fs.readFile(filePath, 'utf8'));
+    return normalizeOpenAiChatGptAuth(parsed, format);
+};
+export const inspectOpenAiChatGptAuthSources = async (options = {}) => {
+    const now = options.now ?? new Date();
+    const sourceConfigs = normalizeSourceConfigs(options.sources, options.homeDir);
+    return Promise.all(sourceConfigs.map(async (sourceConfig) => {
+        try {
+            const tokenData = await readOpenAiChatGptAuthFile(sourceConfig.filePath, sourceConfig.format ?? sourceConfig.source);
+            if (!tokenData) {
+                return {
+                    source: sourceConfig.source,
+                    filePath: sourceConfig.filePath,
+                    exists: true,
+                    usable: false,
+                    error: 'No OpenAI ChatGPT auth token found in file.',
+                };
+            }
+            return toInspection(sourceConfig.source, sourceConfig.filePath, tokenData, now);
+        }
+        catch (error) {
+            const nodeError = error;
+            return {
+                source: sourceConfig.source,
+                filePath: sourceConfig.filePath,
+                exists: nodeError.code !== 'ENOENT',
+                usable: false,
+                error: nodeError.code === 'ENOENT' ? undefined : nodeError.message,
+            };
+        }
+    }));
+};
+export const resolveOpenAiChatGptAuth = async (options = {}) => {
+    const now = options.now ?? new Date();
+    const sourceConfigs = normalizeSourceConfigs(options.sources, options.homeDir);
+    const refresh = options.refresh ?? 'ifNeeded';
+    for (const sourceConfig of sourceConfigs) {
+        let tokenData;
+        try {
+            tokenData = await readOpenAiChatGptAuthFile(sourceConfig.filePath, sourceConfig.format ?? sourceConfig.source);
+        }
+        catch (error) {
+            const nodeError = error;
+            if (nodeError.code === 'ENOENT')
+                continue;
+            continue;
+        }
+        if (!tokenData)
+            continue;
+        const shouldRefresh = refresh === 'ifNeeded' && shouldRefreshToken(tokenData, now);
+        const writeBack = sourceConfig.writeBack ?? options.writeBack?.[sourceConfig.source] ?? sourceConfig.source === 'smartai';
+        if (!shouldRefresh) {
+            return { source: sourceConfig.source, filePath: sourceConfig.filePath, tokenData, refreshed: false };
+        }
+        if (!writeBack) {
+            if (!isExpired(tokenData, now)) {
+                return { source: sourceConfig.source, filePath: sourceConfig.filePath, tokenData, refreshed: false };
+            }
+            continue;
+        }
+        try {
+            const refreshed = await refreshOpenAiChatGptTokenData(tokenData, options.authOptions ?? {});
+            await writeOpenAiChatGptAuthFile(sourceConfig.filePath, refreshed, sourceConfig.format ?? sourceConfig.source);
+            return { source: sourceConfig.source, filePath: sourceConfig.filePath, tokenData: refreshed, refreshed: true };
+        }
+        catch {
+            continue;
+        }
+    }
+    return undefined;
+};
+export const writeOpenAiChatGptAuthFile = async (filePath, tokenData, format = 'smartai') => {
+    const current = await readJsonFileIfExists(filePath);
+    const payload = format === 'opencode'
+        ? toOpenCodeAuthFile(current, tokenData)
+        : format === 'codex'
+            ? toCodexAuthFile(current, tokenData)
+            : toSmartAiAuthFile(tokenData);
+    await writeJsonAtomic(filePath, payload);
+};
+const normalizeSourceConfigs = (sources, homeDir = os.homedir()) => {
+    return (sources ?? defaultSources).map((sourceInput) => {
+        const sourceConfig = typeof sourceInput === 'string' ? { source: sourceInput } : sourceInput;
+        return {
+            source: sourceConfig.source,
+            filePath: sourceConfig.filePath ?? getDefaultOpenAiChatGptAuthPath(sourceConfig.source, homeDir),
+            format: sourceConfig.format ?? sourceConfig.source,
+            writeBack: sourceConfig.writeBack,
+        };
+    });
+};
+const toInspection = (source, filePath, tokenData, now) => {
+    const expired = isExpired(tokenData, now);
+    return {
+        source,
+        filePath,
+        exists: true,
+        usable: !expired,
+        expired,
+        accountId: tokenData.accountId ?? tokenData.tokenInfo.chatgptAccountId,
+        email: tokenData.tokenInfo.email,
+        plan: tokenData.tokenInfo.chatgptPlanType,
+        expiresAt: tokenData.tokenInfo.expiresAt,
+    };
+};
+const normalizeTokenObject = (input) => {
+    const accessToken = stringValue(input.accessToken) ?? stringValue(input.access_token);
+    const refreshToken = stringValue(input.refreshToken) ?? stringValue(input.refresh_token);
+    const idToken = stringValue(input.idToken) ?? stringValue(input.id_token) ?? stringValue(input.tokenInfo?.rawJwt);
+    const accountId = stringValue(input.accountId) ?? stringValue(input.account_id);
+    return createTokenDataFromValues({ accessToken, refreshToken, idToken, accountId });
+};
+const normalizeOpenCodeAuth = (input) => {
+    if (!isRecord(input.openai))
+        return undefined;
+    const accessToken = stringValue(input.openai.access);
+    const refreshToken = stringValue(input.openai.refresh);
+    const accountId = stringValue(input.openai.accountId);
+    const expiresAt = typeof input.openai.expires === 'number' ? new Date(input.openai.expires).toISOString() : undefined;
+    return createTokenDataFromValues({ accessToken, refreshToken, accountId, fallbackExpiresAt: expiresAt });
+};
+const createTokenDataFromValues = (input) => {
+    if (!input.accessToken || !input.refreshToken)
+        return undefined;
+    const parseToken = input.idToken ?? input.accessToken;
+    const tokenInfo = parseTokenInfo(parseToken, input.accountId, input.fallbackExpiresAt);
+    return {
+        accessToken: input.accessToken,
+        refreshToken: input.refreshToken,
+        idToken: input.idToken,
+        accountId: input.accountId ?? tokenInfo.chatgptAccountId,
+        tokenInfo,
+    };
+};
+const parseTokenInfo = (token, accountId, fallbackExpiresAt) => {
+    try {
+        const tokenInfo = parseOpenAiChatGptTokenInfo(token);
+        return {
+            ...tokenInfo,
+            chatgptAccountId: tokenInfo.chatgptAccountId ?? accountId,
+            expiresAt: tokenInfo.expiresAt ?? fallbackExpiresAt,
+        };
+    }
+    catch {
+        return {
+            chatgptAccountId: accountId,
+            chatgptAccountIsFedramp: false,
+            expiresAt: fallbackExpiresAt,
+            rawJwt: token,
+        };
+    }
+};
+const toSmartAiAuthFile = (tokenData) => ({
+    accessToken: tokenData.accessToken,
+    refreshToken: tokenData.refreshToken,
+    idToken: tokenData.idToken,
+    accountId: tokenData.accountId,
+    tokenInfo: tokenData.tokenInfo,
+});
+const toCodexAuthFile = (current, tokenData) => ({
+    ...current,
+    OPENAI_API_KEY: current.OPENAI_API_KEY ?? null,
+    tokens: {
+        ...(isRecord(current.tokens) ? current.tokens : {}),
+        id_token: tokenData.idToken,
+        access_token: tokenData.accessToken,
+        refresh_token: tokenData.refreshToken,
+        account_id: tokenData.accountId ?? tokenData.tokenInfo.chatgptAccountId,
+    },
+    last_refresh: new Date().toISOString(),
+});
+const toOpenCodeAuthFile = (current, tokenData) => ({
+    ...current,
+    openai: {
+        ...(isRecord(current.openai) ? current.openai : {}),
+        type: 'oauth',
+        refresh: tokenData.refreshToken,
+        access: tokenData.accessToken,
+        expires: tokenData.tokenInfo.expiresAt ? Date.parse(tokenData.tokenInfo.expiresAt) : undefined,
+        accountId: tokenData.accountId ?? tokenData.tokenInfo.chatgptAccountId,
+    },
+});
+const shouldRefreshToken = (tokenData, now) => {
+    if (!tokenData.tokenInfo.expiresAt)
+        return false;
+    return Date.parse(tokenData.tokenInfo.expiresAt) - now.getTime() < refreshWindowMs;
+};
+const isExpired = (tokenData, now) => {
+    if (!tokenData.tokenInfo.expiresAt)
+        return false;
+    return Date.parse(tokenData.tokenInfo.expiresAt) <= now.getTime();
+};
+const readJsonFileIfExists = async (filePath) => {
+    try {
+        const parsed = JSON.parse(await fs.readFile(filePath, 'utf8'));
+        return isRecord(parsed) ? parsed : {};
+    }
+    catch (error) {
+        const nodeError = error;
+        if (nodeError.code === 'ENOENT')
+            return {};
+        throw error;
+    }
+};
+const writeJsonAtomic = async (filePath, payload) => {
+    const tempPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    await fs.mkdir(path.dirname(filePath), { recursive: true, mode: 0o700 });
+    await fs.writeFile(tempPath, `${JSON.stringify(payload, undefined, 2)}\n`, { mode: 0o600 });
+    await fs.rename(tempPath, filePath);
+};
+const isRecord = (value) => {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+};
+const stringValue = (value) => {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../ts_openai_chatgpt_auth/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartai",
-  "version": "2.3.0",
+  "version": "4.0.1",
   "private": false,
   "description": "Provider registry and capability utilities for ai-sdk (Vercel AI SDK). Core export returns LanguageModel; subpath exports provide vision, audio, image, document and research capabilities.",
   "main": "dist_ts/index.js",
@@ -30,6 +30,10 @@
     "./research": {
       "import": "./dist_ts_research/index.js",
       "types": "./dist_ts_research/index.d.ts"
+    },
+    "./openai-chatgpt-auth": {
+      "import": "./dist_ts_openai_chatgpt_auth/index.js",
+      "types": "./dist_ts_openai_chatgpt_auth/index.d.ts"
     }
   },
   "author": "Task Venture Capital GmbH",
@@ -78,6 +82,7 @@
     "ts_image/**/*",
     "ts_document/**/*",
     "ts_research/**/*",
+    "ts_openai_chatgpt_auth/**/*",
     "dist_*/**/*",
     "assets/**/*",
     ".smartconfig.json",

package/readme.hints.md

@@ -10,7 +10,8 @@ The package is a **provider registry** built on the Vercel AI SDK (`ai` v6). The
 - Providers: anthropic, openai, google, groq, mistral, xai, perplexity, ollama
 - Anthropic prompt caching via `wrapLanguageModel` middleware (enabled by default)
 - Custom Ollama provider implementing `LanguageModelV3` directly (for think, num_ctx support)
-- OpenAI ChatGPT/Max device-code auth in `smartai.auth.openai.ts`; `openAiMaxAuth` routes OpenAI models to the ChatGPT Codex backend
+- OpenAI ChatGPT/Codex device-code auth in `smartai.auth.openai.ts`; `openAiChatGptAuth` routes OpenAI models to the ChatGPT Codex backend
+- Node-only local auth source helpers live in `ts_openai_chatgpt_auth/` and support SmartAI, OpenCode, and Codex auth file formats
 
 ### Subpath Exports
 - `@push.rocks/smartai/vision` — `analyzeImage()` using `generateText` with image content

package/readme.md

@@ -107,29 +107,60 @@ console.log(result.text);
 
 OpenAI `reasoningEffort` supports `'none'`, `'minimal'`, `'low'`, `'medium'`, `'high'`, and `'xhigh'`. Model IDs are accepted as strings, so new IDs like `'gpt-5.5'` can be used before upstream model unions are updated.
 
-### OpenAI Max / ChatGPT Auth
+### OpenAI ChatGPT / Codex Auth
 
-SmartAI can request ChatGPT subscription-backed Codex credentials with OpenAI's device-code flow. The returned credentials are passed to `getModel()` through `openAiMaxAuth`; SmartAI then routes OpenAI model calls through the ChatGPT Codex backend with the required account headers.
+SmartAI can request ChatGPT subscription-backed Codex credentials with OpenAI's device-code flow. The returned credentials are passed to `getModel()` through `openAiChatGptAuth`; SmartAI then routes OpenAI model calls through the ChatGPT Codex backend with the required account headers.
 
 ```typescript
 import {
-  completeOpenAiMaxDeviceCodeLogin,
+  completeOpenAiChatGptDeviceCodeLogin,
   getModel,
-  requestOpenAiMaxDeviceCode,
+  requestOpenAiChatGptDeviceCode,
 } from '@push.rocks/smartai';
 
-const deviceCode = await requestOpenAiMaxDeviceCode();
+const deviceCode = await requestOpenAiChatGptDeviceCode();
 console.log(`Open ${deviceCode.verificationUrl} and enter ${deviceCode.userCode}`);
 
-const openAiMaxAuth = await completeOpenAiMaxDeviceCodeLogin(deviceCode);
+const openAiChatGptAuth = await completeOpenAiChatGptDeviceCodeLogin(deviceCode);
 const model = getModel({
   provider: 'openai',
   model: 'gpt-5.5',
-  openAiMaxAuth,
+  openAiChatGptAuth,
 });
 ```
 
-Use `refreshOpenAiMaxTokenData(openAiMaxAuth)` before stored credentials expire, or after receiving an unauthorized response.
+Use `refreshOpenAiChatGptTokenData(openAiChatGptAuth)` before stored credentials expire, or after receiving an unauthorized response.
+
+Node.js consumers can inspect and resolve local ChatGPT auth files through the Node-only subpath. This supports SmartAI's canonical auth file, OpenCode's `~/.local/share/opencode/auth.json`, and Codex's `~/.codex/auth.json` without exposing token values in inspection results.
+
+```typescript
+import {
+  inspectOpenAiChatGptAuthSources,
+  resolveOpenAiChatGptAuth,
+} from '@push.rocks/smartai/openai-chatgpt-auth';
+
+const sources = await inspectOpenAiChatGptAuthSources({
+  sources: ['smartai', 'opencode', 'codex'],
+});
+
+const resolved = await resolveOpenAiChatGptAuth({
+  sources: ['smartai', 'opencode', 'codex'],
+  refresh: 'ifNeeded',
+  writeBack: {
+    smartai: true,
+    opencode: false,
+    codex: false,
+  },
+});
+
+if (resolved) {
+  const model = getModel({
+    provider: 'openai',
+    model: 'gpt-5.5',
+    openAiChatGptAuth: resolved.tokenData,
+  });
+}
+```
 
 ### Re-exported AI SDK Functions
 

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartai',
-  version: '2.3.0',
+  version: '4.0.1',
   description: 'Provider registry and capability utilities for ai-sdk (Vercel AI SDK). Core export returns LanguageModel; subpath exports provide vision, audio, image, document and research capabilities.'
 }

package/ts/index.ts

@@ -1,13 +1,13 @@
 export { getModel, getModelSetup } from './smartai.classes.smartai.js';
 export type {
   IOpenAiProviderOptions,
-  IOpenAiMaxAuthCredentials,
-  IOpenAiMaxAuthOptions,
-  IOpenAiMaxCompleteDeviceCodeOptions,
-  IOpenAiMaxDeviceCode,
-  IOpenAiMaxDeviceCodePollOptions,
-  IOpenAiMaxIdTokenInfo,
-  IOpenAiMaxTokenData,
+  IOpenAiChatGptAuthCredentials,
+  IOpenAiChatGptAuthOptions,
+  IOpenAiChatGptCompleteDeviceCodeOptions,
+  IOpenAiChatGptDeviceCode,
+  IOpenAiChatGptDeviceCodePollOptions,
+  IOpenAiChatGptTokenData,
+  IOpenAiChatGptTokenInfo,
   ISmartAiModelSetup,
   ISmartAiOptions,
   TOpenAiReasoningEffort,
@@ -36,21 +36,21 @@ export type {
 } from './smartai.cache.js';
 export { createOllamaModel } from './smartai.provider.ollama.js';
 export {
-  OPENAI_MAX_AUTH_ISSUER,
-  OPENAI_MAX_CLIENT_ID,
-  OPENAI_MAX_CODEX_BASE_URL,
-  OPENAI_MAX_DEFAULT_ORIGINATOR,
-  OpenAiMaxAuthError,
-  completeOpenAiMaxDeviceCodeLogin,
-  createOpenAiMaxProviderSettings,
-  ensureOpenAiMaxWorkspaceAllowed,
-  exchangeOpenAiMaxAuthorizationCode,
-  parseOpenAiMaxIdToken,
-  pollOpenAiMaxDeviceCode,
-  refreshOpenAiMaxTokenData,
-  requestOpenAiMaxDeviceCode,
+  OPENAI_CHATGPT_AUTH_ISSUER,
+  OPENAI_CHATGPT_CLIENT_ID,
+  OPENAI_CHATGPT_CODEX_BASE_URL,
+  OPENAI_CHATGPT_DEFAULT_ORIGINATOR,
+  OpenAiChatGptAuthError,
+  completeOpenAiChatGptDeviceCodeLogin,
+  createOpenAiChatGptProviderSettings,
+  ensureOpenAiChatGptWorkspaceAllowed,
+  exchangeOpenAiChatGptAuthorizationCode,
+  parseOpenAiChatGptTokenInfo,
+  pollOpenAiChatGptDeviceCode,
+  refreshOpenAiChatGptTokenData,
+  requestOpenAiChatGptDeviceCode,
 } from './smartai.auth.openai.js';
-export type { IOpenAiMaxAuthorizationCode } from './smartai.auth.openai.js';
+export type { IOpenAiChatGptAuthorizationCode } from './smartai.auth.openai.js';
 
 // Re-export commonly used ai-sdk functions for consumer convenience
 export { generateText, streamText, tool, jsonSchema } from 'ai';