dexto 1.14.4 → 2.0.0-beta.0

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

@@ -0,0 +1,119 @@
+// `profile`: read and change your own Dexto profile, as Settings → Profile does.
+import { z } from 'zod';
+import { CommandFailure, stringOption, UsageError, } from '../command.js';
+import { queryWorkspaceTool } from './workspace.js';
+const ProfileSchema = z.object({
+    bio: z.string().nullable(),
+    displayName: z.string(),
+    handle: z.string(),
+    links: z.array(z.unknown()),
+    showTokenUsage: z.boolean(),
+    visibility: z.enum(['private', 'public']),
+    workEntries: z.array(z.unknown()),
+});
+const get = {
+    path: ['profile', 'get'],
+    summary: 'Show your Dexto profile: handle, name, bio, links, work and whether it is public.',
+    async run(context) {
+        const profile = await readProfile(context, 'dexto_profile_get', {});
+        context.output.result({ profile }, describeProfile(profile));
+    },
+};
+const update = {
+    options: {
+        bio: {
+            description: 'Your bio; "" clears it.',
+            type: 'string',
+            valueName: 'TEXT',
+        },
+        'display-name': { description: 'Your display name.', type: 'string', valueName: 'NAME' },
+        handle: {
+            description: 'Your handle, unique across Dexto: 3 to 30 lowercase letters, digits and hyphens.',
+            type: 'string',
+            valueName: 'HANDLE',
+        },
+        links: {
+            description: 'Your links, replacing them all, as JSON: [{"kind":"github","url":"https://…"}] or {"kind":"custom","label":"…","url":"…"} entries.',
+            type: 'string',
+            valueName: 'JSON',
+        },
+        'token-usage': {
+            description: 'Whether your profile shows your token usage: show or hide.',
+            type: 'string',
+            valueName: 'show|hide',
+        },
+        visibility: {
+            description: 'private, or public for anyone with the link.',
+            type: 'string',
+            valueName: 'private|public',
+        },
+        work: {
+            description: 'Your work entries, replacing them all, as JSON: {"kind":"site","siteId":"…"} or {"kind":"external","title":"…","url":"…","description":null,"imageUrl":null} entries.',
+            type: 'string',
+            valueName: 'JSON',
+        },
+    },
+    path: ['profile', 'update'],
+    summary: 'Change your Dexto profile: only the fields you pass change, such as --handle shaun --visibility public.',
+    async run(context, input) {
+        const changes = profileChanges(input);
+        if (Object.keys(changes).length === 0)
+            throw new UsageError('Pass at least one field to change, such as --handle or --visibility.');
+        const profile = await readProfile(context, 'dexto_profile_update', changes);
+        context.output.result({ profile }, `Updated.\n${describeProfile(profile)}`);
+    },
+};
+/** What `profile update` asks to change, in `dexto_profile_update`'s fields. */
+function profileChanges(input) {
+    const visibility = stringOption(input, 'visibility');
+    if (visibility !== undefined && visibility !== 'private' && visibility !== 'public')
+        throw new UsageError('--visibility must be private or public.');
+    const tokenUsage = stringOption(input, 'token-usage');
+    if (tokenUsage !== undefined && tokenUsage !== 'show' && tokenUsage !== 'hide')
+        throw new UsageError('--token-usage must be show or hide.');
+    const bio = stringOption(input, 'bio');
+    const displayName = stringOption(input, 'display-name');
+    const handle = stringOption(input, 'handle');
+    const links = jsonListOption(input, 'links');
+    const work = jsonListOption(input, 'work');
+    return {
+        ...(bio === undefined ? {} : { bio: bio.trim().length === 0 ? null : bio }),
+        ...(displayName === undefined ? {} : { displayName }),
+        ...(handle === undefined ? {} : { handle }),
+        ...(links === undefined ? {} : { links }),
+        ...(tokenUsage === undefined ? {} : { showTokenUsage: tokenUsage === 'show' }),
+        ...(visibility === undefined ? {} : { visibility }),
+        ...(work === undefined ? {} : { workEntries: work }),
+    };
+}
+/** A JSON list option: every link or work entry at once, replacing what is there. */
+function jsonListOption(input, name) {
+    const value = stringOption(input, name);
+    if (value === undefined)
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        throw new UsageError(`--${name} must be a JSON list.`);
+    }
+    if (!Array.isArray(parsed))
+        throw new UsageError(`--${name} must be a JSON list.`);
+    return parsed;
+}
+async function readProfile(context, tool, input) {
+    const value = await queryWorkspaceTool(context, tool, input);
+    const parsed = z.object({ profile: ProfileSchema }).safeParse(value);
+    if (!parsed.success)
+        throw new CommandFailure('failed', "Dexto didn't return your profile.", null);
+    return parsed.data.profile;
+}
+function describeProfile(profile) {
+    return [
+        `@${profile.handle} (${profile.displayName}), ${profile.visibility}`,
+        ...(profile.bio === null ? [] : [profile.bio]),
+        `${profile.links.length} links, ${profile.workEntries.length} work entries, token usage ${profile.showTokenUsage ? 'shown' : 'hidden'}`,
+    ].join('\n');
+}
+export const profileCommands = [get, update];

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

@@ -0,0 +1,5 @@
+import { type Command } from '../command.js';
+/** Chooses the project a person's sign-in acts in; `accounts` reads the same saved login. */
+export declare function projectsUse(accountsDir: string): Command;
+export declare const projectCommands: readonly Command[];
+//# sourceMappingURL=projects.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"projects.d.ts","sourceRoot":"","sources":["../../../../src/cli/cloud/commands/projects.ts"],"names":[],"mappings":"AAIA,OAAO,EAAwB,KAAK,OAAO,EAAuB,MAAM,eAAe,CAAC;AA8CxF,6FAA6F;AAC7F,wBAAgB,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAkCxD;AAED,eAAO,MAAM,eAAe,EAAE,SAAS,OAAO,EAAmB,CAAC"}

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

@@ -0,0 +1,66 @@
+// `cloud projects`: the Cloud projects you can act in, and which one commands use.
+import { dextoAccounts } from '@dexto/agent-management';
+import { unwrap } from '@dexto/cloud-client';
+import { argument, UsageError } from '../command.js';
+async function listProjects(context) {
+    return await unwrap(await (await context.client()).GET('/v1/projects'));
+}
+const list = {
+    path: ['cloud', 'projects', 'list'],
+    summary: 'List the Cloud projects you can act in; * marks the current one.',
+    async run(context) {
+        const connection = await context.connection();
+        const projects = await listProjects(context);
+        context.output.list(projects, [
+            {
+                header: '',
+                value: (project) => project.id === connection.cloudProject ||
+                    (connection.kind === 'api_key' && projects.data.length === 1)
+                    ? '*'
+                    : '',
+            },
+            { header: 'id', value: (project) => project.id },
+            { header: 'name', value: (project) => project.name },
+            { header: 'default', value: (project) => (project.is_default ? 'yes' : '') },
+            { header: 'archived', value: (project) => project.archived_at },
+        ]);
+    },
+};
+const create = {
+    arguments: '<name>',
+    path: ['cloud', 'projects', 'create'],
+    summary: 'Create a Cloud project. Owners and Admins create projects.',
+    async run(context, input) {
+        const project = await unwrap(await (await context.client()).POST('/v1/projects', { body: { name: argument(input, 0, 'name') } }));
+        context.output.result(project, `Created Cloud project ${project.name} (${project.id}). Act in it with dexto cloud projects use ${project.id}.`);
+    },
+};
+/** Chooses the project a person's sign-in acts in; `accounts` reads the same saved login. */
+export function projectsUse(accountsDir) {
+    return {
+        arguments: '<project>',
+        path: ['cloud', 'projects', 'use'],
+        summary: 'Act in this Cloud project, by id or name, from now on. Dexto models bill it too.',
+        async run(context, input) {
+            const connection = await context.connection();
+            if (connection.kind !== 'oauth' || connection.source !== 'login')
+                throw new UsageError('A key acts only in its own project. Sign in with dexto login to choose projects.');
+            const wanted = argument(input, 0, 'project');
+            const projects = await listProjects(context);
+            const matches = projects.data.filter((project) => project.id === wanted || project.name === wanted);
+            const [project] = matches;
+            if (project === undefined)
+                throw new UsageError(`No Cloud project ${wanted}.`);
+            if (matches.length > 1)
+                throw new UsageError(`More than one project is named ${wanted}; use its id.`);
+            if (project.archived_at !== null)
+                throw new UsageError(`${project.name} is archived. Restore it in the Cloud app first.`);
+            await dextoAccounts.writeLogin(accountsDir, connection.profile, {
+                ...connection.login,
+                cloudProject: { id: project.id, name: project.name },
+            });
+            context.output.result(project, `Acting in Cloud project ${project.name} (${project.id}).`);
+        },
+    };
+}
+export const projectCommands = [list, create];

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"publish.d.ts","sourceRoot":"","sources":["../../../../src/cli/cloud/commands/publish.ts"],"names":[],"mappings":"AAQA,OAAO,EAOH,KAAK,OAAO,EACf,MAAM,eAAe,CAAC;AAiKvB,eAAO,MAAM,eAAe,EAAE,SAAS,OAAO,EAAc,CAAC"}

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

@@ -0,0 +1,138 @@
+// `publish`: puts a page, a document or a folder online as a link anyone with it can open.
+import { createHash } from 'node:crypto';
+import { readdir, readFile, stat } from 'node:fs/promises';
+import path from 'node:path';
+import { z } from 'zod';
+import { argument, CommandFailure, stringOption, flag, UsageError, YES_OPTION, } from '../command.js';
+import { sendBytes } from '../transfer.js';
+import { zipArchive } from '../zip.js';
+import { requireLoginScopes } from './deploys.js';
+import { formatBytes } from './files.js';
+import { agreeToCall, listWorkspaceTools, queryWorkspaceTool, toolCallLevel } from './workspace.js';
+/** What a published link takes, as Dexto's Sites do: files, each file's size and their total. */
+const MAX_FILES = 100;
+const MAX_FILE_BYTES = 10 * 1024 * 1024;
+const MAX_TOTAL_BYTES = 25 * 1024 * 1024;
+/** The most the .zip that carries them can be, with room for its own headers. */
+const MAX_UPLOAD_BYTES = MAX_TOTAL_BYTES + 1024 * 1024;
+const PreparedSchema = z.object({
+    headers: z.record(z.string(), z.string()),
+    method: z.string(),
+    path: z.string(),
+    url: z.string(),
+});
+const PublishedSchema = z.object({
+    created: z.boolean(),
+    files: z.number(),
+    url: z.string(),
+});
+const publish = {
+    arguments: '<path>',
+    options: {
+        name: {
+            description: "What it's called: the page's title and, with your handle, its address (default: the file or folder's name). Publishing the same name again updates the same link.",
+            type: 'string',
+        },
+        slug: {
+            description: 'Publish at <slug>.dexto.dev instead of an address made from the name; a Site of yours there is updated.',
+            type: 'string',
+        },
+        title: { description: "The page's title (default: the name).", type: 'string' },
+        ...YES_OPTION,
+    },
+    path: ['publish'],
+    summary: 'Publish a file, a folder or a .zip of one as a link anyone with it can open; publishing the same name again updates it.',
+    async run(context, input) {
+        await requireLoginScopes(context, ['sites:write']);
+        const target = path.resolve(argument(input, 0, 'path'));
+        const found = await stat(target).catch(() => null);
+        if (found === null || !(found.isFile() || found.isDirectory()))
+            throw new UsageError(`${target} isn't a file or folder.`);
+        const isZip = found.isFile() && /\.zip$/iu.test(target);
+        const name = stringOption(input, 'name') ??
+            (found.isDirectory()
+                ? path.basename(target)
+                : path.basename(target, path.extname(target)));
+        const slug = stringOption(input, 'slug');
+        const title = stringOption(input, 'title');
+        let archive;
+        let count = null;
+        if (isZip)
+            archive = new Uint8Array(await readFile(target));
+        else {
+            const files = found.isDirectory()
+                ? await readFolder(target)
+                : [{ bytes: await readFile(target), path: path.basename(target) }];
+            checkSizes(files);
+            archive = zipArchive(files);
+            count = files.length;
+        }
+        if (archive.byteLength > MAX_UPLOAD_BYTES)
+            throw new UsageError(`The .zip is ${formatBytes(archive.byteLength)}, over the ${formatBytes(MAX_UPLOAD_BYTES)} a published link's .zip can be.`);
+        const tool = (await listWorkspaceTools(context)).find((each) => each.name === 'dexto_site_publish');
+        if (tool === undefined)
+            throw new CommandFailure('failed', "This Dexto can't publish files yet.", null);
+        const call = {
+            name,
+            ...(slug === undefined ? {} : { slug }),
+            ...(title === undefined ? {} : { title }),
+        };
+        const agreed = await agreeToCall(context, {
+            level: toolCallLevel(tool, call),
+            schema: tool.inputSchema,
+            title: `Publish ${name} as a link anyone with it can open`,
+        }, flag(input, 'yes'));
+        const prepared = PreparedSchema.safeParse(await queryWorkspaceTool(context, 'dexto_upload_prepare', {
+            filename: `${path.basename(target, '.zip')}.zip`,
+            mimeType: 'application/zip',
+            purpose: 'site-files',
+            sha256: createHash('sha256').update(archive).digest('hex'),
+            sizeBytes: archive.byteLength,
+        }));
+        if (!prepared.success)
+            throw new CommandFailure('failed', "Dexto didn't say where to upload the files.", null);
+        const { headers, method, url } = prepared.data;
+        await sendBytes(context, { headers, method, url }, new globalThis.Blob([archive]));
+        const published = await queryWorkspaceTool(context, 'dexto_site_publish', {
+            ...call,
+            uploadPath: prepared.data.path,
+            ...agreed,
+        });
+        const shown = PublishedSchema.safeParse(published);
+        const files = shown.success ? shown.data.files : count;
+        context.output.result(published, shown.success
+            ? `${shown.data.created ? 'Published' : 'Updated'} ${name} at ${shown.data.url} (${files} file${files === 1 ? '' : 's'}). Anyone with the link can open it.`
+            : JSON.stringify(published, null, 2));
+    },
+};
+/** The folder's files, by path, leaving out names that start with a dot and links. */
+async function readFolder(folder) {
+    const found = [];
+    const visit = async (relative) => {
+        const entries = await readdir(path.join(folder, relative), { withFileTypes: true });
+        for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+            if (entry.name.startsWith('.'))
+                continue;
+            const child = relative === '' ? entry.name : `${relative}/${entry.name}`;
+            if (entry.isDirectory())
+                await visit(child);
+            else if (entry.isFile())
+                found.push(child);
+            if (found.length > MAX_FILES)
+                throw new UsageError(`${folder} has more than ${MAX_FILES} files; a published link takes up to ${MAX_FILES}.`);
+        }
+    };
+    await visit('');
+    if (found.length === 0)
+        throw new UsageError(`${folder} has no files to publish.`);
+    return await Promise.all(found.map(async (file) => ({ bytes: await readFile(path.join(folder, file)), path: file })));
+}
+function checkSizes(files) {
+    const large = files.find((file) => file.bytes.byteLength > MAX_FILE_BYTES);
+    if (large !== undefined)
+        throw new UsageError(`${large.path} is ${formatBytes(large.bytes.byteLength)}; a published file can be up to ${formatBytes(MAX_FILE_BYTES)}.`);
+    const total = files.reduce((sum, file) => sum + file.bytes.byteLength, 0);
+    if (total > MAX_TOTAL_BYTES)
+        throw new UsageError(`The files come to ${formatBytes(total)}; a published link takes up to ${formatBytes(MAX_TOTAL_BYTES)}.`);
+}
+export const publishCommands = [publish];

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"sandboxes.d.ts","sourceRoot":"","sources":["../../../../src/cli/cloud/commands/sandboxes.ts"],"names":[],"mappings":"AAMA,OAAO,EAUH,KAAK,OAAO,EACf,MAAM,eAAe,CAAC;AAkUvB,eAAO,MAAM,eAAe,EAAE,SAAS,OAAO,EAc7C,CAAC"}

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

@@ -0,0 +1,265 @@
+// `cloud sandboxes`: create and control project sandboxes, run commands and move files.
+import { randomUUID } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import { unwrap } from '@dexto/cloud-client';
+import { argument, flag, integerOption, PAGE_OPTIONS, pageQuery, requireConsent, stringOption, UsageError, YES_OPTION, } from '../command.js';
+import { formatBytes } from './files.js';
+/** A sandbox by id, for the calls under /v1/sandboxes/{sandbox_id}. */
+function sandboxPath(id) {
+    return { params: { path: { sandbox_id: id } } };
+}
+/** A mutation that may be retried without doing it twice. */
+function once() {
+    return { 'Idempotency-Key': randomUUID() };
+}
+const COLUMNS = [
+    { header: 'id', value: (sandbox) => sandbox.id },
+    { header: 'name', value: (sandbox) => sandbox.name },
+    { header: 'status', value: (sandbox) => sandbox.status },
+    { header: 'size', value: (sandbox) => sandbox.size },
+    { header: 'updated', value: (sandbox) => sandbox.updated_at },
+];
+const list = {
+    options: PAGE_OPTIONS,
+    path: ['cloud', 'sandboxes', 'list'],
+    summary: "List the project's sandboxes.",
+    async run(context, input) {
+        context.output.list(await unwrap(await (await context.client()).GET('/v1/sandboxes', {
+            params: { query: pageQuery(input) },
+        })), COLUMNS);
+    },
+};
+const create = {
+    arguments: '<name>',
+    options: {
+        size: {
+            description: 'The sandbox size; large (4 vCPU, 8 GiB) is the only one.',
+            type: 'string',
+        },
+    },
+    path: ['cloud', 'sandboxes', 'create'],
+    summary: 'Create a sandbox. Start it before running commands in it.',
+    async run(context, input) {
+        const size = stringOption(input, 'size') ?? 'large';
+        if (size !== 'large')
+            throw new UsageError('large is the only sandbox size.');
+        const sandbox = await unwrap(await (await context.client()).POST('/v1/sandboxes', {
+            params: { header: once() },
+            body: { name: argument(input, 0, 'name'), size },
+        }));
+        context.output.result(sandbox, `Created sandbox ${sandbox.id} (${sandbox.name}), ${sandbox.status}.`);
+    },
+};
+const get = {
+    arguments: '<sandbox_id>',
+    path: ['cloud', 'sandboxes', 'get'],
+    summary: 'Show a sandbox.',
+    async run(context, input) {
+        context.output.record(await unwrap(await (await context.client()).GET('/v1/sandboxes/{sandbox_id}', sandboxPath(argument(input, 0, 'sandbox_id')))));
+    },
+};
+function lifecycle(action, summary) {
+    return {
+        arguments: '<sandbox_id>',
+        ...(action === 'delete' ? { options: YES_OPTION } : {}),
+        path: ['cloud', 'sandboxes', action],
+        summary,
+        async run(context, input) {
+            const client = await context.client();
+            const id = argument(input, 0, 'sandbox_id');
+            if (action === 'delete') {
+                await requireConsent(context, flag(input, 'yes'), `Deleting sandbox ${id} deletes its workspace for good.`);
+                const result = await unwrap(await client.DELETE('/v1/sandboxes/{sandbox_id}', {
+                    params: { path: { sandbox_id: id }, header: once() },
+                }));
+                return context.output.result(result, `Deleted sandbox ${id}.`);
+            }
+            const request = { params: { path: { sandbox_id: id }, header: once() } };
+            const sandbox = await unwrap(action === 'start'
+                ? await client.POST('/v1/sandboxes/{sandbox_id}/start', request)
+                : await client.POST('/v1/sandboxes/{sandbox_id}/pause', request));
+            context.output.result(sandbox, `Sandbox ${id} is ${sandbox.status}.`);
+        },
+    };
+}
+const exec = {
+    arguments: '<sandbox_id> <command...>',
+    options: {
+        cwd: { description: 'The working directory (default /workspace).', type: 'string' },
+        timeout: {
+            description: 'Milliseconds to wait, up to 120000 (default 60000).',
+            type: 'string',
+            valueName: 'MS',
+        },
+    },
+    path: ['cloud', 'sandboxes', 'exec'],
+    summary: 'Run a shell command and print its output; exits with its exit code. Put -- before a command with options.',
+    async run(context, input) {
+        const cwd = stringOption(input, 'cwd');
+        const timeout = integerOption(input, 'timeout');
+        const result = await unwrap(await (await context.client()).POST('/v1/sandboxes/{sandbox_id}/processes', {
+            ...sandboxPath(argument(input, 0, 'sandbox_id')),
+            body: {
+                command: input.positionals.slice(1).join(' '),
+                ...(cwd === undefined ? {} : { cwd }),
+                ...(timeout === undefined ? {} : { timeout_ms: timeout }),
+            },
+        }));
+        if (context.output.jsonContent) {
+            context.output.record(result);
+            return result.exit_code;
+        }
+        context.runtime.writeOutput(result.stdout);
+        context.runtime.writeError(result.stderr);
+        if (result.stdout_truncated || result.stderr_truncated)
+            context.output.note('The output was cut short.');
+        return result.exit_code;
+    },
+};
+const ls = {
+    arguments: '<sandbox_id> [path]',
+    options: {
+        depth: { description: 'Levels to list (default 1).', type: 'string', valueName: 'N' },
+    },
+    path: ['cloud', 'sandboxes', 'ls'],
+    summary: 'List a sandbox directory (default /workspace).',
+    async run(context, input) {
+        const directory = input.positionals[1];
+        const depth = integerOption(input, 'depth');
+        const result = await unwrap(await (await context.client()).POST('/v1/sandboxes/{sandbox_id}/files/list', {
+            ...sandboxPath(argument(input, 0, 'sandbox_id')),
+            body: {
+                ...(directory === undefined ? {} : { path: directory }),
+                ...(depth === undefined ? {} : { depth }),
+            },
+        }));
+        context.output.list(result, [
+            {
+                header: 'path',
+                value: (entry) => (entry.is_directory ? `${entry.path}/` : entry.path),
+            },
+            {
+                header: 'size',
+                value: (entry) => (entry.is_directory ? null : formatBytes(entry.size)),
+            },
+            { header: 'modified', value: (entry) => entry.modified_at },
+        ]);
+        if (result.truncated)
+            context.output.note('The listing was cut short.');
+    },
+};
+const cat = {
+    arguments: '<sandbox_id> <path>',
+    path: ['cloud', 'sandboxes', 'cat'],
+    summary: 'Print a UTF-8 sandbox file of up to 1 MiB.',
+    async run(context, input) {
+        const result = await unwrap(await (await context.client()).POST('/v1/sandboxes/{sandbox_id}/files/read', {
+            ...sandboxPath(argument(input, 0, 'sandbox_id')),
+            body: { path: argument(input, 1, 'path') },
+        }));
+        if (context.output.jsonContent)
+            return context.output.record(result);
+        context.runtime.writeOutput(result.content);
+    },
+};
+const write = {
+    arguments: '<sandbox_id> <path>',
+    options: {
+        from: {
+            description: 'Read the content from this local file instead of stdin.',
+            type: 'string',
+            valueName: 'PATH',
+        },
+        parents: { description: 'Create missing directories.', short: 'p', type: 'boolean' },
+    },
+    path: ['cloud', 'sandboxes', 'write'],
+    summary: 'Write a UTF-8 sandbox file of up to 1 MiB from stdin or --from.',
+    async run(context, input) {
+        const from = stringOption(input, 'from');
+        const content = from === undefined ? await context.runtime.readStdin() : await readFile(from, 'utf8');
+        const result = await unwrap(await (await context.client()).POST('/v1/sandboxes/{sandbox_id}/files/write', {
+            ...sandboxPath(argument(input, 0, 'sandbox_id')),
+            body: {
+                content,
+                create_directories: flag(input, 'parents'),
+                path: argument(input, 1, 'path'),
+            },
+        }));
+        context.output.result(result, `Wrote ${formatBytes(result.bytes_written)} to ${result.path}.`);
+    },
+};
+const rm = {
+    arguments: '<sandbox_id> <path>',
+    options: YES_OPTION,
+    path: ['cloud', 'sandboxes', 'rm'],
+    summary: 'Delete a sandbox file.',
+    async run(context, input) {
+        const path = argument(input, 1, 'path');
+        await requireConsent(context, flag(input, 'yes'), `Deleting ${path} can't be undone.`);
+        const result = await unwrap(await (await context.client()).POST('/v1/sandboxes/{sandbox_id}/files/delete', {
+            ...sandboxPath(argument(input, 0, 'sandbox_id')),
+            body: { path },
+        }));
+        context.output.result(result, `Deleted ${path}.`);
+    },
+};
+const importFiles = {
+    arguments: '<sandbox_id> <file_id...>',
+    options: {
+        dir: {
+            description: 'The sandbox directory to copy into (default /workspace).',
+            type: 'string',
+        },
+    },
+    path: ['cloud', 'sandboxes', 'import'],
+    summary: 'Copy project files into a sandbox.',
+    async run(context, input) {
+        const directory = stringOption(input, 'dir');
+        const result = await unwrap(await (await context.client()).POST('/v1/sandboxes/{sandbox_id}/files/import', {
+            ...sandboxPath(argument(input, 0, 'sandbox_id')),
+            body: {
+                file_ids: input.positionals.slice(1),
+                ...(directory === undefined ? {} : { directory }),
+            },
+        }));
+        context.output.list(result, [
+            { header: 'file', value: (entry) => entry.path },
+            { header: 'sandbox path', value: (entry) => entry.sandbox_path },
+            { header: 'size', value: (entry) => formatBytes(entry.size_bytes) },
+        ]);
+    },
+};
+const exportFile = {
+    arguments: '<sandbox_id> <sandbox_path> <file_path>',
+    options: {
+        overwrite: { description: 'Replace a project file at file_path.', type: 'boolean' },
+    },
+    path: ['cloud', 'sandboxes', 'export'],
+    summary: 'Save a sandbox file as a project file.',
+    async run(context, input) {
+        const file = await unwrap(await (await context.client()).POST('/v1/sandboxes/{sandbox_id}/files/export', {
+            ...sandboxPath(argument(input, 0, 'sandbox_id')),
+            body: {
+                file_path: argument(input, 2, 'file_path'),
+                overwrite: flag(input, 'overwrite'),
+                path: argument(input, 1, 'sandbox_path'),
+            },
+        }));
+        context.output.result(file, `Saved ${file.path} (${file.id}).`);
+    },
+};
+export const sandboxCommands = [
+    list,
+    create,
+    get,
+    lifecycle('start', 'Start or resume a sandbox.'),
+    lifecycle('pause', 'Pause a sandbox, keeping its workspace.'),
+    lifecycle('delete', 'Delete a sandbox and its workspace.'),
+    exec,
+    ls,
+    cat,
+    write,
+    rm,
+    importFiles,
+    exportFile,
+];

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"secrets.d.ts","sourceRoot":"","sources":["../../../../src/cli/cloud/commands/secrets.ts"],"names":[],"mappings":"AAGA,OAAO,EAUH,KAAK,OAAO,EAGf,MAAM,eAAe,CAAC;AA8IvB,eAAO,MAAM,cAAc,EAAE,SAAS,OAAO,EAAwC,CAAC"}