dexto 1.14.4 → 2.0.0-beta.0

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

@@ -1,144 +0,0 @@
-import { existsSync, promises as fs } from 'fs';
-import path from 'path';
-import { z } from 'zod';
-export const DEPLOY_CONFIG_RELATIVE_PATH = path.join('.dexto', 'deploy.json');
-export const DEFAULT_DEPLOY_EXCLUDES = [
-    '.git',
-    'node_modules',
-    'dist',
-    '.next',
-    '.turbo',
-    '.env*',
-];
-export function normalizeWorkspaceRelativePath(value) {
-    const trimmed = value.trim().replace(/\\/g, '/');
-    if (trimmed.length === 0) {
-        throw new Error('Path must not be empty');
-    }
-    if (path.posix.isAbsolute(trimmed)) {
-        throw new Error('Path must be relative to the workspace root');
-    }
-    const normalized = path.posix.normalize(trimmed);
-    if (normalized === '.' || normalized.length === 0) {
-        throw new Error('Path must point to a file inside the workspace');
-    }
-    if (normalized === '..' || normalized.startsWith('../')) {
-        throw new Error('Path must stay inside the workspace');
-    }
-    return normalized;
-}
-const WorkspaceRelativePathSchema = z
-    .string()
-    .trim()
-    .min(1)
-    .transform((value, ctx) => {
-    try {
-        return normalizeWorkspaceRelativePath(value);
-    }
-    catch (error) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: error instanceof Error ? error.message : 'Invalid workspace-relative path',
-        });
-        return z.NEVER;
-    }
-});
-const CloudDefaultDeployAgentSchema = z
-    .object({
-    type: z.literal('cloud-default'),
-})
-    .strict();
-const WorkspaceDeployAgentSchema = z
-    .object({
-    type: z.literal('workspace'),
-    path: WorkspaceRelativePathSchema.describe('Repo-relative path to the agent YAML that should boot in cloud'),
-})
-    .strict();
-export const DeployAgentSchema = z.discriminatedUnion('type', [
-    CloudDefaultDeployAgentSchema,
-    WorkspaceDeployAgentSchema,
-]);
-export const DeployConfigSchema = z
-    .object({
-    version: z.literal(1).default(1),
-    agent: DeployAgentSchema,
-    exclude: z.array(z.string().trim().min(1)).default([...DEFAULT_DEPLOY_EXCLUDES]),
-})
-    .strict();
-const LegacyDeployConfigSchema = z
-    .object({
-    version: z.literal(1).default(1),
-    entryAgent: WorkspaceRelativePathSchema.describe('Repo-relative path to the agent YAML that should boot in cloud'),
-    exclude: z.array(z.string().trim().min(1)).default([...DEFAULT_DEPLOY_EXCLUDES]),
-})
-    .strict();
-export function getDeployConfigPath(workspaceRoot) {
-    return path.join(workspaceRoot, DEPLOY_CONFIG_RELATIVE_PATH);
-}
-export async function loadDeployConfig(workspaceRoot) {
-    const configPath = getDeployConfigPath(workspaceRoot);
-    if (!existsSync(configPath)) {
-        return null;
-    }
-    const raw = await fs.readFile(configPath, 'utf8');
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch (error) {
-        throw new Error(`Failed to parse deploy config at ${configPath}: ${error instanceof Error ? error.message : 'Invalid JSON'}`);
-    }
-    return parseDeployConfig(parsed);
-}
-export async function saveDeployConfig(workspaceRoot, config) {
-    const normalized = DeployConfigSchema.parse(config);
-    const configPath = getDeployConfigPath(workspaceRoot);
-    await fs.mkdir(path.dirname(configPath), { recursive: true });
-    await fs.writeFile(configPath, `${JSON.stringify(normalized, null, 2)}\n`, 'utf8');
-    return normalized;
-}
-function parseDeployConfig(value) {
-    const parsed = DeployConfigSchema.safeParse(value);
-    if (parsed.success) {
-        return parsed.data;
-    }
-    const legacyParsed = LegacyDeployConfigSchema.safeParse(value);
-    if (legacyParsed.success) {
-        return createWorkspaceDeployConfig(legacyParsed.data.entryAgent, legacyParsed.data.exclude);
-    }
-    throw parsed.error;
-}
-export function createCloudDefaultDeployConfig(exclude = DEFAULT_DEPLOY_EXCLUDES) {
-    return DeployConfigSchema.parse({
-        version: 1,
-        agent: {
-            type: 'cloud-default',
-        },
-        exclude: [...exclude],
-    });
-}
-export function createWorkspaceDeployConfig(agentPath, exclude = DEFAULT_DEPLOY_EXCLUDES) {
-    return DeployConfigSchema.parse({
-        version: 1,
-        agent: {
-            type: 'workspace',
-            path: agentPath,
-        },
-        exclude: [...exclude],
-    });
-}
-export function isWorkspaceDeployAgent(agent) {
-    return agent.type === 'workspace';
-}
-export function resolveWorkspaceDeployAgentPath(workspaceRoot, agentPath) {
-    const normalizedAgentPath = normalizeWorkspaceRelativePath(agentPath);
-    const resolvedPath = path.resolve(workspaceRoot, normalizedAgentPath);
-    const relativeToWorkspace = path.relative(path.resolve(workspaceRoot), resolvedPath);
-    if (relativeToWorkspace.length === 0 ||
-        relativeToWorkspace === '..' ||
-        relativeToWorkspace.startsWith(`..${path.sep}`) ||
-        path.isAbsolute(relativeToWorkspace)) {
-        throw new Error(`Workspace agent path must stay inside the workspace: ${agentPath}`);
-    }
-    return resolvedPath;
-}

package/dist/cli/commands/deploy/entry-agent.d.ts

@@ -1,3 +0,0 @@
-export declare function isAgentYamlPath(filePath: string): boolean;
-export declare function discoverPrimaryWorkspaceAgent(workspaceRoot: string): Promise<string | null>;
-//# sourceMappingURL=entry-agent.d.ts.map

package/dist/cli/commands/deploy/entry-agent.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"entry-agent.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/deploy/entry-agent.ts"],"names":[],"mappings":"AAiFA,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED,wBAAsB,6BAA6B,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAuBjG"}

package/dist/cli/commands/deploy/entry-agent.js

@@ -1,70 +0,0 @@
-import { findProjectRegistryPath, getDefaultProjectRegistryEntry, readProjectRegistry, } from '@dexto/agent-management';
-import { existsSync, promises as fs } from 'fs';
-import path from 'path';
-import { normalizeWorkspaceRelativePath } from './config.js';
-const PRIMARY_WORKSPACE_AGENT_PATHS = [
-    path.join('agents', 'coding-agent', 'coding-agent.yml'),
-    path.join('agents', 'coding-agent', 'coding-agent.yaml'),
-    path.join('agents', 'coding-agent.yml'),
-    path.join('agents', 'coding-agent.yaml'),
-];
-async function loadWorkspaceProjectRegistry(workspaceRoot) {
-    const registryPath = await findProjectRegistryPath(workspaceRoot);
-    if (!registryPath) {
-        return null;
-    }
-    const registry = await readProjectRegistry(registryPath);
-    const defaultEntry = getDefaultProjectRegistryEntry(registry, registryPath);
-    if (!defaultEntry) {
-        return null;
-    }
-    return {
-        registryPath,
-        defaultConfigPath: await resolveWorkspaceRegistryConfigPath(workspaceRoot, registryPath, defaultEntry.configPath, defaultEntry.id),
-    };
-}
-async function resolveWorkspaceRegistryConfigPath(workspaceRoot, registryPath, configPath, agentId) {
-    const normalizedPath = normalizeWorkspaceRelativePath(configPath);
-    const absolutePath = path.resolve(path.dirname(registryPath), normalizedPath);
-    const relativeToWorkspace = path.relative(workspaceRoot, absolutePath);
-    if (relativeToWorkspace.startsWith('..') ||
-        path.isAbsolute(relativeToWorkspace) ||
-        relativeToWorkspace === '') {
-        throw new Error(`Agent '${agentId}' in ${registryPath} has invalid configPath '${configPath}': path must stay inside the workspace root.`);
-    }
-    let stat;
-    try {
-        stat = await fs.stat(absolutePath);
-    }
-    catch (error) {
-        if (error.code === 'ENOENT') {
-            throw new Error(`Agent '${agentId}' in ${registryPath} has invalid configPath '${configPath}': file does not exist.`);
-        }
-        throw error;
-    }
-    if (!stat.isFile()) {
-        throw new Error(`Agent '${agentId}' in ${registryPath} has invalid configPath '${configPath}': path must point to a file.`);
-    }
-    return absolutePath;
-}
-export function isAgentYamlPath(filePath) {
-    return /\.(ya?ml)$/i.test(filePath);
-}
-export async function discoverPrimaryWorkspaceAgent(workspaceRoot) {
-    const loadedRegistry = await loadWorkspaceProjectRegistry(workspaceRoot);
-    if (loadedRegistry) {
-        return normalizeWorkspaceRelativePath(path.relative(workspaceRoot, loadedRegistry.defaultConfigPath).replace(/\\/g, '/'));
-    }
-    for (const relativePath of PRIMARY_WORKSPACE_AGENT_PATHS) {
-        const absolutePath = path.join(workspaceRoot, relativePath);
-        if (!existsSync(absolutePath)) {
-            continue;
-        }
-        const stat = await fs.stat(absolutePath);
-        if (!stat.isFile()) {
-            continue;
-        }
-        return normalizeWorkspaceRelativePath(relativePath);
-    }
-    return null;
-}

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

@@ -1,12 +0,0 @@
-interface InteractiveOptions {
-    interactive?: boolean;
-}
-export declare function handleDeployCommand(options?: InteractiveOptions): Promise<void>;
-export declare function handleDeployListCommand(): Promise<void>;
-export declare function handleDeployOpenCommand(): Promise<void>;
-export declare function handleDeployStatusCommand(): Promise<void>;
-export declare function handleDeployStopCommand(): Promise<void>;
-export declare function handleDeployDeleteCommand(options?: InteractiveOptions): Promise<void>;
-export declare function handleDeployChatCommand(cloudAgentId?: string): Promise<void>;
-export {};
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/deploy/index.ts"],"names":[],"mappings":"AA6BA,UAAU,kBAAkB;IACxB,WAAW,CAAC,EAAE,OAAO,CAAC;CACzB;AA4MD,wBAAsB,mBAAmB,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CA8ErF;AAED,wBAAsB,uBAAuB,IAAI,OAAO,CAAC,IAAI,CAAC,CAiD7D;AAED,wBAAsB,uBAAuB,IAAI,OAAO,CAAC,IAAI,CAAC,CAqB7D;AAED,wBAAsB,yBAAyB,IAAI,OAAO,CAAC,IAAI,CAAC,CAkB/D;AAED,wBAAsB,uBAAuB,IAAI,OAAO,CAAC,IAAI,CAAC,CA4B7D;AAED,wBAAsB,yBAAyB,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CA2C3F;AAED,wBAAsB,uBAAuB,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAOlF"}

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

@@ -1,370 +0,0 @@
-import { existsSync } from 'fs';
-import path from 'path';
-import * as p from '@clack/prompts';
-import { findDextoProjectRoot, loadAgentConfig } from '@dexto/agent-management';
-import chalk from 'chalk';
-import open from 'open';
-import { confirmOrExit } from '../../utils/prompt-helpers.js';
-import { validateAgentConfig } from '../../utils/config-validation.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';
-import { startCloudChatCli } from '../../cloud-chat.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 formatCloudAgentSelectionLabel(cloudAgent) {
-    const trimmedName = cloudAgent.name?.trim();
-    const heading = trimmedName && trimmedName !== cloudAgent.cloudAgentId
-        ? `${trimmedName} (${cloudAgent.cloudAgentId})`
-        : cloudAgent.cloudAgentId;
-    return `${heading} ${chalk.gray('[')}${formatCloudAgentStatus(cloudAgent.state.status)}${chalk.gray(']')}`;
-}
-function sortCloudAgentsForChat(cloudAgents, linkedCloudAgentId) {
-    return cloudAgents.slice().sort((left, right) => {
-        const leftIsLinked = linkedCloudAgentId !== null && left.cloudAgentId === linkedCloudAgentId;
-        const rightIsLinked = linkedCloudAgentId !== null && right.cloudAgentId === linkedCloudAgentId;
-        if (leftIsLinked !== rightIsLinked) {
-            return leftIsLinked ? -1 : 1;
-        }
-        const leftReady = left.state.status === 'ready';
-        const rightReady = right.state.status === 'ready';
-        if (leftReady !== rightReady) {
-            return leftReady ? -1 : 1;
-        }
-        const leftName = (left.name?.trim() || left.cloudAgentId).toLowerCase();
-        const rightName = (right.name?.trim() || right.cloudAgentId).toLowerCase();
-        return leftName.localeCompare(rightName);
-    });
-}
-async function selectCloudAgentForChat(workspaceRoot) {
-    const deployLink = await loadWorkspaceDeployLink(workspaceRoot);
-    const spinner = p.spinner();
-    spinner.start('Loading cloud agents...');
-    const client = createDeployClient();
-    let cloudAgents;
-    try {
-        cloudAgents = await client.listCloudAgents();
-    }
-    catch (error) {
-        spinner.stop(chalk.red('✗ Failed to load cloud agents'));
-        throw error;
-    }
-    spinner.stop(chalk.green('✓ Cloud agents loaded'));
-    if (cloudAgents.length === 0) {
-        throw new Error('No cloud agents available yet. Run `dexto deploy` first, or pass a cloud agent ID explicitly.');
-    }
-    const linkedCloudAgentId = deployLink?.cloudAgentId ?? null;
-    const sortedCloudAgents = sortCloudAgentsForChat(cloudAgents, linkedCloudAgentId);
-    const selected = await p.select({
-        message: 'Choose a cloud agent to chat with',
-        options: sortedCloudAgents.map((cloudAgent) => {
-            const isLinked = linkedCloudAgentId !== null && cloudAgent.cloudAgentId === linkedCloudAgentId;
-            const hintParts = [cloudAgent.agentUrl];
-            if (isLinked) {
-                hintParts.unshift('Linked to this workspace');
-            }
-            return {
-                value: cloudAgent.cloudAgentId,
-                label: formatCloudAgentSelectionLabel(cloudAgent),
-                hint: hintParts.join(' • '),
-            };
-        }),
-    });
-    if (p.isCancel(selected)) {
-        p.cancel('Cloud chat cancelled');
-        process.exit(0);
-    }
-    return selected;
-}
-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;
-}
-async function validateWorkspaceAgent(entryAgentPath, workspaceAgentPath) {
-    const config = await loadAgentConfig(entryAgentPath);
-    const validation = await validateAgentConfig(config, false, {
-        agentPath: workspaceAgentPath,
-        credentialPolicy: 'error',
-    });
-    if (!validation.success) {
-        throw new Error(`Workspace agent validation failed for ${workspaceAgentPath}. Fix the issues above before deploying.`);
-    }
-}
-export async function handleDeployCommand(options) {
-    void options;
-    p.intro(chalk.inverse('Deploy Workspace'));
-    const workspaceRoot = resolveWorkspaceRoot();
-    const deployConfig = await resolveDeployConfig(workspaceRoot);
-    const entryAgentPath = ensureWorkspaceAgentExists(workspaceRoot, deployConfig);
-    if (entryAgentPath && isWorkspaceDeployAgent(deployConfig.agent)) {
-        await validateWorkspaceAgent(entryAgentPath, deployConfig.agent.path);
-    }
-    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;
-    }
-}
-export async function handleDeployChatCommand(cloudAgentId) {
-    const workspaceRoot = resolveWorkspaceRoot();
-    const selectedCloudAgentId = cloudAgentId ?? (await selectCloudAgentForChat(workspaceRoot));
-    await startCloudChatCli({
-        cloudAgentId: selectedCloudAgentId,
-        workspaceRoot,
-    });
-}

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

@@ -1,3 +0,0 @@
-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

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

@@ -1,53 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

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