npm - faces-cli - Versions diffs - 1.6.17 → 1.6.18 - Mend

faces-cli 1.6.17 → 1.6.18

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 (7) hide show

package/dist/client.d.ts +2 -0
package/dist/client.js +12 -4
package/dist/commands/auth/connect.d.ts +2 -1
package/dist/commands/auth/connect.js +162 -194
package/dist/commands/auth/connections.js +13 -1
package/oclif.manifest.json +914 -920
package/package.json +1 -1

package/dist/client.d.ts CHANGED Viewed

@@ -2,9 +2,11 @@ export declare class FacesAPIError extends Error {
     statusCode: number;
     errorCode?: string;
     fallbackAvailable?: boolean;
+    details?: Record<string, unknown>;
     constructor(statusCode: number, message: string, opts?: {
         errorCode?: string;
         fallbackAvailable?: boolean;
+        details?: Record<string, unknown>;
     });
 }
 export interface ResponseWithHeaders<T = unknown> {

package/dist/client.js CHANGED Viewed

@@ -2,12 +2,14 @@ export class FacesAPIError extends Error {
     statusCode;
     errorCode;
     fallbackAvailable;
+    details;
     constructor(statusCode, message, opts) {
         super(message);
         this.statusCode = statusCode;
         this.name = 'FacesAPIError';
         this.errorCode = opts?.errorCode;
         this.fallbackAvailable = opts?.fallbackAvailable;
+        this.details = opts?.details;
     }
 }
 export class FacesClient {
@@ -46,6 +48,7 @@ export class FacesClient {
         let msg = resp.statusText;
         let errorCode;
         let fallbackAvailable;
+        let details;
         try {
             const body = await resp.json();
             // Structured OAuth rejection (422)
@@ -56,11 +59,16 @@ export class FacesClient {
             }
             else {
                 const raw = body.detail ?? body.error ?? body.message ?? msg;
-                if (typeof raw === 'object' && raw !== null && 'message' in raw) {
-                    msg = String(raw.message);
+                if (typeof raw === 'object' && raw !== null) {
+                    // Structured error detail, e.g. {error, message, settings_url, settings_steps}
+                    const obj = raw;
+                    details = obj;
+                    if (typeof obj.error === 'string')
+                        errorCode = obj.error;
+                    msg = 'message' in obj ? String(obj.message) : JSON.stringify(obj);
                 }
                 else {
-                    msg = typeof raw === 'object' ? JSON.stringify(raw) : String(raw);
+                    msg = String(raw);
                 }
             }
         }
@@ -71,7 +79,7 @@ export class FacesClient {
             msg = `Payment required: ${msg}`;
         if (resp.status === 403)
             msg = `Forbidden: ${msg}`;
-        return new FacesAPIError(resp.status, msg, { errorCode, fallbackAvailable });
+        return new FacesAPIError(resp.status, msg, { errorCode, fallbackAvailable, details });
     }
     async get(path, opts = {}) {
         let url = this.url(path);

package/dist/commands/auth/connect.d.ts CHANGED Viewed

@@ -5,11 +5,12 @@ export default class AuthConnect extends BaseCommand {
         provider: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
     static flags: {
-        manual: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'base-url': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         token: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'api-key': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
     static examples: string[];
     run(): Promise<unknown>;
+    private startDevice;
+    private handleStartError;
 }

package/dist/commands/auth/connect.js CHANGED Viewed

@@ -1,71 +1,27 @@
-import { Args, Flags } from '@oclif/core';
-import * as http from 'node:http';
-import * as readline from 'node:readline';
-import { spawn } from 'node:child_process';
+import { Args } from '@oclif/core';
 import { BaseCommand } from '../../base.js';
 import { FacesAPIError } from '../../client.js';
-const CALLBACK_PORT = 1455;
-const HTML_SUCCESS = `<!DOCTYPE html><html>
-<head><title>Connected</title><style>body{font-family:sans-serif;padding:48px;max-width:480px;color:#333}</style></head>
-<body><h2 style="color:#2e7d32">✅ Connected</h2>
-<p>Your account is linked. You can close this tab and return to your terminal.</p>
-</body></html>`;
-const HTML_ERROR = `<!DOCTYPE html><html>
-<head><title>Error</title><style>body{font-family:sans-serif;padding:48px;max-width:480px;color:#333}</style></head>
-<body><h2 style="color:#c62828">Connection failed</h2>
-<p>Something went wrong. Check your terminal for details.</p>
-</body></html>`;
-function openBrowser(url) {
-    const p = process.platform;
-    const [cmd, args] = p === 'darwin' ? ['open', [url]] :
-        p === 'win32' ? ['cmd', ['/c', 'start', url]] :
-            ['xdg-open', [url]];
-    spawn(cmd, args, { detached: true, stdio: 'ignore' }).unref();
+const VERIFICATION_FALLBACK = 'https://auth.openai.com/codex/device';
+const SETTINGS_URL = 'https://chatgpt.com/#settings/Security';
+const HARD_STOP_MS = 15 * 60 * 1000; // device codes expire after 15 minutes
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const emit = (msg = '') => process.stderr.write(msg + '\n');
+// Unwrap a possible StandardResponse envelope ({data: {...}}) without
+// clobbering a flat payload that already has the expected key.
+function unwrap(raw, key) {
+    const r = raw;
+    if (r && typeof r === 'object' && !(key in r) && r.data && typeof r.data === 'object') {
+        return r.data;
+    }
+    return raw;
 }
-function waitForCallback(timeoutMs = 300_000) {
-    return new Promise((resolve, reject) => {
-        const server = http.createServer((req, res) => {
-            const url = new URL(req.url ?? '/', `http://127.0.0.1:${CALLBACK_PORT}`);
-            if (url.pathname !== '/auth/callback') {
-                res.writeHead(404);
-                res.end();
-                return;
-            }
-            const code = url.searchParams.get('code');
-            const state = url.searchParams.get('state');
-            if (!code || !state) {
-                res.writeHead(400, { 'Content-Type': 'text/html' });
-                res.end(HTML_ERROR);
-                server.close();
-                reject(new Error('OAuth callback missing code or state'));
-                return;
-            }
-            res.writeHead(200, { 'Content-Type': 'text/html' });
-            res.end(HTML_SUCCESS);
-            server.close();
-            resolve({ code, state });
-        });
-        server.on('error', (err) => {
-            const code = err.code;
-            if (code === 'EADDRINUSE') {
-                reject(new Error(`Port ${CALLBACK_PORT} is already in use. ` +
-                    'Make sure no other process is listening on that port and retry.'));
-            }
-            else {
-                reject(err);
-            }
-        });
-        server.listen(CALLBACK_PORT, '127.0.0.1');
-        const timer = setTimeout(() => {
-            server.close();
-            reject(new Error('Timed out waiting for OAuth callback (5 minutes). Please try again.'));
-        }, timeoutMs);
-        // Don't let the timer keep the process alive
-        timer.unref();
-    });
+function planLabel(plan) {
+    if (!plan)
+        return '';
+    return plan.charAt(0).toUpperCase() + plan.slice(1);
 }
 export default class AuthConnect extends BaseCommand {
-    static description = 'Connect an OAuth provider account to Faces (e.g. ChatGPT Plus/Pro)';
+    static description = 'Connect your ChatGPT account to Faces via device-code authorization (Subscription Connect plan)';
     static args = {
         provider: Args.string({
             description: 'OAuth provider to connect',
@@ -75,165 +31,177 @@ export default class AuthConnect extends BaseCommand {
     };
     static flags = {
         ...BaseCommand.baseFlags,
-        manual: Flags.boolean({
-            description: 'Manual mode for headless environments: prints the authorize URL and ' +
-                'prompts you to paste the callback URL after approving in any browser.',
-            default: false,
-        }),
     };
     static examples = [
         '<%= config.bin %> auth connect openai',
-        '<%= config.bin %> auth connect openai --manual',
+        '<%= config.bin %> auth connect openai --json',
     ];
     async run() {
-        const { args, flags } = await this.parse(AuthConnect);
+        const { flags } = await this.parse(AuthConnect);
         const client = this.makeClient(flags, true);
-        // 0. Short-circuit if already connected
+        // 0. Short-circuit if already connected.
         try {
             const existing = (await client.get('/v1/oauth', { requireJwt: true }));
-            if (existing.some((r) => r.provider === args.provider)) {
-                const output = { provider: args.provider, connected: true, already_connected: true };
-                if (!this.jsonEnabled())
-                    this.log(`Already connected to ${args.provider}. Run 'faces auth:disconnect ${args.provider}' to reconnect.`);
+            const row = existing.find((r) => r.provider === 'openai');
+            if (row) {
+                const email = row.account_email ?? null;
+                const plan = row.chatgpt_plan_type ?? null;
+                const output = { provider: 'openai', connected: true, already_connected: true, account_email: email, chatgpt_plan_type: plan };
+                if (!this.jsonEnabled()) {
+                    const who = email ? ` as ${email}` : '';
+                    const tier = plan ? ` (${planLabel(plan)})` : '';
+                    this.log(`Already connected to ChatGPT${who}${tier}. Run 'faces auth:disconnect openai' to reconnect.`);
+                }
                 return output;
             }
         }
-        catch { /* ignore — proceed with connect flow */ }
-        // 1. Get the authorize URL (backend generates PKCE, stores state)
-        this.log(`Connecting ${args.provider}...`);
-        let authorizeData;
+        catch {
+            /* ignore — proceed with connect flow */
+        }
+        // 1. Start the device authorization (backend brokers OpenAI).
+        let start;
         try {
-            authorizeData = (await client.get(`/v1/oauth/${args.provider}/authorize`, {
-                requireJwt: true,
-            }));
+            start = await this.startDevice(client);
         }
         catch (err) {
-            if (err instanceof FacesAPIError) {
-                if (err.statusCode === 403)
-                    this.error('OAuth provider routing requires the connect plan.\n' +
-                        'Upgrade with: faces billing checkout');
-                if (err.statusCode === 501)
-                    this.error(`Provider '${args.provider}' is not yet available.`);
-                this.error(`Failed to get authorize URL (${err.statusCode}): ${err.message}`);
-            }
-            throw err;
+            this.handleStartError(err);
         }
-        // 2. Get code + state — either via local server or manual paste
-        let code, state;
-        if (flags.manual) {
-            this.log('\nOpen this URL in any browser (phone, laptop, etc.):\n' +
-                `  ${authorizeData.authorize_url}\n\n` +
-                'After approving on the OpenAI page:\n' +
-                '  • If you have the Faces browser extension installed, it will handle the rest automatically.\n' +
-                '  • If not, your browser will try to load localhost:1455 and fail — copy the full URL\n' +
-                '    from your address bar and paste it below.\n');
-            // Race: poll for connection (extension path) vs paste (no-extension path)
-            let rl = null;
-            const pastePromise = new Promise((resolve) => {
-                rl = readline.createInterface({ input: process.stdin, output: process.stderr });
-                rl.question('Callback URL (skip if using extension): ', (answer) => {
-                    rl?.close();
-                    rl = null;
-                    resolve(answer);
+        const verificationUri = start.verification_uri || VERIFICATION_FALLBACK;
+        // 2. Cancel the device session if the user aborts (Ctrl-C).
+        let done = false;
+        const onSigint = () => {
+            if (done)
+                return;
+            done = true;
+            emit('\nAborted. Cancelling device authorization…');
+            Promise.race([
+                client.post('/v1/oauth/openai/device/cancel', { requireJwt: true, body: { device_auth_id: start.device_auth_id } }).catch(() => { }),
+                sleep(2000),
+            ]).finally(() => process.exit(130));
+        };
+        process.once('SIGINT', onSigint);
+        // 3. Show the code + URL and the one-time enable-setting guidance.
+        emit('');
+        emit('To connect ChatGPT:');
+        emit(`  1. Open this URL in any browser (phone, laptop — anywhere):`);
+        emit(`       ${verificationUri}`);
+        emit(`  2. Enter this code:  ${start.user_code}`);
+        emit(`  3. Sign in to ChatGPT and click Continue.`);
+        emit('');
+        emit('If this is your first time, you may need to enable device-code authorization in ChatGPT first:');
+        emit(`  1. Open ${SETTINGS_URL}  (the settings panel can take a few seconds to appear — give it a moment)`);
+        emit('  2. Turn on "Enable device code authorization for Codex"');
+        emit('  3. Then enter the code above');
+        emit('');
+        emit('Waiting for approval (the code expires in 15 minutes; press Ctrl-C to cancel)…');
+        // 4. Poll until completed / expired / timed out.
+        const startedAt = Date.now();
+        const expiresAt = Date.parse(start.expires_at); // NaN if unparseable
+        let intervalMs = Math.max(1, start.interval || 5) * 1000;
+        for (;;) {
+            const now = Date.now();
+            if (now - startedAt > HARD_STOP_MS || (!Number.isNaN(expiresAt) && now >= expiresAt)) {
+                process.removeListener('SIGINT', onSigint);
+                this.error('The code expired before it was approved. Run `faces auth:connect openai` again to get a new code.');
+            }
+            await sleep(intervalMs);
+            let poll;
+            try {
+                const raw = await client.post('/v1/oauth/openai/device/poll', {
+                    requireJwt: true,
+                    body: { device_auth_id: start.device_auth_id },
                 });
-            });
-            const result = await Promise.race([
-                pollForConnection(client, args.provider, 300_000),
-                pastePromise,
-            ]);
-            // Clean up readline + stdin if polling won (keeps Node from hanging)
-            if (rl) {
-                rl.close();
-                rl = null;
+                poll = unwrap(raw, 'status');
             }
-            process.stdin.destroy();
-            if (result === 'connected') {
-                const output = { provider: args.provider, connected: true };
-                if (!this.jsonEnabled())
-                    this.log(`\n✅ ${args.provider} connected. Your connect plan requests will route through your subscription.`);
-                return output;
+            catch (err) {
+                // Transient upstream errors: keep polling. Everything else is fatal.
+                if (err instanceof FacesAPIError && (err.statusCode === 502 || err.statusCode === 503)) {
+                    process.stderr.write('.');
+                    continue;
+                }
+                process.removeListener('SIGINT', onSigint);
+                if (err instanceof FacesAPIError)
+                    this.error(`Polling failed (${err.statusCode}): ${err.message}`);
+                throw err;
             }
-            // User pasted a URL — exchange it ourselves
-            const raw = result;
-            if (!raw.trim())
-                this.error('No callback URL provided and connection was not detected.');
-            let parsed;
-            try {
-                const normalized = raw.trim().startsWith('http') ? raw.trim() : `http://localhost:1455${raw.trim()}`;
-                parsed = new URL(normalized);
+            if (poll.status === 'completed') {
+                done = true;
+                process.removeListener('SIGINT', onSigint);
+                const email = poll.account_email ?? null;
+                const plan = poll.chatgpt_plan_type ?? null;
+                const output = { provider: 'openai', connected: true, account_email: email, chatgpt_plan_type: plan };
+                if (!this.jsonEnabled()) {
+                    const who = email ? ` as ${email}` : '';
+                    const tier = plan ? ` (${planLabel(plan)})` : '';
+                    this.log(`\n✅ ChatGPT connected${who}${tier}.`);
+                    if (!plan || plan === 'free') {
+                        this.log('⚠️  Your ChatGPT plan may not include API access. Connecting requires a paid plan (Plus/Pro/Team, etc.).');
+                    }
+                    else {
+                        this.log('Requests to supported OpenAI models will now route through your ChatGPT subscription.');
+                    }
+                }
+                return output;
             }
-            catch {
-                this.error('Could not parse the URL you pasted. Make sure to copy the full address bar URL.');
+            if (poll.status === 'expired') {
+                process.removeListener('SIGINT', onSigint);
+                this.error('The code expired or was not recognized. Run `faces auth:connect openai` again to get a new code.');
             }
-            code = parsed.searchParams.get('code') ?? '';
-            state = parsed.searchParams.get('state') ?? '';
-            if (!code || !state)
-                this.error('The pasted URL is missing code or state parameters. Did you copy the full URL?');
+            // pending — honor server-supplied retry_after, else fall back to interval.
+            intervalMs = (poll.retry_after && poll.retry_after > 0 ? poll.retry_after : (start.interval || 5)) * 1000;
+            process.stderr.write('.');
         }
-        else {
-            // Automatic mode: local callback server + open browser
-            const callbackPromise = waitForCallback();
-            openBrowser(authorizeData.authorize_url);
-            this.log(`\nBrowser opened. Approve access on the ${args.provider} page.\n` +
-                `If the browser didn't open, paste this URL:\n  ${authorizeData.authorize_url}\n`);
+    }
+    // Start the device flow, retrying transient upstream (502/503) errors.
+    async startDevice(client) {
+        let attempts502 = 0;
+        let attempts503 = 0;
+        for (;;) {
             try {
-                ;
-                ({ code, state } = await callbackPromise);
+                const raw = await client.post('/v1/oauth/openai/device/start', { requireJwt: true });
+                return unwrap(raw, 'device_auth_id');
             }
             catch (err) {
-                this.error(err instanceof Error ? err.message : String(err));
-            }
-        }
-        // 3. Exchange code for tokens (stored encrypted in backend DB)
-        this.log('Completing authorization...');
-        try {
-            const raw = (await client.post('/v1/oauth/openai/exchange', {
-                requireJwt: true,
-                body: { code, state },
-            }));
-            // Unwrap StandardResponse envelope if present
-            const inner = (raw.data ?? raw);
-            if (!inner.connected)
-                this.error('Exchange succeeded but the server did not confirm the connection.');
-        }
-        catch (err) {
-            if (err instanceof FacesAPIError) {
-                // If state was already consumed (browser extension beat us to it),
-                // check whether the connection was stored anyway and succeed if so.
-                if (err.statusCode === 400) {
-                    try {
-                        const rows = (await client.get('/v1/oauth', { requireJwt: true }));
-                        if (rows.some((r) => r.provider === args.provider)) {
-                            const output = { provider: args.provider, connected: true };
-                            if (!this.jsonEnabled())
-                                this.log(`\n✅ ${args.provider} connected. Your connect plan requests will route through your subscription.`);
-                            return output;
-                        }
-                    }
-                    catch { /* ignore */ }
+                if (err instanceof FacesAPIError && err.statusCode === 503 && attempts503 < 4) {
+                    attempts503++;
+                    emit('OpenAI is temporarily unavailable, retrying…');
+                    await sleep(2000);
+                    continue;
+                }
+                if (err instanceof FacesAPIError && err.statusCode === 502 && attempts502 < 2) {
+                    attempts502++;
+                    emit('OpenAI returned an error, retrying…');
+                    await sleep(2000);
+                    continue;
                 }
-                this.error(`Token exchange failed (${err.statusCode}): ${err.message}`);
+                throw err;
             }
-            throw err;
         }
-        const output = { provider: args.provider, connected: true };
-        if (!this.jsonEnabled())
-            this.log(`\n✅ ${args.provider} connected. Your connect plan requests will route through your subscription.`);
-        return output;
     }
-}
-async function pollForConnection(client, provider, timeoutMs) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        await new Promise((r) => setTimeout(r, 2000));
-        try {
-            const rows = (await client.get('/v1/oauth', { requireJwt: true }));
-            if (rows.some((r) => r.provider === provider))
-                return 'connected';
-        }
-        catch {
-            // ignore transient errors, keep polling
+    handleStartError(err) {
+        if (err instanceof FacesAPIError) {
+            if (err.statusCode === 401) {
+                this.error('Your Faces session is missing or expired. Run `faces auth:login` and try again.');
+            }
+            if (err.statusCode === 403 || err.errorCode === 'connect_plan_required') {
+                this.error('Connecting ChatGPT requires the Subscription Connect plan.\n' +
+                    'Upgrade with: faces billing checkout');
+            }
+            if (err.statusCode === 422 || err.errorCode === 'device_auth_not_enabled') {
+                const d = err.details ?? {};
+                const url = d.settings_url || SETTINGS_URL;
+                const steps = Array.isArray(d.settings_steps) && d.settings_steps.length > 0
+                    ? d.settings_steps
+                    : [
+                        `Open ${url}  (the settings panel can take a few seconds to appear — give it a moment)`,
+                        'Turn on "Enable device code authorization for Codex"',
+                        'Then run `faces auth:connect openai` again',
+                    ];
+                this.error('Device-code authorization is not enabled on your ChatGPT account yet:\n' +
+                    steps.map((s, i) => `  ${i + 1}. ${s}`).join('\n'));
+            }
+            this.error(`Failed to start device authorization (${err.statusCode}): ${err.message}`);
         }
+        throw err;
     }
-    throw new Error('Timed out waiting for connection (5 minutes).');
 }

package/dist/commands/auth/connections.js CHANGED Viewed

@@ -19,7 +19,19 @@ export default class AuthConnections extends BaseCommand {
             }
             else {
                 for (const row of rows) {
-                    this.log(`${row.provider}  connected_at=${row.connected_at}${row.scope ? `  scope=${row.scope}` : ''}`);
+                    if (row.provider === 'openai') {
+                        const plan = row.chatgpt_plan_type;
+                        const label = plan ? plan.charAt(0).toUpperCase() + plan.slice(1) : null;
+                        const who = row.account_email ? ` as ${row.account_email}` : '';
+                        const tier = label ? ` (${label})` : '';
+                        this.log(`openai  connected${who}${tier}  connected_at=${row.connected_at}`);
+                        if (!plan || plan === 'free') {
+                            this.log('  ⚠️  This ChatGPT plan may not include API access — connecting requires a paid plan (Plus/Pro/Team, etc.).');
+                        }
+                    }
+                    else {
+                        this.log(`${row.provider}  connected_at=${row.connected_at}${row.scope ? `  scope=${row.scope}` : ''}`);
+                    }
                 }
             }
         }