dexto 1.14.6 → 2.0.0-beta.1

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

@@ -1,128 +0,0 @@
-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 chat
-  $ dexto deploy chat sbx_123
-  $ 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('chat')
-        .description('Start Ink CLI chat against a selected or explicit cloud agent')
-        .argument('[cloudAgentId]', 'Cloud agent ID (omit to choose from your available cloud agents)')
-        .action(withAnalytics('deploy chat', async (cloudAgentId) => {
-        try {
-            const { handleDeployChatCommand } = await import('./index.js');
-            await handleDeployChatCommand(cloudAgentId);
-            safeExit('deploy chat', 0);
-        }
-        catch (err) {
-            if (err instanceof ExitSignal)
-                throw err;
-            console.error(`❌ dexto deploy chat command failed: ${err}`);
-            safeExit('deploy chat', 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

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

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

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

@@ -1,13 +0,0 @@
-import { z } from 'zod';
-declare const DeployLinkSchema: z.ZodObject<{
-    cloudAgentId: z.ZodString;
-    agentUrl: z.ZodOptional<z.ZodString>;
-    updatedAt: z.ZodString;
-}, z.core.$strict>;
-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

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

@@ -1,122 +0,0 @@
-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/span/register.d.ts

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/span/register.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGzC,MAAM,WAAW,0BAA0B;IACvC,OAAO,EAAE,OAAO,CAAC;CACpB;AAED,wBAAgB,mBAAmB,CAAC,EAAE,OAAO,EAAE,EAAE,0BAA0B,GAAG,IAAI,CAwBjF"}

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

@@ -1,25 +0,0 @@
-import { withAnalytics, safeExit, ExitSignal } from '../../../analytics/wrapper.js';
-export function registerSpanCommand({ program }) {
-    const span = program.command('span').description('Inspect hosted run spans from Dexto Cloud');
-    span.command('list <runId>')
-        .description('List spans for a hosted run')
-        .option('--json', 'Print the raw span list response as JSON')
-        .option('--limit <count>', 'Maximum number of spans to return')
-        .option('--name <spanName>', 'Filter to an exact span name')
-        .option('--platform-url <url>', 'Use a custom Dexto platform URL')
-        .option('--sort <sort>', 'Sort by started_at or duration')
-        .option('--status <status>', 'Filter to a span status')
-        .action(withAnalytics('span:list', async (runId, options) => {
-        try {
-            const { handleSpanListCommand } = await import('../trace/index.js');
-            await handleSpanListCommand(runId, options);
-            safeExit('span:list', 0);
-        }
-        catch (err) {
-            if (err instanceof ExitSignal)
-                throw err;
-            console.error(`❌ dexto span list command failed: ${err}`);
-            safeExit('span:list', 1, 'error');
-        }
-    }));
-}

package/dist/cli/commands/trace/client.d.ts

@@ -1,98 +0,0 @@
-import { z } from 'zod';
-declare const RunTraceSpanSchema: z.ZodObject<{
-    attributes: z.ZodUnknown;
-    durationMs: z.ZodNullable<z.ZodNumber>;
-    endedAt: z.ZodNullable<z.ZodString>;
-    errorCode: z.ZodNullable<z.ZodString>;
-    errorMessage: z.ZodNullable<z.ZodString>;
-    id: z.ZodString;
-    name: z.ZodString;
-    parentSpanId: z.ZodNullable<z.ZodString>;
-    runAttemptId: z.ZodNullable<z.ZodString>;
-    runId: z.ZodString;
-    sessionId: z.ZodNullable<z.ZodString>;
-    spanId: z.ZodString;
-    startedAt: z.ZodString;
-    status: z.ZodEnum<{
-        failed: "failed";
-        cancelled: "cancelled";
-        completed: "completed";
-        running: "running";
-    }>;
-    traceId: z.ZodString;
-}, z.core.$loose>;
-declare const RunTraceSchema: z.ZodObject<{
-    events: z.ZodArray<z.ZodObject<{
-        attributes: z.ZodUnknown;
-        eventId: z.ZodString;
-        name: z.ZodString;
-        occurredAt: z.ZodString;
-        runId: z.ZodString;
-        runSpanId: z.ZodString;
-    }, z.core.$loose>>;
-    spans: z.ZodArray<z.ZodObject<{
-        attributes: z.ZodUnknown;
-        durationMs: z.ZodNullable<z.ZodNumber>;
-        endedAt: z.ZodNullable<z.ZodString>;
-        errorCode: z.ZodNullable<z.ZodString>;
-        errorMessage: z.ZodNullable<z.ZodString>;
-        id: z.ZodString;
-        name: z.ZodString;
-        parentSpanId: z.ZodNullable<z.ZodString>;
-        runAttemptId: z.ZodNullable<z.ZodString>;
-        runId: z.ZodString;
-        sessionId: z.ZodNullable<z.ZodString>;
-        spanId: z.ZodString;
-        startedAt: z.ZodString;
-        status: z.ZodEnum<{
-            failed: "failed";
-            cancelled: "cancelled";
-            completed: "completed";
-            running: "running";
-        }>;
-        traceId: z.ZodString;
-    }, z.core.$loose>>;
-}, z.core.$loose>;
-declare const RunTraceSummarySchema: z.ZodObject<{
-    durationMs: z.ZodNumber;
-    errorCount: z.ZodNumber;
-    eventCount: z.ZodNumber;
-    firstSpanStartedAt: z.ZodString;
-    lastSpanStartedAt: z.ZodString;
-    runId: z.ZodString;
-    sessionId: z.ZodString;
-    spanCount: z.ZodNumber;
-    spanNames: z.ZodArray<z.ZodString>;
-    status: z.ZodString;
-}, z.core.$loose>;
-export type RunTrace = z.output<typeof RunTraceSchema>;
-export type RunTraceSpan = z.output<typeof RunTraceSpanSchema>;
-export type RunTraceSummary = z.output<typeof RunTraceSummarySchema>;
-export interface TraceClientOptions {
-    platformUrl?: string | undefined;
-}
-export interface RequestOptions {
-    signal?: AbortSignal | undefined;
-}
-export interface FetchRunTraceOptions extends RequestOptions {
-}
-export interface ListRunTracesOptions extends RequestOptions {
-    limit?: number | undefined;
-    period?: string | undefined;
-    sessionId?: string | undefined;
-    status?: string | undefined;
-}
-export interface ListRunSpansOptions extends RequestOptions {
-    limit?: number | undefined;
-    name?: string | undefined;
-    sort?: 'started_at' | 'duration' | undefined;
-    status?: string | undefined;
-}
-export declare function resolveTracePlatformUrl(platformUrl?: string): string;
-export declare function createTraceClient(options?: TraceClientOptions): {
-    fetchRunTrace(runId: string, fetchOptions?: FetchRunTraceOptions): Promise<RunTrace>;
-    listRunSpans(runId: string, listOptions?: ListRunSpansOptions): Promise<RunTraceSpan[]>;
-    listRunTraces(listOptions?: ListRunTracesOptions): Promise<RunTraceSummary[]>;
-};
-export {};
-//# sourceMappingURL=client.d.ts.map

package/dist/cli/commands/trace/client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/trace/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;iBAkBN,CAAC;AAanB,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKF,CAAC;AAQnB,QAAA,MAAM,qBAAqB;;;;;;;;;;;iBAaT,CAAC;AAcnB,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,cAAc,CAAC,CAAC;AACvD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC/D,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAErE,MAAM,WAAW,kBAAkB;IAC/B,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACpC;AAED,MAAM,WAAW,cAAc;IAC3B,MAAM,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;CACpC;AAED,MAAM,WAAW,oBAAqB,SAAQ,cAAc;CAAG;AAE/D,MAAM,WAAW,oBAAqB,SAAQ,cAAc;IACxD,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/B;AAED,MAAM,WAAW,mBAAoB,SAAQ,cAAc;IACvD,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,IAAI,CAAC,EAAE,YAAY,GAAG,UAAU,GAAG,SAAS,CAAC;IAC7C,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/B;AAED,wBAAgB,uBAAuB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,MAAM,CAOpE;AAiDD,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,kBAAuB;yBAsB/C,MAAM,iBACC,oBAAoB,GACnC,OAAO,CAAC,QAAQ,CAAC;wBAUT,MAAM,gBACA,mBAAmB,GACjC,OAAO,CAAC,YAAY,EAAE,CAAC;gCAYO,oBAAoB,GAAQ,OAAO,CAAC,eAAe,EAAE,CAAC;EAY9F"}

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

@@ -1,150 +0,0 @@
-import { z } from 'zod';
-import { DEXTO_PLATFORM_URL } from '../../auth/constants.js';
-import { getDextoApiKey } from '../../auth/service.js';
-const TRACE_REQUEST_TIMEOUT_MS = 10_000;
-const RunTraceSpanStatusSchema = z.enum(['running', 'completed', 'failed', 'cancelled']);
-const RunTraceSpanSchema = z
-    .object({
-    attributes: z.unknown(),
-    durationMs: z.number().nullable(),
-    endedAt: z.string().nullable(),
-    errorCode: z.string().nullable(),
-    errorMessage: z.string().nullable(),
-    id: z.string(),
-    name: z.string(),
-    parentSpanId: z.string().nullable(),
-    runAttemptId: z.string().nullable(),
-    runId: z.string(),
-    sessionId: z.string().nullable(),
-    spanId: z.string(),
-    startedAt: z.string(),
-    status: RunTraceSpanStatusSchema,
-    traceId: z.string(),
-})
-    .passthrough();
-const RunTraceEventSchema = z
-    .object({
-    attributes: z.unknown(),
-    eventId: z.string(),
-    name: z.string(),
-    occurredAt: z.string(),
-    runId: z.string(),
-    runSpanId: z.string(),
-})
-    .passthrough();
-const RunTraceSchema = z
-    .object({
-    events: z.array(RunTraceEventSchema),
-    spans: z.array(RunTraceSpanSchema),
-})
-    .passthrough();
-const RunTraceResponseSchema = z
-    .object({
-    trace: RunTraceSchema,
-})
-    .passthrough();
-const RunTraceSummarySchema = z
-    .object({
-    durationMs: z.number(),
-    errorCount: z.number(),
-    eventCount: z.number(),
-    firstSpanStartedAt: z.string(),
-    lastSpanStartedAt: z.string(),
-    runId: z.string(),
-    sessionId: z.string(),
-    spanCount: z.number(),
-    spanNames: z.array(z.string()),
-    status: z.string(),
-})
-    .passthrough();
-const RunTraceListResponseSchema = z
-    .object({
-    traces: z.array(RunTraceSummarySchema),
-})
-    .passthrough();
-const RunSpansResponseSchema = z
-    .object({
-    spans: z.array(RunTraceSpanSchema),
-})
-    .passthrough();
-export function resolveTracePlatformUrl(platformUrl) {
-    const rawUrl = platformUrl?.trim() || DEXTO_PLATFORM_URL;
-    if (rawUrl.trim().length === 0) {
-        throw new Error('Dexto platform URL is empty.');
-    }
-    return rawUrl.replace(/\/+$/, '');
-}
-async function resolveTraceApiKey() {
-    const apiKey = await getDextoApiKey();
-    if (!apiKey?.trim()) {
-        throw new Error('Authentication required. Run `dexto login` before using `dexto trace`.');
-    }
-    return apiKey.trim();
-}
-async function parseJsonResponse(response) {
-    const contentType = response.headers.get('content-type') ?? '';
-    if (!contentType.toLowerCase().includes('application/json')) {
-        return null;
-    }
-    return response.json().catch(() => null);
-}
-function formatHttpFailure(status, payload) {
-    if (payload && typeof payload === 'object' && 'error' in payload) {
-        return `${status} ${JSON.stringify(payload)}`;
-    }
-    return `${status}`;
-}
-function appendOptionalSearchParam(url, key, value) {
-    if (value === undefined) {
-        return;
-    }
-    url.searchParams.set(key, String(value));
-}
-function createRequestSignal(signal) {
-    const timeoutSignal = AbortSignal.timeout(TRACE_REQUEST_TIMEOUT_MS);
-    if (!signal) {
-        return timeoutSignal;
-    }
-    return AbortSignal.any([signal, timeoutSignal]);
-}
-export function createTraceClient(options = {}) {
-    const platformBaseUrl = resolveTracePlatformUrl(options.platformUrl);
-    async function fetchJson(path, fetchOptions = {}) {
-        const response = await fetch(`${platformBaseUrl}${path}`, {
-            method: 'GET',
-            headers: {
-                Authorization: `Bearer ${await resolveTraceApiKey()}`,
-            },
-            signal: createRequestSignal(fetchOptions.signal),
-        });
-        const payload = await parseJsonResponse(response);
-        if (!response.ok) {
-            throw new Error(`Trace request failed: ${formatHttpFailure(response.status, payload)}`);
-        }
-        return payload;
-    }
-    return {
-        async fetchRunTrace(runId, fetchOptions = {}) {
-            const payload = await fetchJson(`/api/runs/${encodeURIComponent(runId)}/trace`, fetchOptions);
-            return RunTraceResponseSchema.parse(payload).trace;
-        },
-        async listRunSpans(runId, listOptions = {}) {
-            const url = new URL(`${platformBaseUrl}/api/runs/${encodeURIComponent(runId)}/spans`);
-            appendOptionalSearchParam(url, 'limit', listOptions.limit);
-            appendOptionalSearchParam(url, 'name', listOptions.name);
-            appendOptionalSearchParam(url, 'sort', listOptions.sort);
-            appendOptionalSearchParam(url, 'status', listOptions.status);
-            const payload = await fetchJson(`${url.pathname}${url.search}`, listOptions);
-            return RunSpansResponseSchema.parse(payload).spans;
-        },
-        async listRunTraces(listOptions = {}) {
-            const url = new URL(`${platformBaseUrl}/api/runs/traces`);
-            appendOptionalSearchParam(url, 'limit', listOptions.limit);
-            appendOptionalSearchParam(url, 'period', listOptions.period);
-            appendOptionalSearchParam(url, 'sessionId', listOptions.sessionId);
-            appendOptionalSearchParam(url, 'status', listOptions.status);
-            const payload = await fetchJson(`${url.pathname}${url.search}`, listOptions);
-            return RunTraceListResponseSchema.parse(payload).traces;
-        },
-    };
-}

package/dist/cli/commands/trace/format.d.ts

@@ -1,5 +0,0 @@
-import type { RunTrace, RunTraceSpan, RunTraceSummary } from './client.js';
-export declare function formatTraceSummary(runId: string, trace: RunTrace): string;
-export declare function formatTraceList(traces: RunTraceSummary[]): string;
-export declare function formatSpanList(runId: string, spans: RunTraceSpan[]): string;
-//# sourceMappingURL=format.d.ts.map

package/dist/cli/commands/trace/format.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../../../src/cli/commands/trace/format.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAc3E,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,GAAG,MAAM,CAsBzE;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,eAAe,EAAE,GAAG,MAAM,CAkBjE;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,EAAE,GAAG,MAAM,CAoB3E"}