dexto 1.6.12 → 1.6.14

package/dist/cli/commands/deploy/index.js

@@ -0,0 +1,283 @@
+import { existsSync } from 'fs';
+import path from 'path';
+import * as p from '@clack/prompts';
+import { findDextoProjectRoot } from '@dexto/agent-management';
+import chalk from 'chalk';
+import open from 'open';
+import { confirmOrExit } from '../../utils/prompt-helpers.js';
+import { createCloudDefaultDeployConfig, createWorkspaceDeployConfig, getDeployConfigPath, isWorkspaceDeployAgent, loadDeployConfig, resolveWorkspaceDeployAgentPath, saveDeployConfig, } from './config.js';
+import { createDeployClient } from './client.js';
+import { discoverPrimaryWorkspaceAgent, isAgentYamlPath } from './entry-agent.js';
+import { getCloudAgentDashboardUrl } from './links.js';
+import { loadWorkspaceDeployLink, removeWorkspaceDeployLink, saveWorkspaceDeployLink, } from './state.js';
+import { createWorkspaceSnapshot } from './snapshot.js';
+function isInteractive(options) {
+    return options?.interactive !== false;
+}
+function describeDeployAgent(config) {
+    if (isWorkspaceDeployAgent(config.agent)) {
+        return `workspace agent (${config.agent.path})`;
+    }
+    return 'default cloud agent';
+}
+function formatCloudAgentSummary(input) {
+    return [
+        `Cloud agent: ${input.cloudAgentId}`,
+        `Status: ${input.status}`,
+        `Agent URL: ${input.agentUrl}`,
+        `Dashboard: ${getCloudAgentDashboardUrl(input.cloudAgentId)}`,
+    ].join('\n');
+}
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function formatCloudAgentStatus(status) {
+    switch (status) {
+        case 'ready':
+            return chalk.green(status);
+        case 'stopped':
+            return chalk.yellow(status);
+        case 'failed':
+        case 'deleted':
+            return chalk.red(status);
+        default:
+            return chalk.cyan(status);
+    }
+}
+function formatCloudAgentListItem(cloudAgent, linkedToWorkspace) {
+    const prefix = linkedToWorkspace ? chalk.green('→') : ' ';
+    const trimmedName = cloudAgent.name?.trim();
+    const heading = trimmedName && trimmedName !== cloudAgent.cloudAgentId
+        ? `${chalk.cyan(trimmedName)} ${chalk.gray(`(${cloudAgent.cloudAgentId})`)}`
+        : chalk.cyan(cloudAgent.cloudAgentId);
+    const status = `${chalk.gray('[')}${formatCloudAgentStatus(cloudAgent.state.status)}${chalk.gray(']')}`;
+    const lines = [`${prefix} ${heading} ${status}`];
+    if (linkedToWorkspace) {
+        lines.push(`  ${chalk.green('Linked to this workspace')}`);
+    }
+    return lines.join('\n');
+}
+function resolveWorkspaceRoot() {
+    return findDextoProjectRoot(process.cwd()) ?? process.cwd();
+}
+async function resolveDeployConfig(workspaceRoot) {
+    const existingConfig = await loadDeployConfig(workspaceRoot);
+    if (existingConfig) {
+        return existingConfig;
+    }
+    const primaryWorkspaceAgent = await discoverPrimaryWorkspaceAgent(workspaceRoot);
+    const nextConfig = primaryWorkspaceAgent
+        ? createWorkspaceDeployConfig(primaryWorkspaceAgent)
+        : createCloudDefaultDeployConfig();
+    await saveDeployConfig(workspaceRoot, nextConfig);
+    p.note(`${describeDeployAgent(nextConfig)}\n${path.relative(workspaceRoot, getDeployConfigPath(workspaceRoot))}`, 'Saved deploy config');
+    return nextConfig;
+}
+function ensureWorkspaceAgentExists(workspaceRoot, config) {
+    if (!isWorkspaceDeployAgent(config.agent)) {
+        return null;
+    }
+    const entryAgentPath = resolveWorkspaceDeployAgentPath(workspaceRoot, config.agent.path);
+    if (!existsSync(entryAgentPath)) {
+        throw new Error(`Workspace agent not found: ${config.agent.path}. Update ${path.relative(workspaceRoot, getDeployConfigPath(workspaceRoot))} before deploying.`);
+    }
+    if (!isAgentYamlPath(config.agent.path)) {
+        throw new Error(`Workspace agent must be a .yml or .yaml file: ${config.agent.path}`);
+    }
+    return entryAgentPath;
+}
+export async function handleDeployCommand(options) {
+    void options;
+    p.intro(chalk.inverse('Deploy Workspace'));
+    const workspaceRoot = resolveWorkspaceRoot();
+    const deployConfig = await resolveDeployConfig(workspaceRoot);
+    ensureWorkspaceAgentExists(workspaceRoot, deployConfig);
+    const deployLink = await loadWorkspaceDeployLink(workspaceRoot);
+    const spinner = p.spinner();
+    const client = createDeployClient();
+    const workspaceSnapshotInput = isWorkspaceDeployAgent(deployConfig.agent)
+        ? {
+            workspaceRoot,
+            workspaceAgentPath: deployConfig.agent.path,
+            exclude: deployConfig.exclude,
+        }
+        : {
+            workspaceRoot,
+            exclude: deployConfig.exclude,
+        };
+    let snapshot = null;
+    try {
+        spinner.start('Packaging workspace snapshot...');
+        snapshot = await createWorkspaceSnapshot({
+            ...workspaceSnapshotInput,
+        });
+        spinner.message('Uploading workspace and provisioning sandbox...');
+        const deployed = await client.deployWorkspace({
+            agent: deployConfig.agent,
+            snapshotPath: snapshot.archivePath,
+            ...(deployLink?.cloudAgentId ? { cloudAgentId: deployLink.cloudAgentId } : {}),
+        });
+        let linkSyncError = null;
+        try {
+            await saveWorkspaceDeployLink(workspaceRoot, {
+                cloudAgentId: deployed.cloudAgentId,
+                agentUrl: deployed.agentUrl,
+            });
+        }
+        catch (error) {
+            linkSyncError = error;
+        }
+        spinner.stop(chalk.green('✓ Workspace deployed'));
+        p.outro([
+            formatCloudAgentSummary({
+                cloudAgentId: deployed.cloudAgentId,
+                status: deployed.state.status,
+                agentUrl: deployed.agentUrl,
+            }),
+            ...(linkSyncError
+                ? [
+                    '',
+                    `Warning: deployment succeeded, but failed to save local link state (${getErrorMessage(linkSyncError)})`,
+                    'Run `dexto deploy` again in this workspace to re-link.',
+                ]
+                : []),
+            '',
+            'Next steps:',
+            `- Open the dashboard to inspect and interact with the deployment`,
+            `- Run \`dexto deploy status\` from this workspace`,
+        ].join('\n'));
+    }
+    catch (error) {
+        spinner.stop(chalk.red('✗ Deploy failed'));
+        throw error;
+    }
+    finally {
+        if (snapshot) {
+            await snapshot.cleanup();
+        }
+    }
+}
+export async function handleDeployListCommand() {
+    const workspaceRoot = resolveWorkspaceRoot();
+    const deployLink = await loadWorkspaceDeployLink(workspaceRoot);
+    const client = createDeployClient();
+    const cloudAgents = await client.listCloudAgents();
+    if (cloudAgents.length === 0) {
+        p.outro('No cloud deployments found.\nRun `dexto deploy` from this workspace to create one.');
+        return;
+    }
+    const linkedCloudAgentId = deployLink?.cloudAgentId ?? null;
+    const sortedCloudAgents = [...cloudAgents].sort((left, right) => {
+        if (left.cloudAgentId === linkedCloudAgentId && right.cloudAgentId !== linkedCloudAgentId) {
+            return -1;
+        }
+        if (right.cloudAgentId === linkedCloudAgentId && left.cloudAgentId !== linkedCloudAgentId) {
+            return 1;
+        }
+        return 0;
+    });
+    const linkedVisible = linkedCloudAgentId !== null &&
+        sortedCloudAgents.some((cloudAgent) => cloudAgent.cloudAgentId === linkedCloudAgentId);
+    const lines = [
+        'Cloud deployments',
+        '',
+        ...sortedCloudAgents.flatMap((cloudAgent, index) => {
+            const entry = formatCloudAgentListItem(cloudAgent, cloudAgent.cloudAgentId === linkedCloudAgentId);
+            return index === 0 ? [entry] : ['', entry];
+        }),
+    ];
+    if (linkedCloudAgentId && !linkedVisible) {
+        lines.push('', chalk.yellow(`This workspace is linked to ${linkedCloudAgentId}, but that deployment was not returned by the cloud API.`));
+    }
+    p.outro(lines.join('\n'));
+}
+export async function handleDeployOpenCommand() {
+    const workspaceRoot = resolveWorkspaceRoot();
+    const deployLink = await loadWorkspaceDeployLink(workspaceRoot);
+    if (!deployLink) {
+        throw new Error('This workspace is not linked to a cloud deployment yet. Run `dexto deploy` first.');
+    }
+    const dashboardUrl = getCloudAgentDashboardUrl(deployLink.cloudAgentId);
+    try {
+        await open(dashboardUrl);
+        p.outro(`Opened dashboard for ${deployLink.cloudAgentId}\n${dashboardUrl}`);
+    }
+    catch (error) {
+        p.outro([
+            `Unable to open the dashboard automatically (${getErrorMessage(error)})`,
+            dashboardUrl,
+        ].join('\n'));
+    }
+}
+export async function handleDeployStatusCommand() {
+    const workspaceRoot = resolveWorkspaceRoot();
+    const deployLink = await loadWorkspaceDeployLink(workspaceRoot);
+    if (!deployLink) {
+        throw new Error('This workspace is not linked to a cloud deployment yet. Run `dexto deploy` first.');
+    }
+    const client = createDeployClient();
+    const status = await client.getCloudAgent(deployLink.cloudAgentId);
+    p.outro(formatCloudAgentSummary({
+        cloudAgentId: status.cloudAgentId,
+        status: status.state.status,
+        agentUrl: status.agentUrl,
+    }));
+}
+export async function handleDeployStopCommand() {
+    const workspaceRoot = resolveWorkspaceRoot();
+    const deployLink = await loadWorkspaceDeployLink(workspaceRoot);
+    if (!deployLink) {
+        throw new Error('This workspace is not linked to a cloud deployment yet. Run `dexto deploy` first.');
+    }
+    const spinner = p.spinner();
+    spinner.start('Stopping cloud sandbox...');
+    try {
+        const client = createDeployClient();
+        const result = await client.stopCloudAgent(deployLink.cloudAgentId);
+        spinner.stop(chalk.green('✓ Cloud sandbox stopped'));
+        p.outro([
+            `Cloud agent: ${result.cloudAgentId}`,
+            `Stopped: ${result.stopped ? 'yes' : 'no'}`,
+            `Already stopped: ${result.alreadyStopped ? 'yes' : 'no'}`,
+            `Snapshot status: ${result.snapshotStatus}`,
+        ].join('\n'));
+    }
+    catch (error) {
+        spinner.stop(chalk.red('✗ Stop failed'));
+        throw error;
+    }
+}
+export async function handleDeployDeleteCommand(options) {
+    const workspaceRoot = resolveWorkspaceRoot();
+    const deployLink = await loadWorkspaceDeployLink(workspaceRoot);
+    if (!deployLink) {
+        throw new Error('This workspace is not linked to a cloud deployment yet. Run `dexto deploy` first.');
+    }
+    if (isInteractive(options)) {
+        await confirmOrExit({
+            message: `Delete cloud deployment ${deployLink.cloudAgentId}?`,
+            initialValue: false,
+        }, 'Delete cancelled');
+    }
+    const spinner = p.spinner();
+    spinner.start('Deleting cloud deployment...');
+    try {
+        const client = createDeployClient();
+        const result = await client.deleteCloudAgent(deployLink.cloudAgentId);
+        let linkRemoveError = null;
+        try {
+            await removeWorkspaceDeployLink(workspaceRoot);
+        }
+        catch (error) {
+            linkRemoveError = error;
+        }
+        spinner.stop(chalk.green('✓ Cloud deployment deleted'));
+        p.outro(linkRemoveError
+            ? `Deleted ${result.cloudAgentId}\nWarning: failed to remove local deploy link state (${getErrorMessage(linkRemoveError)})`
+            : `Deleted ${result.cloudAgentId}`);
+    }
+    catch (error) {
+        spinner.stop(chalk.red('✗ Delete failed'));
+        throw error;
+    }
+}

package/dist/cli/commands/deploy/links.d.ts

@@ -0,0 +1,3 @@
+export declare function resolveDashboardBaseUrl(): string;
+export declare function getCloudAgentDashboardUrl(cloudAgentId: string): string;
+//# sourceMappingURL=links.d.ts.map

package/dist/cli/commands/deploy/links.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"links.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/deploy/links.ts"],"names":[],"mappings":"AAgCA,wBAAgB,uBAAuB,IAAI,MAAM,CA2BhD;AAED,wBAAgB,yBAAyB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAEtE"}

package/dist/cli/commands/deploy/links.js

@@ -0,0 +1,53 @@
+const APP_URL_ENV_VAR = 'DEXTO_APP_URL';
+const SANDBOX_URL_ENV_VAR = 'DEXTO_SANDBOX_URL';
+const DEFAULT_APP_URL = 'https://app.dexto.ai';
+const LOCAL_DASHBOARD_URL = 'http://localhost:5173';
+function normalizeBaseUrl(value) {
+    const trimmed = value?.trim();
+    if (!trimmed) {
+        return null;
+    }
+    try {
+        const url = new URL(trimmed);
+        url.pathname = '';
+        url.search = '';
+        url.hash = '';
+        return url.toString().replace(/\/$/, '');
+    }
+    catch {
+        return null;
+    }
+}
+function isLocalHostUrl(value) {
+    const normalized = normalizeBaseUrl(value);
+    if (!normalized) {
+        return false;
+    }
+    const hostname = new URL(normalized).hostname;
+    return hostname === 'localhost' || hostname === '127.0.0.1';
+}
+export function resolveDashboardBaseUrl() {
+    const explicitAppUrl = normalizeBaseUrl(process.env[APP_URL_ENV_VAR]);
+    if (explicitAppUrl) {
+        return explicitAppUrl;
+    }
+    if (isLocalHostUrl(process.env[SANDBOX_URL_ENV_VAR]) ||
+        isLocalHostUrl(process.env.DEXTO_API_URL)) {
+        return LOCAL_DASHBOARD_URL;
+    }
+    const normalizedApiUrl = normalizeBaseUrl(process.env.DEXTO_API_URL);
+    if (normalizedApiUrl) {
+        const apiUrl = new URL(normalizedApiUrl);
+        if (apiUrl.hostname === 'api.dexto.ai') {
+            return DEFAULT_APP_URL;
+        }
+        if (apiUrl.hostname.startsWith('api.')) {
+            apiUrl.hostname = `app.${apiUrl.hostname.slice('api.'.length)}`;
+            return apiUrl.toString().replace(/\/$/, '');
+        }
+    }
+    return DEFAULT_APP_URL;
+}
+export function getCloudAgentDashboardUrl(cloudAgentId) {
+    return `${resolveDashboardBaseUrl()}/dashboard/cloud-agents/${encodeURIComponent(cloudAgentId)}`;
+}

package/dist/cli/commands/deploy/register.d.ts

@@ -0,0 +1,6 @@
+import type { Command } from 'commander';
+export interface DeployCommandRegisterContext {
+    program: Command;
+}
+export declare function registerDeployCommand({ program }: DeployCommandRegisterContext): void;
+//# sourceMappingURL=register.d.ts.map

package/dist/cli/commands/deploy/register.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/deploy/register.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGzC,MAAM,WAAW,4BAA4B;IACzC,OAAO,EAAE,OAAO,CAAC;CACpB;AAED,wBAAgB,qBAAqB,CAAC,EAAE,OAAO,EAAE,EAAE,4BAA4B,GAAG,IAAI,CAqHrF"}

package/dist/cli/commands/deploy/register.js

@@ -0,0 +1,109 @@
+import { ExitSignal, safeExit, withAnalytics } from '../../../analytics/wrapper.js';
+export function registerDeployCommand({ program }) {
+    const deployCommand = program
+        .command('deploy')
+        .description('Deploy the current workspace to a cloud sandbox');
+    deployCommand.addHelpText('after', `
+Examples:
+  $ dexto deploy
+  $ dexto deploy list
+  $ dexto deploy open
+  $ dexto deploy status
+  $ dexto deploy stop
+  $ dexto deploy delete
+`);
+    deployCommand.option('--no-interactive', 'Disable interactive prompts').action(withAnalytics('deploy', async (options) => {
+        try {
+            const { handleDeployCommand } = await import('./index.js');
+            await handleDeployCommand(options);
+            safeExit('deploy', 0);
+        }
+        catch (err) {
+            if (err instanceof ExitSignal)
+                throw err;
+            console.error(`❌ dexto deploy command failed: ${err}`);
+            safeExit('deploy', 1, 'error');
+        }
+    }));
+    deployCommand
+        .command('list')
+        .description('List cloud deployments for your account')
+        .action(withAnalytics('deploy list', async () => {
+        try {
+            const { handleDeployListCommand } = await import('./index.js');
+            await handleDeployListCommand();
+            safeExit('deploy list', 0);
+        }
+        catch (err) {
+            if (err instanceof ExitSignal)
+                throw err;
+            console.error(`❌ dexto deploy list command failed: ${err}`);
+            safeExit('deploy list', 1, 'error');
+        }
+    }));
+    deployCommand
+        .command('open')
+        .description('Open the linked cloud deployment in the dashboard')
+        .action(withAnalytics('deploy open', async () => {
+        try {
+            const { handleDeployOpenCommand } = await import('./index.js');
+            await handleDeployOpenCommand();
+            safeExit('deploy open', 0);
+        }
+        catch (err) {
+            if (err instanceof ExitSignal)
+                throw err;
+            console.error(`❌ dexto deploy open command failed: ${err}`);
+            safeExit('deploy open', 1, 'error');
+        }
+    }));
+    deployCommand
+        .command('status')
+        .description('Show the linked cloud deployment for the current workspace')
+        .action(withAnalytics('deploy status', async () => {
+        try {
+            const { handleDeployStatusCommand } = await import('./index.js');
+            await handleDeployStatusCommand();
+            safeExit('deploy status', 0);
+        }
+        catch (err) {
+            if (err instanceof ExitSignal)
+                throw err;
+            console.error(`❌ dexto deploy status command failed: ${err}`);
+            safeExit('deploy status', 1, 'error');
+        }
+    }));
+    deployCommand
+        .command('stop')
+        .description('Stop the linked cloud sandbox for the current workspace')
+        .action(withAnalytics('deploy stop', async () => {
+        try {
+            const { handleDeployStopCommand } = await import('./index.js');
+            await handleDeployStopCommand();
+            safeExit('deploy stop', 0);
+        }
+        catch (err) {
+            if (err instanceof ExitSignal)
+                throw err;
+            console.error(`❌ dexto deploy stop command failed: ${err}`);
+            safeExit('deploy stop', 1, 'error');
+        }
+    }));
+    deployCommand
+        .command('delete')
+        .description('Delete the linked cloud deployment and unlink this workspace')
+        .option('--no-interactive', 'Disable confirmation prompts')
+        .action(withAnalytics('deploy delete', async (options) => {
+        try {
+            const { handleDeployDeleteCommand } = await import('./index.js');
+            await handleDeployDeleteCommand(options);
+            safeExit('deploy delete', 0);
+        }
+        catch (err) {
+            if (err instanceof ExitSignal)
+                throw err;
+            console.error(`❌ dexto deploy delete command failed: ${err}`);
+            safeExit('deploy delete', 1, 'error');
+        }
+    }));
+}

package/dist/cli/commands/deploy/snapshot.d.ts

@@ -0,0 +1,12 @@
+export interface WorkspaceSnapshotResult {
+    archivePath: string;
+    sizeBytes: number;
+    cleanup: () => Promise<void>;
+}
+export declare function shouldExcludeRelativePath(relativePath: string, excludePatterns: string[]): boolean;
+export declare function createWorkspaceSnapshot(input: {
+    workspaceRoot: string;
+    workspaceAgentPath?: string;
+    exclude: string[];
+}): Promise<WorkspaceSnapshotResult>;
+//# sourceMappingURL=snapshot.d.ts.map

package/dist/cli/commands/deploy/snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/deploy/snapshot.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,uBAAuB;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAChC;AAiBD,wBAAgB,yBAAyB,CACrC,YAAY,EAAE,MAAM,EACpB,eAAe,EAAE,MAAM,EAAE,GAC1B,OAAO,CAoBT;AAED,wBAAsB,uBAAuB,CAAC,KAAK,EAAE;IACjD,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,OAAO,EAAE,MAAM,EAAE,CAAC;CACrB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAiDnC"}

package/dist/cli/commands/deploy/snapshot.js

@@ -0,0 +1,76 @@
+import { promises as fs } from 'fs';
+import os from 'os';
+import path from 'path';
+import { minimatch } from 'minimatch';
+import { create as createTar } from 'tar';
+import { normalizeWorkspaceRelativePath } from './config.js';
+function normalizeArchivePath(value) {
+    return value
+        .replace(/\\/g, '/')
+        .replace(/^\.\/+/, '')
+        .replace(/\/+$/, '');
+}
+function normalizeExcludePattern(value) {
+    return value
+        .trim()
+        .replace(/\\/g, '/')
+        .replace(/^\.\/+/, '')
+        .replace(/\/+$/, '');
+}
+export function shouldExcludeRelativePath(relativePath, excludePatterns) {
+    const normalizedRelativePath = normalizeWorkspaceRelativePath(relativePath);
+    const basename = path.posix.basename(normalizedRelativePath);
+    return excludePatterns.some((pattern) => {
+        const normalizedPattern = normalizeExcludePattern(pattern);
+        if (normalizedPattern.length === 0) {
+            return false;
+        }
+        if (normalizedRelativePath === normalizedPattern ||
+            normalizedRelativePath.startsWith(`${normalizedPattern}/`)) {
+            return true;
+        }
+        return (minimatch(normalizedRelativePath, normalizedPattern, { dot: true }) ||
+            minimatch(basename, normalizedPattern, { dot: true }));
+    });
+}
+export async function createWorkspaceSnapshot(input) {
+    const workspaceRoot = path.resolve(input.workspaceRoot);
+    const workspaceAgentPath = typeof input.workspaceAgentPath === 'string'
+        ? normalizeWorkspaceRelativePath(input.workspaceAgentPath)
+        : null;
+    if (workspaceAgentPath && shouldExcludeRelativePath(workspaceAgentPath, input.exclude)) {
+        throw new Error(`Deploy config excludes the selected workspace agent: ${workspaceAgentPath}. Remove it from exclude before deploying.`);
+    }
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'dexto-deploy-'));
+    const archivePath = path.join(tempDir, 'workspace.tar.gz');
+    const topLevelEntries = await fs.readdir(workspaceRoot);
+    try {
+        await createTar({
+            cwd: workspaceRoot,
+            file: archivePath,
+            gzip: true,
+            portable: true,
+            noMtime: true,
+            prefix: 'workspace',
+            filter: (entryPath) => {
+                const relativePath = normalizeArchivePath(entryPath);
+                if (relativePath.length === 0) {
+                    return false;
+                }
+                return !shouldExcludeRelativePath(relativePath, input.exclude);
+            },
+        }, topLevelEntries);
+        const stats = await fs.stat(archivePath);
+        return {
+            archivePath,
+            sizeBytes: stats.size,
+            cleanup: async () => {
+                await fs.rm(tempDir, { recursive: true, force: true });
+            },
+        };
+    }
+    catch (error) {
+        await fs.rm(tempDir, { recursive: true, force: true });
+        throw error;
+    }
+}

package/dist/cli/commands/deploy/state.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+declare const DeployLinkSchema: z.ZodObject<{
+    cloudAgentId: z.ZodString;
+    agentUrl: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    cloudAgentId: string;
+    updatedAt: string;
+    agentUrl?: string | undefined;
+}, {
+    cloudAgentId: string;
+    updatedAt: string;
+    agentUrl?: string | undefined;
+}>;
+export type DeployLink = z.output<typeof DeployLinkSchema>;
+type DeployLinkInput = Pick<z.input<typeof DeployLinkSchema>, 'cloudAgentId' | 'agentUrl'>;
+export declare function loadWorkspaceDeployLink(workspaceRoot: string): Promise<DeployLink | null>;
+export declare function saveWorkspaceDeployLink(workspaceRoot: string, link: DeployLinkInput): Promise<void>;
+export declare function removeWorkspaceDeployLink(workspaceRoot: string): Promise<void>;
+export {};
+//# sourceMappingURL=state.d.ts.map

package/dist/cli/commands/deploy/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/deploy/state.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,QAAA,MAAM,gBAAgB;;;;;;;;;;;;EAMT,CAAC;AASd,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC3D,KAAK,eAAe,GAAG,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,EAAE,cAAc,GAAG,UAAU,CAAC,CAAC;AA4F3F,wBAAsB,uBAAuB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAG/F;AAED,wBAAsB,uBAAuB,CACzC,aAAa,EAAE,MAAM,EACrB,IAAI,EAAE,eAAe,GACtB,OAAO,CAAC,IAAI,CAAC,CAUf;AAED,wBAAsB,yBAAyB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAMpF"}