dexto 1.6.11 → 1.6.13

package/dist/cli/utils/self-management.js

@@ -0,0 +1,423 @@
+import { spawn } from 'child_process';
+import { promises as fs } from 'fs';
+import os from 'os';
+import path from 'path';
+import { z } from 'zod';
+const DEXTO_BINARY = process.platform === 'win32' ? 'dexto.exe' : 'dexto';
+const DEXTO_PATH_COMMAND = process.platform === 'win32' ? 'where' : 'which';
+const DEXTO_PATH_ARGS = process.platform === 'win32' ? ['dexto'] : ['-a', 'dexto'];
+const DEFAULT_NATIVE_INSTALL_URL = 'https://dexto.ai/install';
+const DEFAULT_WINDOWS_INSTALL_URL = 'https://dexto.ai/install.ps1';
+const InstallMetadataSchema = z
+    .object({
+    schemaVersion: z.number().int().positive().default(1),
+    method: z.enum(['native', 'npm']),
+    installedPath: z.string().min(1),
+    installedAt: z.string().min(1),
+    version: z.string().min(1),
+    sourceUrl: z.string().min(1).optional(),
+    releaseTag: z.string().min(1).optional(),
+    platform: z.string().min(1).optional(),
+    arch: z.string().min(1).optional(),
+})
+    .strict();
+export async function executeCommand(command, args, options = {}) {
+    const stdio = options.stdio ?? 'pipe';
+    return await new Promise((resolve) => {
+        const child = spawn(command, args, {
+            cwd: options.cwd,
+            env: options.env,
+            stdio,
+            windowsHide: true,
+        });
+        let stdout = '';
+        let stderr = '';
+        if (stdio === 'pipe') {
+            if (child.stdout) {
+                child.stdout.on('data', (chunk) => {
+                    stdout += chunk.toString();
+                });
+            }
+            if (child.stderr) {
+                child.stderr.on('data', (chunk) => {
+                    stderr += chunk.toString();
+                });
+            }
+        }
+        child.on('error', (error) => {
+            resolve({
+                code: -1,
+                stdout,
+                stderr: `${stderr}\n${error.message}`.trim(),
+            });
+        });
+        child.on('close', (code) => {
+            resolve({
+                code: code ?? -1,
+                stdout,
+                stderr,
+            });
+        });
+    });
+}
+export async function executeManagedCommand(commandSpec, options) {
+    if (options.dryRun) {
+        console.log(`[dry-run] ${commandSpec.displayCommand}`);
+        return;
+    }
+    const executeOptions = { stdio: 'inherit' };
+    if (options.cwd) {
+        executeOptions.cwd = options.cwd;
+    }
+    if (commandSpec.env) {
+        executeOptions.env = commandSpec.env;
+    }
+    const result = await executeCommand(commandSpec.command, commandSpec.args, executeOptions);
+    if (result.code !== 0) {
+        throw new Error(`Command failed: ${commandSpec.displayCommand}`);
+    }
+}
+export function getDextoHomePath() {
+    return path.join(os.homedir(), '.dexto');
+}
+export async function readInstallMetadata() {
+    const metadataPath = path.join(getDextoHomePath(), 'install.json');
+    try {
+        const content = await fs.readFile(metadataPath, 'utf-8');
+        const parsed = JSON.parse(content);
+        const validated = InstallMetadataSchema.safeParse(parsed);
+        if (!validated.success) {
+            return null;
+        }
+        return validated.data;
+    }
+    catch {
+        return null;
+    }
+}
+function normalizePathForComparison(targetPath) {
+    const normalized = path.normalize(targetPath);
+    return process.platform === 'win32' ? normalized.toLowerCase() : normalized;
+}
+function uniquePaths(paths) {
+    const seen = new Set();
+    const result = [];
+    for (const candidate of paths) {
+        const normalized = normalizePathForComparison(candidate);
+        if (seen.has(normalized)) {
+            continue;
+        }
+        seen.add(normalized);
+        result.push(path.normalize(candidate));
+    }
+    return result;
+}
+async function getBinaryPathsFromPath() {
+    const result = await executeCommand(DEXTO_PATH_COMMAND, DEXTO_PATH_ARGS);
+    if (result.code !== 0) {
+        return [];
+    }
+    const candidates = result.stdout
+        .split(/\r?\n/)
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+    return uniquePaths(candidates);
+}
+function inferInstallMethodFromPath(binaryPath) {
+    const normalized = normalizePathForComparison(binaryPath);
+    if (normalized.includes('.dexto') || normalized.includes(path.join('.local', 'bin'))) {
+        return 'native';
+    }
+    return 'unknown';
+}
+export function isProjectLocalBinaryPath(binaryPath) {
+    const normalized = normalizePathForSignatureMatch(binaryPath);
+    return (normalized.includes('/node_modules/.bin/') || normalized.includes('/node_modules/dexto/'));
+}
+function pathStartsWith(targetPath, candidatePrefix) {
+    const normalizedTarget = normalizePathForComparison(targetPath);
+    const normalizedPrefix = normalizePathForComparison(candidatePrefix);
+    return (normalizedTarget === normalizedPrefix ||
+        normalizedTarget.startsWith(`${normalizedPrefix}${path.sep}`));
+}
+function pathBasenameIsDexto(targetPath) {
+    const basename = path.basename(targetPath).toLowerCase();
+    return basename === 'dexto' || basename === 'dexto.exe' || basename === 'dexto.cmd';
+}
+async function detectNodePackageManagerFromPath(binaryPath) {
+    const npmPrefix = await executeCommand('npm', ['prefix', '-g']);
+    if (npmPrefix.code === 0) {
+        const prefix = npmPrefix.stdout.trim();
+        if (prefix.length > 0) {
+            const npmBinDir = process.platform === 'win32' ? prefix : path.join(prefix, 'bin');
+            if (pathStartsWith(binaryPath, npmBinDir)) {
+                return 'npm';
+            }
+        }
+    }
+    return null;
+}
+function normalizePathForSignatureMatch(targetPath) {
+    return normalizePathForComparison(targetPath).replace(/\\/g, '/');
+}
+export function detectUnsupportedPackageManagerFromPath(binaryPath) {
+    const normalized = normalizePathForSignatureMatch(binaryPath);
+    const pnpmHome = process.env.PNPM_HOME;
+    if (pnpmHome && pathStartsWith(binaryPath, pnpmHome)) {
+        return 'pnpm';
+    }
+    const bunInstall = process.env.BUN_INSTALL;
+    if (bunInstall && pathStartsWith(binaryPath, path.join(bunInstall, 'bin'))) {
+        return 'bun';
+    }
+    if (normalized.includes('/.local/share/pnpm/') ||
+        normalized.includes('/appdata/local/pnpm/') ||
+        normalized.includes('/pnpm/')) {
+        return 'pnpm';
+    }
+    if (normalized.includes('/.bun/bin/')) {
+        return 'bun';
+    }
+    return null;
+}
+export function buildMultipleInstallWarning(allDetectedPaths, activePath) {
+    if (allDetectedPaths.length <= 1) {
+        return null;
+    }
+    const formattedPaths = allDetectedPaths
+        .map((entry, index) => {
+        const isActive = activePath !== null &&
+            normalizePathForComparison(entry) === normalizePathForComparison(activePath);
+        const prefix = isActive || (activePath === null && index === 0) ? '*' : '-';
+        return `${prefix} ${entry}`;
+    })
+        .join('\n');
+    return [
+        'Multiple dexto binaries detected in PATH:',
+        formattedPaths,
+        'The active binary is marked with *.',
+    ].join('\n');
+}
+export async function detectInstallMethod() {
+    return await detectInstallMethodWithDeps();
+}
+export async function detectInstallMethodWithDeps(deps = {}) {
+    const readMetadata = deps.readMetadata ?? readInstallMetadata;
+    const getPathEntries = deps.getPathEntries ?? getBinaryPathsFromPath;
+    const detectNodeManager = deps.detectNodeManager ?? detectNodePackageManagerFromPath;
+    const pathExistsFn = deps.pathExists ?? pathExists;
+    const metadata = await readMetadata();
+    const allDetectedPaths = await getPathEntries();
+    const activePath = allDetectedPaths[0] ?? null;
+    async function detectMethodFromActivePath(pathEntry) {
+        if (isProjectLocalBinaryPath(pathEntry)) {
+            return 'project-local';
+        }
+        let method = inferInstallMethodFromPath(pathEntry);
+        if (method === 'unknown' || method === 'native') {
+            const pmMethod = await detectNodeManager(pathEntry);
+            if (pmMethod) {
+                method = pmMethod;
+            }
+        }
+        if (method === 'unknown' && pathBasenameIsDexto(pathEntry)) {
+            const normalizedPath = normalizePathForComparison(pathEntry);
+            if (normalizedPath.includes(normalizePathForComparison(path.join(os.homedir(), '.local', 'bin')))) {
+                method = 'native';
+            }
+        }
+        return method;
+    }
+    if (metadata) {
+        const installedPath = metadata.installedPath;
+        const metadataPathExists = await pathExistsFn(installedPath);
+        const metadataMatchesActivePath = activePath !== null &&
+            normalizePathForComparison(activePath) === normalizePathForComparison(installedPath);
+        const metadataIsTrusted = metadataPathExists && (allDetectedPaths.length === 0 || metadataMatchesActivePath);
+        if (!metadataIsTrusted && activePath) {
+            const method = await detectMethodFromActivePath(activePath);
+            return {
+                method,
+                source: 'heuristic',
+                metadata,
+                installedPath: activePath,
+                installDir: path.dirname(activePath),
+                allDetectedPaths,
+                multipleInstallWarning: buildMultipleInstallWarning(allDetectedPaths, activePath),
+            };
+        }
+        if (!metadataIsTrusted) {
+            return {
+                method: 'unknown',
+                source: 'heuristic',
+                metadata,
+                installedPath: null,
+                installDir: null,
+                allDetectedPaths,
+                multipleInstallWarning: null,
+            };
+        }
+        const installDir = path.dirname(installedPath);
+        return {
+            method: metadata.method,
+            source: 'metadata',
+            metadata,
+            installedPath,
+            installDir,
+            allDetectedPaths,
+            multipleInstallWarning: buildMultipleInstallWarning(allDetectedPaths, installedPath),
+        };
+    }
+    if (!activePath) {
+        return {
+            method: 'unknown',
+            source: 'heuristic',
+            metadata: null,
+            installedPath: null,
+            installDir: null,
+            allDetectedPaths,
+            multipleInstallWarning: null,
+        };
+    }
+    const method = await detectMethodFromActivePath(activePath);
+    return {
+        method,
+        source: 'heuristic',
+        metadata: null,
+        installedPath: activePath,
+        installDir: path.dirname(activePath),
+        allDetectedPaths,
+        multipleInstallWarning: buildMultipleInstallWarning(allDetectedPaths, activePath),
+    };
+}
+function shellEscapeForPosix(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function shellEscapeForPowerShell(value) {
+    return `'${value.replace(/'/g, `''`)}'`;
+}
+export function commandDisplayWithEnvPosix(command, envOverrides) {
+    const parts = [];
+    for (const [key, value] of Object.entries(envOverrides)) {
+        parts.push(`${key}=${shellEscapeForPosix(value)}`);
+    }
+    if (parts.length === 0) {
+        return command;
+    }
+    return `${parts.join(' ')} ${command}`;
+}
+export function commandDisplayWithEnvPowerShell(command, envOverrides) {
+    const parts = [];
+    for (const [key, value] of Object.entries(envOverrides)) {
+        parts.push(`$env:${key}=${shellEscapeForPowerShell(value)};`);
+    }
+    if (parts.length === 0) {
+        return command;
+    }
+    return `${parts.join(' ')} ${command}`;
+}
+export function createNativeInstallCommand(options) {
+    const env = { ...process.env };
+    const envOverrides = {};
+    if (options.version) {
+        env.DEXTO_VERSION = options.version;
+        envOverrides.DEXTO_VERSION = options.version;
+    }
+    if (options.installDir) {
+        env.DEXTO_INSTALL_DIR = options.installDir;
+        envOverrides.DEXTO_INSTALL_DIR = options.installDir;
+    }
+    if (options.force) {
+        env.DEXTO_INSTALL_FORCE = '1';
+        envOverrides.DEXTO_INSTALL_FORCE = '1';
+    }
+    if (process.platform === 'win32') {
+        const commandText = `irm ${DEFAULT_WINDOWS_INSTALL_URL} | iex`;
+        return {
+            command: 'powershell',
+            args: ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-Command', commandText],
+            env,
+            displayCommand: commandDisplayWithEnvPowerShell(`powershell -NoProfile -ExecutionPolicy Bypass -Command ${shellEscapeForPowerShell(commandText)}`, envOverrides),
+        };
+    }
+    const commandText = `curl -fsSL ${DEFAULT_NATIVE_INSTALL_URL} | bash`;
+    return {
+        command: 'bash',
+        args: ['-lc', commandText],
+        env,
+        displayCommand: commandDisplayWithEnvPosix(commandText, envOverrides),
+    };
+}
+export function createLegacyNpmUninstallCommand() {
+    return {
+        command: 'npm',
+        args: ['uninstall', '-g', 'dexto'],
+        displayCommand: 'npm uninstall -g dexto',
+    };
+}
+export function normalizeRequestedVersion(version) {
+    if (!version) {
+        return null;
+    }
+    const trimmed = version.trim();
+    if (trimmed.length === 0) {
+        return null;
+    }
+    return trimmed.startsWith('dexto@') ? trimmed.slice('dexto@'.length) : trimmed;
+}
+export async function scheduleDeferredWindowsRemoval(targetPaths) {
+    const uniqueTargets = uniquePaths(targetPaths);
+    const removalScript = uniqueTargets
+        .map((targetPath) => {
+        const escapedPath = shellEscapeForPowerShell(targetPath);
+        return [
+            `if (Test-Path -LiteralPath ${escapedPath}) {`,
+            `Remove-Item -LiteralPath ${escapedPath} -Recurse -Force -ErrorAction SilentlyContinue`,
+            '}',
+        ].join(' ');
+    })
+        .join('; ');
+    const commandText = `Start-Sleep -Seconds 2; ${removalScript}`;
+    await new Promise((resolve, reject) => {
+        const child = spawn('powershell', ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-Command', commandText], {
+            detached: true,
+            stdio: 'ignore',
+            windowsHide: true,
+        });
+        child.once('error', reject);
+        child.once('spawn', () => {
+            child.unref();
+            resolve();
+        });
+    });
+}
+export async function pathExists(targetPath) {
+    try {
+        await fs.lstat(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function hasErrorCode(error, code) {
+    return typeof error === 'object' && error !== null && 'code' in error && error.code === code;
+}
+export async function removePath(targetPath) {
+    try {
+        const stat = await fs.lstat(targetPath);
+        await fs.rm(targetPath, { recursive: stat.isDirectory(), force: true });
+    }
+    catch (error) {
+        if (hasErrorCode(error, 'ENOENT')) {
+            return;
+        }
+        throw error;
+    }
+}
+export function getDefaultNativeBinaryPath() {
+    if (process.platform === 'win32') {
+        return path.join(os.homedir(), '.dexto', 'bin', DEXTO_BINARY);
+    }
+    return path.join(os.homedir(), '.local', 'bin', DEXTO_BINARY);
+}

package/dist/cli/utils/version-check.d.ts

@@ -37,7 +37,7 @@ export declare function checkForUpdates(currentVersion: string): Promise<UpdateI
  * displayUpdateNotification({
  *   current: '1.5.4',
  *   latest: '1.6.0',
- *   updateCommand: 'npm i -g dexto'
+ *   updateCommand: 'dexto upgrade'
  * });
  * ```
  */

package/dist/cli/utils/version-check.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"version-check.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/version-check.ts"],"names":[],"mappings":"AAkBA;;GAEG;AACH,MAAM,WAAW,UAAU;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;CACzB;AAqGD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,eAAe,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CA+DxF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,CAatE"}
+{"version":3,"file":"version-check.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/version-check.ts"],"names":[],"mappings":"AAiBA;;GAEG;AACH,MAAM,WAAW,UAAU;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;CACzB;AAkJD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,eAAe,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CA6DxF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,yBAAyB,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI,CAatE"}

package/dist/cli/utils/version-check.js

@@ -1,13 +1,17 @@
 // packages/cli/src/cli/utils/version-check.ts
 import { promises as fs } from 'fs';
+import os from 'os';
 import path from 'path';
 import chalk from 'chalk';
 import boxen from 'boxen';
-import { logger } from '@dexto/core';
-import { getDextoGlobalPath } from '@dexto/agent-management';
 const CACHE_TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
-const NPM_REGISTRY_URL = 'https://registry.npmjs.org/dexto/latest';
-const CACHE_FILE_PATH = getDextoGlobalPath('cache', 'version-check.json');
+const GITHUB_RELEASES_LATEST_URL = 'https://api.github.com/repos/truffle-ai/dexto/releases/latest';
+const CACHE_FILE_PATH = path.join(os.homedir(), '.dexto', 'cache', 'version-check.json');
+function debugLog(message) {
+    if (process.env.DEXTO_DEBUG === 'true') {
+        console.debug(`[version-check] ${message}`);
+    }
+}
 /**
  * Compare two semver versions.
  * Returns:
@@ -63,32 +67,62 @@ async function saveCache(cache) {
     }
     catch (error) {
         // Non-critical - just log and continue
-        logger.debug(`Failed to save version cache: ${error instanceof Error ? error.message : String(error)}`);
+        debugLog(`Failed to save version cache: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function normalizeReleaseTag(tagName) {
+    const trimmed = tagName.trim();
+    if (trimmed.length === 0) {
+        return null;
+    }
+    // GitHub releases in this monorepo can include scoped package tags like
+    // "@dexto/tools-filesystem@1.6.10". Always extract a trailing semver.
+    const trailingSemverMatch = trimmed.match(/(v?\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?)$/);
+    if (!trailingSemverMatch) {
+        return null;
     }
+    const version = trailingSemverMatch[1]?.trim();
+    return version && version.length > 0 ? version : null;
+}
+function extractLatestVersionFromRelease(payload) {
+    if (!payload || typeof payload !== 'object') {
+        return null;
+    }
+    const tagName = Reflect.get(payload, 'tag_name');
+    if (typeof tagName !== 'string') {
+        return null;
+    }
+    return normalizeReleaseTag(tagName);
 }
 /**
- * Fetch latest version from npm registry
+ * Fetch latest version from GitHub Releases
  */
 async function fetchLatestVersion() {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), 5000); // 5 second timeout
     try {
-        const response = await fetch(NPM_REGISTRY_URL, {
+        const response = await fetch(GITHUB_RELEASES_LATEST_URL, {
             signal: controller.signal,
             headers: {
-                Accept: 'application/json',
+                Accept: 'application/vnd.github+json',
+                'User-Agent': 'dexto-cli-version-check',
             },
         });
         if (!response.ok) {
-            logger.debug(`npm registry returned status ${response.status}`);
+            debugLog(`GitHub releases API returned status ${response.status}`);
             return null;
         }
         const data = (await response.json());
-        return data.version || null;
+        const latestVersion = extractLatestVersionFromRelease(data);
+        if (!latestVersion) {
+            debugLog('GitHub releases API response missing valid tag_name');
+            return null;
+        }
+        return latestVersion;
     }
     catch (error) {
         // Network errors, timeouts, etc. - silent fail
-        logger.debug(`Failed to fetch latest version: ${error instanceof Error ? error.message : String(error)}`);
+        debugLog(`Failed to fetch latest version: ${error instanceof Error ? error.message : String(error)}`);
         return null;
     }
     finally {
@@ -118,7 +152,7 @@ async function fetchLatestVersion() {
 export async function checkForUpdates(currentVersion) {
     // Check if update checks are disabled
     if (process.env.DEXTO_NO_UPDATE_CHECK === 'true') {
-        logger.debug('Version check disabled via DEXTO_NO_UPDATE_CHECK');
+        debugLog('Version check disabled via DEXTO_NO_UPDATE_CHECK');
         return null;
     }
     try {
@@ -128,20 +162,20 @@ export async function checkForUpdates(currentVersion) {
         if (cache && cache.currentVersion === currentVersion) {
             const cacheAge = now - cache.lastCheck;
             if (cacheAge < CACHE_TTL_MS) {
-                logger.debug(`Using cached version info (age: ${Math.round(cacheAge / 1000 / 60)} minutes)`);
+                debugLog(`Using cached version info (age: ${Math.round(cacheAge / 1000 / 60)} minutes)`);
                 // Return cached result if newer version exists
                 if (compareSemver(cache.latestVersion, currentVersion) > 0) {
                     return {
                         current: currentVersion,
                         latest: cache.latestVersion,
-                        updateCommand: 'npm i -g dexto',
+                        updateCommand: 'dexto upgrade',
                     };
                 }
                 return null;
             }
         }
-        // Cache expired or invalid - fetch from npm
-        logger.debug('Fetching latest version from npm registry');
+        // Cache expired or invalid - fetch from GitHub releases
+        debugLog('Fetching latest version from GitHub releases');
         const latestVersion = await fetchLatestVersion();
         if (!latestVersion) {
             return null;
@@ -158,14 +192,14 @@ export async function checkForUpdates(currentVersion) {
             return {
                 current: currentVersion,
                 latest: latestVersion,
-                updateCommand: 'npm i -g dexto',
+                updateCommand: 'dexto upgrade',
             };
         }
         return null;
     }
     catch (error) {
         // Never fail the CLI startup due to version check errors
-        logger.debug(`Version check error: ${error instanceof Error ? error.message : String(error)}`);
+        debugLog(`Version check error: ${error instanceof Error ? error.message : String(error)}`);
         return null;
     }
 }
@@ -179,7 +213,7 @@ export async function checkForUpdates(currentVersion) {
  * displayUpdateNotification({
  *   current: '1.5.4',
  *   latest: '1.6.0',
- *   updateCommand: 'npm i -g dexto'
+ *   updateCommand: 'dexto upgrade'
  * });
  * ```
  */

package/dist/index-main.js

@@ -22,7 +22,7 @@ function readVersionFromPackageJson(packageJsonPath) {
     return undefined;
 }
 function resolveCliVersion() {
-    // Regular installs (npm/pnpm): package.json is next to dist/.
+    // Regular npm installs: package.json is next to dist/.
     const scriptDir = path.dirname(fileURLToPath(import.meta.url));
     const localPackageJsonPath = path.resolve(scriptDir, '..', 'package.json');
     const localVersion = readVersionFromPackageJson(localPackageJsonPath);
@@ -58,6 +58,7 @@ import { registerMcpCommand } from './cli/commands/mcp/register.js';
 import { registerImageCommand } from './cli/commands/image/register.js';
 import { registerPluginCommand } from './cli/commands/plugin/register.js';
 import { registerAgentsCommand } from './cli/commands/agents/register.js';
+import { registerDeployCommand } from './cli/commands/deploy/register.js';
 const program = new Command();
 let imageImporterConfigured = false;
 let dextoApiKeyBootstrapped = false;
@@ -146,6 +147,7 @@ program
     }
 }));
 registerImageCommand({ program });
+registerDeployCommand({ program });
 // 4) `init-app` SUB-COMMAND
 program
     .command('init-app')
@@ -211,7 +213,45 @@ program
     }
 }));
 registerAgentsCommand({ program });
-// 7) `which` SUB-COMMAND
+// 7) `upgrade` SUB-COMMAND
+program
+    .command('upgrade [version]')
+    .description('Upgrade Dexto CLI (auto-migrates npm installs to native)')
+    .option('--dry-run', 'Print commands without executing them')
+    .option('--force', 'Force reinstall during upgrade')
+    .action(withAnalytics('upgrade', async (version, options) => {
+    try {
+        const { handleUpgradeCommand } = await import('./cli/commands/upgrade.js');
+        await handleUpgradeCommand(version, options);
+        safeExit('upgrade', 0);
+    }
+    catch (err) {
+        if (err instanceof ExitSignal)
+            throw err;
+        console.error(`❌ dexto upgrade command failed: ${err}`);
+        safeExit('upgrade', 1, 'error');
+    }
+}));
+// 8) `uninstall` SUB-COMMAND (CLI self uninstall)
+program
+    .command('uninstall')
+    .description('Uninstall the Dexto CLI binary (does not uninstall agents)')
+    .option('--purge', 'Also remove ~/.dexto completely')
+    .option('--dry-run', 'Print actions without deleting files')
+    .action(withAnalytics('uninstall', async (options) => {
+    try {
+        const { handleUninstallCliCommand } = await import('./cli/commands/uninstall.js');
+        await handleUninstallCliCommand(options);
+        safeExit('uninstall', 0);
+    }
+    catch (err) {
+        if (err instanceof ExitSignal)
+            throw err;
+        console.error(`❌ dexto uninstall command failed: ${err}`);
+        safeExit('uninstall', 1, 'error');
+    }
+}));
+// 9) `which` SUB-COMMAND
 program
     .command('which <agent>')
     .description('Show the path to an agent')
@@ -520,6 +560,23 @@ program
             }
             // Now resolve agent (will auto-install since setup is complete)
             resolvedPath = await resolveAgentPath(opts.agent, opts.autoInstall !== false);
+            if (opts.interactive !== false) {
+                const { getBundledSyncTargetForAgentPath, shouldPromptForSync, handleSyncAgentsCommand, } = await import('./cli/commands/agents/sync.js');
+                const syncTarget = getBundledSyncTargetForAgentPath(resolvedPath);
+                if (syncTarget && (await shouldPromptForSync(resolvedPath))) {
+                    const shouldSync = await p.confirm({
+                        message: `Bundled agent updates available for '${syncTarget.agentId}'. Sync now?`,
+                        initialValue: true,
+                    });
+                    if (!p.isCancel(shouldSync) && shouldSync) {
+                        await handleSyncAgentsCommand({
+                            force: true,
+                            quiet: true,
+                            agentIds: [syncTarget.agentId],
+                        });
+                    }
+                }
+            }
         }
         // Load raw config and apply CLI overrides
         const rawConfig = await loadAgentConfig(resolvedPath);