npm - faces-cli - Versions diffs - 1.2.0 → 1.3.1 - Mend

faces-cli 1.2.0 → 1.3.1

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

package/dist/commands/auth/connect.d.ts +15 -0
package/dist/commands/auth/connect.js +239 -0
package/dist/commands/auth/connections.d.ts +11 -0
package/dist/commands/auth/connections.js +28 -0
package/dist/commands/auth/disconnect.d.ts +14 -0
package/dist/commands/auth/disconnect.js +38 -0
package/dist/commands/auth/login.js +5 -3
package/dist/commands/auth/register.d.ts +1 -1
package/dist/commands/auth/register.js +16 -6
package/dist/commands/compile/import.d.ts +17 -0
package/dist/commands/compile/import.js +81 -0
package/dist/commands/face/create.js +2 -2
package/dist/commands/face/get.js +1 -1
package/dist/commands/face/list.js +1 -1
package/oclif.manifest.json +679 -388
package/package.json +1 -1

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

@@ -0,0 +1,15 @@
+import { BaseCommand } from '../../base.js';
+export default class AuthConnect extends BaseCommand {
+    static description: string;
+    static args: {
+        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>;
+}

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

@@ -0,0 +1,239 @@
+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 { 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();
+}
+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();
+    });
+}
+export default class AuthConnect extends BaseCommand {
+    static description = 'Connect an OAuth provider account to Faces (e.g. ChatGPT Plus/Pro)';
+    static args = {
+        provider: Args.string({
+            description: 'OAuth provider to connect',
+            required: true,
+            options: ['openai'],
+        }),
+    };
+    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',
+    ];
+    async run() {
+        const { args, flags } = await this.parse(AuthConnect);
+        const client = this.makeClient(flags, true);
+        // 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.`);
+                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;
+        try {
+            authorizeData = (await client.get(`/v1/oauth/${args.provider}/authorize`, {
+                requireJwt: true,
+            }));
+        }
+        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;
+        }
+        // 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 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;
+            }
+            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;
+            }
+            // 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);
+            }
+            catch {
+                this.error('Could not parse the URL you pasted. Make sure to copy the full address bar URL.');
+            }
+            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?');
+        }
+        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`);
+            try {
+                ;
+                ({ code, state } = await callbackPromise);
+            }
+            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 */ }
+                }
+                this.error(`Token exchange failed (${err.statusCode}): ${err.message}`);
+            }
+            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
+        }
+    }
+    throw new Error('Timed out waiting for connection (5 minutes).');
+}

package/dist/commands/auth/connections.d.ts ADDED Viewed

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../../base.js';
+export default class AuthConnections extends BaseCommand {
+    static description: string;
+    static flags: {
+        '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>;
+}

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

@@ -0,0 +1,28 @@
+import { BaseCommand } from '../../base.js';
+export default class AuthConnections extends BaseCommand {
+    static description = 'List connected OAuth provider accounts';
+    static flags = {
+        ...BaseCommand.baseFlags,
+    };
+    static examples = [
+        '<%= config.bin %> auth connections',
+        '<%= config.bin %> auth connections --json',
+    ];
+    async run() {
+        const { flags } = await this.parse(AuthConnections);
+        const client = this.makeClient(flags, true);
+        const data = await client.get('/v1/oauth', { requireJwt: true });
+        if (!this.jsonEnabled()) {
+            const rows = data;
+            if (!rows || rows.length === 0) {
+                this.log('No connected providers.');
+            }
+            else {
+                for (const row of rows) {
+                    this.log(`${row.provider}  connected_at=${row.connected_at}${row.scope ? `  scope=${row.scope}` : ''}`);
+                }
+            }
+        }
+        return data;
+    }
+}

package/dist/commands/auth/disconnect.d.ts ADDED Viewed

@@ -0,0 +1,14 @@
+import { BaseCommand } from '../../base.js';
+export default class AuthDisconnect extends BaseCommand {
+    static description: string;
+    static args: {
+        provider: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        '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>;
+}

package/dist/commands/auth/disconnect.js ADDED Viewed

@@ -0,0 +1,38 @@
+import { Args } from '@oclif/core';
+import { BaseCommand } from '../../base.js';
+import { FacesAPIError } from '../../client.js';
+export default class AuthDisconnect extends BaseCommand {
+    static description = 'Disconnect a linked OAuth provider account';
+    static args = {
+        provider: Args.string({
+            description: 'OAuth provider to disconnect',
+            required: true,
+            options: ['openai'],
+        }),
+    };
+    static flags = {
+        ...BaseCommand.baseFlags,
+    };
+    static examples = [
+        '<%= config.bin %> auth disconnect openai',
+    ];
+    async run() {
+        const { args, flags } = await this.parse(AuthDisconnect);
+        const client = this.makeClient(flags, true);
+        try {
+            await client.delete(`/v1/oauth/${args.provider}`, { requireJwt: true });
+        }
+        catch (err) {
+            if (err instanceof FacesAPIError) {
+                if (err.statusCode === 404)
+                    this.error(`No connected ${args.provider} account found.`);
+                this.error(`Disconnect failed (${err.statusCode}): ${err.message}`);
+            }
+            throw err;
+        }
+        const output = { provider: args.provider, connected: false };
+        if (!this.jsonEnabled())
+            this.log(`✅ ${args.provider} disconnected.`);
+        return output;
+    }
+}

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

@@ -16,7 +16,7 @@ export default class AuthLogin extends BaseCommand {
         const client = new FacesClient(baseUrl);
         let data;
         try {
-            data = (await client.postNoAuth('/v1/auth/login', {
+            data = (await client.postNoAuth('/auth/login', {
                 email: flags.email,
                 password: flags.password,
             }));
@@ -27,8 +27,10 @@ export default class AuthLogin extends BaseCommand {
             }
             throw err;
         }
-        const token = (data.access_token ?? data.token);
-        const userId = data.user_id ?? data.id ?? data.user?.id;
+        // Unwrap StandardResponse envelope if present
+        const inner = (data.data ?? data);
+        const token = (inner.access_token ?? inner.token);
+        const userId = inner.user_id ?? inner.id ?? inner.user?.id;
         if (!token)
             this.error(`Unexpected response: ${JSON.stringify(data)}`);
         saveConfig({ token, user_id: userId ? String(userId) : undefined });

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

@@ -4,7 +4,7 @@ export default class AuthRegister extends BaseCommand {
     static flags: {
         email: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         password: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
-        name: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         username: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         'invite-key': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'base-url': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;

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

@@ -8,7 +8,7 @@ export default class AuthRegister extends BaseCommand {
         ...BaseCommand.baseFlags,
         email: Flags.string({ description: 'Email address', required: true }),
         password: Flags.string({ description: 'Password', required: true }),
-        name: Flags.string({ description: 'Display name', required: true }),
+        name: Flags.string({ description: 'Display name (defaults to username)' }),
         username: Flags.string({ description: 'Username (lowercase, dashes, numbers)', required: true }),
         'invite-key': Flags.string({ description: 'Invite key (if required)' }),
     };
@@ -20,14 +20,14 @@ export default class AuthRegister extends BaseCommand {
         const payload = {
             email: flags.email,
             password: flags.password,
-            name: flags.name,
+            name: flags.name ?? flags.username,
             username: flags.username,
         };
         if (flags['invite-key'])
             payload.invite_key = flags['invite-key'];
         let data;
         try {
-            data = (await client.postNoAuth('/v1/auth/register', payload));
+            data = (await client.postNoAuth('/auth/register-email', payload));
         }
         catch (err) {
             if (err instanceof FacesAPIError) {
@@ -35,11 +35,21 @@ export default class AuthRegister extends BaseCommand {
             }
             throw err;
         }
-        const token = (data.access_token ?? data.token);
+        // Unwrap StandardResponse envelope if present
+        const inner = (data.data ?? data);
+        const token = (inner.access_token ?? inner.token);
         if (token)
             saveConfig({ token });
+        const result = {
+            status: 'registered',
+            user_id: inner.user_id,
+            activation_required: inner.activation_required ?? false,
+        };
+        if (inner.activation_checkout_url) {
+            result.activation_checkout_url = inner.activation_checkout_url;
+        }
         if (!this.jsonEnabled())
-            this.printHuman(data);
-        return data;
+            this.printHuman(result);
+        return result;
     }
 }

package/dist/commands/compile/import.d.ts ADDED Viewed

@@ -0,0 +1,17 @@
+import { BaseCommand } from '../../base.js';
+export default class CompileImport extends BaseCommand {
+    static description: string;
+    static flags: {
+        url: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        type: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        perspective: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        'face-speaker': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        '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 args: {
+        face_id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<unknown>;
+}

package/dist/commands/compile/import.js ADDED Viewed

@@ -0,0 +1,81 @@
+import { Args, Flags } from '@oclif/core';
+import { BaseCommand } from '../../base.js';
+import { FacesAPIError } from '../../client.js';
+export default class CompileImport extends BaseCommand {
+    static description = 'Import a YouTube video into a face via server-side download and transcription';
+    static flags = {
+        ...BaseCommand.baseFlags,
+        url: Flags.string({
+            description: 'YouTube URL (youtube.com/watch?v=... or youtu.be/...)',
+            required: true,
+        }),
+        type: Flags.string({
+            description: '"document" for solo talks, lectures, monologues; "thread" for interviews or multi-speaker conversations',
+            options: ['document', 'thread'],
+            default: 'document',
+        }),
+        perspective: Flags.string({
+            description: '"first-person" if the face is the speaker; "third-person" if the video is about the face',
+            options: ['first-person', 'third-person'],
+            default: 'third-person',
+        }),
+        'face-speaker': Flags.string({
+            description: 'For --type thread: AssemblyAI speaker label (e.g. "A") that corresponds to the face. Defaults to first detected speaker.',
+        }),
+    };
+    static args = {
+        face_id: Args.string({ description: 'Face ID or username', required: true }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(CompileImport);
+        const client = this.makeClient(flags);
+        if (flags['face-speaker'] && flags.type !== 'thread') {
+            this.error('--face-speaker is only valid with --type thread');
+        }
+        const payload = {
+            url: flags.url,
+            type: flags.type,
+            perspective: flags.perspective,
+        };
+        if (flags['face-speaker'])
+            payload.face_speaker = flags['face-speaker'];
+        this.log('Importing… (transcription may take 10–60s depending on video length)');
+        let data;
+        try {
+            data = await client.post(`/v1/faces/${args.face_id}/import`, { body: payload });
+        }
+        catch (err) {
+            if (err instanceof FacesAPIError) {
+                if (err.statusCode === 422 && flags.type === 'thread') {
+                    this.error(`${err.message} — try again with --type document`);
+                }
+                this.error(`Error (${err.statusCode}): ${err.message}`);
+            }
+            throw err;
+        }
+        if (!this.jsonEnabled()) {
+            const res = data;
+            if (res.type === 'document') {
+                const doc = res;
+                this.log(`Imported as document`);
+                this.log(`id:          ${doc.document_id}`);
+                this.log(`label:       ${doc.label}`);
+                this.log(`tokens:      ${doc.token_count}`);
+                this.log(``);
+                this.log(`Next steps:`);
+                this.log(`  faces compile:doc:prepare ${doc.document_id}`);
+                this.log(`  faces compile:doc:sync    ${doc.document_id} --yes`);
+            }
+            else {
+                const thread = res;
+                this.log(`Imported as thread`);
+                this.log(`id:          ${thread.thread_id}`);
+                this.log(`label:       ${thread.label}`);
+                this.log(``);
+                this.log(`Next step:`);
+                this.log(`  faces compile:thread:sync ${thread.thread_id}`);
+            }
+        }
+        return data;
+    }
+}

package/dist/commands/face/create.js CHANGED Viewed

@@ -7,7 +7,7 @@ export default class FaceCreate extends BaseCommand {
         ...BaseCommand.baseFlags,
         name: Flags.string({ description: 'Display name', required: true }),
         username: Flags.string({ description: 'Unique username slug', required: true }),
-        formula: Flags.string({ description: 'Boolean formula over owned concrete face usernames (e.g. "a | b", "(a | b) - c"). Creates a synthetic face.' }),
+        formula: Flags.string({ description: 'Boolean formula over owned concrete face usernames (e.g. "a | b", "(a | b) - c"). Creates a composite face.' }),
         attr: Flags.string({ description: 'Attribute KEY=VALUE (repeatable)', multiple: true }),
         tool: Flags.string({ description: 'Tool name to enable (repeatable)', multiple: true }),
     };
@@ -16,7 +16,7 @@ export default class FaceCreate extends BaseCommand {
         const { flags } = await this.parse(FaceCreate);
         const client = this.makeClient(flags);
         if (flags.formula && (flags.attr?.length || flags.tool?.length)) {
-            this.error('--formula cannot be combined with --attr or --tool. Synthetic faces do not have compiled knowledge.');
+            this.error('--formula cannot be combined with --attr or --tool. Composite faces do not have compiled knowledge.');
         }
         const payload = { name: flags.name, username: flags.username };
         if (flags.formula) {

package/dist/commands/face/get.js CHANGED Viewed

@@ -30,7 +30,7 @@ export default class FaceGet extends BaseCommand {
             this.log(`created:   ${new Date(f.created * 1000).toISOString().slice(0, 10)}`);
             if (f.formula) {
                 this.log(`formula:   ${f.formula}`);
-                this.log(`type:      synthetic`);
+                this.log(`type:      composite`);
             }
             else {
                 this.log(`type:      concrete`);

package/dist/commands/face/list.js CHANGED Viewed

@@ -26,7 +26,7 @@ export default class FaceList extends BaseCommand {
                 const idWidth = Math.max(...faces.map(f => f.id.length));
                 const nameWidth = Math.max(...faces.map(f => f.name.length));
                 for (const f of faces) {
-                    const synthetic = f.formula ? `  [synthetic: ${f.formula}]` : '';
+                    const synthetic = f.formula ? `  [composite: ${f.formula}]` : '';
                     this.log(`${f.id.padEnd(idWidth)}  ${f.name.padEnd(nameWidth)}${synthetic}`);
                 }
             }