dexto 1.6.12 → 1.6.13

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

@@ -0,0 +1,204 @@
+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 { 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 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 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,CAiFrF"}

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

@@ -0,0 +1,75 @@
+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 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('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"}

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

@@ -0,0 +1,122 @@
+import { existsSync, promises as fs } from 'fs';
+import path from 'path';
+import { setTimeout as delay } from 'timers/promises';
+import { getDextoGlobalPath } from '@dexto/core';
+import { z } from 'zod';
+const DEPLOY_LINKS_FILENAME = 'links.json';
+const DEPLOY_LOCK_SUFFIX = '.lock';
+const DEPLOY_LOCK_RETRY_MS = 25;
+const DEPLOY_LOCK_TIMEOUT_MS = 5_000;
+const DEPLOY_LOCK_STALE_MS = DEPLOY_LOCK_TIMEOUT_MS;
+const DeployLinkSchema = z
+    .object({
+    cloudAgentId: z.string().trim().min(1),
+    agentUrl: z.string().trim().min(1).optional(),
+    updatedAt: z.string().datetime(),
+})
+    .strict();
+const DeployStateSchema = z
+    .object({
+    version: z.literal(1).default(1),
+    links: z.record(z.string(), DeployLinkSchema).default({}),
+})
+    .strict();
+function getDeployLinksPath() {
+    return getDextoGlobalPath('deployments', DEPLOY_LINKS_FILENAME);
+}
+function getDeployLockPath(filePath) {
+    return `${filePath}${DEPLOY_LOCK_SUFFIX}`;
+}
+function normalizeWorkspaceKey(workspaceRoot) {
+    return path.resolve(workspaceRoot);
+}
+async function loadDeployStateFromPath(filePath) {
+    if (!existsSync(filePath)) {
+        return DeployStateSchema.parse({ version: 1, links: {} });
+    }
+    const raw = await fs.readFile(filePath, 'utf8');
+    return DeployStateSchema.parse(JSON.parse(raw));
+}
+async function loadDeployState() {
+    return loadDeployStateFromPath(getDeployLinksPath());
+}
+async function writeDeployStateAtomic(filePath, state) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    const tempPath = `${filePath}.tmp.${process.pid}.${Date.now()}`;
+    try {
+        await fs.writeFile(tempPath, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+        await fs.rename(tempPath, filePath);
+    }
+    catch (error) {
+        await fs.rm(tempPath, { force: true }).catch(() => undefined);
+        throw error;
+    }
+}
+async function reclaimStaleDeployLock(lockPath) {
+    try {
+        const stat = await fs.stat(lockPath);
+        if (Date.now() - stat.mtimeMs < DEPLOY_LOCK_STALE_MS) {
+            return false;
+        }
+        await fs.rm(lockPath, { recursive: true, force: true });
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return true;
+        }
+        throw error;
+    }
+}
+async function withDeployStateLock(operation) {
+    const filePath = getDeployLinksPath();
+    const lockPath = getDeployLockPath(filePath);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    const deadline = Date.now() + DEPLOY_LOCK_TIMEOUT_MS;
+    for (;;) {
+        try {
+            await fs.mkdir(lockPath);
+            break;
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST') {
+                throw error;
+            }
+            if (await reclaimStaleDeployLock(lockPath)) {
+                continue;
+            }
+            if (Date.now() >= deadline) {
+                throw new Error(`Timed out waiting for deploy state lock: ${lockPath}`);
+            }
+            await delay(DEPLOY_LOCK_RETRY_MS);
+        }
+    }
+    try {
+        return await operation(filePath);
+    }
+    finally {
+        await fs.rm(lockPath, { recursive: true, force: true });
+    }
+}
+export async function loadWorkspaceDeployLink(workspaceRoot) {
+    const state = await loadDeployState();
+    return state.links[normalizeWorkspaceKey(workspaceRoot)] ?? null;
+}
+export async function saveWorkspaceDeployLink(workspaceRoot, link) {
+    await withDeployStateLock(async (filePath) => {
+        const state = await loadDeployStateFromPath(filePath);
+        state.links[normalizeWorkspaceKey(workspaceRoot)] = DeployLinkSchema.parse({
+            cloudAgentId: link.cloudAgentId,
+            agentUrl: link.agentUrl,
+            updatedAt: new Date().toISOString(),
+        });
+        await writeDeployStateAtomic(filePath, state);
+    });
+}
+export async function removeWorkspaceDeployLink(workspaceRoot) {
+    await withDeployStateLock(async (filePath) => {
+        const state = await loadDeployStateFromPath(filePath);
+        delete state.links[normalizeWorkspaceKey(workspaceRoot)];
+        await writeDeployStateAtomic(filePath, state);
+    });
+}

package/dist/cli/commands/index.d.ts

@@ -2,11 +2,13 @@ export { createDextoProject, type CreateAppOptions } from './create-app.js';
 export { createImage } from './create-image.js';
 export { getUserInputToInitDextoApp, initDexto, postInitDexto } from './init-app.js';
 export { handleSetupCommand, type CLISetupOptions, type CLISetupOptionsInput } from './setup.js';
-export { handleInstallCommand, type InstallCommandOptions } from './install.js';
-export { handleUninstallCommand, type UninstallCommandOptions } from './uninstall.js';
-export { handleListAgentsCommand, type ListAgentsCommandOptions, type ListAgentsCommandOptionsInput, } from './list-agents.js';
+export { handleInstallCommand, type InstallCommandOptions } from './agents/install.js';
+export { handleUninstallCommand, type UninstallCommandOptions } from './agents/uninstall.js';
+export { handleUpgradeCommand, type UpgradeCommandOptions } from './upgrade.js';
+export { handleUninstallCliCommand, type UninstallCliCommandOptions } from './uninstall.js';
+export { handleListAgentsCommand, type ListAgentsCommandOptions, type ListAgentsCommandOptionsInput, } from './agents/list.js';
 export { handleWhichCommand, type WhichCommandOptions } from './which.js';
-export { handleSyncAgentsCommand, shouldPromptForSync, type SyncAgentsCommandOptions, } from './sync-agents.js';
+export { handleSyncAgentsCommand, shouldPromptForSync, type SyncAgentsCommandOptions, } from './agents/sync.js';
 export { handleImageInstallCommand, handleImageListCommand, handleImageUseCommand, handleImageRemoveCommand, handleImageDoctorCommand, type ImageInstallCommandOptions, type ImageInstallCommandOptionsInput, } from './image.js';
 export { handleLoginCommand, handleLogoutCommand, handleStatusCommand } from './auth/index.js';
 export { handleBillingStatusCommand } from './billing/index.js';

package/dist/cli/commands/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,kBAAkB,EAAE,KAAK,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAE5E,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,EAAE,0BAA0B,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAErF,OAAO,EAAE,kBAAkB,EAAE,KAAK,eAAe,EAAE,KAAK,oBAAoB,EAAE,MAAM,YAAY,CAAC;AACjG,OAAO,EAAE,oBAAoB,EAAE,KAAK,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAChF,OAAO,EAAE,sBAAsB,EAAE,KAAK,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AACtF,OAAO,EACH,uBAAuB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,6BAA6B,GACrC,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,kBAAkB,EAAE,KAAK,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAC1E,OAAO,EACH,uBAAuB,EACvB,mBAAmB,EACnB,KAAK,wBAAwB,GAChC,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACH,yBAAyB,EACzB,sBAAsB,EACtB,qBAAqB,EACrB,wBAAwB,EACxB,wBAAwB,EACxB,KAAK,0BAA0B,EAC/B,KAAK,+BAA+B,GACvC,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAG/F,OAAO,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AAGhE,OAAO,EACH,uBAAuB,EACvB,0BAA0B,EAC1B,4BAA4B,EAC5B,2BAA2B,EAE3B,2BAA2B,EAC3B,8BAA8B,EAC9B,8BAA8B,EAC9B,4BAA4B,EAC5B,+BAA+B,EAC/B,+BAA+B,EAC/B,KAAK,wBAAwB,EAC7B,KAAK,6BAA6B,EAClC,KAAK,2BAA2B,EAChC,KAAK,gCAAgC,EACrC,KAAK,6BAA6B,EAClC,KAAK,kCAAkC,EACvC,KAAK,4BAA4B,EACjC,KAAK,iCAAiC,EAEtC,KAAK,iCAAiC,EACtC,KAAK,oCAAoC,EACzC,KAAK,oCAAoC,EACzC,KAAK,kCAAkC,EACvC,KAAK,qCAAqC,GAC7C,MAAM,aAAa,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,kBAAkB,EAAE,KAAK,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAE5E,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,EAAE,0BAA0B,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAErF,OAAO,EAAE,kBAAkB,EAAE,KAAK,eAAe,EAAE,KAAK,oBAAoB,EAAE,MAAM,YAAY,CAAC;AACjG,OAAO,EAAE,oBAAoB,EAAE,KAAK,qBAAqB,EAAE,MAAM,qBAAqB,CAAC;AACvF,OAAO,EAAE,sBAAsB,EAAE,KAAK,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAC7F,OAAO,EAAE,oBAAoB,EAAE,KAAK,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAChF,OAAO,EAAE,yBAAyB,EAAE,KAAK,0BAA0B,EAAE,MAAM,gBAAgB,CAAC;AAC5F,OAAO,EACH,uBAAuB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,6BAA6B,GACrC,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,kBAAkB,EAAE,KAAK,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAC1E,OAAO,EACH,uBAAuB,EACvB,mBAAmB,EACnB,KAAK,wBAAwB,GAChC,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACH,yBAAyB,EACzB,sBAAsB,EACtB,qBAAqB,EACrB,wBAAwB,EACxB,wBAAwB,EACxB,KAAK,0BAA0B,EAC/B,KAAK,+BAA+B,GACvC,MAAM,YAAY,CAAC;AAGpB,OAAO,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAG/F,OAAO,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AAGhE,OAAO,EACH,uBAAuB,EACvB,0BAA0B,EAC1B,4BAA4B,EAC5B,2BAA2B,EAE3B,2BAA2B,EAC3B,8BAA8B,EAC9B,8BAA8B,EAC9B,4BAA4B,EAC5B,+BAA+B,EAC/B,+BAA+B,EAC/B,KAAK,wBAAwB,EAC7B,KAAK,6BAA6B,EAClC,KAAK,2BAA2B,EAChC,KAAK,gCAAgC,EACrC,KAAK,6BAA6B,EAClC,KAAK,kCAAkC,EACvC,KAAK,4BAA4B,EACjC,KAAK,iCAAiC,EAEtC,KAAK,iCAAiC,EACtC,KAAK,oCAAoC,EACzC,KAAK,oCAAoC,EACzC,KAAK,kCAAkC,EACvC,KAAK,qCAAqC,GAC7C,MAAM,aAAa,CAAC"}

package/dist/cli/commands/index.js

@@ -4,11 +4,13 @@ export { createDextoProject } from './create-app.js';
 export { createImage } from './create-image.js';
 export { getUserInputToInitDextoApp, initDexto, postInitDexto } from './init-app.js';
 export { handleSetupCommand } from './setup.js';
-export { handleInstallCommand } from './install.js';
-export { handleUninstallCommand } from './uninstall.js';
-export { handleListAgentsCommand, } from './list-agents.js';
+export { handleInstallCommand } from './agents/install.js';
+export { handleUninstallCommand } from './agents/uninstall.js';
+export { handleUpgradeCommand } from './upgrade.js';
+export { handleUninstallCliCommand } from './uninstall.js';
+export { handleListAgentsCommand, } from './agents/list.js';
 export { handleWhichCommand } from './which.js';
-export { handleSyncAgentsCommand, shouldPromptForSync, } from './sync-agents.js';
+export { handleSyncAgentsCommand, shouldPromptForSync, } from './agents/sync.js';
 // Image commands
 export { handleImageInstallCommand, handleImageListCommand, handleImageUseCommand, handleImageRemoveCommand, handleImageDoctorCommand, } from './image.js';
 // Auth commands

package/dist/cli/commands/setup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/setup.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAuDxB,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0ClB,CAAC;AAEP,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAClE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AA6JtE;;GAEG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,OAAO,CAAC,oBAAoB,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAmC9F"}
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/setup.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA6DxB,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0ClB,CAAC;AAEP,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAClE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AA6JtE;;GAEG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,OAAO,CAAC,oBAAoB,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAmC9F"}