dsh-openai-subscription 0.1.2 → 0.1.4

package/dist/models.js

@@ -1,4 +1,5 @@
 /** Dynamic ChatGPT Codex model discovery and catalog ownership helpers. */
+import { SubscriptionError } from './errors.js';
 const MODELS_ENDPOINT = 'https://chatgpt.com/backend-api/codex/models';
 /**
  * Codex releases replace their workspace's 0.0.0 version at build time, while
@@ -71,7 +72,7 @@ function normalizeInputs(value) {
 export function parseOpenAIModelCatalog(value) {
     const root = recordOf(value);
     if (root === null || !Array.isArray(root.models))
-        throw new Error('ChatGPT 模型服务返回了无效数据');
+        throw new SubscriptionError('invalid-response');
     const candidates = [];
     const seenIds = new Set();
     const adoptedIds = new Set();
@@ -108,77 +109,106 @@ export function parseOpenAIModelCatalog(value) {
     candidates.sort((left, right) => left.priority - right.priority || left.index - right.index);
     const models = candidates.map((candidate) => candidate.model);
     if (models.length === 0)
-        throw new Error('ChatGPT 当前没有返回可用模型');
+        throw new SubscriptionError('models-empty');
     return { models, seenIds: [...seenIds] };
 }
 function abortableSignal(parent, timeoutMs) {
     const controller = new AbortController();
-    let timeoutReached = false;
-    const onAbort = () => controller.abort(parent?.reason);
+    // Never propagate the caller's reason: it can contain tokens or remote text.
+    const onAbort = () => controller.abort(new SubscriptionError('cancelled'));
     if (parent?.aborted)
         onAbort();
     else
         parent?.addEventListener('abort', onAbort, { once: true });
-    const timeout = setTimeout(() => {
-        timeoutReached = true;
-        controller.abort(new Error('model discovery timed out'));
-    }, timeoutMs);
+    const timeout = setTimeout(() => controller.abort(new SubscriptionError('timeout')), timeoutMs);
     return {
         signal: controller.signal,
-        timedOut: () => timeoutReached,
         dispose: () => {
             clearTimeout(timeout);
             parent?.removeEventListener('abort', onAbort);
         },
     };
 }
-class ResponseTooLargeError extends Error {
+/** Bound even implementations whose fetch/read promises ignore the signal. */
+async function awaitWithAbort(promise, signal) {
+    let onAbort = () => { };
+    const aborted = new Promise((_resolve, reject) => {
+        onAbort = () => reject(signal.reason);
+        signal.addEventListener('abort', onAbort, { once: true });
+        if (signal.aborted)
+            onAbort();
+    });
+    try {
+        return await Promise.race([aborted, promise]);
+    }
+    finally {
+        signal.removeEventListener('abort', onAbort);
+    }
+}
+function cancelBody(response) {
+    // Cancellation is best-effort, not another unbounded part of the deadline.
+    try {
+        void response.body?.cancel().catch(() => { });
+    }
+    catch { /* Already unavailable. */ }
 }
 async function readBoundedResponse(response, signal) {
+    signal.throwIfAborted();
     if (response.body === null)
         return '';
     const reader = response.body.getReader();
     const decoder = new TextDecoder();
     let total = 0;
     let text = '';
-    const cancel = () => { void reader.cancel(signal.reason).catch(() => { }); };
-    signal.addEventListener('abort', cancel, { once: true });
+    let complete = false;
     try {
         while (true) {
-            if (signal.aborted)
-                throw signal.reason;
-            const chunk = await reader.read();
+            signal.throwIfAborted();
+            let chunk;
+            try {
+                chunk = await awaitWithAbort(reader.read(), signal);
+            }
+            catch {
+                signal.throwIfAborted();
+                throw new SubscriptionError('network');
+            }
             if (chunk.done)
                 break;
             total += chunk.value.byteLength;
             if (total > MAX_RESPONSE_BYTES)
-                throw new ResponseTooLargeError();
+                throw new SubscriptionError('invalid-response');
             text += decoder.decode(chunk.value, { stream: true });
         }
-        if (signal.aborted)
-            throw signal.reason;
+        signal.throwIfAborted();
+        complete = true;
         return text + decoder.decode();
     }
-    catch (error) {
-        await reader.cancel().catch(() => { });
-        throw error;
-    }
     finally {
-        signal.removeEventListener('abort', cancel);
+        // Do not await cancel(): an underlying source can stall or reject it. The
+        // pending read is handled by awaitWithAbort and its lock is always released.
+        if (!complete) {
+            try {
+                void reader.cancel().catch(() => { });
+            }
+            catch { /* Already unavailable. */ }
+        }
         reader.releaseLock();
     }
 }
 /** Fetch the live model catalog available to this exact ChatGPT account. */
 export async function discoverOpenAIModels(credential, options = {}) {
+    if (options.signal?.aborted)
+        throw new SubscriptionError('cancelled');
     if (nonEmptyString(credential.access) === undefined)
-        throw new Error('ChatGPT 授权不可用，请重新登录');
+        throw new SubscriptionError('not-connected');
     const fetcher = options.fetch ?? globalThis.fetch;
     if (typeof fetcher !== 'function')
-        throw new Error('当前运行环境无法连接 ChatGPT 模型服务');
+        throw new SubscriptionError('network');
     const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
-        throw new TypeError('timeoutMs must be positive');
+        throw new SubscriptionError('invalid-response');
     const control = abortableSignal(options.signal, timeoutMs);
+    let response;
     try {
         const url = new URL(MODELS_ENDPOINT);
         url.searchParams.set('client_version', CLIENT_VERSION);
@@ -191,51 +221,57 @@ export async function discoverOpenAIModels(credential, options = {}) {
         const accountId = nonEmptyString(credential.accountId);
         if (accountId !== undefined)
             headers.set('chatgpt-account-id', accountId);
-        let response;
         try {
-            response = await fetcher(url, { method: 'GET', headers, signal: control.signal, redirect: 'error' });
+            control.signal.throwIfAborted();
+            const pending = fetcher(url, { method: 'GET', headers, signal: control.signal, redirect: 'error' })
+                .then((result) => {
+                // A non-cooperative fetch may finish after discovery already stopped.
+                if (control.signal.aborted) {
+                    cancelBody(result);
+                    control.signal.throwIfAborted();
+                }
+                response = result;
+                return result;
+            });
+            response = await awaitWithAbort(pending, control.signal);
         }
         catch {
-            if (options.signal?.aborted)
-                throw new Error('模型同步已取消');
-            if (control.timedOut())
-                throw new Error('获取 ChatGPT 模型超时，请稍后重试');
-            throw new Error('无法连接 ChatGPT 模型服务，请检查网络后重试');
+            control.signal.throwIfAborted();
+            throw new SubscriptionError('network');
         }
-        if (response.status === 401 || response.status === 403) {
-            throw new Error('ChatGPT 授权已失效，请刷新授权后重试');
+        if (!response.ok) {
+            if (response.status === 401)
+                throw new SubscriptionError('authorization-expired');
+            if (response.status === 403)
+                throw new SubscriptionError('access-denied');
+            if (response.status === 429)
+                throw new SubscriptionError('rate-limited');
+            throw new SubscriptionError('models-unavailable');
         }
-        if (response.status === 429)
-            throw new Error('模型同步请求过于频繁，请稍后重试');
-        if (!response.ok)
-            throw new Error(`ChatGPT 模型服务暂时不可用（HTTP ${response.status}）`);
         const contentLength = Number(response.headers.get('content-length'));
-        if (Number.isFinite(contentLength) && contentLength > MAX_RESPONSE_BYTES) {
-            throw new Error('ChatGPT 模型服务返回的数据过大');
-        }
-        let text;
-        try {
-            text = await readBoundedResponse(response, control.signal);
-        }
-        catch (error) {
-            if (error instanceof ResponseTooLargeError)
-                throw new Error('ChatGPT 模型服务返回的数据过大');
-            if (options.signal?.aborted)
-                throw new Error('模型同步已取消');
-            if (control.timedOut())
-                throw new Error('获取 ChatGPT 模型超时，请稍后重试');
-            throw new Error('读取 ChatGPT 模型数据失败，请稍后重试');
+        if (contentLength > MAX_RESPONSE_BYTES) {
+            throw new SubscriptionError('invalid-response');
         }
+        const text = await readBoundedResponse(response, control.signal);
         let body;
         try {
             body = JSON.parse(text);
         }
         catch {
-            throw new Error('ChatGPT 模型服务返回了无效数据');
+            throw new SubscriptionError('invalid-response');
         }
         return parseOpenAIModelCatalog(body);
     }
+    catch (error) {
+        control.signal.throwIfAborted();
+        if (error instanceof SubscriptionError)
+            throw error;
+        throw new SubscriptionError('network');
+    }
     finally {
+        // Includes non-OK responses, oversized headers, and failures before reading.
+        if (response !== undefined && !response.bodyUsed)
+            cancelBody(response);
         control.dispose();
     }
 }

package/dist/oauth.js

@@ -1,5 +1,5 @@
 function nonEmptyString(value) {
-    return typeof value === 'string' && value.length > 0 ? value : undefined;
+    return typeof value === 'string' && value.trim().length > 0 && !/[\r\n\0]/.test(value) ? value : undefined;
 }
 function positiveFiniteNumber(value) {
     return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : undefined;
@@ -9,7 +9,7 @@ function positiveFiniteNumber(value) {
  * previously normalized credential.
  */
 export function normalizeOAuthCredential(value, fallback = {}) {
-    if (typeof value !== 'object' || value === null)
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
         return null;
     const raw = value;
     const access = nonEmptyString(raw.access);

package/dist/platform.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Ordered filesystem fallbacks: running DSH first, then Node/npm/nvm,
+ * NODE_PATH and user pnpm/bun roots. The fourth argument permits portable
+ * win32 fixtures; omitted, it uses the current OS and preserves the old API.
+ * This list is not a trust decision and does not import any candidate.
+ */
+export declare function authModuleCandidates(entryScript: string | undefined, nodeBinary: string | undefined, env: NodeJS.ProcessEnv | undefined, platform?: NodeJS.Platform): string[];
+/** Find a real file, without loading OAuth code or launching external commands. */
+export declare function resolveAuthModule(entryScript?: string | undefined, nodeBinary?: string | undefined, env?: NodeJS.ProcessEnv | undefined): string;
+/** pi-ai's supported Node floor; reject malformed version reports conservatively. */
+export declare function runtimeSupported(version?: string): boolean;
+/**
+ * Build only a command; callers MUST keep execution through ctx.shell.
+ * Default DSH providers use POSIX Bash on Unix and PowerShell on Windows.
+ * Custom providers using a different dialect need an explicit platform override.
+ */
+export declare function buildNodeCommand(script: string, modulePath: string, platform?: NodeJS.Platform, nodeBinary?: string): string;

package/dist/platform.js

@@ -0,0 +1,279 @@
+import { realpathSync, statSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { join, posix, win32 } from 'node:path';
+import { pathToFileURL } from 'node:url';
+const AUTH_PACKAGE = '@earendil-works/pi-ai';
+const AUTH_RELATIVE = 'dist/auth/oauth/openai-codex.js';
+const ADAPTER_PACKAGE = '@deepseek-ai/dsh-llm-pi-ai';
+const DSH_PACKAGE = '@deepseek-ai/dsh';
+const PI_CLI_PACKAGE = '@earendil-works/pi-coding-agent';
+function paths(platform) {
+    return platform === 'win32' ? win32 : posix;
+}
+/** Canonical targets precede shims/symlinks, without invoking readlink or a shell. */
+function entryPaths(value, platform) {
+    if (!value)
+        return [];
+    const normalized = paths(platform).resolve(value);
+    if (platform === process.platform) {
+        try {
+            const actual = realpathSync(normalized);
+            if (actual !== normalized)
+                return [actual, normalized];
+        }
+        catch {
+            // Missing/inaccessible paths still provide useful lexical fallback roots.
+        }
+    }
+    return [normalized];
+}
+function moduleRoots(entry, platform) {
+    const path = paths(platform);
+    const roots = [];
+    let directory = path.dirname(entry);
+    for (let depth = 0; depth < 40; depth++) {
+        if (path.basename(directory) !== 'node_modules')
+            roots.push(path.join(directory, 'node_modules'));
+        const parent = path.dirname(directory);
+        if (parent === directory)
+            break;
+        directory = parent;
+    }
+    return roots;
+}
+function globalRoots(nodeBinary, env, platform) {
+    const path = paths(platform);
+    const roots = [];
+    const addPrefix = (prefix) => {
+        if (!prefix)
+            return;
+        roots.push(path.join(prefix, 'node_modules'), path.join(prefix, 'lib/node_modules'));
+    };
+    const addPnpm = (home) => {
+        if (!home)
+            return;
+        roots.push(path.join(home, 'global/5/node_modules'), path.join(home, 'global/node_modules'));
+    };
+    for (const binary of entryPaths(nodeBinary, platform)) {
+        const directory = path.dirname(binary);
+        roots.push(path.resolve(directory, '../lib/node_modules'), path.join(directory, 'node_modules'));
+    }
+    for (const root of env?.NODE_PATH?.split(path.delimiter) ?? []) {
+        if (root)
+            roots.push(root, path.join(root, 'node_modules'));
+    }
+    addPrefix(env?.npm_config_prefix ?? env?.NPM_CONFIG_PREFIX ?? env?.PREFIX);
+    if (env?.NVM_BIN)
+        roots.push(path.resolve(env.NVM_BIN, '../lib/node_modules'));
+    addPrefix(env?.NVM_SYMLINK);
+    addPnpm(env?.PNPM_HOME);
+    if (env?.BUN_INSTALL)
+        roots.push(path.join(env.BUN_INSTALL, 'install/global/node_modules'));
+    if (platform === 'win32') {
+        if (env?.APPDATA)
+            roots.push(path.join(env.APPDATA, 'npm/node_modules'));
+        if (env?.LOCALAPPDATA)
+            addPnpm(path.join(env.LOCALAPPDATA, 'pnpm'));
+    }
+    if (env?.XDG_DATA_HOME)
+        addPnpm(path.join(env.XDG_DATA_HOME, 'pnpm'));
+    const home = platform === 'win32'
+        ? env?.USERPROFILE || (env?.HOMEDRIVE && env.HOMEPATH ? env.HOMEDRIVE + env.HOMEPATH : env?.HOME)
+        : env?.HOME;
+    if (home) {
+        roots.push(path.join(home, '.bun/install/global/node_modules'));
+        addPrefix(path.join(home, '.npm-global'));
+        addPrefix(path.join(home, '.local'));
+        if (platform === 'win32') {
+            roots.push(path.join(home, 'AppData/Roaming/npm/node_modules'));
+            addPnpm(path.join(home, 'AppData/Local/pnpm'));
+        }
+        else if (platform === 'darwin') {
+            addPnpm(path.join(home, 'Library/pnpm'));
+        }
+        else {
+            addPnpm(path.join(home, '.local/share/pnpm'));
+        }
+    }
+    return roots;
+}
+function pathDirectories(env, platform) {
+    return ((platform === 'win32' ? env?.PATH ?? env?.Path : env?.PATH) ?? '')
+        .split(paths(platform).delimiter).filter(Boolean);
+}
+function pathEntries(env, platform) {
+    if (platform !== process.platform)
+        return [];
+    const entries = [];
+    for (const name of ['dsh', 'pi', 'pi-ai']) {
+        for (const directory of pathDirectories(env, platform)) {
+            for (const suffix of platform === 'win32' ? ['.cmd', '.exe', '.js', ''] : ['']) {
+                const entry = file(join(directory, name + suffix));
+                if (entry)
+                    entries.push(entry);
+            }
+        }
+    }
+    return entries;
+}
+function pathRoots(env, platform) {
+    const path = paths(platform);
+    return pathDirectories(env, platform).flatMap((directory) => [
+        path.join(directory, 'node_modules'), path.resolve(directory, '../lib/node_modules'),
+    ]);
+}
+function lookupRoots(entryScript, nodeBinary, env, platform) {
+    return [
+        ...entryPaths(entryScript, platform).flatMap((entry) => moduleRoots(entry, platform)),
+        ...globalRoots(nodeBinary, env, platform),
+        ...pathEntries(env, platform).flatMap((entry) => moduleRoots(entry, platform)),
+        ...pathRoots(env, platform),
+    ];
+}
+/**
+ * Ordered filesystem fallbacks: running DSH first, then Node/npm/nvm,
+ * NODE_PATH and user pnpm/bun roots. The fourth argument permits portable
+ * win32 fixtures; omitted, it uses the current OS and preserves the old API.
+ * This list is not a trust decision and does not import any candidate.
+ */
+export function authModuleCandidates(entryScript, nodeBinary, env, platform = process.platform) {
+    const path = paths(platform);
+    const candidates = [];
+    const seen = new Set();
+    for (const root of lookupRoots(entryScript, nodeBinary, env, platform)) {
+        for (const base of [
+            path.join(root, DSH_PACKAGE, 'node_modules', ADAPTER_PACKAGE, 'node_modules'),
+            path.join(root, DSH_PACKAGE, 'node_modules'),
+            path.join(root, ADAPTER_PACKAGE, 'node_modules'),
+            root,
+            path.join(root, PI_CLI_PACKAGE, 'node_modules'),
+        ]) {
+            const candidate = path.resolve(base, AUTH_PACKAGE, AUTH_RELATIVE);
+            const key = platform === 'win32' ? candidate.toLowerCase() : candidate;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            candidates.push(candidate);
+        }
+    }
+    return candidates;
+}
+function file(value) {
+    try {
+        return statSync(value).isFile() ? realpathSync(value) : '';
+    }
+    catch {
+        return '';
+    }
+}
+function packageEntry(directory) {
+    try {
+        return statSync(directory).isDirectory() ? join(realpathSync(directory), 'package.json') : '';
+    }
+    catch {
+        return '';
+    }
+}
+/** Only local ancestry, not createRequire's ambient NODE_PATH/globalPaths. */
+function dependencyRoots(entry, name) {
+    const allowed = new Set(moduleRoots(entry, process.platform));
+    try {
+        return (createRequire(pathToFileURL(entry)).resolve.paths(name) ?? []).filter((root) => allowed.has(root));
+    }
+    catch {
+        return [...allowed];
+    }
+}
+function probePiAi(entry) {
+    // Walk require's roots rather than requiring/importing the module. pi-ai's
+    // exports are import-only and deliberately hide package.json and this file.
+    for (const root of dependencyRoots(entry, AUTH_PACKAGE)) {
+        const candidate = file(join(root, AUTH_PACKAGE, AUTH_RELATIVE));
+        if (candidate)
+            return candidate;
+    }
+    return '';
+}
+function probeInstallation(entry) {
+    // Canonicalizing the adapter follows pnpm's symlink into its virtual store,
+    // where its own pi-ai dependency can differ from a top-level hoisted copy.
+    for (const root of dependencyRoots(entry, ADAPTER_PACKAGE)) {
+        const adapter = packageEntry(join(root, ADAPTER_PACKAGE));
+        if (adapter) {
+            const candidate = probePiAi(adapter);
+            if (candidate)
+                return candidate;
+        }
+    }
+    return probePiAi(entry);
+}
+function probeRoot(root) {
+    const dsh = packageEntry(join(root, DSH_PACKAGE));
+    if (dsh) {
+        const candidate = probeInstallation(dsh);
+        if (candidate)
+            return candidate;
+    }
+    const adapter = packageEntry(join(root, ADAPTER_PACKAGE));
+    const candidate = (adapter && probePiAi(adapter)) || file(join(root, AUTH_PACKAGE, AUTH_RELATIVE));
+    if (candidate)
+        return candidate;
+    const pi = packageEntry(join(root, PI_CLI_PACKAGE));
+    return pi ? probePiAi(pi) : '';
+}
+/** Find a real file, without loading OAuth code or launching external commands. */
+export function resolveAuthModule(entryScript = process.argv[1], nodeBinary = process.execPath, env = process.env) {
+    for (const entry of entryPaths(entryScript, process.platform)) {
+        const candidate = probeInstallation(entry);
+        if (candidate)
+            return candidate;
+    }
+    for (const root of globalRoots(nodeBinary, env, process.platform)) {
+        const candidate = probeRoot(root);
+        if (candidate)
+            return candidate;
+    }
+    // Last-resort replacement for `command -v pi`: inspect PATH entries with
+    // Node fs only. Canonical targets cover Unix symlinks; adjacent package
+    // roots cover npm's Windows .cmd shims without parsing or executing them.
+    for (const entry of pathEntries(env, process.platform)) {
+        const candidate = probeInstallation(entry);
+        if (candidate)
+            return candidate;
+    }
+    for (const root of pathRoots(env, process.platform)) {
+        const candidate = probeRoot(root);
+        if (candidate)
+            return candidate;
+    }
+    return '';
+}
+/** pi-ai's supported Node floor; reject malformed version reports conservatively. */
+export function runtimeSupported(version = process.versions.node) {
+    const match = /^(\d+)\.(\d+)\.(\d+)(?:[-+].*)?$/.exec(version);
+    if (!match)
+        return false;
+    const major = Number(match[1]);
+    return major > 22 || (major === 22 && Number(match[2]) >= 19);
+}
+/**
+ * Build only a command; callers MUST keep execution through ctx.shell.
+ * Default DSH providers use POSIX Bash on Unix and PowerShell on Windows.
+ * Custom providers using a different dialect need an explicit platform override.
+ */
+export function buildNodeCommand(script, modulePath, platform = process.platform, nodeBinary = process.execPath) {
+    if ([script, modulePath, nodeBinary].some((value) => value.includes('\0'))) {
+        throw new TypeError('Node command arguments must not contain NUL');
+    }
+    if (platform === 'win32') {
+        const quote = (value) => "'" + value.replace(/'/g, "''") + "'";
+        // No embedded double quotes in the native eval argument: this also works
+        // with Windows PowerShell's legacy native argument marshalling. Data URLs
+        // retain ESM syntax without temporary files; drivers use node: imports and
+        // the absolute modulePath argument, not relative imports from this module.
+        const bootstrap = "await import('data:text/javascript;base64," + Buffer.from(script).toString('base64') + "')";
+        return '& ' + quote(nodeBinary) + ' --input-type=module --eval ' + quote(bootstrap) + ' -- ' + quote(modulePath);
+    }
+    const quote = (value) => "'" + value.replace(/'/g, "'\\''") + "'";
+    return quote(nodeBinary) + ' --input-type=module --eval ' + quote(script) + ' -- ' + quote(modulePath);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-openai-subscription",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "ChatGPT subscription sign-in for DeepSeek Harness via OpenAI device authorization.",
   "type": "module",
   "packageManager": "pnpm@10.6.3",
@@ -27,7 +27,7 @@
     "clean": "node --eval \"for (const path of ['dist', '.test-dist']) require('node:fs').rmSync(path, { recursive: true, force: true })\"",
     "build": "node --eval \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.test.json --noEmit",
-    "test": "node --eval \"require('node:fs').rmSync('.test-dist', { recursive: true, force: true })\" && tsc -p tsconfig.test.json && node --test .test-dist/tests/*.test.js && node --eval \"require('node:fs').rmSync('.test-dist', { recursive: true, force: true })\"",
+    "test": "node --eval \"require('node:fs').rmSync('.test-dist', { recursive: true, force: true })\" && tsc -p tsconfig.test.json && node scripts/run-tests.mjs && node --eval \"require('node:fs').rmSync('.test-dist', { recursive: true, force: true })\"",
     "check": "node scripts/run-scripts.mjs typecheck build test",
     "prepack": "node scripts/run-scripts.mjs check"
   },