@skrr-ai/cli 0.1.36 → 0.1.38

package/dist/commands/agents/mute.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const agent_pin_mute_1 = require("../../lib/agent-pin-mute");
+/**
+ * Per-USER preference, not agent config: it changes your view of the agent and
+ * nobody else's. Idempotent over a toggle endpoint — see `lib/agent-pin-mute.ts`.
+ */
+class AgentsMute extends base_command_1.BaseCommand {
+    static description = "Silence an agent's notifications for you";
+    static examples = ['<%= config.bin %> agents mute <agent-id>'];
+    static args = {
+        id: core_1.Args.string({ description: 'Agent 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(AgentsMute);
+        let result;
+        try {
+            result = await (0, agent_pin_mute_1.setAgentFlag)(args.id, 'mute', true);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(this.agentJson(args.id, { mute: result.value, changed: result.changed }));
+            return;
+        }
+        this.log(result.changed
+            ? `Agent ${args.id}: mute is now ${result.value}`
+            : `Agent ${args.id}: mute was already ${result.value} — nothing to do`);
+    }
+}
+exports.default = AgentsMute;

package/dist/commands/agents/pin.d.ts

@@ -0,0 +1,16 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * Per-USER preference, not agent config: it changes your view of the agent and
+ * nobody else's. Idempotent over a toggle endpoint — see `lib/agent-pin-mute.ts`.
+ */
+export default class AgentsPin extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: 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/pin.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const agent_pin_mute_1 = require("../../lib/agent-pin-mute");
+/**
+ * Per-USER preference, not agent config: it changes your view of the agent and
+ * nobody else's. Idempotent over a toggle endpoint — see `lib/agent-pin-mute.ts`.
+ */
+class AgentsPin extends base_command_1.BaseCommand {
+    static description = 'Pin an agent to the top of your list';
+    static examples = ['<%= config.bin %> agents pin <agent-id>'];
+    static args = {
+        id: core_1.Args.string({ description: 'Agent 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(AgentsPin);
+        let result;
+        try {
+            result = await (0, agent_pin_mute_1.setAgentFlag)(args.id, 'pin', true);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(this.agentJson(args.id, { pin: result.value, changed: result.changed }));
+            return;
+        }
+        this.log(result.changed
+            ? `Agent ${args.id}: pin is now ${result.value}`
+            : `Agent ${args.id}: pin was already ${result.value} — nothing to do`);
+    }
+}
+exports.default = AgentsPin;

package/dist/commands/agents/scene-background/upload.d.ts

@@ -0,0 +1,30 @@
+import { BaseCommand } from '../../../base-command';
+/**
+ * Upload an image as an agent's 3D backdrop.
+ *
+ * `--scene-background image:<filepath>@<source>` was documented and had no value
+ * that could succeed from the CLI. The server accepts an image backdrop only from
+ * the writer's own WALLPAPER upload namespace (`/images/<userId>/wallpaper-…`),
+ * and the only thing that writes there is `POST /api/files/images/wallpaper` —
+ * which nothing in `skrr` called. Every attempt ended in
+ * "Scene background image must be one you uploaded", and the flag's word
+ * `<filepath>` read like a path on disk, which sent people looking in the wrong
+ * place.
+ *
+ * This is that upload, followed by setting it, so the documented form finally
+ * has a producer. `--upload-only` prints the `--scene-background` value instead,
+ * for scripts that set it later or on several agents.
+ */
+export default class AgentsSceneBackgroundUpload extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        agentId: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        file: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'upload-only': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/agents/scene-background/upload.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const base_command_1 = require("../../../base-command");
+const agent_visual_refs_1 = require("../../../lib/agent-visual-refs");
+/**
+ * Upload an image as an agent's 3D backdrop.
+ *
+ * `--scene-background image:<filepath>@<source>` was documented and had no value
+ * that could succeed from the CLI. The server accepts an image backdrop only from
+ * the writer's own WALLPAPER upload namespace (`/images/<userId>/wallpaper-…`),
+ * and the only thing that writes there is `POST /api/files/images/wallpaper` —
+ * which nothing in `skrr` called. Every attempt ended in
+ * "Scene background image must be one you uploaded", and the flag's word
+ * `<filepath>` read like a path on disk, which sent people looking in the wrong
+ * place.
+ *
+ * This is that upload, followed by setting it, so the documented form finally
+ * has a producer. `--upload-only` prints the `--scene-background` value instead,
+ * for scripts that set it later or on several agents.
+ */
+class AgentsSceneBackgroundUpload extends base_command_1.BaseCommand {
+    static description = "Upload an image as an agent's 3D backdrop and set it";
+    static examples = [
+        '<%= config.bin %> agents scene-background upload agent_abc --file ./room.png',
+        '<%= config.bin %> agents scene-background upload agent_abc --file ./room.jpg --upload-only',
+    ];
+    static args = {
+        agentId: core_1.Args.string({ description: 'Agent ID', required: true, ignoreStdin: true }),
+    };
+    static flags = {
+        file: core_1.Flags.string({
+            description: 'Image to upload: PNG, JPEG, WebP or GIF (not SVG). Resized to at most 2560px wide.',
+            required: true,
+        }),
+        'upload-only': core_1.Flags.boolean({
+            description: 'Upload, then print the --scene-background value without changing the agent',
+        }),
+        json: core_1.Flags.boolean({ description: 'Output JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(AgentsSceneBackgroundUpload);
+        // The server gates on the part's MIME type, so an untyped Blob would be
+        // refused as "Unsupported file type" whatever its bytes were.
+        const type = (0, agent_visual_refs_1.imageUploadMimeType)(flags.file);
+        if (!type) {
+            this.error(`--file must be a .png, .jpg, .jpeg, .webp or .gif image (got ${(0, node_path_1.basename)(flags.file)}).`, { exit: 1 });
+        }
+        let bytes;
+        try {
+            bytes = await (0, promises_1.readFile)(flags.file);
+        }
+        catch (err) {
+            this.error(`Could not read --file ${flags.file}: ${err.message}`, { exit: 1 });
+        }
+        const form = new FormData();
+        form.append('file', new Blob([new Uint8Array(bytes)], { type }), (0, node_path_1.basename)(flags.file));
+        let uploaded;
+        try {
+            uploaded = (await data_provider_1.dataService.uploadWallpaper(form));
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        const sceneBackground = {
+            type: 'image',
+            filepath: uploaded.filepath,
+            source: uploaded.source,
+        };
+        const flagValue = `image:${sceneBackground.filepath}@${sceneBackground.source}`;
+        if (!flags['upload-only']) {
+            try {
+                await data_provider_1.dataService.updateAgent({
+                    agent_id: args.agentId,
+                    data: { sceneBackground },
+                });
+            }
+            catch (err) {
+                this.handleApiError(err);
+            }
+        }
+        if (flags.json) {
+            this.log(JSON.stringify({ agentId: args.agentId, sceneBackground, flagValue, applied: !flags['upload-only'] }, null, 2));
+            return;
+        }
+        this.log(flags['upload-only']
+            ? `Uploaded. Set it with: --scene-background ${flagValue}`
+            : `Backdrop for agent ${args.agentId} is now the uploaded image.`);
+        if (!flags['upload-only'])
+            this.printAgentUrl(args.agentId);
+    }
+}
+exports.default = AgentsSceneBackgroundUpload;

package/dist/commands/agents/show.js

@@ -8,6 +8,7 @@ const base_command_1 = require("../../base-command");
 const harness_provider_input_1 = require("../../lib/harness-provider-input");
 const web_url_1 = require("../../lib/web-url");
 const hosted_machines_1 = require("../../lib/hosted-machines");
+const agent_visual_refs_1 = require("../../lib/agent-visual-refs");
 /**
  * OSK-4901 — the tone line for `agents show` text output.
  *
@@ -139,6 +140,18 @@ class AgentsShow extends base_command_1.BaseCommand {
         this.log(`Provider:    ${a.provider ?? '-'}`);
         this.log(`Model:       ${a.model ?? '-'}`);
         this.log(`Tone:        ${agentToneLine(a)}`);
+        this.log(`Avatar:      ${(0, agent_visual_refs_1.agentAvatarLine)(a.avatar)}`);
+        this.log(`Backdrop:    ${(0, agent_visual_refs_1.agentSceneBackgroundLine)(a.sceneBackground)}`);
+        // Pin and mute are per-user, so they live in preferences rather than on the
+        // agent — which is why this view never showed either. Best-effort read.
+        try {
+            const prefs = (await data_provider_1.dataService.getAgentPreferences(String(a.id ?? args.id)))?.preferences;
+            this.log(`Pinned:      ${prefs?.isPinned ? 'yes' : 'no'}`);
+            this.log(`Muted:       ${prefs?.isMuted ? 'yes' : 'no'}`);
+        }
+        catch {
+            /* preferences unreadable — omit rather than claim "no" */
+        }
         this.log(`Category:    ${a.category ?? '-'}`);
         this.log(`Author:      ${a.author ?? '-'}`);
         // A cap the user cannot see is a cap they cannot diagnose: a saturated

package/dist/commands/agents/tools/auth.d.ts

@@ -0,0 +1,19 @@
+import { BaseCommand } from '../../../base-command';
+/**
+ * Whether this account has credentials for one tool.
+ *
+ * Separate from the `AUTH` column in `agents tools` because that column reports
+ * what the catalog said in one batch read, and this asks the server about one
+ * tool now — which is the question worth asking after wiring up a key.
+ */
+export default class AgentsToolsAuth extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        toolId: 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/tools/auth.js

@@ -0,0 +1,41 @@
+"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");
+/**
+ * Whether this account has credentials for one tool.
+ *
+ * Separate from the `AUTH` column in `agents tools` because that column reports
+ * what the catalog said in one batch read, and this asks the server about one
+ * tool now — which is the question worth asking after wiring up a key.
+ */
+class AgentsToolsAuth extends base_command_1.BaseCommand {
+    static description = 'Check whether this account is authenticated for one tool';
+    static examples = ['<%= config.bin %> agents tools auth <plugin-key>'];
+    static args = {
+        toolId: core_1.Args.string({ description: 'Plugin key', 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(AgentsToolsAuth);
+        let result;
+        try {
+            result = await data_provider_1.dataService.getVerifyAgentToolAuth({ toolId: args.toolId });
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        this.log(result.authenticated
+            ? `${args.toolId}: authenticated`
+            : `${args.toolId}: not authenticated${result.message ? ` — ${result.message}` : ''}`);
+    }
+}
+exports.default = AgentsToolsAuth;

package/dist/commands/agents/tools/calls.d.ts

@@ -0,0 +1,36 @@
+import { BaseCommand } from '../../../base-command';
+type ToolCallRow = {
+    messageId: string;
+    toolUseId: string;
+    name: string;
+    args: string;
+    output: string;
+    complete: boolean;
+    source: 'message' | 'ledger';
+};
+/**
+ * The tool calls in a conversation, read from the conversation's own messages.
+ *
+ * This command read `GET /api/agents/tools/calls`, the `ToolCall` ledger — and
+ * nothing in the codebase writes that ledger: `createToolCall` has no caller. So
+ * it answered "No tool calls recorded" for EVERY conversation, including one where
+ * the agent had just run a Bash command, and for a conversation id that did not
+ * exist at all. Nobody could tell a broken command from an empty answer.
+ *
+ * Every agent turn records its tool calls as `tool_call` content parts on the
+ * assistant message (name, arguments, output), so that is the primary source. A
+ * conversation that does not exist is a NOT_FOUND, not an empty list. Ledger rows
+ * are still read and merged, so the endpoint stays reachable and a future writer
+ * is not silently ignored.
+ */
+export declare function toolCallsFromMessages(messages: unknown): ToolCallRow[];
+export default class AgentsToolsCalls extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        conversation: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}
+export {};

package/dist/commands/agents/tools/calls.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolCallsFromMessages = toolCallsFromMessages;
+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");
+const clip = (value, width) => {
+    const text = value == null
+        ? ''
+        : typeof value === 'string'
+            ? value
+            : (JSON.stringify(value) ?? String(value));
+    const flat = text.replace(/\s+/g, ' ').trim();
+    return flat.length > width ? `${flat.slice(0, width - 1)}…` : flat;
+};
+/**
+ * The tool calls in a conversation, read from the conversation's own messages.
+ *
+ * This command read `GET /api/agents/tools/calls`, the `ToolCall` ledger — and
+ * nothing in the codebase writes that ledger: `createToolCall` has no caller. So
+ * it answered "No tool calls recorded" for EVERY conversation, including one where
+ * the agent had just run a Bash command, and for a conversation id that did not
+ * exist at all. Nobody could tell a broken command from an empty answer.
+ *
+ * Every agent turn records its tool calls as `tool_call` content parts on the
+ * assistant message (name, arguments, output), so that is the primary source. A
+ * conversation that does not exist is a NOT_FOUND, not an empty list. Ledger rows
+ * are still read and merged, so the endpoint stays reachable and a future writer
+ * is not silently ignored.
+ */
+function toolCallsFromMessages(messages) {
+    const rows = [];
+    for (const message of Array.isArray(messages) ? messages : []) {
+        const m = message;
+        for (const part of Array.isArray(m.content) ? m.content : []) {
+            const p = part;
+            if (p?.type !== 'tool_call' || !p.tool_call)
+                continue;
+            const call = p.tool_call;
+            rows.push({
+                messageId: String(m.messageId ?? '-'),
+                toolUseId: String(call.id ?? '-'),
+                name: String(call.name ?? '-'),
+                args: clip(call.args, 200),
+                output: clip(call.output, 200),
+                complete: Number(call.progress ?? 0) >= 1 || call.output != null,
+                source: 'message',
+            });
+        }
+    }
+    return rows;
+}
+class AgentsToolsCalls extends base_command_1.BaseCommand {
+    static description = 'List the tool calls an agent made in one conversation';
+    static examples = [
+        '<%= config.bin %> agents tools calls --conversation <conversation-id>',
+    ];
+    static flags = {
+        conversation: core_1.Flags.string({ description: 'Conversation ID', required: true }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(AgentsToolsCalls);
+        let messages;
+        try {
+            // NOT_FOUND here is the honest answer for a conversation that does not
+            // exist, and handleApiError reports it as such.
+            messages = await data_provider_1.dataService.getMessagesByConvoId(flags.conversation);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        const rows = toolCallsFromMessages(messages);
+        try {
+            const ledger = (await data_provider_1.dataService.getToolCalls({
+                conversationId: flags.conversation,
+            }));
+            for (const entry of ledger ?? []) {
+                rows.push({
+                    messageId: String(entry.messageId ?? '-'),
+                    toolUseId: String(entry.toolId ?? '-'),
+                    name: String(entry.toolId ?? '-'),
+                    args: '',
+                    output: clip(entry.result, 200),
+                    complete: true,
+                    source: 'ledger',
+                });
+            }
+        }
+        catch {
+            /* the ledger is supplementary; the messages already answered */
+        }
+        if (flags.json) {
+            this.log(JSON.stringify(rows, null, 2));
+            return;
+        }
+        if (rows.length === 0) {
+            const count = Array.isArray(messages) ? messages.length : 0;
+            this.log(`Conversation ${flags.conversation} has ${count} message${count === 1 ? '' : 's'} and no tool calls.`);
+            return;
+        }
+        (0, format_1.renderTable)(rows.map((row) => ({
+            name: row.name,
+            args: row.args || '-',
+            output: row.complete ? row.output || '(empty)' : '(no result recorded)',
+            toolUseId: row.toolUseId,
+        })), [
+            { key: 'name', header: 'TOOL', maxWidth: 28 },
+            { key: 'args', header: 'ARGUMENTS', maxWidth: 48 },
+            { key: 'output', header: 'OUTPUT', maxWidth: 40 },
+            { key: 'toolUseId', header: 'TOOL USE ID', verbatim: true },
+        ], (line) => this.log(line));
+    }
+}
+exports.default = AgentsToolsCalls;

package/dist/commands/agents/tools/index.d.ts

@@ -0,0 +1,20 @@
+import { BaseCommand } from '../../../base-command';
+/**
+ * The tool catalog `--tools` is chosen from.
+ *
+ * `agents create --tools '["..."]'` has always taken an array of plugin keys the
+ * caller had no way to enumerate — the web fills the same field from a picker
+ * backed by this endpoint, so the flag was only usable by someone reading the
+ * server's source or copying another agent's array.
+ *
+ * PLUGIN KEY is the column that matters: it is the string the field stores.
+ */
+export default class AgentsToolsList extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        authenticated: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/agents/tools/index.js

@@ -0,0 +1,77 @@
+"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");
+const format_1 = require("../../../lib/format");
+/**
+ * The tool catalog `--tools` is chosen from.
+ *
+ * `agents create --tools '["..."]'` has always taken an array of plugin keys the
+ * caller had no way to enumerate — the web fills the same field from a picker
+ * backed by this endpoint, so the flag was only usable by someone reading the
+ * server's source or copying another agent's array.
+ *
+ * PLUGIN KEY is the column that matters: it is the string the field stores.
+ */
+class AgentsToolsList extends base_command_1.BaseCommand {
+    static description = 'List the tools `agents create/update --tools` accepts';
+    static examples = [
+        '<%= config.bin %> agents tools',
+        '<%= config.bin %> agents tools --authenticated',
+        '<%= config.bin %> agents tools --json',
+    ];
+    static flags = {
+        authenticated: core_1.Flags.boolean({
+            description: 'Only tools this account has already authenticated',
+        }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(AgentsToolsList);
+        let tools;
+        try {
+            tools = await data_provider_1.dataService.getAvailableTools();
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        const rows = flags.authenticated
+            ? tools.filter((tool) => tool.authenticated === true)
+            : tools;
+        if (flags.json) {
+            this.log(JSON.stringify(rows, null, 2));
+            return;
+        }
+        if (rows.length === 0) {
+            this.log(flags.authenticated ? 'No authenticated tools.' : 'No tools available.');
+            return;
+        }
+        /**
+         * Three states, not two. `authConfig` present means the tool needs
+         * credentials; `authenticated` says whether this account has supplied them.
+         * A tool that needs nothing is neither — printing "no" for it would send
+         * someone to configure a key that does not exist.
+         */
+        const authState = (tool) => {
+            if (!tool.authConfig || tool.authConfig.length === 0)
+                return '-';
+            return tool.authenticated ? 'yes' : 'needed';
+        };
+        (0, format_1.renderTable)(rows.map((tool) => ({
+            pluginKey: tool.pluginKey,
+            name: tool.name,
+            auth: authState(tool),
+            description: String(tool.description ?? ''),
+        })), [
+            { key: 'pluginKey', header: 'PLUGIN KEY', verbatim: true },
+            { key: 'name', header: 'NAME', maxWidth: 28 },
+            { key: 'auth', header: 'AUTH' },
+            { key: 'description', header: 'DESCRIPTION', maxWidth: 52 },
+        ], (line) => this.log(line));
+        this.log('');
+        this.log('PLUGIN KEY is what --tools stores, e.g. --tools \'["web_search"]\'.');
+    }
+}
+exports.default = AgentsToolsList;

package/dist/commands/agents/unmute.d.ts

@@ -0,0 +1,16 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * Per-USER preference, not agent config: it changes your view of the agent and
+ * nobody else's. Idempotent over a toggle endpoint — see `lib/agent-pin-mute.ts`.
+ */
+export default class AgentsUnmute extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: 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/unmute.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const agent_pin_mute_1 = require("../../lib/agent-pin-mute");
+/**
+ * Per-USER preference, not agent config: it changes your view of the agent and
+ * nobody else's. Idempotent over a toggle endpoint — see `lib/agent-pin-mute.ts`.
+ */
+class AgentsUnmute extends base_command_1.BaseCommand {
+    static description = "Un-silence an agent's notifications for you";
+    static examples = ['<%= config.bin %> agents unmute <agent-id>'];
+    static args = {
+        id: core_1.Args.string({ description: 'Agent 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(AgentsUnmute);
+        let result;
+        try {
+            result = await (0, agent_pin_mute_1.setAgentFlag)(args.id, 'mute', false);
+        }
+        catch (err) {
+            this.handleApiError(err);
+        }
+        if (flags.json) {
+            this.log(this.agentJson(args.id, { mute: result.value, changed: result.changed }));
+            return;
+        }
+        this.log(result.changed
+            ? `Agent ${args.id}: mute is now ${result.value}`
+            : `Agent ${args.id}: mute was already ${result.value} — nothing to do`);
+    }
+}
+exports.default = AgentsUnmute;

package/dist/commands/agents/unpin.d.ts

@@ -0,0 +1,16 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * Per-USER preference, not agent config: it changes your view of the agent and
+ * nobody else's. Idempotent over a toggle endpoint — see `lib/agent-pin-mute.ts`.
+ */
+export default class AgentsUnpin extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}