twentythree-cli 1.0.0

package/dist/commands/video/upload.cjs

@@ -0,0 +1,151 @@
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_lib_term_map = require("../../lib/term-map.cjs");
+const require_lib_base_command = require("../../lib/base-command.cjs");
+const require_lib_output = require("../../lib/output.cjs");
+const require_upload_types = require("../../upload/types.cjs");
+const require_upload_chunked_upload = require("../../upload/chunked-upload.cjs");
+let _oclif_core = require("@oclif/core");
+let chalk = require("chalk");
+chalk = require_runtime.__toESM(chalk);
+let node_fs_promises = require("node:fs/promises");
+//#region src/commands/video/upload.ts
+/**
+* Simple inline progress bar that writes directly to stderr using \r.
+* Avoids all TTY-detection issues that afflict cli-progress.
+* T-03-06: shows only byte counts, never the upload_token.
+*/
+var ProgressBar = class {
+	lastLen = 0;
+	render(bytesUploaded, total, speed) {
+		const pct = total > 0 ? Math.floor(bytesUploaded / total * 100) : 0;
+		const filled = Math.floor(pct / 5);
+		const line = `[${"█".repeat(filled) + "░".repeat(20 - filled)}] ${pct}% | ${require_lib_output.formatBytes(bytesUploaded)} / ${require_lib_output.formatBytes(total)} | ${require_lib_output.formatBytes(speed)}/s`;
+		const padding = " ".repeat(Math.max(0, this.lastLen - line.length));
+		process.stderr.write(`\r${line}${padding}`);
+		this.lastLen = line.length;
+	}
+	finish() {
+		process.stderr.write("\n");
+		this.lastLen = 0;
+	}
+};
+/**
+* Video upload command — uploads a video file using the chunked upload engine.
+*
+* Flow:
+*   1. GET /photo/get-upload-token (with optional metadata)
+*   2. Upload file in chunks with inline progress bar
+*   3. Display success message; optionally return --json result
+*
+* Threat mitigations:
+*   T-03-06: upload_token is never logged to stdout — only byte counts shown
+*   T-03-09: extends AuthenticatedCommand — anonymous mode rejected
+*/
+var VideoUpload = class VideoUpload extends require_lib_base_command.AuthenticatedCommand {
+	static description = "Upload a video file to the active workspace";
+	static examples = [
+		"<%= config.bin %> video upload ./video.mp4",
+		"<%= config.bin %> video upload ./video.mp4 --title \"My Video\" --publish",
+		"<%= config.bin %> video upload ./video.mp4 --chunk-size 52428800 --concurrency 3"
+	];
+	static enableJsonFlag = true;
+	static agentMetadata = {
+		api_endpoint: "POST /photo/redeem-upload-token",
+		auth_scope: "write",
+		output_shape: { type: "key-value" },
+		side_effects: "creates"
+	};
+	static flags = {
+		...require_lib_base_command.AuthenticatedCommand.baseFlags,
+		title: _oclif_core.Flags.string({
+			description: "Title for the uploaded video",
+			required: false
+		}),
+		description: _oclif_core.Flags.string({
+			description: "Description for the uploaded video",
+			required: false
+		}),
+		tags: _oclif_core.Flags.string({
+			description: "Space-separated tags for the uploaded video",
+			required: false
+		}),
+		"category-id": _oclif_core.Flags.string({
+			description: "Category ID (or comma-separated IDs) to assign the video to",
+			required: false
+		}),
+		publish: _oclif_core.Flags.boolean({
+			description: "Publish the video immediately after upload",
+			default: false
+		}),
+		"chunk-size": _oclif_core.Flags.integer({
+			description: `Chunk size in bytes (default: ${require_upload_types.DEFAULT_CHUNK_SIZE} = 100MB)`,
+			default: require_upload_types.DEFAULT_CHUNK_SIZE
+		}),
+		concurrency: _oclif_core.Flags.integer({
+			description: `Number of chunks to upload in parallel (default: 5)`,
+			default: 5
+		})
+	};
+	static args = { file: _oclif_core.Args.string({
+		description: "Path to the video file to upload",
+		required: true
+	}) };
+	async run() {
+		const { args, flags } = await this.parse(VideoUpload);
+		this.printWorkspaceHeader();
+		try {
+			await (0, node_fs_promises.stat)(args.file);
+		} catch {
+			this.error(`File not found: ${args.file}`, { exit: 1 });
+		}
+		const { data: tokenData, error: tokenError } = await this.apiClient.GET("/photo/get-upload-token", { params: { query: {
+			title: flags.title,
+			description: flags.description,
+			tags: flags.tags,
+			album_id: flags["category-id"]
+		} } });
+		if (tokenError) this.error(require_lib_term_map.applyCliTerms(String(tokenError)), { exit: 1 });
+		const uploadToken = tokenData?.data?.upload_token;
+		if (!uploadToken) this.error("Failed to obtain upload token from API", { exit: 1 });
+		const totalBytes = (await (0, node_fs_promises.stat)(args.file)).size;
+		const bar = new ProgressBar();
+		const startTime = Date.now();
+		let result;
+		bar.render(0, totalBytes, 0);
+		try {
+			result = await require_upload_chunked_upload.uploadChunked({
+				filePath: args.file,
+				uploadToken,
+				uploadUrl: `${this.apiBaseUrl}photo/redeem-upload-token`,
+				bearerToken: this.activeWorkspace.bearer_token || void 0,
+				chunkSize: flags["chunk-size"],
+				concurrency: flags.concurrency,
+				onProgress(bytesUploaded, total) {
+					const elapsed = (Date.now() - startTime) / 1e3;
+					const speed = elapsed > 0 ? bytesUploaded / elapsed : 0;
+					bar.render(bytesUploaded, total, speed);
+				}
+			});
+		} finally {
+			bar.finish();
+		}
+		const videoId = result.photo_id;
+		const adminUrl = `https://${this.activeWorkspace.domain}/manage/video/${videoId}`;
+		this.log(chalk.default.green("Video uploaded successfully"));
+		if (videoId) {
+			this.log(`ID:    ${videoId}`);
+			this.log(`Admin: ${adminUrl}`);
+		}
+		if (this.jsonEnabled()) return require_lib_output.formatJsonOutput({
+			ok: true,
+			data: result,
+			summary: "Video uploaded",
+			breadcrumbs: [{ domain: this.activeWorkspace.domain }, {
+				resource: "video",
+				id: result.photo_id ? String(result.photo_id) : void 0
+			}]
+		});
+	}
+};
+//#endregion
+module.exports = VideoUpload;

package/dist/commands/webhook/events.cjs

@@ -0,0 +1,68 @@
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_lib_term_map = require("../../lib/term-map.cjs");
+const require_lib_base_command = require("../../lib/base-command.cjs");
+const require_lib_output = require("../../lib/output.cjs");
+let _oclif_core = require("@oclif/core");
+let chalk = require("chalk");
+chalk = require_runtime.__toESM(chalk);
+//#region src/commands/webhook/events.ts
+/**
+* Webhook events command — lists available webhook event types (WHK-04).
+*
+* Threat mitigations:
+*   T-08-05: extends AuthenticatedCommand — anonymous mode rejected
+*/
+var WebhookEvents = class WebhookEvents extends require_lib_base_command.AuthenticatedCommand {
+	static description = "List available webhook event types";
+	static examples = [
+		"<%= config.bin %> webhook events",
+		"<%= config.bin %> webhook events --test-authentication",
+		"<%= config.bin %> webhook events --json"
+	];
+	static enableJsonFlag = true;
+	static flags = {
+		...require_lib_base_command.AuthenticatedCommand.baseFlags,
+		"test-authentication": _oclif_core.Flags.boolean({
+			description: "Include test authentication events",
+			required: false
+		}),
+		"test-authentication-p": _oclif_core.Flags.string({
+			hidden: true,
+			required: false
+		})
+	};
+	static args = {};
+	static agentMetadata = {
+		api_endpoint: "GET /webhook/events",
+		auth_scope: "read",
+		output_shape: {
+			type: "table",
+			columns: ["Event"]
+		},
+		side_effects: "none"
+	};
+	async run() {
+		const { flags } = await this.parse(WebhookEvents);
+		this.printWorkspaceHeader();
+		const testAuthVal = parseBoolParam(flags["test-authentication"], flags["test-authentication-p"]);
+		const { data, error } = await this.apiClient.GET("/webhook/events", { params: { query: { test_authentication_p: testAuthVal !== void 0 ? testAuthVal ? 1 : 0 : void 0 } } });
+		if (error) this.error(require_lib_term_map.applyCliTerms(formatApiError(error)), { exit: 1 });
+		const resp = data;
+		const rows = Array.isArray(resp?.data) ? resp.data : resp?.data ? [resp.data] : [];
+		if (this.jsonEnabled()) return require_lib_output.formatJsonOutput({
+			ok: true,
+			data: rows,
+			summary: `${rows.length} event type(s)`,
+			breadcrumbs: [{ domain: this.activeWorkspace.domain }, { resource: "webhook" }]
+		});
+		if (rows.length === 0) {
+			this.log("No event types found.");
+			return;
+		}
+		const table = require_lib_output.renderTable(["Event"], rows.map((item) => [String(item.event ?? item)]));
+		this.log(table.toString());
+		this.log(chalk.default.dim(`${rows.length} event type(s)`));
+	}
+};
+//#endregion
+module.exports = WebhookEvents;

package/dist/commands/webhook/list.cjs

@@ -0,0 +1,64 @@
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_lib_term_map = require("../../lib/term-map.cjs");
+const require_lib_base_command = require("../../lib/base-command.cjs");
+const require_lib_output = require("../../lib/output.cjs");
+let chalk = require("chalk");
+chalk = require_runtime.__toESM(chalk);
+//#region src/commands/webhook/list.ts
+/**
+* Webhook list command — lists all webhook subscriptions (WHK-01).
+*
+* Threat mitigations:
+*   T-08-05: extends AuthenticatedCommand — anonymous mode rejected
+*/
+var WebhookList = class WebhookList extends require_lib_base_command.AuthenticatedCommand {
+	static description = "List webhook subscriptions for the active workspace";
+	static examples = ["<%= config.bin %> webhook list", "<%= config.bin %> webhook list --json"];
+	static enableJsonFlag = true;
+	static flags = { ...require_lib_base_command.AuthenticatedCommand.baseFlags };
+	static args = {};
+	static agentMetadata = {
+		api_endpoint: "GET /webhook/list",
+		auth_scope: "read",
+		output_shape: {
+			type: "table",
+			columns: [
+				"ID",
+				"Event",
+				"Target URL"
+			]
+		},
+		side_effects: "none"
+	};
+	async run() {
+		const {} = await this.parse(WebhookList);
+		this.printWorkspaceHeader();
+		const { data, error } = await this.apiClient.GET("/webhook/list", {});
+		if (error) this.error(require_lib_term_map.applyCliTerms(formatApiError(error)), { exit: 1 });
+		const resp = data;
+		const rows = Array.isArray(resp?.data) ? resp.data : resp?.data ? [resp.data] : [];
+		if (this.jsonEnabled()) return require_lib_output.formatJsonOutput({
+			ok: true,
+			data: rows,
+			summary: `${rows.length} webhook(s)`,
+			breadcrumbs: [{ domain: this.activeWorkspace.domain }, { resource: "webhook" }]
+		});
+		if (rows.length === 0) {
+			this.log("No webhooks found.");
+			return;
+		}
+		const table = require_lib_output.renderTable([
+			"ID",
+			"Event",
+			"Target URL"
+		], rows.map((r) => [
+			String(r.webhook_id ?? ""),
+			String(r.event ?? ""),
+			String(r.target_url ?? "")
+		]));
+		this.log(table.toString());
+		this.log(chalk.default.dim(`${rows.length} webhook(s)`));
+	}
+};
+//#endregion
+module.exports = WebhookList;

package/dist/commands/webhook/sample.cjs

@@ -0,0 +1,47 @@
+require("../../_virtual/_rolldown/runtime.cjs");
+const require_lib_term_map = require("../../lib/term-map.cjs");
+const require_lib_base_command = require("../../lib/base-command.cjs");
+const require_lib_output = require("../../lib/output.cjs");
+let _oclif_core = require("@oclif/core");
+//#region src/commands/webhook/sample.ts
+/**
+* Webhook sample command — prints a sample payload for an event type (WHK-05).
+*
+* Sample payloads are complex nested JSON, so we output raw JSON instead of
+* key-value rendering.
+*
+* Threat mitigations:
+*   T-08-05: extends AuthenticatedCommand — anonymous mode rejected
+*/
+var WebhookSample = class WebhookSample extends require_lib_base_command.AuthenticatedCommand {
+	static description = "Get a sample payload for a webhook event type";
+	static examples = ["<%= config.bin %> webhook sample video.uploaded", "<%= config.bin %> webhook sample video.uploaded --json"];
+	static enableJsonFlag = true;
+	static flags = { ...require_lib_base_command.AuthenticatedCommand.baseFlags };
+	static args = { event: _oclif_core.Args.string({
+		description: "Event type to get sample for",
+		required: true
+	}) };
+	static agentMetadata = {
+		api_endpoint: "GET /webhook/sample",
+		auth_scope: "read",
+		output_shape: { type: "key-value" },
+		side_effects: "none"
+	};
+	async run() {
+		const { args } = await this.parse(WebhookSample);
+		this.printWorkspaceHeader();
+		const { data, error } = await this.apiClient.GET("/webhook/sample", { params: { query: { event: args.event } } });
+		if (error) this.error(require_lib_term_map.applyCliTerms(formatApiError(error)), { exit: 1 });
+		const resp = data;
+		if (this.jsonEnabled()) return require_lib_output.formatJsonOutput({
+			ok: true,
+			data: resp?.data ?? resp,
+			summary: `Sample payload for ${args.event}`,
+			breadcrumbs: [{ domain: this.activeWorkspace.domain }, { resource: "webhook" }]
+		});
+		this.log(JSON.stringify(resp?.data ?? resp, null, 2));
+	}
+};
+//#endregion
+module.exports = WebhookSample;

package/dist/commands/webhook/subscribe.cjs

@@ -0,0 +1,66 @@
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_lib_term_map = require("../../lib/term-map.cjs");
+const require_lib_base_command = require("../../lib/base-command.cjs");
+const require_lib_output = require("../../lib/output.cjs");
+let _oclif_core = require("@oclif/core");
+let chalk = require("chalk");
+chalk = require_runtime.__toESM(chalk);
+//#region src/commands/webhook/subscribe.ts
+/**
+* Webhook subscribe command — creates a webhook subscription (WHK-02).
+*
+* Threat mitigations:
+*   T-08-05: extends AuthenticatedCommand — anonymous mode rejected
+*   T-08-06: target_url passed as-is; server validates reachability
+*/
+var WebhookSubscribe = class WebhookSubscribe extends require_lib_base_command.AuthenticatedCommand {
+	static description = "Subscribe to a webhook event";
+	static examples = ["<%= config.bin %> webhook subscribe --target-url https://example.com/hook --event video.uploaded", "<%= config.bin %> webhook subscribe --target-url https://example.com/hook --event video.uploaded --json"];
+	static enableJsonFlag = true;
+	static flags = {
+		...require_lib_base_command.AuthenticatedCommand.baseFlags,
+		"target-url": _oclif_core.Flags.string({
+			description: "URL to receive webhook POST requests",
+			required: true
+		}),
+		event: _oclif_core.Flags.string({
+			description: "Event type to subscribe to",
+			required: true
+		})
+	};
+	static args = {};
+	static agentMetadata = {
+		api_endpoint: "POST /webhook/subscribe",
+		auth_scope: "write",
+		output_shape: { type: "key-value" },
+		side_effects: "creates"
+	};
+	async run() {
+		const { flags } = await this.parse(WebhookSubscribe);
+		this.printWorkspaceHeader();
+		const { data: createData, error: createError } = await this.apiClient.POST("/webhook/subscribe", {
+			body: {
+				target_url: flags["target-url"],
+				event: flags.event
+			},
+			headers: { "Content-Type": "application/x-www-form-urlencoded" }
+		});
+		if (createError) this.error(require_lib_term_map.applyCliTerms(formatApiError(createError)), { exit: 1 });
+		const webhookId = createData?.data?.webhook_id;
+		this.log(chalk.default.green("Webhook subscription created"));
+		this.log(`ID:         ${webhookId}`);
+		this.log(`Event:      ${flags.event}`);
+		this.log(`Target URL: ${flags["target-url"]}`);
+		if (this.jsonEnabled()) return require_lib_output.formatJsonOutput({
+			ok: true,
+			data: createData,
+			summary: "Webhook subscription created",
+			breadcrumbs: [{ domain: this.activeWorkspace.domain }, {
+				resource: "webhook",
+				id: String(webhookId)
+			}]
+		});
+	}
+};
+//#endregion
+module.exports = WebhookSubscribe;

package/dist/commands/webhook/unsubscribe.cjs

@@ -0,0 +1,71 @@
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_lib_term_map = require("../../lib/term-map.cjs");
+const require_lib_base_command = require("../../lib/base-command.cjs");
+const require_lib_output = require("../../lib/output.cjs");
+let _oclif_core = require("@oclif/core");
+let chalk = require("chalk");
+chalk = require_runtime.__toESM(chalk);
+let _clack_prompts = require("@clack/prompts");
+//#region src/commands/webhook/unsubscribe.ts
+/**
+* Webhook unsubscribe command — removes a webhook subscription after confirmation (WHK-03).
+*
+* Accepts either --webhook-id or --target-url (API accepts either for identification).
+*
+* Threat mitigations:
+*   T-08-04: confirm() prompt includes workspace domain before destructive POST (repudiation)
+*   T-08-05: extends AuthenticatedCommand — anonymous mode rejected
+*/
+var WebhookUnsubscribe = class WebhookUnsubscribe extends require_lib_base_command.AuthenticatedCommand {
+	static description = "Unsubscribe from a webhook event";
+	static examples = [
+		"<%= config.bin %> webhook unsubscribe --webhook-id 12345",
+		"<%= config.bin %> webhook unsubscribe --target-url https://example.com/hook",
+		"<%= config.bin %> webhook unsubscribe --webhook-id 12345 --json"
+	];
+	static enableJsonFlag = true;
+	static flags = {
+		...require_lib_base_command.AuthenticatedCommand.baseFlags,
+		"webhook-id": _oclif_core.Flags.string({
+			description: "Webhook subscription ID",
+			required: false
+		}),
+		"target-url": _oclif_core.Flags.string({
+			description: "Target URL to unsubscribe",
+			required: false
+		})
+	};
+	static args = {};
+	static agentMetadata = {
+		api_endpoint: "POST /webhook/unsubscribe",
+		auth_scope: "write",
+		output_shape: { type: "key-value" },
+		side_effects: "destructive"
+	};
+	async run() {
+		const { flags } = await this.parse(WebhookUnsubscribe);
+		this.printWorkspaceHeader();
+		if (!flags["webhook-id"] && !flags["target-url"]) this.error("Provide --webhook-id or --target-url", { exit: 1 });
+		if (!this.jsonEnabled()) {
+			const confirmed = await (0, _clack_prompts.confirm)({ message: `Unsubscribe webhook from ${this.activeWorkspace.domain}? This cannot be undone.` });
+			if ((0, _clack_prompts.isCancel)(confirmed) || !confirmed) process.exit(2);
+		}
+		const { data: deleteData, error: deleteError } = await this.apiClient.POST("/webhook/unsubscribe", {
+			body: {
+				webhook_id: flags["webhook-id"] ? Number(flags["webhook-id"]) : void 0,
+				target_url: flags["target-url"]
+			},
+			headers: { "Content-Type": "application/x-www-form-urlencoded" }
+		});
+		if (deleteError) this.error(require_lib_term_map.applyCliTerms(formatApiError(deleteError)), { exit: 1 });
+		this.log(chalk.default.green("Webhook unsubscribed"));
+		if (this.jsonEnabled()) return require_lib_output.formatJsonOutput({
+			ok: true,
+			data: deleteData,
+			summary: "Webhook unsubscribed",
+			breadcrumbs: [{ domain: this.activeWorkspace.domain }, { resource: "webhook" }]
+		});
+	}
+};
+//#endregion
+module.exports = WebhookUnsubscribe;

package/dist/commands/webinar/attachment/delete.cjs

@@ -0,0 +1,79 @@
+const require_runtime = require("../../../_virtual/_rolldown/runtime.cjs");
+const require_lib_term_map = require("../../../lib/term-map.cjs");
+const require_lib_base_command = require("../../../lib/base-command.cjs");
+const require_lib_output = require("../../../lib/output.cjs");
+let _oclif_core = require("@oclif/core");
+let chalk = require("chalk");
+chalk = require_runtime.__toESM(chalk);
+let _clack_prompts = require("@clack/prompts");
+//#region src/commands/webinar/attachment/delete.ts
+/**
+* Webinar attachment delete command — deletes an attachment from a webinar by filename.
+*
+* CRITICAL: uses `filename` param (NOT an attachment ID) to identify the attachment.
+*
+* Threat mitigations:
+*   T-05-03: applyCliTerms() on all error messages — no 'live'/'photo'/'album' leaks
+*   T-05-04: Confirmation prompt includes domain and filename before delete
+*/
+var WebinarAttachmentDelete = class WebinarAttachmentDelete extends require_lib_base_command.AuthenticatedCommand {
+	static description = "Delete an attachment from a webinar";
+	static examples = ["<%= config.bin %> webinar attachment delete 12345 --filename slides.pdf", "<%= config.bin %> webinar attachment delete 12345 --filename handout.pdf --json"];
+	static enableJsonFlag = true;
+	static flags = {
+		...require_lib_base_command.AuthenticatedCommand.baseFlags,
+		filename: _oclif_core.Flags.string({
+			description: "Filename of the attachment to delete",
+			required: false
+		})
+	};
+	static args = { id: _oclif_core.Args.string({
+		description: "Webinar ID",
+		required: true
+	}) };
+	static agentMetadata = {
+		api_endpoint: "POST /live/attachment/delete",
+		auth_scope: "write",
+		output_shape: { type: "none" },
+		side_effects: "destructive"
+	};
+	async run() {
+		const { args, flags } = await this.parse(WebinarAttachmentDelete);
+		this.printWorkspaceHeader();
+		let filename = flags.filename;
+		if (!filename && !this.jsonEnabled()) {
+			const result = await (0, _clack_prompts.text)({ message: "Attachment filename" });
+			if ((0, _clack_prompts.isCancel)(result)) process.exit(2);
+			filename = result;
+		}
+		if (!filename) this.error("--filename is required in non-interactive mode", { exit: 1 });
+		if (!this.jsonEnabled()) {
+			const confirmed = await (0, _clack_prompts.confirm)({ message: `Delete attachment "${filename}" from webinar ${args.id} on ${this.activeWorkspace.domain}? This cannot be undone.` });
+			if ((0, _clack_prompts.isCancel)(confirmed) || !confirmed) process.exit(2);
+		}
+		const { data, error } = await this.apiClient.POST("/live/attachment/delete", {
+			body: {
+				live_id: Number(args.id),
+				filename
+			},
+			headers: { "Content-Type": "application/x-www-form-urlencoded" }
+		});
+		if (error) this.error(require_lib_term_map.applyCliTerms(formatApiError(error)), { exit: 1 });
+		this.log(chalk.default.green(`Attachment "${filename}" deleted`));
+		if (this.jsonEnabled()) return require_lib_output.formatJsonOutput({
+			ok: true,
+			data,
+			summary: "Attachment deleted",
+			breadcrumbs: [
+				{ domain: this.activeWorkspace.domain },
+				{
+					resource: "webinar",
+					id: args.id
+				},
+				{ resource: "attachment" }
+			]
+		});
+	}
+};
+//#endregion
+module.exports = WebinarAttachmentDelete;

package/dist/commands/webinar/attachment/list.cjs

@@ -0,0 +1,94 @@
+require("../../../_virtual/_rolldown/runtime.cjs");
+const require_lib_term_map = require("../../../lib/term-map.cjs");
+const require_lib_base_command = require("../../../lib/base-command.cjs");
+const require_lib_output = require("../../../lib/output.cjs");
+let _oclif_core = require("@oclif/core");
+//#region src/commands/webinar/attachment/list.ts
+/**
+* Webinar attachment list command — lists all attachments for a webinar.
+*
+* Token is auto-looked up via fetchWebinarToken if not supplied via --token.
+*
+* Threat mitigations:
+*   T-05-03: applyCliTerms() on all error messages — no 'live'/'photo'/'album' leaks
+*/
+var WebinarAttachmentList = class WebinarAttachmentList extends require_lib_base_command.AuthenticatedCommand {
+	static description = "List attachments for a webinar";
+	static examples = [
+		"<%= config.bin %> webinar attachment list 12345",
+		"<%= config.bin %> webinar attachment list 12345 --json",
+		"<%= config.bin %> webinar attachment list 12345 --include-hidden"
+	];
+	static enableJsonFlag = true;
+	static flags = {
+		...require_lib_base_command.AuthenticatedCommand.baseFlags,
+		token: _oclif_core.Flags.string({
+			description: "Webinar token (auto-looked up if omitted)",
+			required: false
+		}),
+		"include-hidden": _oclif_core.Flags.boolean({
+			description: "Include hidden attachments",
+			allowNo: true,
+			required: false
+		})
+	};
+	static args = { id: _oclif_core.Args.string({
+		description: "Webinar ID",
+		required: true
+	}) };
+	static agentMetadata = {
+		api_endpoint: "GET /live/attachment/list",
+		auth_scope: "read",
+		output_shape: {
+			type: "table",
+			columns: [
+				"Filename",
+				"Size",
+				"Hidden"
+			]
+		},
+		side_effects: "none"
+	};
+	async run() {
+		const { args, flags } = await this.parse(WebinarAttachmentList);
+		this.printWorkspaceHeader();
+		const webinarId = Number(args.id);
+		const token = flags.token ?? await this.fetchWebinarToken(webinarId);
+		const { data, error } = await this.apiClient.GET("/live/attachment/list", { params: { query: {
+			live_id: webinarId,
+			token,
+			include_hidden_p: parseBoolParam(flags["include-hidden"], void 0) ?? void 0
+		} } });
+		if (error) this.error(require_lib_term_map.applyCliTerms(formatApiError(error)), { exit: 1 });
+		const attachments = data?.attachments ?? data?.data ?? [];
+		if (this.jsonEnabled()) return require_lib_output.formatJsonOutput({
+			ok: true,
+			data: attachments,
+			summary: `${attachments.length} attachment${attachments.length === 1 ? "" : "s"}`,
+			breadcrumbs: [
+				{ domain: this.activeWorkspace.domain },
+				{
+					resource: "webinar",
+					id: args.id
+				},
+				{ resource: "attachment" }
+			]
+		});
+		if (attachments.length === 0) {
+			this.log("No attachments found.");
+			return;
+		}
+		const table = require_lib_output.renderTable([
+			"Filename",
+			"Size",
+			"Hidden"
+		], attachments.map((a) => [
+			String(a.filename ?? ""),
+			String(a.filesize ?? ""),
+			a.hidden_p ? "yes" : "no"
+		]));
+		this.log(table.toString());
+	}
+};
+//#endregion
+module.exports = WebinarAttachmentList;