@skrr-ai/cli 0.1.36 → 0.1.38

package/dist/commands/agents/api-actions/add.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const promises_1 = require("node:fs/promises");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../../base-command");
+/**
+ * Attach (or re-attach) an OpenAPI document to an agent as a tool surface.
+ *
+ * The derivation is the SAME code the web builder runs —
+ * `validateAndParseOpenAPISpec` then `openapiToFunction`, both from
+ * `@skrr-ai/data-provider`. That matters more than it looks: the server stores
+ * `functions` verbatim and never re-reads the spec, so a CLI that derived them
+ * its own way would produce actions subtly unlike the ones the web produces from
+ * the same document, and the difference would only show up at call time.
+ *
+ * The spec is validated LOCALLY before anything is sent, because the endpoint's
+ * failure for a malformed document is `400 No functions provided` — true, and
+ * useless for finding the line that is wrong.
+ */
+class AgentsApiActionsAdd extends base_command_1.BaseCommand {
+    static description = 'Attach an OpenAPI spec to an agent as a callable Action';
+    static examples = [
+        '<%= config.bin %> agents api-actions add <agent-id> --spec ./weather.yaml',
+        'cat weather.json | <%= config.bin %> agents api-actions add <agent-id> --spec -',
+        '<%= config.bin %> agents api-actions add <agent-id> --spec ./api.yaml --auth service_http --api-key $KEY',
+        '<%= config.bin %> agents api-actions add <agent-id> --spec ./api.yaml --action-id <existing> # replace in place',
+    ];
+    static args = {
+        agentId: core_1.Args.string({ description: 'Agent ID', required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        spec: core_1.Flags.string({
+            description: 'OpenAPI document — path to a JSON/YAML file, or "-" for stdin',
+            required: true,
+        }),
+        'action-id': core_1.Flags.string({
+            description: 'Replace this existing action instead of creating a new one',
+        }),
+        auth: core_1.Flags.string({
+            description: 'How the API authenticates',
+            options: [data_provider_1.AuthTypeEnum.None, data_provider_1.AuthTypeEnum.ServiceHttp, data_provider_1.AuthTypeEnum.OAuth],
+            default: data_provider_1.AuthTypeEnum.None,
+        }),
+        'api-key': core_1.Flags.string({ description: '--auth service_http: the key or token' }),
+        'authorization-type': core_1.Flags.string({
+            description: '--auth service_http: how the key is presented',
+            options: [
+                data_provider_1.AuthorizationTypeEnum.Bearer,
+                data_provider_1.AuthorizationTypeEnum.Basic,
+                data_provider_1.AuthorizationTypeEnum.Custom,
+            ],
+        }),
+        'custom-auth-header': core_1.Flags.string({
+            description: '--authorization-type custom: the header name',
+        }),
+        'oauth-client-id': core_1.Flags.string({ description: '--auth oauth: client id' }),
+        'oauth-client-secret': core_1.Flags.string({ description: '--auth oauth: client secret' }),
+        'oauth-authorization-url': core_1.Flags.string({ description: '--auth oauth: authorization URL' }),
+        'oauth-client-url': core_1.Flags.string({ description: '--auth oauth: token URL' }),
+        'oauth-scope': core_1.Flags.string({ description: '--auth oauth: space-separated scopes' }),
+        'oauth-token-exchange-method': core_1.Flags.string({
+            description: '--auth oauth: how the token is exchanged',
+            options: [data_provider_1.TokenExchangeMethodEnum.DefaultPost, data_provider_1.TokenExchangeMethodEnum.BasicAuthHeader],
+        }),
+        'dry-run': core_1.Flags.boolean({
+            description: 'Parse the spec and report the functions it yields, send nothing',
+        }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async readSpec(source) {
+        if (source === '-') {
+            const chunks = [];
+            for await (const chunk of process.stdin)
+                chunks.push(Buffer.from(chunk));
+            return Buffer.concat(chunks).toString('utf8');
+        }
+        return (0, promises_1.readFile)(source, 'utf8');
+    }
+    buildAuth(flags) {
+        const type = flags.auth;
+        if (type === data_provider_1.AuthTypeEnum.ServiceHttp) {
+            if (!flags['api-key']) {
+                this.error('--auth service_http needs --api-key.', { exit: 1 });
+            }
+            if (flags['authorization-type'] === data_provider_1.AuthorizationTypeEnum.Custom &&
+                !flags['custom-auth-header']) {
+                this.error('--authorization-type custom needs --custom-auth-header.', { exit: 1 });
+            }
+            return {
+                api_key: String(flags['api-key']),
+                auth: {
+                    type,
+                    authorization_type: flags['authorization-type'] ?? data_provider_1.AuthorizationTypeEnum.Bearer,
+                    ...(flags['custom-auth-header'] === undefined
+                        ? {}
+                        : { custom_auth_header: String(flags['custom-auth-header']) }),
+                },
+            };
+        }
+        if (type === data_provider_1.AuthTypeEnum.OAuth) {
+            const missing = [
+                ['--oauth-client-id', flags['oauth-client-id']],
+                ['--oauth-client-secret', flags['oauth-client-secret']],
+                ['--oauth-authorization-url', flags['oauth-authorization-url']],
+                ['--oauth-client-url', flags['oauth-client-url']],
+            ]
+                .filter(([, value]) => !value)
+                .map(([name]) => name);
+            if (missing.length > 0) {
+                this.error(`--auth oauth needs ${missing.join(', ')}.`, { exit: 1 });
+            }
+            return {
+                oauth_client_id: String(flags['oauth-client-id']),
+                oauth_client_secret: String(flags['oauth-client-secret']),
+                auth: {
+                    type,
+                    authorization_url: String(flags['oauth-authorization-url']),
+                    client_url: String(flags['oauth-client-url']),
+                    ...(flags['oauth-scope'] === undefined ? {} : { scope: String(flags['oauth-scope']) }),
+                    token_exchange_method: flags['oauth-token-exchange-method'] ??
+                        data_provider_1.TokenExchangeMethodEnum.DefaultPost,
+                },
+            };
+        }
+        return { auth: { type: data_provider_1.AuthTypeEnum.None } };
+    }
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(AgentsApiActionsAdd);
+        let rawSpec;
+        try {
+            rawSpec = await this.readSpec(flags.spec);
+        }
+        catch (err) {
+            this.error(`Could not read --spec ${flags.spec}: ${err.message}`, { exit: 1 });
+        }
+        const validation = (0, data_provider_1.validateAndParseOpenAPISpec)(rawSpec);
+        if (!validation.status || !validation.spec) {
+            this.error(`The OpenAPI document is not usable: ${validation.message}`, { exit: 1 });
+        }
+        const { functionSignatures, requestBuilders } = (0, data_provider_1.openapiToFunction)(validation.spec);
+        const functions = functionSignatures.map((signature) => signature.toObjectTool());
+        if (functions.length === 0) {
+            this.error('The spec parsed but yielded no callable operations. Every path needs an ' +
+                'operationId and a method the parser understands.', { exit: 1 });
+        }
+        const first = Object.values(requestBuilders)[0];
+        if (!first?.domain) {
+            this.error('The spec has no server URL to call — `servers[0].url` is required.', { exit: 1 });
+        }
+        let domain;
+        try {
+            domain = new URL(first.domain).hostname;
+        }
+        catch {
+            this.error(`The spec's server URL is not a URL: ${first.domain}`, { exit: 1 });
+        }
+        if (flags['dry-run']) {
+            const preview = {
+                domain: domain,
+                functions: Object.entries(requestBuilders).map(([name, props]) => ({
+                    name,
+                    method: props.method,
+                    path: props.path,
+                })),
+            };
+            // Say it was a dry run: the output used to be indistinguishable from what
+            // a real add would have printed, so a reader could not tell whether
+            // anything had been written.
+            this.log(flags.json
+                ? JSON.stringify({ dryRun: true, written: false, ...preview }, null, 2)
+                : `Dry run — nothing was written. ${preview.functions.length} operation(s) on ${domain}:\n` +
+                    preview.functions
+                        .map((f) => `  ${f.name}  ${f.method.toUpperCase()} ${f.path}`)
+                        .join('\n'));
+            return;
+        }
+        const metadata = {
+            raw_spec: rawSpec,
+            domain: domain,
+            ...this.buildAuth(flags),
+        };
+        let result;
+        try {
+            result = await data_provider_1.dataService.updateAgentAction({
+                agent_id: args.agentId,
+                ...(flags['action-id'] === undefined ? {} : { action_id: flags['action-id'] }),
+                metadata,
+                functions,
+            });
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(this.agentJson(args.agentId, result));
+            return;
+        }
+        this.log(`${flags['action-id'] ? 'Updated' : 'Added'} an OpenAPI action on agent ${args.agentId} — ` +
+            `${functions.length} operation(s) on ${domain}`);
+        this.printAgentUrl(args.agentId);
+    }
+}
+exports.default = AgentsApiActionsAdd;

package/dist/commands/agents/api-actions/index.d.ts

@@ -0,0 +1,39 @@
+import { BaseCommand } from '../../../base-command';
+/**
+ * OpenAPI-spec-backed Actions — an agent calling a third-party HTTP API.
+ *
+ * WHY THE COMMAND IS NOT CALLED `actions`
+ * ───────────────────────────────────────
+ * Three different things in this product are called an "action", and two of
+ * them already own that word in the CLI:
+ *
+ *   skrr agents actions   — embedded `agentActions`: prompt/builtin buttons
+ *                           that live ON the agent document
+ *   skrr actions          — marketplace LISTINGS of those embedded actions
+ *   skrr agents api-actions (this) — `/api/agents/actions`: a tool surface
+ *                           generated from an OpenAPI document
+ *
+ * The third had no CLI at all, which the naming collision helped hide. Renaming
+ * the other two would break muscle memory for a surface that works, so this one
+ * takes an unambiguous name and all three now say which concept they are.
+ */
+/**
+ * The operation names an action exposes, parsed from its stored spec by the same
+ * parser `add` and the web builder use. The listing used to show id, agent,
+ * domain and auth — never what the action can DO — so answering "which tools does
+ * this give the agent" meant reading the raw spec.
+ */
+export declare function operationNames(action: {
+    metadata?: {
+        raw_spec?: string;
+    };
+}): string[];
+export default class AgentsApiActionsList extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        agent: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/agents/api-actions/index.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.operationNames = operationNames;
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../../base-command");
+const format_1 = require("../../../lib/format");
+/**
+ * OpenAPI-spec-backed Actions — an agent calling a third-party HTTP API.
+ *
+ * WHY THE COMMAND IS NOT CALLED `actions`
+ * ───────────────────────────────────────
+ * Three different things in this product are called an "action", and two of
+ * them already own that word in the CLI:
+ *
+ *   skrr agents actions   — embedded `agentActions`: prompt/builtin buttons
+ *                           that live ON the agent document
+ *   skrr actions          — marketplace LISTINGS of those embedded actions
+ *   skrr agents api-actions (this) — `/api/agents/actions`: a tool surface
+ *                           generated from an OpenAPI document
+ *
+ * The third had no CLI at all, which the naming collision helped hide. Renaming
+ * the other two would break muscle memory for a surface that works, so this one
+ * takes an unambiguous name and all three now say which concept they are.
+ */
+/**
+ * The operation names an action exposes, parsed from its stored spec by the same
+ * parser `add` and the web builder use. The listing used to show id, agent,
+ * domain and auth — never what the action can DO — so answering "which tools does
+ * this give the agent" meant reading the raw spec.
+ */
+function operationNames(action) {
+    const raw = action.metadata?.raw_spec;
+    if (!raw)
+        return [];
+    const parsed = (0, data_provider_1.validateAndParseOpenAPISpec)(raw);
+    if (!parsed.status || !parsed.spec)
+        return [];
+    return Object.keys((0, data_provider_1.openapiToFunction)(parsed.spec).requestBuilders);
+}
+class AgentsApiActionsList extends base_command_1.BaseCommand {
+    static description = 'List OpenAPI-backed Actions on agents you can edit (NOT `agents actions`, which is embedded buttons)';
+    static examples = [
+        '<%= config.bin %> agents api-actions',
+        '<%= config.bin %> agents api-actions --agent <agent-id>',
+        '<%= config.bin %> agents api-actions --json',
+    ];
+    static flags = {
+        agent: core_1.Flags.string({ description: 'Only actions on this agent' }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(AgentsApiActionsList);
+        let actions;
+        try {
+            actions = await data_provider_1.dataService.getActions();
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        // Filtered here rather than server-side: the endpoint returns every action
+        // on every agent the caller may EDIT, and has no agent filter. Doing it in
+        // the CLI keeps the flag honest instead of inventing a query the API does
+        // not answer.
+        const rows = flags.agent
+            ? actions.filter((action) => action.agent_id === flags.agent)
+            : actions;
+        if (flags.json) {
+            // Database internals (`_id`, `__v`) are not part of an action; a script
+            // reading this should not learn to depend on them.
+            const clean = rows.map((action) => {
+                const { _id, __v, ...rest } = action;
+                void _id;
+                void __v;
+                return { ...rest, operations: operationNames(action) };
+            });
+            this.log(JSON.stringify(clean, null, 2));
+            return;
+        }
+        if (rows.length === 0) {
+            this.log(flags.agent
+                ? `No OpenAPI actions on agent ${flags.agent}.`
+                : 'No OpenAPI actions on any agent you can edit.');
+            this.log('Add one with: skrr agents api-actions add <agent-id> --spec <openapi.yaml>');
+            return;
+        }
+        (0, format_1.renderTable)(rows.map((action) => ({
+            actionId: action.action_id,
+            agentId: action.agent_id ?? '-',
+            domain: action.metadata?.domain ?? '-',
+            auth: action.metadata?.auth?.type ?? 'none',
+            operations: operationNames(action).join(', ') || '-',
+        })), [
+            { key: 'actionId', header: 'ACTION ID', verbatim: true },
+            { key: 'agentId', header: 'AGENT ID', verbatim: true },
+            { key: 'domain', header: 'DOMAIN', maxWidth: 40 },
+            { key: 'auth', header: 'AUTH' },
+            { key: 'operations', header: 'OPERATIONS', maxWidth: 48 },
+        ], (line) => this.log(line));
+    }
+}
+exports.default = AgentsApiActionsList;

package/dist/commands/agents/api-actions/remove.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand } from '../../../base-command';
+/** Detach an OpenAPI Action from an agent. Wraps `DELETE /api/agents/actions/:agent_id/:action_id`. */
+export default class AgentsApiActionsRemove extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        agentId: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        actionId: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/agents/api-actions/remove.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../../base-command");
+/** Detach an OpenAPI Action from an agent. Wraps `DELETE /api/agents/actions/:agent_id/:action_id`. */
+class AgentsApiActionsRemove extends base_command_1.BaseCommand {
+    static description = 'Remove an OpenAPI-backed Action from an agent';
+    static examples = ['<%= config.bin %> agents api-actions remove <agent-id> <action-id>'];
+    static args = {
+        agentId: core_1.Args.string({ description: 'Agent ID', required: true, ignoreStdin: true }),
+        actionId: core_1.Args.string({ description: 'Action ID', required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(AgentsApiActionsRemove);
+        try {
+            await data_provider_1.dataService.deleteAgentAction({
+                agent_id: args.agentId,
+                action_id: args.actionId,
+            });
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify({ removed: args.actionId, agentId: args.agentId }, null, 2));
+            return;
+        }
+        this.log(`Removed action ${args.actionId} from agent ${args.agentId}`);
+    }
+}
+exports.default = AgentsApiActionsRemove;

package/dist/commands/agents/avatar/default/apply.d.ts

@@ -0,0 +1,25 @@
+import { BaseCommand } from '../../../../base-command';
+/**
+ * Apply the policy to agents that ALREADY EXIST — the one retroactive path in
+ * the avatar system, and deliberately user-initiated.
+ *
+ * It is not a sweep over everything: an agent whose owner explicitly chose the
+ * platform logo stores `{type:'default'}` and is NOT eligible, while an agent
+ * that never had a face stores nothing and is. "Never chose" and "chose the
+ * logo" are different facts and the server keeps them apart.
+ *
+ * The count is shown BEFORE anything is written. `--dry-run` asks the server how
+ * many are eligible without touching them; without `--yes` that is what this
+ * command does first, then asks. A command that silently re-skinned an unknown
+ * number of agents would be the wrong shape for an irreversible bulk write.
+ */
+export default class AgentsAvatarDefaultApply extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        'dry-run': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        yes: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/agents/avatar/default/apply.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../../../base-command");
+/**
+ * Apply the policy to agents that ALREADY EXIST — the one retroactive path in
+ * the avatar system, and deliberately user-initiated.
+ *
+ * It is not a sweep over everything: an agent whose owner explicitly chose the
+ * platform logo stores `{type:'default'}` and is NOT eligible, while an agent
+ * that never had a face stores nothing and is. "Never chose" and "chose the
+ * logo" are different facts and the server keeps them apart.
+ *
+ * The count is shown BEFORE anything is written. `--dry-run` asks the server how
+ * many are eligible without touching them; without `--yes` that is what this
+ * command does first, then asks. A command that silently re-skinned an unknown
+ * number of agents would be the wrong shape for an irreversible bulk write.
+ */
+class AgentsAvatarDefaultApply extends base_command_1.BaseCommand {
+    static description = 'Apply your default-avatar policy to existing agents that never had a face chosen';
+    static examples = [
+        '<%= config.bin %> agents avatar default apply --dry-run',
+        '<%= config.bin %> agents avatar default apply --yes',
+    ];
+    static flags = {
+        'dry-run': core_1.Flags.boolean({ description: 'Report how many agents are eligible, write nothing' }),
+        yes: core_1.Flags.boolean({ description: 'Skip the eligible-count preview and write' }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(AgentsAvatarDefaultApply);
+        const dryRun = flags['dry-run'] === true || flags.yes !== true;
+        let result;
+        try {
+            result = await data_provider_1.dataService.applyAgentAvatarDefault(dryRun);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        if (!dryRun) {
+            this.log(`Applied the default-avatar policy to ${result.updated} agent(s).`);
+            return;
+        }
+        this.log(`${result.eligible} agent(s) would get a new avatar. Nothing was written.`);
+        if (!flags['dry-run']) {
+            this.log('Re-run with --yes to apply.');
+        }
+    }
+}
+exports.default = AgentsAvatarDefaultApply;

package/dist/commands/agents/avatar/default/index.d.ts

@@ -0,0 +1,29 @@
+import { BaseCommand } from '../../../../base-command';
+/**
+ * Which of the two states produced the policy line above it.
+ *
+ * The route sends `explicit` precisely because the policy alone cannot carry
+ * it: `resolveAgentAvatarDefaultPolicy` maps an absent field and a deliberate
+ * choice of the same shape onto one value. So "I picked random-from-all" and "I
+ * have never picked anything" printed identically, and they are not the same
+ * fact — only the second follows the shipped default if it ever changes, which
+ * is the whole reason clearing exists as a separate operation from choosing.
+ */
+export declare function describePolicyProvenance(explicit: boolean): string;
+/**
+ * What face a NEW agent gets when its creator does not pick one.
+ *
+ * Wraps `GET /api/agents/avatar-default`. The policy is read exactly ONCE, at
+ * creation, and the drawn reference is written onto the agent — so changing it
+ * is structurally incapable of re-skinning an agent that already exists. That
+ * property is worth stating here, because "default" in most products means a
+ * live fallback and this one does not.
+ */
+export default class AgentsAvatarDefaultShow extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/agents/avatar/default/index.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describePolicyProvenance = describePolicyProvenance;
+const core_1 = require("@oclif/core");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../../../base-command");
+/**
+ * Which of the two states produced the policy line above it.
+ *
+ * The route sends `explicit` precisely because the policy alone cannot carry
+ * it: `resolveAgentAvatarDefaultPolicy` maps an absent field and a deliberate
+ * choice of the same shape onto one value. So "I picked random-from-all" and "I
+ * have never picked anything" printed identically, and they are not the same
+ * fact — only the second follows the shipped default if it ever changes, which
+ * is the whole reason clearing exists as a separate operation from choosing.
+ */
+function describePolicyProvenance(explicit) {
+    return explicit
+        ? '  You chose this. It stays until you change or clear it.'
+        : '  You have not chosen one, so this follows the shipped default — including if it changes.';
+}
+/**
+ * What face a NEW agent gets when its creator does not pick one.
+ *
+ * Wraps `GET /api/agents/avatar-default`. The policy is read exactly ONCE, at
+ * creation, and the drawn reference is written onto the agent — so changing it
+ * is structurally incapable of re-skinning an agent that already exists. That
+ * property is worth stating here, because "default" in most products means a
+ * live fallback and this one does not.
+ */
+class AgentsAvatarDefaultShow extends base_command_1.BaseCommand {
+    static description = 'Show the default-avatar policy new agents are drawn from';
+    static examples = [
+        '<%= config.bin %> agents avatar default',
+        '<%= config.bin %> agents avatar default --json',
+    ];
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(AgentsAvatarDefaultShow);
+        let response;
+        try {
+            response = await data_provider_1.dataService.getAgentAvatarDefault();
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(response, null, 2));
+            return;
+        }
+        this.log((0, data_provider_1.describeAgentAvatarPolicy)(response.policy));
+        this.log(describePolicyProvenance(Boolean(response.explicit)));
+        this.log('');
+        this.log('Applies to agents created from now on. Existing agents keep the face they have —');
+        this.log('`skrr agents avatar default apply` is the one path that changes them.');
+    }
+}
+exports.default = AgentsAvatarDefaultShow;

package/dist/commands/agents/avatar/default/set.d.ts

@@ -0,0 +1,24 @@
+import { BaseCommand } from '../../../../base-command';
+/**
+ * Choose the policy. Wraps `PUT /api/agents/avatar-default`.
+ *
+ * ONE value, not three switches: `--mode` selects which of the shapes in
+ * `AgentAvatarDefaultPolicy` is being written, and the other flags supply that
+ * shape's payload. The union is the server's contract, so the command refuses a
+ * combination that cannot be one of its members rather than sending a
+ * half-formed object and letting zod name the problem.
+ */
+export default class AgentsAvatarDefaultSet extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        mode: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        clear: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        ref: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        scope: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        category: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    private buildPolicy;
+    run(): Promise<void>;
+}