@bussolabs/closeyourit-cli 0.22.0 → 0.23.1

package/dist/commands/errors/bulk-triage.d.ts

@@ -0,0 +1,11 @@
+import { BaseCommand } from '../../base';
+export default class ErrorsBulkTriage extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        action: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        group: import("@oclif/core/lib/interfaces").OptionFlag<string[], import("@oclif/core/lib/interfaces").CustomOptions>;
+        project: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<unknown>;
+}

package/dist/commands/errors/bulk-triage.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_1 = require("../../base");
+const error_codes_1 = require("../../errors/error-codes");
+const bulk_triage_1 = require("../../lib/bulk-triage");
+const output_1 = require("../../lib/output");
+class ErrorsBulkTriage extends base_1.BaseCommand {
+    static description = 'Resolve, ignore or reopen several error groups in one call';
+    static examples = [
+        '<%= config.bin %> errors bulk-triage -p acme-api --action resolve --group <id-a> --group <id-b>',
+        '<%= config.bin %> errors bulk-triage -p acme-api --action ignore --group <id-a> --json',
+    ];
+    static flags = {
+        ...base_1.projectFlag,
+        action: core_1.Flags.string({ description: 'What to do with them', options: [...bulk_triage_1.TRIAGE_ACTIONS], required: true }),
+        group: core_1.Flags.string({ description: 'Error group id (repeatable)', multiple: true, required: true }),
+    };
+    async run() {
+        const { flags } = await this.parse(ErrorsBulkTriage);
+        const projectId = await this.resolveProjectId(flags.project);
+        const ids = (0, bulk_triage_1.uniqueIds)(flags.group);
+        const res = await this.api.post(`/cli/v1/projects/${encodeURIComponent(projectId)}/error_groups/bulk_triage`, { bulk_action: flags.action, ids });
+        const groups = res.data ?? [];
+        if (!this.jsonEnabled()) {
+            this.log((0, bulk_triage_1.triagedLine)(groups.length, 'error group', flags.action));
+            this.log((0, output_1.renderTable)(['ID', 'TITLE', 'STATUS'], groups.map((group) => [String(group.id ?? ''), String(group.title ?? ''), (0, output_1.statusCell)(group.status)])));
+        }
+        // After printing: the groups that did change are worth showing even when the selection was not
+        // whole, and only then does the command refuse to call it a success.
+        (0, bulk_triage_1.assertNothingDropped)({
+            action: flags.action,
+            code: error_codes_1.ErrorCodes.ErrorGroup.notFound,
+            noun: 'error group',
+            requested: ids,
+            rows: groups,
+        });
+        return res;
+    }
+}
+exports.default = ErrorsBulkTriage;

package/dist/commands/errors/delete.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../../base';
+export default class ErrorsDelete extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        confirm: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<unknown>;
+}

package/dist/commands/errors/delete.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_1 = require("../../base");
+class ErrorsDelete extends base_1.BaseCommand {
+    static description = 'Delete an error group and every occurrence it holds (irreversible)';
+    static examples = ['<%= config.bin %> errors delete <group-id> --project acme-api --confirm'];
+    static args = {
+        id: core_1.Args.string({ description: 'Error group id', required: true }),
+    };
+    static flags = {
+        ...base_1.projectFlag,
+        confirm: core_1.Flags.boolean({ description: 'Required: confirm the irreversible deletion' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ErrorsDelete);
+        if (!flags.confirm) {
+            this.error('Refusing to delete without --confirm (the group and its occurrences are gone for good).', { exit: 2 });
+        }
+        const projectId = await this.resolveProjectId(flags.project);
+        const res = await this.api.delete(`/cli/v1/projects/${encodeURIComponent(projectId)}/error_groups/${encodeURIComponent(args.id)}`);
+        if (!this.jsonEnabled()) {
+            this.log(`Deleted error group ${args.id} and its occurrences.`);
+        }
+        return res;
+    }
+}
+exports.default = ErrorsDelete;

package/dist/commands/errors/grouping-rules/create.d.ts

@@ -0,0 +1,15 @@
+import { BaseCommand } from '../../../base';
+export default class ErrorsGroupingRulesCreate extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        field: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        operator: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        value: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'fingerprint-key': import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        position: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        active: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<unknown>;
+}

package/dist/commands/errors/grouping-rules/create.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_1 = require("../../../base");
+const grouping_rules_1 = require("../../../lib/grouping-rules");
+const output_1 = require("../../../lib/output");
+class ErrorsGroupingRulesCreate extends base_1.BaseCommand {
+    static description = 'Add a grouping rule: occurrences that match it are grouped under one key';
+    static examples = [
+        '<%= config.bin %> errors grouping-rules create -p acme-api --field message --operator contains --value "timeout" --fingerprint-key net-timeout',
+        '<%= config.bin %> errors grouping-rules create -p acme-api --field culprit --operator starts_with --value "app/jobs/" --fingerprint-key jobs --position 2',
+    ];
+    static flags = {
+        ...base_1.projectFlag,
+        field: core_1.Flags.string({
+            description: 'Occurrence field the rule looks at',
+            options: [...grouping_rules_1.GROUPING_RULE_FIELDS],
+            required: true,
+        }),
+        operator: core_1.Flags.string({
+            description: 'How the field is compared (always case-insensitive)',
+            options: [...grouping_rules_1.GROUPING_RULE_OPERATORS],
+            required: true,
+        }),
+        value: core_1.Flags.string({ description: 'Text to compare the field against', required: true }),
+        'fingerprint-key': core_1.Flags.string({
+            description: 'Grouping key: rules sharing it send their occurrences to the same group',
+            required: true,
+        }),
+        position: core_1.Flags.integer({ description: 'Order of application (lower runs first)' }),
+        active: core_1.Flags.boolean({ allowNo: true, description: 'Whether the rule applies at ingest' }),
+    };
+    async run() {
+        const { flags } = await this.parse(ErrorsGroupingRulesCreate);
+        const projectId = await this.resolveProjectId(flags.project);
+        const res = await this.api.post(`/cli/v1/projects/${encodeURIComponent(projectId)}/error_grouping_rules`, (0, grouping_rules_1.groupingRuleBody)(flags));
+        if (!this.jsonEnabled()) {
+            this.log('Grouping rule created:');
+            this.log((0, output_1.renderRecord)(res.data ?? {}));
+        }
+        return res;
+    }
+}
+exports.default = ErrorsGroupingRulesCreate;

package/dist/commands/errors/grouping-rules/delete.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../../../base';
+export default class ErrorsGroupingRulesDelete extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        confirm: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<unknown>;
+}

package/dist/commands/errors/grouping-rules/delete.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_1 = require("../../../base");
+class ErrorsGroupingRulesDelete extends base_1.BaseCommand {
+    static description = 'Delete a grouping rule (the groups it already made stay where they are)';
+    static examples = ['<%= config.bin %> errors grouping-rules delete <rule-id> --project acme-api --confirm'];
+    static args = {
+        id: core_1.Args.string({ description: 'Grouping rule id', required: true }),
+    };
+    static flags = {
+        ...base_1.projectFlag,
+        confirm: core_1.Flags.boolean({ description: 'Required: confirm the deletion' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ErrorsGroupingRulesDelete);
+        if (!flags.confirm) {
+            this.error('Refusing to delete without --confirm.', { exit: 2 });
+        }
+        const projectId = await this.resolveProjectId(flags.project);
+        await this.api.delete(`/cli/v1/projects/${encodeURIComponent(projectId)}/error_grouping_rules/${encodeURIComponent(args.id)}`);
+        if (!this.jsonEnabled())
+            this.log(`Deleted grouping rule ${args.id}.`);
+        return { deleted: args.id };
+    }
+}
+exports.default = ErrorsGroupingRulesDelete;

package/dist/commands/errors/grouping-rules/list.d.ts

@@ -0,0 +1,10 @@
+import { BaseCommand } from '../../../base';
+export default class ErrorsGroupingRulesList extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static flags: {
+        page: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
+        project: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<unknown>;
+}

package/dist/commands/errors/grouping-rules/list.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const base_1 = require("../../../base");
+const output_1 = require("../../../lib/output");
+class ErrorsGroupingRulesList extends base_1.BaseCommand {
+    static description = 'List the custom grouping rules of a project, in the order they are applied';
+    static examples = ['<%= config.bin %> errors grouping-rules list --project acme-api'];
+    static flags = { ...base_1.projectFlag, ...base_1.pageFlag };
+    async run() {
+        const { flags } = await this.parse(ErrorsGroupingRulesList);
+        const projectId = await this.resolveProjectId(flags.project);
+        const res = await this.api.get(`/cli/v1/projects/${encodeURIComponent(projectId)}/error_grouping_rules?page=${flags.page}`);
+        const rules = res.data ?? [];
+        if (!this.jsonEnabled()) {
+            this.log((0, output_1.renderTable)(['POS', 'FIELD', 'OPERATOR', 'VALUE', 'GROUPS AS', 'ACTIVE', 'ID'], rules.map((rule) => [
+                String(rule.position ?? ''),
+                String(rule.field ?? ''),
+                String(rule.operator ?? ''),
+                String(rule.value ?? ''),
+                String(rule.fingerprint_key ?? ''),
+                (0, output_1.statusCell)(rule.active === true ? 'active' : 'paused'),
+                String(rule.id ?? ''),
+            ])));
+        }
+        return res;
+    }
+}
+exports.default = ErrorsGroupingRulesList;

package/dist/commands/errors/grouping-rules/update.d.ts

@@ -0,0 +1,18 @@
+import { BaseCommand } from '../../../base';
+export default class ErrorsGroupingRulesUpdate extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        field: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        operator: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        value: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'fingerprint-key': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        position: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        active: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<unknown>;
+}

package/dist/commands/errors/grouping-rules/update.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_1 = require("../../../base");
+const grouping_rules_1 = require("../../../lib/grouping-rules");
+const output_1 = require("../../../lib/output");
+class ErrorsGroupingRulesUpdate extends base_1.BaseCommand {
+    static description = 'Change a grouping rule: what it matches, where it sends, when it runs, or turn it off';
+    static examples = [
+        '<%= config.bin %> errors grouping-rules update <rule-id> -p acme-api --value "connection reset"',
+        '<%= config.bin %> errors grouping-rules update <rule-id> -p acme-api --position 0',
+        '<%= config.bin %> errors grouping-rules update <rule-id> -p acme-api --no-active',
+    ];
+    static args = {
+        id: core_1.Args.string({ description: 'Grouping rule id', required: true }),
+    };
+    static flags = {
+        ...base_1.projectFlag,
+        field: core_1.Flags.string({ description: 'Occurrence field the rule looks at', options: [...grouping_rules_1.GROUPING_RULE_FIELDS] }),
+        operator: core_1.Flags.string({ description: 'How the field is compared', options: [...grouping_rules_1.GROUPING_RULE_OPERATORS] }),
+        value: core_1.Flags.string({ description: 'Text to compare the field against' }),
+        'fingerprint-key': core_1.Flags.string({ description: 'Grouping key the matching occurrences land on' }),
+        position: core_1.Flags.integer({ description: 'Order of application (lower runs first)' }),
+        active: core_1.Flags.boolean({ allowNo: true, description: 'Whether the rule applies at ingest' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ErrorsGroupingRulesUpdate);
+        const body = (0, grouping_rules_1.groupingRuleBody)(flags);
+        // An empty PATCH would come back 200 with the rule untouched, and the command would announce an
+        // update that never happened. Say it before the call instead.
+        if (Object.keys(body).length === 0) {
+            this.error('Nothing to update: pass at least one of --field, --operator, --value, --fingerprint-key, --position, --active/--no-active.', { exit: 2 });
+        }
+        const projectId = await this.resolveProjectId(flags.project);
+        const res = await this.api.put(`/cli/v1/projects/${encodeURIComponent(projectId)}/error_grouping_rules/${encodeURIComponent(args.id)}`, body);
+        if (!this.jsonEnabled()) {
+            this.log('Grouping rule updated:');
+            this.log((0, output_1.renderRecord)(res.data ?? {}));
+        }
+        return res;
+    }
+}
+exports.default = ErrorsGroupingRulesUpdate;

package/dist/commands/errors/merge.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand } from '../../base';
+export default class ErrorsMerge extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        group: import("@oclif/core/lib/interfaces").OptionFlag<string[], import("@oclif/core/lib/interfaces").CustomOptions>;
+        confirm: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        project: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<unknown>;
+}

package/dist/commands/errors/merge.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_1 = require("../../base");
+const output_1 = require("../../lib/output");
+class ErrorsMerge extends base_1.BaseCommand {
+    static description = 'Merge error groups into one: the occurrences move, the absorbed groups disappear (irreversible)';
+    static examples = [
+        '<%= config.bin %> errors merge <primary-id> --project acme-api --group <duplicate-a> --group <duplicate-b> --confirm',
+    ];
+    static args = {
+        id: core_1.Args.string({ description: 'Error group that keeps everything (the primary)', required: true }),
+    };
+    static flags = {
+        ...base_1.projectFlag,
+        group: core_1.Flags.string({ description: 'Error group to absorb (repeatable)', multiple: true, required: true }),
+        confirm: core_1.Flags.boolean({ description: 'Required: confirm the irreversible merge' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ErrorsMerge);
+        if (!flags.confirm) {
+            this.error('Refusing to merge without --confirm (the action is irreversible).', { exit: 2 });
+        }
+        const projectId = await this.resolveProjectId(flags.project);
+        // The ids travel raw — not deduplicated, not filtered, not looked up first. All-or-nothing is
+        // the server's to keep (`Errors::Merge#resolve_sources!`): one id it cannot find in the project
+        // aborts the whole merge. Tidying the list here would hand it a set it can always resolve, so
+        // the groups it did find would be merged and the rest silently forgotten — on an operation
+        // nothing can undo.
+        const res = await this.api.post(`/cli/v1/projects/${encodeURIComponent(projectId)}/error_groups/${encodeURIComponent(args.id)}/merge`, { ids: flags.group });
+        if (!this.jsonEnabled()) {
+            const merged = res.meta?.merged;
+            this.log(`Merged ${merged ?? flags.group.length} error groups into ${args.id}:`);
+            this.log((0, output_1.renderRecord)(res.data ?? {}));
+        }
+        return res;
+    }
+}
+exports.default = ErrorsMerge;

package/dist/commands/errors/split.d.ts

@@ -0,0 +1,13 @@
+import { BaseCommand } from '../../base';
+export default class ErrorsSplit extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static flags: {
+        event: import("@oclif/core/lib/interfaces").OptionFlag<string[], import("@oclif/core/lib/interfaces").CustomOptions>;
+        project: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<unknown>;
+}

package/dist/commands/errors/split.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_1 = require("../../base");
+const output_1 = require("../../lib/output");
+class ErrorsSplit extends base_1.BaseCommand {
+    static description = 'Split an error group: pull some occurrences out into a new one';
+    static examples = [
+        '<%= config.bin %> errors split <group-id> --project acme-api --event <event-a> --event <event-b>',
+    ];
+    static args = {
+        id: core_1.Args.string({ description: 'Error group to split', required: true }),
+    };
+    static flags = {
+        ...base_1.projectFlag,
+        event: core_1.Flags.string({ description: 'Occurrence id to pull out (repeatable)', multiple: true, required: true }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(ErrorsSplit);
+        const projectId = await this.resolveProjectId(flags.project);
+        // Raw ids again: `Errors::Split` refuses the whole split if one occurrence is not in this group,
+        // and that refusal is only possible while the list it receives is the list that was written.
+        const res = await this.api.post(`/cli/v1/projects/${encodeURIComponent(projectId)}/error_groups/${encodeURIComponent(args.id)}/split`, { event_ids: flags.event });
+        if (!this.jsonEnabled()) {
+            // Counted off the group that was born, not off the flags that were typed: the server
+            // deduplicates the ids it receives, so the same occurrence named twice moves once.
+            const moved = Number(res.data?.events_count ?? flags.event.length);
+            this.log(`Split ${moved} occurrence${moved === 1 ? '' : 's'} out of ${args.id} into a new error group:`);
+            this.log((0, output_1.renderRecord)(res.data ?? {}));
+        }
+        return res;
+    }
+}
+exports.default = ErrorsSplit;

package/dist/commands/invitations/create.js

@@ -6,7 +6,7 @@ class InvitationsCreate extends base_1.BaseCommand {
     static args = {
         email: core_1.Args.string({ description: 'Email address to invite', required: true }),
     };
-    static description = 'Invite a person to the organization. Prints the acceptance link (shown only once).';
+    static description = 'Invite a person to the organization. Prints the acceptance link.';
     static examples = [
         '<%= config.bin %> invitations create client@acme.com',
         '<%= config.bin %> invitations create teammate@acme.com --role member',
@@ -30,7 +30,14 @@ class InvitationsCreate extends base_1.BaseCommand {
             this.log('');
             this.log(`  accept link: ${invitation.accept_url ?? '-'}`);
             this.log('');
-            this.warn('Email delivery is not wired in production — send this link to the invitee manually.');
+            // The server reports whether mail actually goes out (email_delivery). This used to be a fixed
+            // sentence printed every time, which said nothing about the real state of delivery.
+            if (invitation.email_delivery === false) {
+                this.warn('Email delivery is off on the server — send this link to the invitee yourself.');
+            }
+            else {
+                this.log('The invitation email is on its way; send the link yourself if it never lands.');
+            }
         }
         return res;
     }

package/dist/commands/invitations/resend.js

@@ -6,7 +6,7 @@ class InvitationsResend extends base_1.BaseCommand {
     static args = {
         id: core_1.Args.string({ description: 'Invitation id (UUID)', required: true }),
     };
-    static description = 'Resend a pending invitation. Prints the acceptance link (shown only once).';
+    static description = 'Resend a pending invitation. Prints the acceptance link.';
     static examples = ['<%= config.bin %> invitations resend <invitation-uuid>'];
     async run() {
         const { args } = await this.parse(InvitationsResend);
@@ -17,7 +17,13 @@ class InvitationsResend extends base_1.BaseCommand {
             this.log('');
             this.log(`  accept link: ${invitation.accept_url ?? '-'}`);
             this.log('');
-            this.warn('Email delivery is not wired in production — send this link to the invitee manually.');
+            // Same as `invitations create`: only the server knows whether mail is being delivered.
+            if (invitation.email_delivery === false) {
+                this.warn('Email delivery is off on the server — send this link to the invitee yourself.');
+            }
+            else {
+                this.log('The invitation email is on its way; send the link yourself if it never lands.');
+            }
         }
         return res;
     }

package/dist/commands/kb/attach.d.ts

@@ -0,0 +1,12 @@
+import { BaseCommand } from '../../base';
+export default class KbAttach extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        id: 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>;
+    };
+    run(): Promise<unknown>;
+}

package/dist/commands/kb/attach.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const core_1 = require("@oclif/core");
+const base_1 = require("../../base");
+const output_1 = require("../../lib/output");
+class KbAttach extends base_1.BaseCommand {
+    static description = 'Attach one or more local files to a knowledge page';
+    static examples = [
+        '<%= config.bin %> kb attach <page-id> --file ./rollback.sh',
+        '<%= config.bin %> kb attach <page-id> --file ./diagram.png --file ./checklist.pdf',
+    ];
+    static args = {
+        id: core_1.Args.string({ description: 'Knowledge page id', required: true }),
+    };
+    static flags = {
+        file: core_1.Flags.string({ description: 'Path to a local file to upload (repeatable)', multiple: true, required: true }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(KbAttach);
+        // Tutti i file si leggono PRIMA di caricarne uno: il server rifiuta il lotto intero se un file
+        // non è ammesso, e un percorso sbagliato deve fermare il comando allo stesso modo — non a metà.
+        const files = [];
+        for (const path of flags.file) {
+            try {
+                // eslint-disable-next-line no-await-in-loop
+                const buf = await (0, promises_1.readFile)(path);
+                files.push({ field: 'files[]', filename: (0, node_path_1.basename)(path), data: new Blob([buf]) });
+            }
+            catch {
+                this.error(`File not found or unreadable: ${path}`, { exit: 2 });
+            }
+        }
+        const res = await this.api.upload('POST', `/cli/v1/knowledge/pages/${encodeURIComponent(args.id)}/attachments`, files);
+        const attachments = res.data ?? [];
+        if (!this.jsonEnabled()) {
+            this.log(`Attached ${files.length} file${files.length === 1 ? '' : 's'} to knowledge page ${args.id}:`);
+            this.log((0, output_1.renderTable)(['ID', 'FILENAME', 'CONTENT_TYPE', 'BYTE_SIZE'], attachments.map((attachment) => [
+                String(attachment.id ?? ''),
+                String(attachment.filename ?? ''),
+                String(attachment.content_type ?? ''),
+                String(attachment.byte_size ?? ''),
+            ])));
+        }
+        return res;
+    }
+}
+exports.default = KbAttach;

package/dist/commands/kb/attachment-download.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand } from '../../base';
+export default class KbAttachmentDownload extends BaseCommand {
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        attachment: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        out: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        filename: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    run(): Promise<unknown>;
+}

package/dist/commands/kb/attachment-download.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const core_1 = require("@oclif/core");
+const base_1 = require("../../base");
+class KbAttachmentDownload extends base_1.BaseCommand {
+    static args = {
+        id: core_1.Args.string({ description: 'Knowledge page id', required: true }),
+        attachment: core_1.Args.string({ description: 'Attachment id', required: true }),
+    };
+    // Il server consegna il binario con tipo neutro e disposition attachment: il file finisce sul
+    // disco e basta, nessun canale lo apre né lo esegue per conto di chi lo scarica.
+    static description = "Download a knowledge page's attachment to disk";
+    static examples = [
+        '<%= config.bin %> kb attachment-download <page-id> <attachment-id>',
+        '<%= config.bin %> kb attachment-download <page-id> <attachment-id> --out ./downloads',
+    ];
+    static flags = {
+        out: core_1.Flags.string({ default: '.', description: 'Output directory' }),
+        filename: core_1.Flags.string({ description: 'Override the output filename' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(KbAttachmentDownload);
+        const { data, filename } = await this.api.download(`/cli/v1/knowledge/pages/${encodeURIComponent(args.id)}/attachments/${encodeURIComponent(args.attachment)}/download`);
+        // Il nome che arriva dal server è ridotto all'ultimo segmento: un `filename` con dei separatori
+        // dentro, letto da Content-Disposition, scriverebbe fuori da --out invece che dentro. `--filename`
+        // no: quello lo scrive chi lancia il comando, e sceglie lui dove mettere il file.
+        const name = flags.filename ?? (filename === undefined ? args.attachment : (0, node_path_1.basename)(filename));
+        const dest = (0, node_path_1.join)(flags.out, name);
+        await (0, promises_1.writeFile)(dest, data);
+        if (!this.jsonEnabled()) {
+            this.log(`Saved ${data.byteLength} bytes → ${dest}`);
+        }
+        return { bytes: data.byteLength, filename: name, path: dest };
+    }
+}
+exports.default = KbAttachmentDownload;

package/dist/commands/kb/attachments.d.ts

@@ -0,0 +1,9 @@
+import { BaseCommand } from '../../base';
+export default class KbAttachments extends BaseCommand {
+    static args: {
+        id: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    run(): Promise<unknown>;
+}

package/dist/commands/kb/attachments.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_1 = require("../../base");
+const output_1 = require("../../lib/output");
+const paginate_1 = require("../../lib/paginate");
+class KbAttachments extends base_1.BaseCommand {
+    static args = {
+        id: core_1.Args.string({ description: 'Knowledge page id', required: true }),
+    };
+    static description = "List a knowledge page's attachments";
+    static examples = [
+        '<%= config.bin %> kb attachments <page-id>',
+        '<%= config.bin %> kb attachments <page-id> --json',
+    ];
+    async run() {
+        const { args } = await this.parse(KbAttachments);
+        // Elenco completo, non la sola prima pagina: il comando non ha un --page, quindi fermarsi a
+        // cento allegati significherebbe nasconderne il resto senza modo di chiederli.
+        const attachments = await (0, paginate_1.fetchAllPages)(this.api, `/cli/v1/knowledge/pages/${encodeURIComponent(args.id)}/attachments`);
+        if (!this.jsonEnabled()) {
+            this.log((0, output_1.renderTable)(['ID', 'FILENAME', 'CONTENT_TYPE', 'BYTE_SIZE', 'SCRIPT', 'CREATED_AT'], attachments.map((attachment) => [
+                String(attachment.id ?? ''),
+                String(attachment.filename ?? ''),
+                String(attachment.content_type ?? ''),
+                String(attachment.byte_size ?? ''),
+                // Il server dichiara se il file è uno script: sapere che si sta scaricando qualcosa di
+                // eseguibile è la sola cosa che l'elenco può dire prima che il file sia sul disco.
+                attachment.script === undefined ? '' : (attachment.script ? 'yes' : 'no'),
+                String(attachment.created_at ?? ''),
+            ])));
+        }
+        return { data: attachments, meta: (0, paginate_1.aggregatedMeta)(attachments.length) };
+    }
+}
+exports.default = KbAttachments;