dexto 1.14.4 → 2.0.0-beta.0

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/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":"AAIA,OAAO,EAYH,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,232 @@
+// `cloud automations`: run the project's agents on a schedule or on a signed webhook.
+import { unwrap } from '@dexto/cloud-client';
+import { argument, BODY_OPTIONS, PAGE_OPTIONS, pageQuery, readJsonBody, requireConsent, 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":"AAIA,OAAO,EAOH,KAAK,OAAO,EAIf,MAAM,eAAe,CAAC;AAwPvB,eAAO,MAAM,YAAY,EAAE,SAAS,OAAO,EAAyB,CAAC"}

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

@@ -0,0 +1,189 @@
+// `chat local` and `chat import`: find Claude Code and Codex chats on this machine and import them.
+import { z } from 'zod';
+import { flag, MissingScopeFailure, requireConsent, stringOption, UsageError, YES_OPTION, } from '../command.js';
+import { findLocalChats, LOCAL_CHAT_SOURCES, toImportInput, } from '../local-chats.js';
+import { queryWorkspaceTool } from './workspace.js';
+const FIND_OPTIONS = {
+    dir: {
+        description: 'Read sessions from this folder (default: $CLAUDE_CONFIG_DIR/projects or ~/.claude/projects; $CODEX_HOME/sessions or ~/.codex/sessions).',
+        type: 'string',
+        valueName: 'PATH',
+    },
+    from: {
+        description: `Where the chats are: ${LOCAL_CHAT_SOURCES.join(' or ')}.`,
+        type: 'string',
+        valueName: 'SOURCE',
+    },
+    folder: {
+        description: 'Only sessions run in this folder or inside it, such as . for this repository.',
+        type: 'string',
+        valueName: 'PATH',
+    },
+    since: {
+        description: 'Only sessions with a turn on or after this date, such as 2026-10-01.',
+        type: 'string',
+        valueName: 'DATE',
+    },
+};
+const ImportedSchema = z.object({
+    session: z.object({ id: z.string() }),
+    status: z.enum(['already_imported', 'imported']),
+    url: z.string(),
+});
+function localQuery(input) {
+    const from = stringOption(input, 'from');
+    if (from === undefined)
+        throw new UsageError(`--from is required: ${LOCAL_CHAT_SOURCES.join(' or ')}.`);
+    const source = LOCAL_CHAT_SOURCES.find((each) => each === from);
+    if (source === undefined)
+        throw new UsageError(`--from takes ${LOCAL_CHAT_SOURCES.join(' or ')}, not ${from}.`);
+    const since = stringOption(input, 'since') ?? null;
+    if (since !== null && Number.isNaN(new Date(since).getTime()))
+        throw new UsageError('--since must be a date, such as 2026-10-01.');
+    return {
+        dir: stringOption(input, 'dir') ?? null,
+        folder: stringOption(input, 'folder') ?? null,
+        since,
+        source,
+    };
+}
+function sourceName(source) {
+    return source === 'claude-code' ? 'Claude Code' : 'Codex';
+}
+const local = {
+    options: FIND_OPTIONS,
+    path: ['chat', 'local'],
+    summary: 'List Claude Code or Codex chats on this machine, newest first, to pick some for chat import.',
+    async run(context, input) {
+        const chats = await findLocalChats(context.runtime, localQuery(input));
+        context.output.list({
+            data: chats.map((chat) => ({
+                cwd: chat.cwd,
+                id: chat.id,
+                messages: chat.messages.length,
+                path: chat.path,
+                source: chat.source,
+                startedAt: chat.startedAt,
+                title: chat.title,
+                updatedAt: chat.updatedAt,
+            })),
+        }, [
+            { header: 'id', value: (row) => row.id },
+            { header: 'title', value: (row) => row.title },
+            { header: 'messages', value: (row) => row.messages },
+            { header: 'updated', value: (row) => row.updatedAt },
+            { header: 'folder', value: (row) => row.cwd },
+        ]);
+    },
+};
+const importChats = {
+    arguments: '[session_ids...]',
+    options: {
+        ...FIND_OPTIONS,
+        all: { description: 'Import every session chat local lists.', type: 'boolean' },
+        'dry-run': {
+            description: 'Send nothing; show what each import would send and what was redacted.',
+            type: 'boolean',
+        },
+        ...YES_OPTION,
+    },
+    path: ['chat', 'import'],
+    summary: 'Import Claude Code or Codex chats from this machine as your private Dexto chats, redacted here first.',
+    async run(context, input) {
+        const query = localQuery(input);
+        const ids = input.positionals;
+        const all = flag(input, 'all');
+        if (ids.length === 0 && !all)
+            throw new UsageError('Name the sessions to import, by the ids chat local lists, or pass --all.');
+        const found = await findLocalChats(context.runtime, query);
+        const planned = (all ? found : ids.map((id) => found.find((chat) => chat.id === id) ?? id)).map((chat) => plan(chat, query.source));
+        const sending = planned.filter((each) => each.input !== null);
+        if (flag(input, 'dry-run') || sending.length === 0) {
+            report(context, planned.map((each) => each.result));
+            return flag(input, 'dry-run') || planned.length === 0 ? 0 : 1;
+        }
+        const messages = sending.reduce((sum, each) => sum + (each.result.messages ?? 0), 0);
+        const redacted = sending.reduce((sum, each) => sum + Object.values(each.result.redactions ?? {}).reduce((one, n) => one + n, 0), 0);
+        await requireConsent(context, flag(input, 'yes'), `Upload ${sending.length} ${sourceName(query.source)} chat${sending.length === 1 ? '' : 's'} (${messages} messages, ${redacted} secrets redacted) as your private Dexto chats?`);
+        const finished = await Promise.all(planned.map(async ({ input: sent, result }) => {
+            if (sent === null)
+                return result;
+            try {
+                const imported = ImportedSchema.parse(await queryWorkspaceTool(context, 'dexto_chat_import', sent));
+                return {
+                    ...result,
+                    chatId: imported.session.id,
+                    status: imported.status,
+                    url: imported.url,
+                };
+            }
+            catch (error) {
+                // A missing permission fails every import alike: exit 3 with the sign-in that fixes it.
+                if (error instanceof MissingScopeFailure)
+                    throw error;
+                return {
+                    ...result,
+                    reason: error instanceof Error ? error.message : 'The import failed.',
+                    status: 'failed',
+                };
+            }
+        }));
+        report(context, finished);
+        return finished.some((result) => result.status === 'failed' || result.status === 'skipped')
+            ? 1
+            : 0;
+    },
+};
+/** What importing one chosen session would send, or why it can't go. */
+function plan(chat, source) {
+    if (typeof chat === 'string')
+        return {
+            input: null,
+            result: {
+                id: chat,
+                reason: `No ${sourceName(source)} session with this id matches here.`,
+                status: 'skipped',
+            },
+        };
+    const prepared = toImportInput(chat);
+    if (prepared.kind === 'skipped')
+        return {
+            input: null,
+            result: { id: chat.id, reason: prepared.reason, status: 'skipped', title: chat.title },
+        };
+    return {
+        input: prepared.input,
+        result: {
+            id: chat.id,
+            messages: prepared.input.messages.length,
+            redactions: prepared.redactions,
+            status: 'ready',
+            title: prepared.input.title,
+            truncated: prepared.truncated,
+        },
+    };
+}
+function report(context, sessions) {
+    context.output.result({ sessions }, sessions
+        .map((session) => [
+        `${session.status.padEnd(16)} ${session.id}`,
+        session.title === undefined ? '' : `  ${session.title}`,
+        session.url === undefined ? '' : `  ${session.url}`,
+        session.reason === undefined ? '' : `  ${session.reason}`,
+        session.status === 'ready' ? `  ${readyLine(session)}` : '',
+    ].join(''))
+        .join('\n'));
+}
+function readyLine(session) {
+    const redactions = Object.entries(session.redactions ?? {})
+        .map(([kind, count]) => `${count} ${kind}`)
+        .join(', ');
+    return [
+        `${session.messages ?? 0} messages`,
+        redactions === '' ? 'nothing redacted' : `redacted ${redactions}`,
+        session.truncated ? `${session.truncated} cut to size` : '',
+    ]
+        .filter((part) => part !== '')
+        .join('; ');
+}
+export const chatCommands = [local, importChats];

package/dist/cli/cloud/commands/data-deletions.d.ts

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

package/dist/cli/cloud/commands/data-deletions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-deletions.d.ts","sourceRoot":"","sources":["../../../../src/cli/cloud/commands/data-deletions.ts"],"names":[],"mappings":"AAGA,OAAO,EASH,KAAK,OAAO,EACf,MAAM,eAAe,CAAC;AAiFvB,eAAO,MAAM,oBAAoB,EAAE,SAAS,OAAO,EAAwB,CAAC"}

package/dist/cli/cloud/commands/data-deletions.js

@@ -0,0 +1,54 @@
+// `cloud data-deletions`: delete an end user's or an agent's data in the background.
+import { unwrap } from '@dexto/cloud-client';
+import { argument, flag, PAGE_OPTIONS, pageQuery, requireConsent, stringOption, UsageError, YES_OPTION, } from '../command.js';
+const COLUMNS = [
+    { header: 'id', value: (deletion) => deletion.id },
+    { header: 'status', value: (deletion) => deletion.status },
+    { header: 'scope', value: (deletion) => JSON.stringify(deletion.scope) },
+    { header: 'created', value: (deletion) => deletion.created_at },
+];
+const create = {
+    options: {
+        agent: { description: 'The agent whose data to delete.', type: 'string', valueName: 'ID' },
+        user: { description: 'The end-user label whose sessions to delete.', type: 'string' },
+        ...YES_OPTION,
+    },
+    path: ['cloud', 'data-deletions', 'create'],
+    summary: "Delete an end user's sessions (--user, optionally of one --agent), or all of an agent's data (--agent).",
+    async run(context, input) {
+        const agentId = stringOption(input, 'agent');
+        const user = stringOption(input, 'user');
+        if (agentId === undefined && user === undefined)
+            throw new UsageError('Pass --user, --agent, or both.');
+        await requireConsent(context, flag(input, 'yes'), user === undefined
+            ? `This deletes all of agent ${agentId}'s data for good.`
+            : `This deletes ${user}'s sessions${agentId === undefined ? '' : ` with agent ${agentId}`} for good.`);
+        const deletion = await unwrap(await (await context.client()).POST('/v1/data_deletions', {
+            body: { agent_id: agentId ?? null, ...(user === undefined ? {} : { user }) },
+        }));
+        context.output.result(deletion, `Data deletion ${deletion.id} is ${deletion.status}.`);
+    },
+};
+const list = {
+    options: PAGE_OPTIONS,
+    path: ['cloud', 'data-deletions', 'list'],
+    summary: 'List data deletions.',
+    async run(context, input) {
+        context.output.list(await unwrap(await (await context.client()).GET('/v1/data_deletions', {
+            params: { query: pageQuery(input) },
+        })), COLUMNS);
+    },
+};
+const get = {
+    arguments: '<data_deletion_id>',
+    path: ['cloud', 'data-deletions', 'get'],
+    summary: 'Show a data deletion and what it deleted.',
+    async run(context, input) {
+        context.output.record(await unwrap(await (await context.client()).GET('/v1/data_deletions/{data_deletion_id}', {
+            params: {
+                path: { data_deletion_id: argument(input, 0, 'data_deletion_id') },
+            },
+        })));
+    },
+};
+export const dataDeletionCommands = [create, list, get];

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

@@ -0,0 +1,10 @@
+import { type Command, type CommandContext } from '../command.js';
+/**
+ * A person's sign-in needs the kind's permission, and to deploy also `cloud:write`, which the API
+ * checks first; asking for every missing one at once lets a single sign-in cover the command. A
+ * deploy spends credits, so running one is asking for `cloud:write`. At a terminal the CLI then
+ * offers to sign in again for them. A key's permissions are checked by the API.
+ */
+export declare function requireLoginScopes(context: CommandContext, scopes: readonly string[]): Promise<void>;
+export declare const deployCommands: readonly Command[];
+//# sourceMappingURL=deploys.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deploys.d.ts","sourceRoot":"","sources":["../../../../src/cli/cloud/commands/deploys.ts"],"names":[],"mappings":"AAQA,OAAO,EAQH,KAAK,OAAO,EACZ,KAAK,cAAc,EAGtB,MAAM,eAAe,CAAC;AAkLvB;;;;;GAKG;AACH,wBAAsB,kBAAkB,CACpC,OAAO,EAAE,cAAc,EACvB,MAAM,EAAE,SAAS,MAAM,EAAE,GAC1B,OAAO,CAAC,IAAI,CAAC,CAYf;AAwED,eAAO,MAAM,cAAc,EAAE,SAAS,OAAO,EAM5C,CAAC"}