@dex-ai/coding-agent 0.1.92

package/src/commands/update.ts

@@ -0,0 +1,419 @@
+/**
+ * `dex update` — Update dex and all installed extensions to latest versions.
+ *
+ * Checks the registry for newer versions of:
+ *   1. @dex-ai/coding-agent (dex itself)
+ *   2. All user-installed extensions
+ *
+ * Uses the configured package manager (settings.packageManager).
+ */
+
+import {
+	existsSync,
+	readFileSync,
+	writeFileSync,
+	mkdirSync,
+	readdirSync,
+} from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { spawnSync } from "node:child_process";
+
+/* ------------------------------------------------------------------ */
+/* Helpers                                                             */
+/* ------------------------------------------------------------------ */
+
+type PackageManagerName = "npm" | "bun" | "pnpm" | "yarn";
+
+/**
+ * Copy .npmrc from ~/.dex/app to a target directory so that npm resolves
+ * packages against the configured registry (e.g. local Verdaccio).
+ */
+function ensureNpmrc(targetDir: string): void {
+	const appNpmrc = join(homedir(), ".dex", "app", ".npmrc");
+	if (!existsSync(appNpmrc)) return;
+	try {
+		const contents = readFileSync(appNpmrc, "utf-8");
+		mkdirSync(targetDir, { recursive: true });
+		writeFileSync(join(targetDir, ".npmrc"), contents);
+	} catch {
+		// Non-fatal
+	}
+}
+
+/**
+ * Query the configured npm registry for the latest version of a package.
+ * Returns null if the query fails (network error, package not found, etc.).
+ */
+function getLatestRegistryVersion(pkg: string, cwd: string): string | null {
+	const result = spawnSync("npm", ["view", pkg, "version"], {
+		cwd,
+		stdio: "pipe",
+	});
+	if (result.status !== 0) return null;
+	const version = result.stdout?.toString().trim();
+	return version || null;
+}
+
+function getConfiguredPackageManager(): PackageManagerName {
+	const settingsPath = join(homedir(), ".dex", "settings.json");
+	if (existsSync(settingsPath)) {
+		try {
+			const settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+			const pm = settings.packageManager;
+			if (pm === "npm" || pm === "bun" || pm === "pnpm" || pm === "yarn") {
+				return pm;
+			}
+		} catch {
+			// Fall through to default
+		}
+	}
+	return "npm";
+}
+
+function getCurrentDexVersion(): string {
+	try {
+		const pkgPath = join(import.meta.dir, "../../package.json");
+		const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+		return pkg.version ?? "unknown";
+	} catch {
+		return "unknown";
+	}
+}
+
+/* ------------------------------------------------------------------ */
+/* Update dex itself                                                   */
+/* ------------------------------------------------------------------ */
+
+function getDexAppDir(): string {
+	return process.env.DEX_APP_DIR ?? join(homedir(), ".dex", "app");
+}
+
+function updateDex(pm: PackageManagerName): {
+	updated: boolean;
+	oldVersion: string;
+	newVersion: string;
+} {
+	const oldVersion = getCurrentDexVersion();
+	console.log(`Checking for dex updates (current: ${oldVersion})...`);
+
+	const appDir = getDexAppDir();
+
+	// Update via the app install directory (local registry)
+	// Use `npm install @latest` instead of `npm update` — the latter doesn't
+	// reliably extract new tarballs from local registries due to cache issues.
+	if (existsSync(join(appDir, "package.json"))) {
+		// Sync overrides with dependencies BEFORE any install to avoid EOVERRIDE.
+		// npm 11 errors when an override range doesn't satisfy the direct dep range.
+		try {
+			const appPkgPath = join(appDir, "package.json");
+			const appPkgRaw = JSON.parse(readFileSync(appPkgPath, "utf-8"));
+			const deps = appPkgRaw.dependencies ?? {};
+			const ov: Record<string, string> = appPkgRaw.overrides ?? {};
+			let changed = false;
+			for (const pkg of Object.keys(ov)) {
+				if (deps[pkg] && deps[pkg] !== ov[pkg]) {
+					ov[pkg] = deps[pkg];
+					changed = true;
+				}
+			}
+			if (changed) {
+				appPkgRaw.overrides = ov;
+				writeFileSync(appPkgPath, JSON.stringify(appPkgRaw, null, 2) + "\n");
+			}
+		} catch {
+			/* non-fatal */
+		}
+
+		// Quick check: is the registry version already installed?
+		const latestVersion = getLatestRegistryVersion(
+			"@dex-ai/coding-agent",
+			appDir,
+		);
+		const coreUpToDate = latestVersion && latestVersion === oldVersion;
+
+		if (!coreUpToDate) {
+			const result = spawnSync(
+				"npm",
+				["install", "@dex-ai/coding-agent@latest", "--prefer-online"],
+				{
+					cwd: appDir,
+					stdio: "pipe",
+				},
+			);
+			if (result.status !== 0) {
+				const stderr = result.stderr?.toString().trim();
+				if (stderr) console.error(`  ${stderr}`);
+				console.error("  Failed to update dex");
+				return { updated: false, oldVersion, newVersion: oldVersion };
+			}
+		}
+
+		// Force-update all @dex-ai/* packages to latest.
+		// npm install respects semver ranges and won't pull newer patch versions
+		// if the range is already satisfied. Explicitly installing each dep
+		// at @latest ensures we always get the newest published version.
+		// This runs even when coding-agent itself is up to date, because
+		// sub-dependencies may have been published independently.
+		// We scan node_modules/@dex-ai/ directly to catch ALL transitive deps,
+		// not just coding-agent's direct dependencies.
+		const dexModulesDir = join(appDir, "node_modules", "@dex-ai");
+		if (existsSync(dexModulesDir)) {
+			try {
+				// Read overrides to skip those packages from force-update
+				const appPkg = JSON.parse(
+					readFileSync(join(appDir, "package.json"), "utf-8"),
+				);
+				const overrideSet = new Set(Object.keys(appPkg.overrides ?? {}));
+
+				const dexPkgs = readdirSync(dexModulesDir)
+					.filter(
+						(d) => d !== "coding-agent" && !overrideSet.has(`@dex-ai/${d}`),
+					)
+					.map((d) => `@dex-ai/${d}@latest`);
+				if (dexPkgs.length > 0) {
+					spawnSync("npm", ["install", ...dexPkgs, "--prefer-online"], {
+						cwd: appDir,
+						stdio: "pipe",
+					});
+				}
+			} catch {
+				/* best effort — transitive dep update is non-critical */
+			}
+		}
+
+		// Read new version from the app dir
+		const pkgPath = join(
+			appDir,
+			"node_modules",
+			"@dex-ai",
+			"coding-agent",
+			"package.json",
+		);
+		let newVersion = oldVersion;
+		if (existsSync(pkgPath)) {
+			try {
+				const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+				newVersion = pkg.version ?? oldVersion;
+			} catch {
+				/* keep oldVersion */
+			}
+		}
+		return { updated: oldVersion !== newVersion, oldVersion, newVersion };
+	}
+
+	// Fallback: global install (legacy path)
+	let cmd: string;
+	let args: string[];
+
+	switch (pm) {
+		case "bun":
+			cmd = "bun";
+			args = ["install", "-g", "@dex-ai/coding-agent"];
+			break;
+		case "pnpm":
+			cmd = "pnpm";
+			args = ["add", "-g", "@dex-ai/coding-agent@latest"];
+			break;
+		case "yarn":
+			cmd = "yarn";
+			args = ["global", "add", "@dex-ai/coding-agent@latest"];
+			break;
+		case "npm":
+		default:
+			cmd = "npm";
+			args = ["install", "-g", "@dex-ai/coding-agent@latest"];
+			break;
+	}
+
+	const result = spawnSync(cmd, args, { stdio: "pipe" });
+	if (result.status !== 0) {
+		const stderr = result.stderr?.toString().trim();
+		if (stderr) console.error(`  ${stderr}`);
+		console.error("  Failed to update dex");
+		return { updated: false, oldVersion, newVersion: oldVersion };
+	}
+
+	// Re-read version after update
+	const newVersion = getCurrentDexVersion();
+	return { updated: oldVersion !== newVersion, oldVersion, newVersion };
+}
+
+/* ------------------------------------------------------------------ */
+/* Update extensions                                                   */
+/* ------------------------------------------------------------------ */
+
+interface RegistryEntry {
+	source: "npm" | "file";
+	package: string;
+	version?: string;
+	path?: string;
+	type?: "native" | "pi-compat";
+	installedAt: string;
+}
+
+interface Registry {
+	version: 1;
+	extensions: Record<string, RegistryEntry>;
+}
+
+const USER_EXTENSIONS_DIR = join(homedir(), ".dex", "extensions");
+const USER_PACKAGES_DIR = join(USER_EXTENSIONS_DIR, "packages");
+const USER_REGISTRY_PATH = join(USER_EXTENSIONS_DIR, "registry.json");
+
+function loadRegistry(path: string): Registry {
+	if (!existsSync(path)) return { version: 1, extensions: {} };
+	try {
+		const data = JSON.parse(readFileSync(path, "utf-8"));
+		if (data.version === 1 && data.extensions) return data as Registry;
+		return { version: 1, extensions: {} };
+	} catch {
+		return { version: 1, extensions: {} };
+	}
+}
+
+function saveRegistry(path: string, registry: Registry): void {
+	const dir = join(path, "..");
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+	writeFileSync(path, JSON.stringify(registry, null, 2) + "\n");
+}
+
+function getPackageManagerUpdateCmd(
+	pm: PackageManagerName,
+	cwd: string,
+	pkg: string,
+): { command: string; args: string[] } {
+	switch (pm) {
+		case "bun":
+			return { command: "bun", args: ["update", pkg] };
+		case "pnpm":
+			return { command: "pnpm", args: ["update", pkg] };
+		case "yarn":
+			return { command: "yarn", args: ["upgrade", pkg] };
+		case "npm":
+		default:
+			// Use `install @latest --prefer-online` instead of `update` —
+			// npm update doesn't reliably extract new tarballs from local registries.
+			return {
+				command: "npm",
+				args: ["install", `${pkg}@latest`, "--prefer-online"],
+			};
+	}
+}
+
+function readInstalledVersion(
+	extensionDir: string,
+	packageName: string,
+): string | null {
+	// Handle scoped packages
+	const pkgJsonPath = join(
+		extensionDir,
+		"node_modules",
+		packageName,
+		"package.json",
+	);
+	if (!existsSync(pkgJsonPath)) return null;
+	try {
+		const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+		return pkg.version ?? null;
+	} catch {
+		return null;
+	}
+}
+
+function updateExtensions(pm: PackageManagerName): {
+	total: number;
+	updated: number;
+} {
+	const registry = loadRegistry(USER_REGISTRY_PATH);
+	const npmEntries = Object.entries(registry.extensions).filter(
+		([_, e]) => e.source === "npm",
+	);
+
+	if (npmEntries.length === 0) {
+		console.log("No extensions installed.");
+		return { total: 0, updated: 0 };
+	}
+
+	console.log(`\nUpdating ${npmEntries.length} extension(s)...`);
+	let updatedCount = 0;
+
+	for (const [name, entry] of npmEntries) {
+		const extensionDir = join(USER_PACKAGES_DIR, name);
+		if (!existsSync(extensionDir)) {
+			console.error(
+				`  ✗ ${name}: directory missing (reinstall with: dex extension install npm:${entry.package})`,
+			);
+			continue;
+		}
+
+		const oldVersion = entry.version ?? "unknown";
+		ensureNpmrc(extensionDir);
+
+		// Quick check: is the registry version already installed?
+		const latestVersion = getLatestRegistryVersion(entry.package, extensionDir);
+		if (latestVersion && latestVersion === oldVersion) {
+			console.log(`  · ${name}: up to date (${oldVersion})`);
+			continue;
+		}
+
+		const cmd = getPackageManagerUpdateCmd(pm, extensionDir, entry.package);
+		const result = spawnSync(cmd.command, cmd.args, {
+			cwd: extensionDir,
+			stdio: "pipe",
+		});
+
+		if (result.status !== 0) {
+			console.error(`  ✗ ${name}: update failed`);
+			continue;
+		}
+
+		const newVersion =
+			readInstalledVersion(extensionDir, entry.package) ?? oldVersion;
+
+		if (oldVersion !== newVersion) {
+			console.log(`  ✓ ${name}: ${oldVersion} → ${newVersion}`);
+			registry.extensions[name] = {
+				...entry,
+				version: newVersion,
+				installedAt: new Date().toISOString(),
+			};
+			updatedCount++;
+		} else {
+			console.log(`  · ${name}: up to date (${newVersion})`);
+		}
+	}
+
+	saveRegistry(USER_REGISTRY_PATH, registry);
+	return { total: npmEntries.length, updated: updatedCount };
+}
+
+/* ------------------------------------------------------------------ */
+/* Main                                                                */
+/* ------------------------------------------------------------------ */
+
+export function runUpdateCommand(): void {
+	const pm = getConfiguredPackageManager();
+
+	// 1. Update dex itself
+	const dex = updateDex(pm);
+	if (dex.updated) {
+		console.log(`  ✓ dex: ${dex.oldVersion} → ${dex.newVersion}`);
+	} else {
+		console.log(`  · dex: up to date (${dex.newVersion})`);
+	}
+
+	// 2. Update all installed extensions
+	const ext = updateExtensions(pm);
+
+	// Summary
+	console.log("");
+	const totalUpdated = (dex.updated ? 1 : 0) + ext.updated;
+	if (totalUpdated > 0) {
+		console.log(
+			`Updated ${totalUpdated} package(s). Restart dex to use new versions.`,
+		);
+	} else {
+		console.log("Everything is up to date.");
+	}
+}

package/src/env.d.ts

@@ -0,0 +1,5 @@
+declare module "*.vue" {
+  import type { Component } from "@vue/runtime-core";
+  const component: Component;
+  export default component;
+}

package/src/extensions/cli-tui-components/ActivityPanel.vue

@@ -0,0 +1,24 @@
+<template>
+  <!-- Extension-contributed content -->
+  <WidgetRenderer v-if="content" :node="content" />
+  <!-- Default spinner when generating -->
+  <line v-else-if="isGenerating">
+    <text color="accent" :style="{ opacity: dotOpacity }">●</text>
+    <text dim :style="{ paddingLeft: 1 }">crushing tokens...</text>
+  </line>
+  <!-- Nothing otherwise -->
+</template>
+
+<script setup lang="ts">
+import { computed } from "@vue/runtime-core";
+import { WidgetRenderer } from "@dex-ai/vue-tui";
+import type { WidgetNode } from "@dex-ai/vue-tui";
+
+const props = defineProps<{
+  content: WidgetNode | null;
+  isGenerating: boolean;
+  spinnerFrame: number;
+}>();
+
+const dotOpacity = computed(() => props.spinnerFrame % 2 === 0 ? 1 : 0.4);
+</script>

package/src/extensions/cli-tui-components/ActivityPanel.vue.compiled.ts

@@ -0,0 +1,96 @@
+/**
+ * ActivityPanel — dynamic content zone above the input area.
+ *
+ * Renders either:
+ * - Extension-contributed content (WidgetNode from a DynamicPanel)
+ * - Default spinner ("crushing tokens") when generating with no panel
+ * - Nothing when idle and no panel is visible
+ */
+
+import * as _Vue from "@vue/runtime-core";
+const {
+	h: _h,
+	createElementVNode: _createElementVNode,
+	createElementBlock: _createElementBlock,
+	createCommentVNode: _createCommentVNode,
+	createVNode: _createVNode,
+	normalizeStyle: _normalizeStyle,
+	openBlock: _openBlock,
+} = _Vue;
+
+import { defineComponent as _defineComponent } from "@vue/runtime-core";
+import { computed } from "@vue/runtime-core";
+import { WidgetRenderer } from "@dex-ai/vue-tui";
+
+const __sfc_main = /*@__PURE__*/ _defineComponent({
+	__name: "ActivityPanel",
+	props: {
+		content: { type: [Object, null], required: true },
+		isGenerating: { type: Boolean, required: true },
+		spinnerFrame: { type: Number, required: true },
+	},
+	setup(__props: any, { expose: __expose }) {
+		__expose();
+
+		const props = __props;
+
+		const dotOpacity = computed(() => (props.spinnerFrame % 2 === 0 ? 1 : 0.4));
+
+		const __returned__ = { props, dotOpacity, WidgetRenderer };
+		Object.defineProperty(__returned__, "__isScriptSetup", {
+			enumerable: false,
+			value: true,
+		});
+		return __returned__;
+	},
+});
+
+const render = (
+	_ctx: any,
+	_cache: any,
+	$props: any,
+	$setup: any,
+	$data: any,
+	$options: any,
+) => {
+	// If we have extension-provided content, render it
+	if ($props.content) {
+		return _createVNode(
+			$setup["WidgetRenderer"],
+			{ node: $props.content },
+			null,
+			8,
+			["node"],
+		);
+	}
+
+	// Default spinner when generating
+	if ($props.isGenerating) {
+		return (
+			_openBlock(),
+			_createElementBlock("line", null, [
+				_createElementVNode(
+					"text",
+					{
+						color: "accent",
+						style: _normalizeStyle({ opacity: $setup.dotOpacity }),
+					},
+					"●",
+					4 /* STYLE */,
+				),
+				_createElementVNode(
+					"text",
+					{ dim: "", style: { paddingLeft: 1 } },
+					"crushing tokens...",
+				),
+			])
+		);
+	}
+
+	// Nothing to show
+	return _createCommentVNode("v-if", true);
+};
+
+__sfc_main.render = render;
+
+export default __sfc_main;

package/src/extensions/cli-tui-components/App.vue

@@ -0,0 +1,127 @@
+<template>
+  <root>
+    <Header :title="title" :subtitle="subtitle" />
+    <spacer />
+    <Messages :messages="messages" :spinnerFrame="spinnerFrame" :expandToolOutput="toolDetailOpen" />
+    <ThinkingBlock v-if="streamingReasoning && !hideThinking" :content="streamingReasoning" status="running" :spinnerFrame="spinnerFrame" :expanded="false" />
+    <MarkdownContent v-if="streamingText" :content="streamingText" :streaming="true" dot />
+    <ActivityPanel :content="activityContent" :isGenerating="isGenerating" :spinnerFrame="spinnerFrame" />
+    <ApprovalPrompt v-if="approvalRequest" :request="approvalRequest" />
+    <Modal v-if="modalProps" :modal="modalProps" />
+    <SteeringPreview v-if="steeringQueue" :text="steeringQueue" />
+
+    <!-- Zone 1: Interactive Panel (above input) -->
+    <InteractivePanel
+      v-if="activeInteractivePanel && !approvalRequest && !modalProps"
+      :panel="activeInteractivePanel"
+      :width="terminalCols"
+      :state="agentState"
+    />
+
+    <SettingsPanel v-if="settingsPanel && settingsPanel.open && !approvalRequest && !modalProps"
+      :tabs="settingsPanel.tabs"
+      :activeTabIndex="settingsPanel.activeTabIndex"
+      :focusedFieldIndex="settingsPanel.focusedFieldIndex"
+      :focusZone="settingsPanel.focusZone"
+      :editing="settingsPanel.editing"
+      :values="settingsPanel.values"
+      :error="settingsPanel.error"
+      :searchFilter="settingsPanel.searchFilter"
+      :scrollOffset="settingsPanel.scrollOffset"
+      :visibleRows="settingsPanel.visibleRows"
+    />
+    <AskPanel v-else-if="askPanel && askPanel.open && !approvalRequest && !modalProps"
+      :tabs="askPanel.tabs"
+      :singleTab="askPanel.singleTab"
+      :activeTabIndex="askPanel.activeTabIndex"
+      :onSubmitTab="askPanel.onSubmitTab"
+      :tabStates="askPanel.tabStates"
+      :focusedOptionIndex="askPanel.focusedOptionIndex"
+      :checkedValues="askPanel.checkedValues"
+      :freeTextFocused="askPanel.freeTextFocused"
+      :freeTextBuffer="askPanel.freeTextBuffer"
+      :actionFocused="askPanel.actionFocused"
+      :actionBarIndex="askPanel.actionBarIndex"
+      :tabResults="askPanel.tabResults"
+      :scrollOffset="askPanel.scrollOffset"
+      :visibleOptions="askPanel.visibleOptions"
+    />
+    <InputArea v-else-if="!approvalRequest && !modalProps" :lines="lines" :cursorRow="cursorRow" :cursorCol="cursorCol" :hint="isGenerating ? 'add steering details' : undefined" :pasteTokens="pasteTokens" :pasteBuffer="pasteBuffer" />
+    <CommandPalette v-if="commandPaletteOpen" :items="filteredCommands" :selectedIndex="commandPaletteIndex" />
+    <StatusBar v-if="!commandPaletteOpen && !modalProps" :cwd="cwd" :model="model" :tokens="tokens" :contextWindow="contextWindow" :permissionMode="permissionMode" :thinkingLevel="thinkingLevel" :extensionStatuses="extensionStatuses" />
+  </root>
+</template>
+
+<script setup lang="ts">
+import Header from "./Header.vue";
+import Messages from "./Messages.vue";
+import ActivityPanel from "./ActivityPanel.vue";
+import InputArea from "./InputArea.vue";
+import SteeringPreview from "./SteeringPreview.vue";
+import StatusBar from "./StatusBar.vue";
+import ApprovalPrompt from "./ApprovalPrompt.vue";
+import CommandPalette from "./CommandPalette.vue";
+import Modal from "./Modal.vue";
+import MarkdownContent from "./MarkdownContent";
+import ThinkingBlock from "./ThinkingBlock.vue";
+import InteractivePanel from "./InteractivePanel.vue";
+import SettingsPanel from "./SettingsPanel.vue";
+import AskPanel from "./AskPanel.vue";
+import type { WidgetNode } from "@dex-ai/vue-tui";
+import type { InteractivePanel as InteractivePanelType } from "../../panels";
+import type { SettingsPanelState } from "./settings-panel-controller";
+import type { AskPanelState } from "./ask-panel-controller";
+
+defineProps<{
+  title: string;
+  subtitle: string;
+  messages: any[];
+  streamingText: string;
+  streamingReasoning: string;
+  hideThinking: boolean;
+  isGenerating: boolean;
+  spinnerFrame: number;
+  lines: string[];
+  cursorRow: number;
+  cursorCol: number;
+  pasteTokens: Map<number, { id: number; content: string; lineCount: number }>;
+  pasteBuffer: { id: number; index: number; entry: { type: string; content?: string; lineCount?: number; data?: Uint8Array; mediaType?: string } }[];
+  cwd: string;
+  model: string;
+  tokens: number;
+  contextWindow: number;
+  permissionMode: 'read' | 'auto' | 'yolo';
+  thinkingLevel: string | undefined;
+  extensionStatuses: Record<string, string>;
+  approvalRequest: { toolName: string; reason: string; input: unknown } | null;
+  commandPaletteOpen: boolean;
+  filteredCommands: Array<{ name: string; description: string }>;
+  commandPaletteIndex: number;
+  modalProps: {
+    type: 'list' | 'form' | 'confirm';
+    title: string;
+    filteredItems?: Array<{ label: string; hint?: string }>;
+    selectedIndex?: number;
+    filter?: string;
+    allowFilter?: boolean;
+    maxVisible?: number;
+    fields?: Array<{ key: string; label: string; type: string; value?: string; placeholder?: string; hint?: string; required?: boolean; readonly?: boolean; options?: string[] }>;
+    values?: Record<string, string>;
+    focusedIndex?: number;
+    editing?: boolean;
+    editBuffer?: string;
+    error?: string;
+    body?: string;
+    options?: Array<{ key: string; label: string; value: string }>;
+  } | null;
+  toolDetailOpen: boolean;
+  activityContent: WidgetNode | null;
+  steeringQueue: string | null;
+  terminalRows: number;
+  terminalCols: number;
+  activeInteractivePanel: InteractivePanelType | null;
+  agentState: ReadonlyMap<string, unknown>;
+  settingsPanel: SettingsPanelState | null;
+  askPanel: AskPanelState | null;
+}>();
+</script>