faces-cli 1.6.1 → 1.6.2

package/README.md

@@ -1,6 +1,6 @@
 # faces-cli
 
-Command-line interface for the [Faces](https://faces.sh) platform.
+Command-line interface for the [Faces](https://faces.sh) platform. Compile source material into AI personas with cognitive primitives, then chat with them, compare them, and compose them.
 
 ## Installation
 
@@ -8,43 +8,76 @@ Command-line interface for the [Faces](https://faces.sh) platform.
 npm install -g faces-cli
 ```
 
-Requires Node.js ≥ 18.
+Requires Node.js >= 18.
 
 ## Quick start
 
 ```bash
-faces auth login
-faces face list
-faces chat chat myface -m "Hello"
+# Register or login
+faces auth:register --email you@example.com --password 'YourPass123!' --username you
+faces auth:login --email you@example.com --password 'YourPass123!'
+
+# Create a face
+faces face:create --name "Alice" --alias alice --default-model gpt-5.4-mini \
+  --attr gender=female --attr age=29 --attr occupation="product designer"
+
+# Add source material and compile
+faces compile:doc alice --file essay.txt --no-wait
+faces compile:upload alice --file interview.mp3 --kind thread --no-wait
+
+# Chat
+faces chat:chat alice -m "What matters most to you?"
+faces chat:chat alice -m "Tell me more" --llm claude-sonnet-4-6
+
+# Compare and compose
+faces face:diff --face alice --face bob
+faces face:create --name "Alice-Bob" --alias alice-bob --formula "alice | bob"
 ```
 
 ## Commands
 
 ```
-faces auth login / logout / register / whoami / refresh
-faces face create / list / get / update / delete / stats / upload
-faces chat chat / messages / responses
-faces compile doc create / list / get / prepare / sync / delete
-faces compile thread create / list / message / sync
-faces keys create / list / revoke / update
-faces billing balance / subscription / quota / usage / topup / checkout / card-setup / llm-costs
-faces account state
-faces config set / show / clear
+faces auth:login / logout / register / whoami / refresh
+faces auth:connect / disconnect / connections
+
+faces face:create / list / get / update / delete / stats / attributes
+faces face:upload / diff / neighbors
+
+faces chat:chat / messages / responses
+
+faces compile:doc / compile:doc:create / list / get / edit / make / pause / reset / delete
+faces compile:thread:create / list / get / edit / message / make / pause / reset / sync / delete
+faces compile:upload / compile:import
+faces compile:all
+
+faces catalog:list / doctor / backup / restore / manyfaced
+
+faces keys:create / list / revoke / update
+
+faces billing:balance / subscription / quota / usage / topup / checkout / card-setup / llm-costs
+
+faces account:state / preferences
+
+faces config:set / show / clear
 ```
 
 Run `faces <command> --help` for details on any command.
 
 ## Authentication
 
-Login stores a JWT at `~/.faces/config.json` (shared with the Python `faces-cli`).
-You can also authenticate via environment variables:
+Login stores a JWT at `~/.faces/config.json`. You can also authenticate via environment variables:
 
 ```bash
-export FACES_API_KEY=your_api_key
+export FACES_API_KEY=sk-faces-...
 export FACES_TOKEN=your_jwt
 export FACES_BASE_URL=https://api.faces.sh   # optional override
 ```
 
+## Plans
+
+- **Pay-per-token** — $5 activation (added as credits), 5% markup on all API calls. No monthly fee.
+- **Subscription Connect** ($17/month) — same 5% markup, plus link your ChatGPT Plus/Pro account to use select OpenAI models at no extra cost for compilation and inference.
+
 ## License
 
 MIT — Copyright (c) 2026 Headwaters Lab Inc.

package/dist/client.d.ts

@@ -33,6 +33,10 @@ export declare class FacesClient {
         body?: unknown;
     }): Promise<ResponseWithHeaders>;
     postNoAuth(path: string, body: unknown): Promise<unknown>;
+    put(path: string, opts?: {
+        requireJwt?: boolean;
+        body?: unknown;
+    }): Promise<unknown>;
     patch(path: string, opts?: {
         requireJwt?: boolean;
         body?: unknown;

package/dist/client.js

@@ -141,6 +141,22 @@ export class FacesClient {
             throw await this.parseError(resp);
         return resp.json();
     }
+    async put(path, opts = {}) {
+        let resp;
+        try {
+            resp = await fetch(this.url(path), {
+                method: 'PUT',
+                headers: { ...this.authHeader(opts.requireJwt), 'Content-Type': 'application/json' },
+                body: opts.body !== undefined ? JSON.stringify(opts.body) : undefined,
+            });
+        }
+        catch (err) {
+            this.wrapNetworkError(err, path);
+        }
+        if (!resp.ok)
+            throw await this.parseError(resp);
+        return resp.json();
+    }
     async patch(path, opts = {}) {
         let resp;
         try {

package/dist/commands/catalog/backup.js

@@ -5,7 +5,7 @@ import { BaseCommand } from '../../base.js';
 import { FacesAPIError } from '../../client.js';
 import { flattenBasicFacts } from '../../utils.js';
 export default class CatalogBackup extends BaseCommand {
-    static description = 'Snapshot all faces and source material for migration';
+    static description = 'Snapshot all faces, teams, and source material for migration';
     static flags = {
         ...BaseCommand.baseFlags,
     };
@@ -31,13 +31,28 @@ export default class CatalogBackup extends BaseCommand {
             const alias = face.alias;
             if (!json)
                 process.stderr.write(`  ${alias}: `);
+            // Fetch full face details (list endpoint may omit description)
+            let fullFace = face;
+            try {
+                fullFace = await client.get(`/v1/faces/${alias}`);
+            }
+            catch { /* use list data */ }
+            // Fetch tags
+            let tags = [];
+            try {
+                const tagResp = await client.get(`/v1/iam/${alias}/tags`);
+                tags = tagResp.tags ?? [];
+            }
+            catch { /* no tags */ }
             const entry = {
                 alias,
-                name: face.name,
-                basic_facts: face.basic_facts ? flattenBasicFacts(face.basic_facts) : null,
-                default_model: face.default_model ?? null,
-                default_tools: face.default_tools ?? [],
-                formula: face.formula ?? null,
+                name: fullFace.name,
+                description: fullFace.description ?? null,
+                basic_facts: fullFace.basic_facts ? flattenBasicFacts(fullFace.basic_facts) : null,
+                default_model: fullFace.default_model ?? null,
+                default_tools: fullFace.default_tools ?? [],
+                formula: fullFace.formula ?? null,
+                tags,
                 documents: [],
                 threads: [],
             };
@@ -52,9 +67,7 @@ export default class CatalogBackup extends BaseCommand {
                     });
                 }
             }
-            catch {
-                // face may have no documents
-            }
+            catch { /* face may have no documents */ }
             // Fetch threads
             try {
                 const threads = await client.get('/v1/compile/threads', { params: { alias } });
@@ -68,22 +81,74 @@ export default class CatalogBackup extends BaseCommand {
                             messages,
                         });
                     }
-                    catch {
-                        // skip threads we can't fetch
-                    }
+                    catch { /* skip threads we can't fetch */ }
                 }
             }
-            catch {
-                // face may have no threads
-            }
+            catch { /* face may have no threads */ }
             if (!json)
-                process.stderr.write(`${entry.documents.length} doc(s), ${entry.threads.length} thread(s)\n`);
+                process.stderr.write(`${entry.documents.length} doc(s), ${entry.threads.length} thread(s), ${tags.length} tag(s)\n`);
             backupFaces.push(entry);
         }
+        // Fetch teams
+        const backupTeams = [];
+        let username;
+        try {
+            const resp = await client.get('/auth/me');
+            const whoami = (resp.data ?? resp);
+            username = whoami.username ?? undefined;
+        }
+        catch { /* proceed */ }
+        try {
+            const resp = await client.get('/v1/me/teams');
+            let teams = resp.data ?? resp;
+            if (username)
+                teams = teams.filter(t => t.name !== username);
+            for (const team of teams) {
+                const teamId = team.id;
+                if (!json)
+                    process.stderr.write(`  team ${team.name}: `);
+                // Fetch members
+                let memberAliases = [];
+                try {
+                    const membersResp = await client.get(`/v1/teams/${teamId}/members`);
+                    const members = membersResp.data ?? [];
+                    // Build uid→alias map from original face list
+                    const uidToAlias = new Map();
+                    for (const f of faces) {
+                        if (f.uid)
+                            uidToAlias.set(f.uid, f.alias);
+                    }
+                    for (const m of members) {
+                        const iamId = m.iam_id;
+                        const alias = uidToAlias.get(iamId) ?? iamId;
+                        memberAliases.push(alias);
+                    }
+                }
+                catch { /* no members */ }
+                // Fetch tags
+                let teamTags = [];
+                try {
+                    const tagResp = await client.get(`/v1/teams/${teamId}/tags`);
+                    teamTags = tagResp.tags ?? [];
+                }
+                catch { /* no tags */ }
+                backupTeams.push({
+                    name: team.name,
+                    description: team.description ?? null,
+                    protocol: team.protocol ?? null,
+                    tags: teamTags,
+                    members: memberAliases,
+                });
+                if (!json)
+                    process.stderr.write(`${memberAliases.length} member(s), ${teamTags.length} tag(s)\n`);
+            }
+        }
+        catch { /* no teams */ }
         const backup = {
-            version: 1,
+            version: 2,
             created_at: new Date().toISOString(),
             faces: backupFaces,
+            teams: backupTeams,
         };
         const backupDir = path.join(os.homedir(), '.faces', 'backups');
         fs.mkdirSync(backupDir, { recursive: true });
@@ -94,8 +159,8 @@ export default class CatalogBackup extends BaseCommand {
         const totalThreads = backupFaces.reduce((n, f) => n + f.threads.length, 0);
         if (!json) {
             this.log(`\nBackup saved: ${filePath}`);
-            this.log(`  ${backupFaces.length} face(s), ${totalDocs} document(s), ${totalThreads} thread(s)`);
+            this.log(`  ${backupFaces.length} face(s), ${totalDocs} document(s), ${totalThreads} thread(s), ${backupTeams.length} team(s)`);
         }
-        return { path: filePath, faces: backupFaces.length, documents: totalDocs, threads: totalThreads };
+        return { path: filePath, faces: backupFaces.length, documents: totalDocs, threads: totalThreads, teams: backupTeams.length };
     }
 }

package/dist/commands/catalog/doctor.js

@@ -130,14 +130,14 @@ export default class CatalogDoctor extends BaseCommand {
         // Fix mode: rebuild missing and stale entries
         let fixed = 0;
         for (const face of [...missing, ...stale]) {
-            catalog.writeFace(face);
+            catalog.writeFace(face, face.description ?? undefined);
             fixed++;
         }
         // Also refresh faces that exist but might have stale attributes
         for (const [alias, remote] of remoteByAlias) {
             if (!missing.some((f) => f.alias === alias) && !stale.some((f) => f.alias === alias)) {
-                // Face exists locally and name matches — still refresh attributes
-                catalog.writeFace(remote);
+                // Face exists locally and name matches — still refresh attributes and description
+                catalog.writeFace(remote, remote.description ?? undefined);
             }
         }
         // Remove orphans
@@ -175,7 +175,13 @@ export default class CatalogDoctor extends BaseCommand {
                         text = resp.choices?.[0]?.message?.content;
                     }
                     if (text) {
-                        catalog.writeFace(remote, text.trim());
+                        const desc = text.trim();
+                        catalog.writeFace(remote, desc);
+                        // Also sync description to server
+                        try {
+                            await client.patch(`/v1/faces/${alias}`, { body: { description: desc } });
+                        }
+                        catch { /* non-fatal */ }
                         generated++;
                         this.log(`  ${alias}: done`);
                     }

package/dist/commands/catalog/restore.js

@@ -6,7 +6,7 @@ import { BaseCommand } from '../../base.js';
 import { FacesAPIError } from '../../client.js';
 import { CatalogService } from '../../catalog.js';
 export default class CatalogRestore extends BaseCommand {
-    static description = 'Restore faces and source material from a backup snapshot';
+    static description = 'Restore faces, teams, and source material from a backup snapshot';
     static flags = {
         ...BaseCommand.baseFlags,
         compile: Flags.boolean({ description: 'Run compile:all after restoring', default: false }),
@@ -22,23 +22,23 @@ export default class CatalogRestore extends BaseCommand {
         if (!fs.existsSync(filePath))
             this.error(`Backup file not found: ${filePath}`);
         const backup = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-        if (backup.version !== 1)
+        if (backup.version !== 1 && backup.version !== 2)
             this.error(`Unsupported backup version: ${backup.version}`);
         if (!json) {
             this.log(`Restoring from: ${filePath}`);
             this.log(`  Created: ${backup.created_at}`);
-            this.log(`  Faces: ${backup.faces.length}\n`);
+            this.log(`  Faces: ${backup.faces.length}, Teams: ${backup.teams?.length ?? 0}\n`);
         }
         const catalog = new CatalogService();
         let facesCreated = 0;
         let facesSkipped = 0;
         let docsUploaded = 0;
         let threadsUploaded = 0;
+        let teamsCreated = 0;
         for (const face of backup.faces) {
             if (!json)
                 process.stderr.write(`${face.alias}: `);
-            // Create face
-            const created = await this.createFace(client, face, json);
+            const created = await this.createFace(client, face);
             if (!created) {
                 facesSkipped++;
                 if (!json)
@@ -46,9 +46,16 @@ export default class CatalogRestore extends BaseCommand {
                 continue;
             }
             facesCreated++;
+            // Post tags
+            if (face.tags && face.tags.length > 0) {
+                try {
+                    await client.post(`/v1/iam/${face.alias}/tags`, { body: { tags: face.tags } });
+                }
+                catch { /* non-fatal */ }
+            }
             // Write to local catalog
             try {
-                catalog.writeFace({ alias: face.alias, name: face.name, basic_facts: face.basic_facts });
+                catalog.writeFace({ alias: face.alias, name: face.name, basic_facts: face.basic_facts }, face.description ?? undefined);
             }
             catch { /* non-fatal */ }
             // Upload documents
@@ -68,7 +75,7 @@ export default class CatalogRestore extends BaseCommand {
                         process.stderr.write(`\n    warn: doc upload failed: ${msg}\n    `);
                 }
             }
-            // Upload threads — create thread then PATCH messages in bulk
+            // Upload threads
             for (const thread of face.threads) {
                 try {
                     const createPayload = { alias: face.alias };
@@ -76,7 +83,6 @@ export default class CatalogRestore extends BaseCommand {
                         createPayload.label = thread.label;
                     const created = await client.post('/v1/compile/threads', { body: createPayload });
                     const threadId = created.thread_id;
-                    // Overwrite the auto-generated messages with the backup messages
                     if (thread.messages.length > 0) {
                         await client.patch(`/v1/compile/threads/${threadId}/messages`, {
                             body: { messages: thread.messages },
@@ -93,21 +99,69 @@ export default class CatalogRestore extends BaseCommand {
             if (!json)
                 process.stderr.write(`${face.documents.length} doc(s), ${face.threads.length} thread(s)\n`);
         }
+        // Restore teams (v2+)
+        if (backup.teams && backup.teams.length > 0) {
+            if (!json)
+                this.log(`\nRestoring ${backup.teams.length} team(s)...`);
+            for (const team of backup.teams) {
+                if (!json)
+                    process.stderr.write(`  ${team.name}: `);
+                try {
+                    const payload = { name: team.name };
+                    if (team.description)
+                        payload.description = team.description;
+                    if (team.protocol)
+                        payload.protocol = team.protocol;
+                    const created = await client.post('/v1/teams', { body: payload });
+                    const teamId = created.id;
+                    // Add tags
+                    if (team.tags.length > 0) {
+                        try {
+                            await client.post(`/v1/teams/${teamId}/tags`, { body: { tags: team.tags } });
+                        }
+                        catch { /* non-fatal */ }
+                    }
+                    // Add members (resolve aliases to iam_ids)
+                    for (const alias of team.members) {
+                        try {
+                            const face = await client.get(`/v1/faces/${alias}`);
+                            const iamId = (face.uid ?? face.id ?? face.iam_id);
+                            if (iamId) {
+                                await client.post(`/v1/teams/${teamId}/members`, { body: { iam_id: iamId } });
+                            }
+                        }
+                        catch { /* member may not exist yet */ }
+                    }
+                    teamsCreated++;
+                    if (!json)
+                        process.stderr.write(`${team.members.length} member(s)\n`);
+                }
+                catch (err) {
+                    const msg = err instanceof FacesAPIError ? `${err.statusCode}: ${err.message}` : String(err);
+                    if (!json)
+                        process.stderr.write(`failed: ${msg}\n`);
+                }
+            }
+        }
         if (!json) {
             this.log(`\nRestore complete:`);
             this.log(`  Faces created: ${facesCreated}, skipped: ${facesSkipped}`);
             this.log(`  Documents uploaded: ${docsUploaded}`);
             this.log(`  Threads uploaded: ${threadsUploaded}`);
+            if (teamsCreated > 0)
+                this.log(`  Teams created: ${teamsCreated}`);
         }
         if (flags.compile) {
             if (!json)
                 this.log('\nRunning compile:all...\n');
             await this.config.runCommand('compile:all', json ? ['--json'] : []);
         }
-        return { faces_created: facesCreated, faces_skipped: facesSkipped, documents: docsUploaded, threads: threadsUploaded };
+        return { faces_created: facesCreated, faces_skipped: facesSkipped, documents: docsUploaded, threads: threadsUploaded, teams_created: teamsCreated };
     }
-    async createFace(client, face, _json) {
+    async createFace(client, face) {
         const payload = { name: face.name, alias: face.alias };
+        if (face.description)
+            payload.description = face.description;
         if (face.formula) {
             payload.formula = face.formula;
             if (face.default_model)
@@ -127,7 +181,6 @@ export default class CatalogRestore extends BaseCommand {
         }
         catch (err) {
             if (err instanceof FacesAPIError && err.statusCode === 400) {
-                // likely "already have a face with alias"
                 return false;
             }
             throw err;

package/dist/commands/face/create.d.ts

@@ -5,6 +5,7 @@ export default class FaceCreate extends BaseCommand {
         name: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         alias: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        tag: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'default-model': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         formula: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         attr: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;

package/dist/commands/face/create.js

@@ -9,7 +9,8 @@ export default class FaceCreate extends BaseCommand {
         ...BaseCommand.baseFlags,
         name: Flags.string({ description: 'Display name', required: true }),
         alias: Flags.string({ description: 'Unique alias slug', required: true }),
-        description: Flags.string({ description: 'Description for local catalog' }),
+        description: Flags.string({ description: 'Plain-text description / bio (max 1500 chars)' }),
+        tag: Flags.string({ description: 'Tag label (repeatable, lowercase)', multiple: true }),
         'default-model': Flags.string({ description: 'Default LLM for chat (e.g. gpt-4o-mini, claude-sonnet-4-6)' }),
         formula: Flags.string({ description: 'Boolean formula over owned concrete face aliases (e.g. "a | b", "(a | b) - c"). Creates a composite face.' }),
         attr: Flags.string({ description: 'Attribute KEY=VALUE (repeatable)', multiple: true }),
@@ -23,6 +24,8 @@ export default class FaceCreate extends BaseCommand {
             this.error('--formula cannot be combined with --attr or --tool. Composite faces do not have compiled knowledge.');
         }
         const payload = { name: flags.name, alias: flags.alias };
+        if (flags.description)
+            payload.description = flags.description;
         if (flags.formula) {
             payload.formula = flags.formula;
             if (flags['default-model'])
@@ -60,6 +63,16 @@ export default class FaceCreate extends BaseCommand {
         if (face.basic_facts && typeof face.basic_facts === 'object') {
             face.basic_facts = flattenBasicFacts(face.basic_facts);
         }
+        // Post tags if provided
+        if (flags.tag && flags.tag.length > 0) {
+            try {
+                await client.post(`/v1/iam/${flags.alias}/tags`, { body: { tags: flags.tag } });
+            }
+            catch (err) {
+                if (err instanceof FacesAPIError)
+                    this.warn(`Tags failed (${err.statusCode}): ${err.message}`);
+            }
+        }
         try {
             const catalog = new CatalogService();
             catalog.writeFace(face, flags.description);

package/dist/commands/face/list.d.ts

@@ -2,6 +2,7 @@ import { BaseCommand } from '../../base.js';
 export default class FaceList extends BaseCommand {
     static description: string;
     static flags: {
+        tag: 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>;

package/dist/commands/face/list.js

@@ -1,3 +1,4 @@
+import { Flags } from '@oclif/core';
 import { BaseCommand } from '../../base.js';
 import { FacesAPIError } from '../../client.js';
 import { flattenBasicFacts } from '../../utils.js';
@@ -5,13 +6,22 @@ export default class FaceList extends BaseCommand {
     static description = 'List all owned faces';
     static flags = {
         ...BaseCommand.baseFlags,
+        tag: Flags.string({ description: 'Filter by tag (repeatable, AND logic)', multiple: true }),
     };
     async run() {
         const { flags } = await this.parse(FaceList);
         const client = this.makeClient(flags);
+        const params = {};
+        // Tags need to be passed as repeated query params: ?tag=a&tag=b
+        // Build the query string manually since URLSearchParams dedupes keys
+        let tagQuery = '';
+        if (flags.tag && flags.tag.length > 0) {
+            tagQuery = flags.tag.map(t => `tag=${encodeURIComponent(t)}`).join('&');
+        }
         let data;
         try {
-            data = await client.get('/v1/faces');
+            const path = tagQuery ? `/v1/faces?${tagQuery}` : '/v1/faces';
+            data = await client.get(path);
         }
         catch (err) {
             if (err instanceof FacesAPIError)

package/dist/commands/face/tag/add.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand } from '../../../base.js';
+export default class FaceTagAdd extends BaseCommand {
+    static description: string;
+    static flags: {
+        tag: import("@oclif/core/interfaces").OptionFlag<string[], 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: {
+        alias: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<unknown>;
+}

package/dist/commands/face/tag/add.js

@@ -0,0 +1,29 @@
+import { Args, Flags } from '@oclif/core';
+import { BaseCommand } from '../../../base.js';
+import { FacesAPIError } from '../../../client.js';
+export default class FaceTagAdd extends BaseCommand {
+    static description = 'Add tags to a face (appends, idempotent)';
+    static flags = {
+        ...BaseCommand.baseFlags,
+        tag: Flags.string({ description: 'Tag to add (repeatable)', multiple: true, required: true }),
+    };
+    static args = {
+        alias: Args.string({ description: 'Face alias', required: true }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(FaceTagAdd);
+        const client = this.makeClient(flags);
+        let data;
+        try {
+            data = await client.post(`/v1/iam/${args.alias}/tags`, { body: { tags: flags.tag } });
+        }
+        catch (err) {
+            if (err instanceof FacesAPIError)
+                this.error(`Error (${err.statusCode}): ${err.message}`);
+            throw err;
+        }
+        if (!this.jsonEnabled())
+            this.printHuman(data);
+        return data;
+    }
+}

package/dist/commands/face/tag/list.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../../../base.js';
+export default class FaceTagList 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 args: {
+        alias: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    run(): Promise<unknown>;
+}

package/dist/commands/face/tag/list.js

@@ -0,0 +1,35 @@
+import { Args } from '@oclif/core';
+import { BaseCommand } from '../../../base.js';
+import { FacesAPIError } from '../../../client.js';
+export default class FaceTagList extends BaseCommand {
+    static description = 'List tags on a face';
+    static flags = {
+        ...BaseCommand.baseFlags,
+    };
+    static args = {
+        alias: Args.string({ description: 'Face alias', required: true }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(FaceTagList);
+        const client = this.makeClient(flags);
+        let data;
+        try {
+            data = await client.get(`/v1/iam/${args.alias}/tags`);
+        }
+        catch (err) {
+            if (err instanceof FacesAPIError)
+                this.error(`Error (${err.statusCode}): ${err.message}`);
+            throw err;
+        }
+        if (!this.jsonEnabled()) {
+            const tags = data.tags ?? [];
+            if (tags.length === 0) {
+                this.log('(no tags)');
+            }
+            else {
+                this.log(tags.join(', '));
+            }
+        }
+        return data;
+    }
+}