dexto 1.14.6 → 2.0.0-beta.1

package/dist/cli/cloud/commands/api.d.ts

@@ -0,0 +1,3 @@
+import { type Command } from '../command.js';
+export declare const apiCommands: readonly Command[];
+//# sourceMappingURL=api.d.ts.map

package/dist/cli/cloud/commands/api.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../../../src/cli/cloud/commands/api.ts"],"names":[],"mappings":"AAEA,OAAO,EAAoD,KAAK,OAAO,EAAE,MAAM,eAAe,CAAC;AAgC/F,eAAO,MAAM,WAAW,EAAE,SAAS,OAAO,EAAU,CAAC"}

package/dist/cli/cloud/commands/api.js

@@ -0,0 +1,26 @@
+// `cloud api`: call any /v1 operation with the sign-in, for what no command covers yet.
+import { argument, BODY_OPTIONS, readJsonBody, UsageError } from '../command.js';
+import { fetchV1, v1Failure } from '../v1.js';
+const METHODS = new Set(['DELETE', 'GET', 'PATCH', 'POST', 'PUT']);
+const api = {
+    arguments: '<method> <path>',
+    options: BODY_OPTIONS,
+    path: ['cloud', 'api'],
+    summary: 'Call a /v1 path, such as: dexto cloud api GET /v1/agents. Prints the response body.',
+    async run(context, input) {
+        const method = argument(input, 0, 'method').toUpperCase();
+        if (!METHODS.has(method))
+            throw new UsageError(`Unknown method ${method}.`);
+        const body = await readJsonBody(context, input);
+        const response = await fetchV1(context, method, argument(input, 1, 'path'), body === null ? null : JSON.stringify(body));
+        const text = await response.text();
+        if (response.headers.get('content-type')?.includes('application/json') === true)
+            context.runtime.writeOutput(`${JSON.stringify(JSON.parse(text), null, 2)}\n`);
+        else
+            context.runtime.writeOutput(text.endsWith('\n') || text.length === 0 ? text : `${text}\n`);
+        if (!response.ok)
+            throw v1Failure(context, response.status, text);
+        return 0;
+    },
+};
+export const apiCommands = [api];

package/dist/cli/cloud/commands/app-files.d.ts

@@ -0,0 +1,29 @@
+import { type CommandContext } from '../command.js';
+/** The JSON Schema `format` of a string that takes a Drive file, as `drive:<id>`. */
+export declare const DRIVE_FILE_FORMAT = "dexto-drive-file";
+/**
+ * How a field takes files: as the reference itself, or as an object whose `property` is the
+ * reference, with the file's `name` and `mimeType` beside it where the object has them. `list`
+ * says the field takes several.
+ */
+export interface FileField {
+    readonly list: boolean;
+    readonly slot: {
+        readonly kind: 'reference';
+    } | {
+        readonly kind: 'object';
+        readonly mimeType: boolean;
+        readonly name: boolean;
+        readonly property: string;
+    };
+}
+/** A field's file slot, from its schema: a string of the Drive file format, alone or in an object. */
+export declare function fileFieldOf(property: Record<string, unknown>): FileField | null;
+/**
+ * The field's values with each local path uploaded into the app's Drive folder: a link (`https:`,
+ * `drive:`) is kept as it is, and a value given as JSON is left alone.
+ */
+export declare function attachFiles(context: CommandContext, appId: string, field: FileField, values: readonly unknown[]): Promise<unknown[]>;
+/** A value naming a local file to upload, rather than a link or JSON given as it is. */
+export declare function isLocalFile(value: unknown): boolean;
+//# sourceMappingURL=app-files.d.ts.map

package/dist/cli/cloud/commands/app-files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app-files.d.ts","sourceRoot":"","sources":["../../../../src/cli/cloud/commands/app-files.ts"],"names":[],"mappings":"AAEA,OAAO,EAAgB,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AAGlE,qFAAqF;AACrF,eAAO,MAAM,iBAAiB,qBAAqB,CAAC;AAEpD;;;;GAIG;AACH,MAAM,WAAW,SAAS;IACtB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,IAAI,EACP;QAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;KAAE,GAC9B;QACI,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;QACxB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;QAC3B,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;QACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;KAC7B,CAAC;CACX;AAED,sGAAsG;AACtG,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GAAG,IAAI,CAI/E;AAwBD;;;GAGG;AACH,wBAAsB,WAAW,CAC7B,OAAO,EAAE,cAAc,EACvB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,SAAS,EAChB,MAAM,EAAE,SAAS,OAAO,EAAE,GAC3B,OAAO,CAAC,OAAO,EAAE,CAAC,CAwBpB;AAKD,wFAAwF;AACxF,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAEnD"}

package/dist/cli/cloud/commands/app-files.js

@@ -0,0 +1,72 @@
+// Local files given for an App action's file fields: uploaded to the app's Drive folder, then referred to.
+import { isJsonObject } from '../command.js';
+import { putAppFile } from './drive.js';
+/** The JSON Schema `format` of a string that takes a Drive file, as `drive:<id>`. */
+export const DRIVE_FILE_FORMAT = 'dexto-drive-file';
+/** A field's file slot, from its schema: a string of the Drive file format, alone or in an object. */
+export function fileFieldOf(property) {
+    const items = property.type === 'array' && isJsonObject(property.items) ? property.items : null;
+    const slot = slotOf(items ?? property);
+    return slot === null ? null : { list: items !== null, slot };
+}
+function slotOf(schema) {
+    if (takesFile(schema))
+        return { kind: 'reference' };
+    if (schema.type !== 'object' || !isJsonObject(schema.properties))
+        return null;
+    const { properties } = schema;
+    const property = Object.keys(properties).find((name) => {
+        const each = properties[name];
+        return isJsonObject(each) && takesFile(each);
+    });
+    return property === undefined
+        ? null
+        : {
+            kind: 'object',
+            mimeType: isJsonObject(properties.mimeType),
+            name: isJsonObject(properties.name),
+            property,
+        };
+}
+function takesFile(schema) {
+    return schema.type === 'string' && schema.format === DRIVE_FILE_FORMAT;
+}
+/**
+ * The field's values with each local path uploaded into the app's Drive folder: a link (`https:`,
+ * `drive:`) is kept as it is, and a value given as JSON is left alone.
+ */
+export async function attachFiles(context, appId, field, values) {
+    const attached = [];
+    for (const value of values) {
+        if (typeof value !== 'string') {
+            attached.push(value);
+            continue;
+        }
+        const file = LINK.test(value)
+            ? { mimeType: null, name: null, uri: value }
+            : await uploadAppFile(context, appId, value);
+        const { slot } = field;
+        attached.push(slot.kind === 'reference'
+            ? file.uri
+            : {
+                [slot.property]: file.uri,
+                ...(slot.name && file.name !== null ? { name: file.name } : {}),
+                ...(slot.mimeType && file.mimeType !== null
+                    ? { mimeType: file.mimeType }
+                    : {}),
+            });
+    }
+    return attached;
+}
+/** A value that already refers to a file, rather than naming a local one. */
+const LINK = /^(?:https?:\/\/|drive:)/iu;
+/** A value naming a local file to upload, rather than a link or JSON given as it is. */
+export function isLocalFile(value) {
+    return typeof value === 'string' && !LINK.test(value);
+}
+async function uploadAppFile(context, appId, localPath) {
+    const file = await putAppFile(context, localPath, appId);
+    const uri = `drive:${file.id}`;
+    context.output.note(`Uploaded ${localPath} to your Drive as ${uri}.`);
+    return { mimeType: file.mimeType, name: file.name, uri };
+}

package/dist/cli/cloud/commands/artifacts.d.ts

@@ -0,0 +1,3 @@
+import { type Command } from '../command.js';
+export declare const artifactCommands: readonly Command[];
+//# sourceMappingURL=artifacts.d.ts.map

package/dist/cli/cloud/commands/artifacts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifacts.d.ts","sourceRoot":"","sources":["../../../../src/cli/cloud/commands/artifacts.ts"],"names":[],"mappings":"AASA,OAAO,EAWH,KAAK,OAAO,EAIf,MAAM,eAAe,CAAC;AAyUvB,eAAO,MAAM,gBAAgB,EAAE,SAAS,OAAO,EAAwC,CAAC"}

package/dist/cli/cloud/commands/artifacts.js

@@ -0,0 +1,267 @@
+// `workspace artifacts`: the person's saved HTML Artifacts, over Dexto's typed Artifacts tools.
+import { CommandFailure } from '../../failure.js';
+import { readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { z } from 'zod';
+import { argument, choiceOption, flag, integerOption, listOption, PAGE_OPTIONS, requiredOption, stringOption, UsageError, YES_OPTION, } from '../command.js';
+import { requireLoginScopes } from './deploys.js';
+import { agreeToCall, listWorkspaceTools, queryWorkspaceTool, toolCallLevel } from './workspace.js';
+/** What Dexto keeps of one Artifact's HTML. */
+const MAX_HTML_BYTES = 524_288;
+const KINDS = [
+    'document',
+    'plan',
+    'mockup',
+    'prototype',
+    'slide-deck',
+    'visualization',
+    'interactive',
+    'other',
+];
+const SURFACES = ['inline', 'panel', 'fullscreen'];
+const RENDERERS = ['html', 'reveal'];
+const VISIBILITIES = ['private', 'org-shared', 'link-shared'];
+const SummarySchema = z.object({
+    artifactId: z.string(),
+    kind: z.string(),
+    preferredSurface: z.string(),
+    summary: z.string(),
+    title: z.string(),
+    updatedAt: z.string(),
+});
+const ListSchema = z.object({ artifacts: z.array(SummarySchema), next: z.string().nullable() });
+const ArtifactSchema = SummarySchema.extend({
+    html: z.string(),
+    renderer: z.string().nullable(),
+});
+const GetSchema = z.object({ artifact: ArtifactSchema.nullable() });
+const SavedSchema = z.object({
+    artifact: z.object({ artifactId: z.string(), title: z.string() }),
+});
+const SharedSchema = z.object({ url: z.string().nullable(), visibility: z.string() });
+const COLUMNS = [
+    { header: 'id', value: (artifact) => artifact.artifactId },
+    { header: 'title', value: (artifact) => artifact.title },
+    { header: 'kind', value: (artifact) => artifact.kind },
+    { header: 'updated', value: (artifact) => artifact.updatedAt },
+];
+const CONTENT_OPTIONS = {
+    kind: { description: `What it is: ${KINDS.join(', ')}.`, type: 'string' },
+    renderer: {
+        description: 'html, or reveal for a slide-deck written for reveal.js.',
+        type: 'string',
+    },
+    summary: { description: 'One or two lines on what it is.', type: 'string' },
+    surface: {
+        description: `Where it opens: ${SURFACES.join(', ')}.`,
+        type: 'string',
+    },
+    tag: { description: 'A tag; repeat for more.', multiple: true, type: 'string' },
+    title: { description: "The Artifact's title.", type: 'string' },
+};
+const DRY_RUN_OPTION = {
+    'dry-run': {
+        description: 'Check the input and show the call, without making it.',
+        type: 'boolean',
+    },
+};
+const list = {
+    options: PAGE_OPTIONS,
+    path: ['workspace', 'artifacts', 'list'],
+    summary: 'List your saved Artifacts, newest first.',
+    async run(context, input) {
+        await requireLoginScopes(context, ['apps:read']);
+        const after = stringOption(input, 'after');
+        const limit = integerOption(input, 'limit');
+        const page = ListSchema.parse(await queryWorkspaceTool(context, 'dexto_artifacts_list', {
+            ...(after === undefined ? {} : { cursor: after }),
+            ...(limit === undefined ? {} : { limit }),
+        }));
+        context.output.list({ data: page.artifacts, has_more: page.next !== null, next_after: page.next }, COLUMNS);
+    },
+};
+const get = {
+    arguments: '<artifact_id>',
+    options: {
+        out: {
+            description: 'Write the HTML to this file, and show the rest without it.',
+            type: 'string',
+            valueName: 'PATH',
+        },
+    },
+    path: ['workspace', 'artifacts', 'get'],
+    summary: 'Show one Artifact, with its HTML or with --out writing the HTML to a file.',
+    async run(context, input) {
+        await requireLoginScopes(context, ['apps:read']);
+        const artifact = await readArtifact(context, argument(input, 0, 'artifact_id'));
+        const out = stringOption(input, 'out');
+        if (out === undefined)
+            return context.output.record(artifact);
+        await writeFile(out, artifact.html, 'utf8');
+        const { html: _html, ...rest } = artifact;
+        context.output.record({ ...rest, htmlPath: path.resolve(out) });
+    },
+};
+const create = {
+    arguments: '<file>',
+    options: {
+        ...CONTENT_OPTIONS,
+        collection: {
+            description: 'A collection to put it in, by id; repeat for more.',
+            multiple: true,
+            type: 'string',
+        },
+        'idempotency-key': {
+            description: 'Any string unique to this Artifact: running again with the same key returns the first one instead of a copy.',
+            type: 'string',
+            valueName: 'KEY',
+        },
+        ...DRY_RUN_OPTION,
+        ...YES_OPTION,
+    },
+    path: ['workspace', 'artifacts', 'create'],
+    summary: "Save an HTML file (or - for stdin) as an Artifact in your library. Its title defaults to the file's name.",
+    async run(context, input) {
+        await requireLoginScopes(context, ['apps:execute']);
+        const file = argument(input, 0, 'file');
+        const title = stringOption(input, 'title') ??
+            (file === '-' ? requiredOption(input, 'title') : path.parse(file).name);
+        const key = stringOption(input, 'idempotency-key');
+        const collections = listOption(input, 'collection');
+        const call = {
+            ...contentFields(input, {
+                kind: 'document',
+                preferredSurface: 'panel',
+                renderer: 'html',
+                summary: '',
+                title,
+            }),
+            html: await readHtml(context, file),
+            ...(collections.length === 0 ? {} : { collectionIds: collections }),
+            ...(key === undefined ? {} : { idempotencyKey: key }),
+        };
+        const saved = await save(context, input, 'dexto_artifacts_create', call, `Save ${title}`);
+        if (saved === null)
+            return;
+        context.output.result(saved.value, `Saved ${saved.artifact.title} as Artifact ${saved.artifact.artifactId}.`);
+    },
+};
+const replace = {
+    arguments: '<artifact_id> <file>',
+    options: { ...CONTENT_OPTIONS, ...DRY_RUN_OPTION, ...YES_OPTION },
+    path: ['workspace', 'artifacts', 'replace'],
+    summary: 'Replace an Artifact with an HTML file (or - for stdin), keeping its id; it keeps its title, kind, summary, surface and renderer unless you give new ones.',
+    async run(context, input) {
+        await requireLoginScopes(context, ['apps:read', 'apps:execute']);
+        const artifactId = argument(input, 0, 'artifact_id');
+        const html = await readHtml(context, argument(input, 1, 'file'));
+        const current = await readArtifact(context, artifactId);
+        const call = {
+            artifactId,
+            ...contentFields(input, {
+                kind: current.kind,
+                preferredSurface: current.preferredSurface,
+                renderer: current.renderer ?? 'html',
+                summary: current.summary,
+                title: current.title,
+            }),
+            html,
+        };
+        const saved = await save(context, input, 'dexto_artifacts_replace', call, `Replace Artifact ${artifactId}`);
+        if (saved === null)
+            return;
+        context.output.result(saved.value, `Replaced Artifact ${artifactId}.`);
+    },
+};
+const share = {
+    arguments: '<artifact_id>',
+    options: {
+        visibility: {
+            description: 'private (only you), org-shared (your organization) or link-shared (anyone with the link).',
+            type: 'string',
+        },
+        ...DRY_RUN_OPTION,
+        ...YES_OPTION,
+    },
+    path: ['workspace', 'artifacts', 'share'],
+    summary: 'Change who can open an Artifact: only you, your organization, or anyone with its link.',
+    async run(context, input) {
+        await requireLoginScopes(context, ['apps:execute']);
+        const visibility = choiceOption(input, 'visibility', VISIBILITIES);
+        if (visibility === undefined)
+            throw new UsageError('--visibility is required.');
+        const artifactId = argument(input, 0, 'artifact_id');
+        const call = { artifactId, visibility };
+        const tool = await requireTool(context, 'dexto_artifacts_share');
+        if (flag(input, 'dry-run'))
+            return dryRun(context, 'dexto_artifacts_share', call);
+        const agreed = await agreeToCall(context, {
+            level: toolCallLevel(tool, call),
+            schema: tool.inputSchema,
+            title: `Make Artifact ${artifactId} ${visibility}`,
+        }, flag(input, 'yes'));
+        const value = await queryWorkspaceTool(context, 'dexto_artifacts_share', {
+            ...call,
+            ...agreed,
+        });
+        const shared = SharedSchema.parse(value);
+        context.output.result(value, shared.url === null
+            ? `Artifact ${artifactId} is now ${shared.visibility}.`
+            : `Artifact ${artifactId} is now ${shared.visibility}: ${shared.url}`);
+    },
+};
+async function readArtifact(context, artifactId) {
+    const { artifact } = GetSchema.parse(await queryWorkspaceTool(context, 'dexto_artifacts_get', { artifactId }));
+    if (artifact === null)
+        throw new CommandFailure('not_found', `There is no Artifact ${artifactId}.`, null);
+    return artifact;
+}
+/** The HTML of a file, or of stdin for -, checked against what an Artifact holds. */
+async function readHtml(context, file) {
+    const html = file === '-' ? await context.runtime.readStdin() : await readFile(file, 'utf8');
+    if (html.length === 0)
+        throw new UsageError(`${file === '-' ? 'stdin' : file} is empty.`);
+    const bytes = Buffer.byteLength(html, 'utf8');
+    if (bytes > MAX_HTML_BYTES)
+        throw new UsageError(`The HTML is ${bytes} bytes; an Artifact holds up to ${MAX_HTML_BYTES}.`);
+    return html;
+}
+/** The content flags given, each falling back to `defaults`. */
+function contentFields(input, defaults) {
+    const tags = listOption(input, 'tag');
+    const fields = {
+        kind: choiceOption(input, 'kind', KINDS) ?? defaults.kind,
+        preferredSurface: choiceOption(input, 'surface', SURFACES) ?? defaults.preferredSurface,
+        renderer: choiceOption(input, 'renderer', RENDERERS) ?? defaults.renderer,
+        summary: stringOption(input, 'summary') ?? defaults.summary,
+        title: stringOption(input, 'title') ?? defaults.title,
+        ...(tags.length === 0 ? {} : { tags }),
+    };
+    if (fields.renderer === 'reveal' && fields.kind !== 'slide-deck')
+        throw new UsageError('--renderer reveal needs --kind slide-deck.');
+    return fields;
+}
+async function requireTool(context, name) {
+    const tool = (await listWorkspaceTools(context)).find((each) => each.name === name);
+    if (tool === undefined)
+        throw new CommandFailure('failed', "This Dexto can't manage Artifacts yet.", null);
+    return tool;
+}
+/** Creates or replaces once agreed, or with --dry-run shows the call; null when it only showed it. */
+async function save(context, input, name, call, title) {
+    const tool = await requireTool(context, name);
+    if (flag(input, 'dry-run')) {
+        dryRun(context, name, call);
+        return null;
+    }
+    const agreed = await agreeToCall(context, { level: toolCallLevel(tool, call), schema: tool.inputSchema, title }, flag(input, 'yes'));
+    const value = await queryWorkspaceTool(context, name, { ...call, ...agreed });
+    return { artifact: SavedSchema.parse(value).artifact, value };
+}
+/** The call a write would make, its HTML shown by size. */
+function dryRun(context, tool, call) {
+    const { html, ...rest } = call;
+    const shown = typeof html === 'string' ? { ...rest, htmlBytes: Buffer.byteLength(html, 'utf8') } : rest;
+    context.output.result({ dryRun: true, tool, arguments: shown }, `Would call ${tool} with ${JSON.stringify(shown)}.`);
+}
+export const artifactCommands = [list, get, create, replace, share];

package/dist/cli/cloud/commands/automations.d.ts

@@ -0,0 +1,3 @@
+import { type Command } from '../command.js';
+export declare const automationCommands: readonly Command[];
+//# sourceMappingURL=automations.d.ts.map

package/dist/cli/cloud/commands/automations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"automations.d.ts","sourceRoot":"","sources":["../../../../src/cli/cloud/commands/automations.ts"],"names":[],"mappings":"AAMA,OAAO,EAWH,KAAK,OAAO,EAEf,MAAM,eAAe,CAAC;AAoSvB,eAAO,MAAM,kBAAkB,EAAE,SAAS,OAAO,EAWhD,CAAC"}

package/dist/cli/cloud/commands/automations.js

@@ -0,0 +1,233 @@
+// `cloud automations`: run the project's agents on a schedule or on a signed webhook.
+import { requireConsent } from '../../interaction.js';
+import { unwrap } from '@dexto/cloud-client';
+import { argument, BODY_OPTIONS, PAGE_OPTIONS, pageQuery, readJsonBody, stringOption, UsageError, YES_OPTION, flag, isJsonObject, } from '../command.js';
+function automationPath(id) {
+    return { params: { path: { automation_id: id } } };
+}
+const COLUMNS = [
+    { header: 'id', value: (automation) => automation.id },
+    { header: 'name', value: (automation) => automation.name },
+    { header: 'status', value: (automation) => automation.status },
+    { header: 'trigger', value: (automation) => describeTrigger(automation) },
+    { header: 'agent', value: (automation) => automation.target.agent_id },
+    { header: 'last fired', value: (automation) => automation.last_fired_at },
+];
+const list = {
+    options: PAGE_OPTIONS,
+    path: ['cloud', 'automations', 'list'],
+    summary: "List the project's automations.",
+    async run(context, input) {
+        context.output.list(await unwrap(await (await context.client()).GET('/v1/automations', {
+            params: { query: pageQuery(input) },
+        })), COLUMNS);
+    },
+};
+const get = {
+    arguments: '<automation_id>',
+    path: ['cloud', 'automations', 'get'],
+    summary: 'Show an automation.',
+    async run(context, input) {
+        context.output.record(await unwrap(await (await context.client()).GET('/v1/automations/{automation_id}', automationPath(argument(input, 0, 'automation_id')))));
+    },
+};
+const create = {
+    options: {
+        ...BODY_OPTIONS,
+        agent: { description: 'The agent each firing runs.', type: 'string', valueName: 'ID' },
+        at: {
+            description: 'Fire once at this ISO 8601 time with an offset.',
+            type: 'string',
+            valueName: 'TIME',
+        },
+        cron: { description: 'Fire on this five-field cron expression.', type: 'string' },
+        message: { description: 'The message each firing sends the agent.', type: 'string' },
+        name: { description: 'Display name.', type: 'string' },
+        session: {
+            description: 'Send every firing to this session instead of a new one each time.',
+            type: 'string',
+            valueName: 'ID',
+        },
+        timezone: {
+            description: 'The IANA timezone the cron is read in (default UTC).',
+            type: 'string',
+        },
+        webhook: { description: 'Fire on each signed request to a webhook URL.', type: 'boolean' },
+    },
+    path: ['cloud', 'automations', 'create'],
+    summary: 'Create an automation from flags (--name --agent --message and one of --cron, --at, --webhook) or --file.',
+    async run(context, input) {
+        const body = await readJsonBody(context, input);
+        const definition = body === null ? fromFlags(input) : asCreateInput(body);
+        const automation = await unwrap(await (await context.client()).POST('/v1/automations', { body: definition }));
+        if (context.output.json)
+            return context.output.record(automation);
+        context.runtime.writeOutput(`Created automation ${automation.id} (${automation.name}).\n`);
+        if (automation.trigger.type === 'webhook') {
+            context.runtime.writeOutput(`Webhook URL: ${automation.trigger.url}\n`);
+            context.runtime.writeOutput(`Signing secret (shown once): ${automation.webhook_secret ?? '-'}\n`);
+        }
+        else if (automation.trigger.next_run_at !== null)
+            context.runtime.writeOutput(`Next run: ${automation.trigger.next_run_at}\n`);
+    },
+};
+const update = {
+    arguments: '<automation_id>',
+    options: {
+        ...BODY_OPTIONS,
+        message: { description: 'The message each firing sends.', type: 'string' },
+        name: { description: 'Display name.', type: 'string' },
+    },
+    path: ['cloud', 'automations', 'update'],
+    summary: "Change an automation's name or message, or any field with --file.",
+    async run(context, input) {
+        const body = await readJsonBody(context, input);
+        const name = stringOption(input, 'name');
+        const message = stringOption(input, 'message');
+        const changes = body === null
+            ? {
+                ...(name === undefined ? {} : { name }),
+                ...(message === undefined ? {} : { target: { message } }),
+            }
+            : asUpdateInput(body);
+        const automation = await unwrap(await (await context.client()).PATCH('/v1/automations/{automation_id}', {
+            ...automationPath(argument(input, 0, 'automation_id')),
+            body: changes,
+        }));
+        context.output.result(automation, `Updated automation ${automation.id}.`);
+    },
+};
+function lifecycle(action, summary) {
+    return {
+        arguments: '<automation_id>',
+        ...(action === 'delete' ? { options: YES_OPTION } : {}),
+        path: ['cloud', 'automations', action],
+        summary,
+        async run(context, input) {
+            const client = await context.client();
+            const id = argument(input, 0, 'automation_id');
+            if (action === 'delete') {
+                await requireConsent(context, flag(input, 'yes'), `Deleting automation ${id} removes it and its firing history for good.`);
+                const result = await unwrap(await client.DELETE('/v1/automations/{automation_id}', automationPath(id)));
+                return context.output.result(result, `Deleted automation ${id}.`);
+            }
+            if (action === 'run') {
+                const firing = await unwrap(await client.POST('/v1/automations/{automation_id}/run', automationPath(id)));
+                return context.output.result(firing, `Fired ${firing.id}: ${firing.status}${firing.run_id === null ? '' : `, run ${firing.run_id} in session ${firing.session_id ?? '-'}`}.`);
+            }
+            const automation = await unwrap(action === 'pause'
+                ? await client.POST('/v1/automations/{automation_id}/pause', automationPath(id))
+                : await client.POST('/v1/automations/{automation_id}/resume', automationPath(id)));
+            context.output.result(automation, `Automation ${id} is ${automation.status}.`);
+        },
+    };
+}
+const firings = {
+    arguments: '<automation_id>',
+    options: PAGE_OPTIONS,
+    path: ['cloud', 'automations', 'firings'],
+    summary: "List an automation's firings, newest first, with each run's status.",
+    async run(context, input) {
+        const page = await unwrap(await (await context.client()).GET('/v1/automations/{automation_id}/firings', {
+            params: {
+                path: { automation_id: argument(input, 0, 'automation_id') },
+                query: pageQuery(input),
+            },
+        }));
+        context.output.list(page, [
+            { header: 'id', value: (firing) => firing.id },
+            { header: 'source', value: (firing) => firing.source },
+            { header: 'status', value: (firing) => firing.status },
+            { header: 'run', value: (firing) => firing.run_id },
+            { header: 'fired', value: (firing) => firing.fired_at },
+        ]);
+    },
+};
+const rotate = {
+    arguments: '<automation_id>',
+    options: YES_OPTION,
+    path: ['cloud', 'automations', 'rotate-secret'],
+    summary: "Replace a webhook's signing secret; the old one stops at once.",
+    async run(context, input) {
+        const id = argument(input, 0, 'automation_id');
+        await requireConsent(context, flag(input, 'yes'), `The webhook's current signing secret stops working at once; senders need the new one.`);
+        const secret = await unwrap(await (await context.client()).POST('/v1/automations/{automation_id}/webhook/rotate_secret', automationPath(id)));
+        context.output.result(secret, `New signing secret (shown once): ${secret.webhook_secret}`);
+    },
+};
+function fromFlags(input) {
+    const name = stringOption(input, 'name');
+    const agentId = stringOption(input, 'agent');
+    const message = stringOption(input, 'message');
+    if (name === undefined || agentId === undefined || message === undefined)
+        throw new UsageError('An automation needs --name, --agent and --message, or --file.');
+    const cron = stringOption(input, 'cron');
+    const at = stringOption(input, 'at');
+    const webhook = flag(input, 'webhook');
+    if ([cron !== undefined, at !== undefined, webhook].filter(Boolean).length !== 1)
+        throw new UsageError('Pass exactly one of --cron, --at or --webhook.');
+    const sessionId = stringOption(input, 'session');
+    return {
+        name,
+        target: {
+            agent_id: agentId,
+            message,
+            ...(sessionId === undefined
+                ? {}
+                : { session: { mode: 'fixed', session_id: sessionId } }),
+            type: 'agent',
+        },
+        trigger: webhook
+            ? { type: 'webhook' }
+            : {
+                schedule: cron === undefined
+                    ? { run_at: at ?? '', type: 'once' }
+                    : {
+                        cron,
+                        timezone: stringOption(input, 'timezone') ?? 'UTC',
+                        type: 'recurring',
+                    },
+                type: 'schedule',
+            },
+    };
+}
+/** The API validates the whole body; the CLI checks only its shape. */
+function isCreateInput(value) {
+    return (isJsonObject(value) &&
+        typeof value.name === 'string' &&
+        isJsonObject(value.target) &&
+        isJsonObject(value.trigger));
+}
+function asCreateInput(value) {
+    if (!isCreateInput(value))
+        throw new UsageError('An automation needs name, and target and trigger objects.');
+    return value;
+}
+function isUpdateInput(value) {
+    return isJsonObject(value);
+}
+function asUpdateInput(value) {
+    if (!isUpdateInput(value))
+        throw new UsageError('The changes must be a JSON object.');
+    return value;
+}
+function describeTrigger(automation) {
+    const trigger = automation.trigger;
+    if (trigger.type === 'webhook')
+        return 'webhook';
+    return trigger.schedule.type === 'once'
+        ? `once ${trigger.schedule.run_at}`
+        : `${trigger.schedule.cron} ${trigger.schedule.timezone}`;
+}
+export const automationCommands = [
+    list,
+    get,
+    create,
+    update,
+    lifecycle('pause', "Stop an automation's schedule."),
+    lifecycle('resume', 'Resume a paused automation.'),
+    lifecycle('run', 'Fire an automation now, whatever its status.'),
+    lifecycle('delete', 'Delete an automation and its firing history.'),
+    firings,
+    rotate,
+];

package/dist/cli/cloud/commands/chats.d.ts

@@ -0,0 +1,3 @@
+import { type Command } from '../command.js';
+export declare const chatCommands: readonly Command[];
+//# sourceMappingURL=chats.d.ts.map

package/dist/cli/cloud/commands/chats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chats.d.ts","sourceRoot":"","sources":["../../../../src/cli/cloud/commands/chats.ts"],"names":[],"mappings":"AAMA,OAAO,EAMH,KAAK,OAAO,EAIf,MAAM,eAAe,CAAC;AAwQvB,eAAO,MAAM,YAAY,EAAE,SAAS,OAAO,EAAyB,CAAC"}