dexto 1.6.12 → 1.6.13

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

@@ -0,0 +1,232 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import { z } from 'zod';
+import { getAuthToken, getDextoApiKey } from '../../auth/service.js';
+const SANDBOX_URL_ENV_VAR = 'DEXTO_SANDBOX_URL';
+const DEFAULT_SANDBOX_URL = 'https://sandbox.dexto.ai';
+const CloudAgentStateSchema = z
+    .object({
+    status: z.string(),
+})
+    .passthrough();
+const CloudAgentSummarySchema = z
+    .object({
+    runId: z.string(),
+    agentUrl: z.string(),
+    hostUrl: z.string().nullable().optional(),
+    state: CloudAgentStateSchema,
+})
+    .passthrough();
+const DeployResponseSchema = z
+    .object({
+    success: z.boolean(),
+    error: z.string().optional(),
+    data: z
+        .object({
+        cloudAgentId: z.string(),
+        agentUrl: z.string(),
+        cloudAgent: CloudAgentSummarySchema,
+    })
+        .passthrough()
+        .optional(),
+})
+    .passthrough();
+const StatusResponseSchema = z
+    .object({
+    success: z.boolean(),
+    error: z.string().optional(),
+    data: z
+        .object({
+        cloudAgentId: z.string(),
+        agentUrl: z.string(),
+        cloudAgent: CloudAgentSummarySchema,
+        stale: z.boolean().optional(),
+    })
+        .passthrough()
+        .optional(),
+})
+    .passthrough();
+const StopResponseSchema = z
+    .object({
+    success: z.boolean(),
+    error: z.string().optional(),
+    data: z
+        .object({
+        cloudAgentId: z.string(),
+        agentUrl: z.string(),
+        stopped: z.boolean(),
+        alreadyStopped: z.boolean(),
+        snapshotStatus: z.string(),
+    })
+        .passthrough()
+        .optional(),
+})
+    .passthrough();
+const DeleteResponseSchema = z
+    .object({
+    success: z.boolean(),
+    error: z.string().optional(),
+    data: z
+        .object({
+        cloudAgentId: z.string(),
+        agentUrl: z.string(),
+    })
+        .passthrough()
+        .optional(),
+})
+    .passthrough();
+class SandboxApiError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        Object.setPrototypeOf(this, SandboxApiError.prototype);
+        this.name = 'SandboxApiError';
+        this.status = status;
+    }
+}
+export function resolveSandboxBaseUrl() {
+    const explicit = process.env[SANDBOX_URL_ENV_VAR]?.trim();
+    if (explicit && explicit.length > 0) {
+        return explicit.replace(/\/+$/, '');
+    }
+    const apiUrl = process.env.DEXTO_API_URL?.trim();
+    if (apiUrl?.startsWith('http://localhost:')) {
+        return 'http://localhost:3004';
+    }
+    return DEFAULT_SANDBOX_URL;
+}
+async function resolveAccessToken() {
+    const dextoApiKey = await getDextoApiKey();
+    if (dextoApiKey && dextoApiKey.trim().length > 0) {
+        return dextoApiKey.trim();
+    }
+    const authToken = await getAuthToken();
+    if (authToken && authToken.trim().length > 0) {
+        return authToken.trim();
+    }
+    throw new Error('Authentication required. Run `dexto login` before using `dexto deploy`.');
+}
+async function parseJsonResponse(response) {
+    const contentType = response.headers.get('content-type') ?? '';
+    if (!contentType.toLowerCase().includes('application/json')) {
+        return null;
+    }
+    return response.json().catch(() => null);
+}
+async function request(pathName, init) {
+    const accessToken = await resolveAccessToken();
+    const headers = new globalThis.Headers(init.headers);
+    headers.set('Authorization', `Bearer ${accessToken}`);
+    return fetch(`${resolveSandboxBaseUrl()}/api${pathName}`, {
+        ...init,
+        headers,
+    });
+}
+function requireSuccessData(payload, response, schema) {
+    const parsed = schema.parse(payload);
+    if (!parsed.success || !parsed.data) {
+        throw new SandboxApiError(parsed.error ?? 'Sandbox request failed', response.status);
+    }
+    return parsed.data;
+}
+async function throwApiError(response) {
+    const payload = await parseJsonResponse(response);
+    const parsed = payload && typeof payload === 'object' && payload !== null && 'error' in payload
+        ? z
+            .object({
+            error: z.string().optional(),
+            hint: z.string().optional(),
+        })
+            .passthrough()
+            .safeParse(payload)
+        : null;
+    const errorMessage = parsed?.success && parsed.data.error
+        ? parsed.data.hint
+            ? `${parsed.data.error} (${parsed.data.hint})`
+            : parsed.data.error
+        : `Sandbox request failed with status ${response.status}`;
+    throw new SandboxApiError(errorMessage, response.status);
+}
+export function createDeployClient() {
+    return {
+        async deployWorkspace(input) {
+            const snapshotBuffer = await fs.readFile(input.snapshotPath);
+            const formData = new globalThis.FormData();
+            formData.set('agentType', input.agent.type);
+            if (input.agent.type === 'workspace') {
+                formData.set('entryAgent', input.agent.path);
+            }
+            if (input.cloudAgentId && input.cloudAgentId.trim().length > 0) {
+                formData.set('cloudAgentId', input.cloudAgentId.trim());
+            }
+            formData.set('workspaceSnapshot', new globalThis.File([new Uint8Array(snapshotBuffer)], path.basename(input.snapshotPath), {
+                type: 'application/gzip',
+            }));
+            const response = await request('/cloud-agents/deploy', {
+                method: 'POST',
+                body: formData,
+            });
+            if (!response.ok) {
+                await throwApiError(response);
+            }
+            const payload = await parseJsonResponse(response);
+            const data = requireSuccessData(payload, response, DeployResponseSchema);
+            return {
+                cloudAgentId: data.cloudAgentId,
+                agentUrl: data.agentUrl,
+                state: data.cloudAgent.state,
+            };
+        },
+        async getCloudAgent(cloudAgentId) {
+            const response = await request(`/cloud-agents/${encodeURIComponent(cloudAgentId)}`, {
+                method: 'GET',
+            });
+            if (!response.ok) {
+                await throwApiError(response);
+            }
+            const payload = await parseJsonResponse(response);
+            const data = requireSuccessData(payload, response, StatusResponseSchema);
+            return {
+                cloudAgentId: data.cloudAgentId,
+                agentUrl: data.agentUrl,
+                state: data.cloudAgent.state,
+                stale: data.stale === true,
+            };
+        },
+        async stopCloudAgent(cloudAgentId) {
+            const response = await request(`/cloud-agents/${encodeURIComponent(cloudAgentId)}/stop`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({}),
+            });
+            if (!response.ok) {
+                await throwApiError(response);
+            }
+            const payload = await parseJsonResponse(response);
+            const data = requireSuccessData(payload, response, StopResponseSchema);
+            return {
+                cloudAgentId: data.cloudAgentId,
+                agentUrl: data.agentUrl,
+                stopped: data.stopped,
+                alreadyStopped: data.alreadyStopped,
+                snapshotStatus: data.snapshotStatus,
+            };
+        },
+        async deleteCloudAgent(cloudAgentId) {
+            const response = await request(`/cloud-agents/${encodeURIComponent(cloudAgentId)}`, {
+                method: 'DELETE',
+            });
+            if (!response.ok) {
+                await throwApiError(response);
+            }
+            const payload = await parseJsonResponse(response);
+            const data = requireSuccessData(payload, response, DeleteResponseSchema);
+            return {
+                cloudAgentId: data.cloudAgentId,
+                agentUrl: data.agentUrl,
+            };
+        },
+    };
+}

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

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+export declare const DEPLOY_CONFIG_RELATIVE_PATH: string;
+export declare const DEFAULT_DEPLOY_EXCLUDES: readonly [".git", "node_modules", "dist", ".next", ".turbo", ".env*"];
+export declare function normalizeWorkspaceRelativePath(value: string): string;
+declare const WorkspaceDeployAgentSchema: z.ZodObject<{
+    type: z.ZodLiteral<"workspace">;
+    path: z.ZodEffects<z.ZodString, string, string>;
+}, "strict", z.ZodTypeAny, {
+    type: "workspace";
+    path: string;
+}, {
+    type: "workspace";
+    path: string;
+}>;
+export declare const DeployAgentSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"cloud-default">;
+}, "strict", z.ZodTypeAny, {
+    type: "cloud-default";
+}, {
+    type: "cloud-default";
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"workspace">;
+    path: z.ZodEffects<z.ZodString, string, string>;
+}, "strict", z.ZodTypeAny, {
+    type: "workspace";
+    path: string;
+}, {
+    type: "workspace";
+    path: string;
+}>]>;
+export declare const DeployConfigSchema: z.ZodObject<{
+    version: z.ZodDefault<z.ZodLiteral<1>>;
+    agent: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"cloud-default">;
+    }, "strict", z.ZodTypeAny, {
+        type: "cloud-default";
+    }, {
+        type: "cloud-default";
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"workspace">;
+        path: z.ZodEffects<z.ZodString, string, string>;
+    }, "strict", z.ZodTypeAny, {
+        type: "workspace";
+        path: string;
+    }, {
+        type: "workspace";
+        path: string;
+    }>]>;
+    exclude: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strict", z.ZodTypeAny, {
+    agent: {
+        type: "cloud-default";
+    } | {
+        type: "workspace";
+        path: string;
+    };
+    version: 1;
+    exclude: string[];
+}, {
+    agent: {
+        type: "cloud-default";
+    } | {
+        type: "workspace";
+        path: string;
+    };
+    version?: 1 | undefined;
+    exclude?: string[] | undefined;
+}>;
+export type DeployConfig = z.output<typeof DeployConfigSchema>;
+export type DeployConfigInput = z.input<typeof DeployConfigSchema>;
+export type DeployAgent = z.output<typeof DeployAgentSchema>;
+export type WorkspaceDeployAgent = z.output<typeof WorkspaceDeployAgentSchema>;
+export declare function getDeployConfigPath(workspaceRoot: string): string;
+export declare function loadDeployConfig(workspaceRoot: string): Promise<DeployConfig | null>;
+export declare function saveDeployConfig(workspaceRoot: string, config: DeployConfigInput): Promise<DeployConfig>;
+export declare function createCloudDefaultDeployConfig(exclude?: readonly string[]): DeployConfig;
+export declare function createWorkspaceDeployConfig(agentPath: string, exclude?: readonly string[]): DeployConfig;
+export declare function isWorkspaceDeployAgent(agent: DeployAgent): agent is WorkspaceDeployAgent;
+export declare function resolveWorkspaceDeployAgentPath(workspaceRoot: string, agentPath: string): string;
+export {};
+//# sourceMappingURL=config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/deploy/config.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,2BAA2B,QAAqC,CAAC;AAE9E,eAAO,MAAM,uBAAuB,uEAO1B,CAAC;AAEX,wBAAgB,8BAA8B,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAkBpE;AAwBD,QAAA,MAAM,0BAA0B;;;;;;;;;EAOnB,CAAC;AAEd,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;IAG5B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMlB,CAAC;AAYd,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC/D,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACnE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC7D,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE/E,wBAAgB,mBAAmB,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAEjE;AAED,wBAAsB,gBAAgB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAmB1F;AAED,wBAAsB,gBAAgB,CAClC,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,iBAAiB,GAC1B,OAAO,CAAC,YAAY,CAAC,CAMvB;AAgBD,wBAAgB,8BAA8B,CAC1C,OAAO,GAAE,SAAS,MAAM,EAA4B,GACrD,YAAY,CAQd;AAED,wBAAgB,2BAA2B,CACvC,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,SAAS,MAAM,EAA4B,GACrD,YAAY,CASd;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,WAAW,GAAG,KAAK,IAAI,oBAAoB,CAExF;AAED,wBAAgB,+BAA+B,CAAC,aAAa,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAahG"}

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

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

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

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

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

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

@@ -0,0 +1,22 @@
+import { existsSync } 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'),
+];
+export function isAgentYamlPath(filePath) {
+    return /\.(ya?ml)$/i.test(filePath);
+}
+export function discoverPrimaryWorkspaceAgent(workspaceRoot) {
+    for (const relativePath of PRIMARY_WORKSPACE_AGENT_PATHS) {
+        const absolutePath = path.join(workspaceRoot, relativePath);
+        if (!existsSync(absolutePath)) {
+            continue;
+        }
+        return normalizeWorkspaceRelativePath(relativePath);
+    }
+    return null;
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/deploy/index.ts"],"names":[],"mappings":"AA0BA,UAAU,kBAAkB;IACxB,WAAW,CAAC,EAAE,OAAO,CAAC;CACzB;AAwED,wBAAsB,mBAAmB,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CA2ErF;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"}