faces-cli 1.8.2 → 1.8.3

package/dist/commands/team/add.d.ts

@@ -10,5 +10,6 @@ export default class TeamAdd extends BaseCommand {
     static args: {
         team_id: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
     };
+    static examples: string[];
     run(): Promise<unknown>;
 }

package/dist/commands/team/add.js

@@ -4,8 +4,8 @@ import { FacesAPIError } from '../../client.js';
 import { TeamCatalogService } from '../../team-catalog.js';
 import { resolveFace } from '../../utils.js';
 export default class TeamAdd extends BaseCommand {
-    static description = 'Add face(s) to a team. A team may only contain faces this account owns: a published or shared face ' +
-        'can be chatted with but cannot be a member.';
+    static description = 'Add face(s) to a team. Any face this account can reach may join: your own, a published one, or one ' +
+        'shared with you. Name someone else\'s as owner:alias, the same address chat uses.';
     static flags = {
         ...BaseCommand.baseFlags,
         face: Flags.string({ description: 'Face alias to add (repeatable)', multiple: true, required: true }),
@@ -13,13 +13,17 @@ export default class TeamAdd extends BaseCommand {
     static args = {
         team_id: Args.string({ description: 'Team ID', required: true }),
     };
+    static examples = [
+        '<%= config.bin %> <%= command.id %> TEAM_ID --face alice --face bob',
+        '<%= config.bin %> <%= command.id %> TEAM_ID --face head:socrates',
+    ];
     async run() {
         const { args, flags } = await this.parse(TeamAdd);
         const client = this.makeClient(flags);
-        // Resolve aliases to iam_ids. resolveFace also finds published and shared
-        // faces, which the plain face route cannot: without that a reachable face
-        // fails here as 404 or 403 depending on how it was named, and both read as
-        // a typo rather than as the rule that teams are owner-scoped.
+        // Resolve to iam_ids. The members endpoint takes a uid or an owner:alias
+        // and not a bare alias, so resolving here means a user can name any face
+        // the way they already name it everywhere else. resolveFace also finds
+        // published and shared faces, which the plain face route cannot.
         const iamIds = [];
         for (const alias of flags.face) {
             let resolved;
@@ -36,15 +40,6 @@ export default class TeamAdd extends BaseCommand {
                 }
                 throw err;
             }
-            // The server enforces this too, but only once it has an id, which this
-            // command cannot reach for a face it does not own. Say the real reason.
-            if (!resolved.owned) {
-                this.error(`A team may only contain faces you own, and '${resolved.handle}' is owned by ` +
-                    `'${resolved.owner ?? 'another account'}'. It is published or shared with you, so you can chat ` +
-                    `it as ${resolved.handle}@<model>, but it cannot be a team member.\n` +
-                    'Do not create a copy to work around this: the copy would be a different face with different ' +
-                    'compiled material.');
-            }
             const face = resolved.face;
             const id = (face.uid ?? face.id ?? face.iam_id);
             if (!id)

package/dist/commands/team/members.d.ts

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

package/dist/commands/team/members.js

@@ -1,8 +1,21 @@
 import { Args } from '@oclif/core';
 import { BaseCommand } from '../../base.js';
 import { FacesAPIError } from '../../client.js';
+/**
+ * Why a member can no longer be reached, in the terms a user can act on.
+ *
+ * The two are kept apart deliberately: access can be granted again, a deleted
+ * face cannot come back. Rendering them the same would tell someone to go and
+ * ask for something that no longer exists.
+ */
+const REASONS = {
+    unpublished_or_unshared: 'access was revoked by its owner',
+    deleted: 'the face was deleted',
+};
 export default class TeamMembers extends BaseCommand {
-    static description = 'List members of a team';
+    static description = 'List members of a team. A member you do not own can stop being reachable if its owner revokes ' +
+        'access or deletes it; those are listed with the reason rather than dropped.';
+    static examples = ['<%= config.bin %> <%= command.id %> TEAM_ID', '<%= config.bin %> <%= command.id %> TEAM_ID --json'];
     static flags = {
         ...BaseCommand.baseFlags,
     };
@@ -17,12 +30,48 @@ export default class TeamMembers extends BaseCommand {
             data = await client.get(`/v1/teams/${args.team_id}/members`);
         }
         catch (err) {
-            if (err instanceof FacesAPIError)
+            if (err instanceof FacesAPIError) {
+                if (err.statusCode === 404)
+                    this.error(`No team '${args.team_id}'. It does not exist, or is not yours.`);
                 this.error(`Error (${err.statusCode}): ${err.message}`);
+            }
             throw err;
         }
-        if (!this.jsonEnabled())
-            this.printHuman(data);
+        if (this.jsonEnabled())
+            return data;
+        const members = (data.data ?? data) ?? [];
+        if (members.length === 0) {
+            this.log('This team has no members.');
+            this.log(`Add one with: faces team:add ${args.team_id} --face <alias>`);
+            return data;
+        }
+        const rows = members.map((m) => ({
+            alias: m.alias?.trim() || '(unknown)',
+            // reachable is absent on older servers; only an explicit false is a problem.
+            status: m.reachable === false
+                ? `unreachable - ${REASONS[m.unreachable_reason ?? ''] ?? m.unreachable_reason ?? 'reason not given'}`
+                : 'ok',
+            id: m.iam_id ?? '-',
+        }));
+        const cols = [
+            ['FACE', (r) => r.alias],
+            ['STATUS', (r) => r.status],
+            ['ID', (r) => r.id],
+        ];
+        const w = cols.map(([h, g]) => Math.max(h.length, ...rows.map((r) => g(r).length)));
+        const line = (c) => c.map((x, i) => x.padEnd(w[i])).join('  ').trimEnd();
+        this.log(line(cols.map(([h]) => h)));
+        for (const r of rows)
+            this.log(line(cols.map(([, g]) => g(r))));
+        const lost = members.filter((m) => m.reachable === false);
+        this.log('');
+        this.log(`${rows.length} member(s).`);
+        if (lost.length > 0) {
+            // Say it plainly: a team that silently changed shape is the thing this
+            // reporting exists to prevent.
+            this.log(`${lost.length} can no longer be reached and will not answer. They are still listed because the ` +
+                'team has not changed; remove them with faces team:remove.');
+        }
         return data;
     }
 }