feat(terminal): add unit test for TerminalSession capabilities

refactor(ui-focus): consolidate FocusLayer type definition

refactor(autocomplete): streamline command registration in AutocompleteInput

refactor(nested-popover-menu): simplify command registration in NestedPopoverMenu

refactor(panel-group): optimize command registration in PanelGroup

refactor(panel-commands): enhance command registration logic in usePanelCommands

refactor(commands): update built-in command handling to use executeCommands

fix(extension-host): improve error logging for worker runtime errors

refactor(extension-lifecycle): clean up useEffect dependencies in useExtensionLifecycleRuntime

fix(extension-theme): handle promise rejection in theme application

refactor(vscodeShim): update imports for better type management across modules

test(commands): enhance command keybinding tests and ensure backward compatibility

Co-authored-by: Copilot <copilot@github.com>

Author: aesopov

package.json

@@ -12,7 +12,8 @@
     "lint": "eslint . --cache",
     "lint:fix": "eslint . --cache --fix",
     "fmt": "eslint . --cache --fix",
-    "fmt:check": "eslint . --cache --fix-dry-run"
+    "fmt:check": "eslint . --cache --fix-dry-run",
+    "test": "turbo run test"
   },
   "dependencies": {
     "@dotdirfm/ui": "workspace:*",

packages/commands/src/commands.ts

@@ -57,7 +57,6 @@ export type KeybindingLayer = "default" | "extension" | "user";
 type CommandHandler = (...args: unknown[]) => void | Promise<void>;
 type RegisteredCommandHandler = {
   handler: CommandHandler;
-  isActive?: () => boolean;
 };
 type ContextGetter = () => Record<string, unknown>;
 type ResolvedKeybinding = Keybinding & { normalizedKey: string };
@@ -117,9 +116,9 @@ export class CommandRegistry {
     };
   }
 
-  registerCommand(id: string, handler: CommandHandler, options?: { isActive?: () => boolean }): () => void {
+  registerCommand(id: string, handler: CommandHandler): () => void {
     const handlers = this.handlers.get(id);
-    const entry: RegisteredCommandHandler = { handler, isActive: options?.isActive };
+    const entry: RegisteredCommandHandler = { handler };
     if (handlers) {
       handlers.push(entry);
     } else {
@@ -175,15 +174,7 @@ export class CommandRegistry {
       return;
     }
 
-    const selected =
-      [...registrations].reverse().find((entry) => {
-        if (!entry.isActive) return false;
-        try {
-          return entry.isActive();
-        } catch {
-          return false;
-        }
-      }) ?? registrations[registrations.length - 1];
+    const selected = registrations[registrations.length - 1];
     if (!selected) return;
 
     console.log("[dotdir:command]", id, ...args);
@@ -484,8 +475,40 @@ export class CommandRegistry {
   private notifyListeners(): void {
     for (const cb of this.listeners) cb();
   }
+
+  async executeCommands(steps: RunCommandsStep[]): Promise<void> {
+    for (const step of steps) {
+      if (typeof step === "string") {
+        await this.executeCommand(step);
+        continue;
+      }
+
+      if (Array.isArray(step.args)) {
+        await this.executeCommand(step.command, ...step.args);
+        continue;
+      }
+
+      if (step.args !== undefined) {
+        await this.executeCommand(step.command, step.args);
+        continue;
+      }
+
+      await this.executeCommand(step.command);
+    }
+  }
 }
 
+export type RunCommandsStep =
+  | string
+  | {
+      command: string;
+      args?: unknown;
+    };
+
+export type RunCommandsArgs = {
+  commands: RunCommandsStep[];
+};
+
 const CommandRegistryReactContext = createContext<CommandRegistry | null>(null);
 
 export function CommandRegistryProvider({ children }: { children: ReactNode }) {

packages/commands/src/runCommands.ts

@@ -1,33 +1,7 @@
-import type { CommandRegistry } from "./commands";
-
-export type RunCommandsStep =
-  | string
-  | {
-      command: string;
-      args?: unknown;
-    };
-
-export type RunCommandsArgs = {
-  commands: RunCommandsStep[];
-};
+import type { CommandRegistry, RunCommandsStep } from "./commands";
 
+/** @deprecated Use `registry.executeCommands(steps)` instead. */
 export async function runCommandSequence(commandRegistry: CommandRegistry, commands: RunCommandsStep[]): Promise<void> {
-  for (const step of commands) {
-    if (typeof step === "string") {
-      await commandRegistry.executeCommand(step);
-      continue;
-    }
-
-    if (Array.isArray(step.args)) {
-      await commandRegistry.executeCommand(step.command, ...step.args);
-      continue;
-    }
-
-    if (step.args !== undefined) {
-      await commandRegistry.executeCommand(step.command, step.args);
-      continue;
-    }
-
-    await commandRegistry.executeCommand(step.command);
-  }
+  return commandRegistry.executeCommands(commands);
 }
+

packages/commands/tests/commands.test.ts

@@ -76,49 +76,37 @@ describe("CommandRegistry", () => {
 
     it("does not throw when command is not found", async () => {
       const registry = createRegistry();
-      await expect(
-        registry.executeCommand("nonexistent.command"),
-      ).resolves.toBeUndefined();
+      await expect(registry.executeCommand("nonexistent.command")).resolves.toBeUndefined();
     });
 
-    it("prefers active-scoped handlers over inactive ones", async () => {
+    it("executes the last registered handler", async () => {
       const registry = createRegistry();
       const results: string[] = [];
 
-      registry.registerCommand("test.scope", () => results.push("default"));
-
-      registry.registerCommand(
-        "test.scope",
-        () => results.push("active"),
-        { isActive: () => true },
-      );
+      registry.registerCommand("test.override", () => {
+        results.push("first");
+      });
 
-      registry.registerCommand(
-        "test.scope",
-        () => results.push("inactive"),
-        { isActive: () => false },
-      );
+      registry.registerCommand("test.override", () => {
+        results.push("second");
+      });
 
-      await registry.executeCommand("test.scope");
-      expect(results).toEqual(["active"]);
+      await registry.executeCommand("test.override");
+      expect(results).toEqual(["second"]);
     });
 
-    it("falls back to the last registered handler when no active scope matches", async () => {
+    it("unregister removes the handler", async () => {
       const registry = createRegistry();
-      const results: string[] = [];
+      let called = false;
 
-      registry.registerCommand(
-        "test.fallback",
-        () => results.push("inactive"),
-        { isActive: () => false },
-      );
+      const unregister = registry.registerCommand("test.unreg", () => {
+        called = true;
+      });
 
-      registry.registerCommand("test.fallback", () =>
-        results.push("fallback"),
-      );
+      unregister();
 
-      await registry.executeCommand("test.fallback");
-      expect(results).toEqual(["fallback"]);
+      await registry.executeCommand("test.unreg");
+      expect(called).toBe(false);
     });
   });
 
@@ -130,34 +118,22 @@ describe("CommandRegistry", () => {
 
     it("adds and retrieves keybindings for a layer", () => {
       const registry = createRegistry();
-      registry.registerKeybinding(
-        { command: "test.cmd", key: "ctrl+a" },
-        "default",
-      );
+      registry.registerKeybinding({ command: "test.cmd", key: "ctrl+a" }, "default");
       const bindings = registry.getKeybindings();
       expect(bindings).toHaveLength(1);
       expect(bindings[0]!.key).toBe("ctrl+a");
     });
 
     it("filters out keybindings with empty command", () => {
       const registry = createRegistry();
-      registry.registerKeybinding(
-        { command: "", key: "ctrl+a" },
-        "default",
-      );
+      registry.registerKeybinding({ command: "", key: "ctrl+a" }, "default");
       expect(registry.getKeybindings()).toHaveLength(0);
     });
 
     it("resolves keybindings for a specific layer", () => {
       const registry = createRegistry();
-      registry.registerKeybinding(
-        { command: "cmd.a", key: "ctrl+x" },
-        "default",
-      );
-      registry.registerKeybinding(
-        { command: "cmd.b", key: "ctrl+y" },
-        "user",
-      );
+      registry.registerKeybinding({ command: "cmd.a", key: "ctrl+x" }, "default");
+      registry.registerKeybinding({ command: "cmd.b", key: "ctrl+y" }, "user");
 
       const defaultBindings = registry.getKeybindingsForLayer("default");
       expect(defaultBindings).toHaveLength(1);

packages/fss/src/layers.ts

@@ -133,7 +133,7 @@ export class LayeredResolver implements StyleResolver {
     const layers = this.getApplicableLayers(node.path);
     const cacheKey = this.buildCacheKey(node, layers);
 
-    let cached = this.styleCache.get(cacheKey);
+    const cached = this.styleCache.get(cacheKey);
     if (cached !== undefined) return cached;
 
     const merged: ResolvedStyle = {};
@@ -155,7 +155,7 @@ export class LayeredResolver implements StyleResolver {
     const layers = this.getApplicableLayers(node.path);
     const cacheKey = this.buildCacheKey(node, layers);
 
-    let cached = this.sortCache.get(cacheKey);
+    const cached = this.sortCache.get(cacheKey);
     if (cached !== undefined) return cached;
 
     const merged: Record<string, FssValue> = {};
@@ -173,7 +173,7 @@ export class LayeredResolver implements StyleResolver {
    * Resolve table config for a given path (uses closest layer).
    */
   resolveTableConfig(path: string): Record<string, any> {
-    let cached = this.tableConfigCache.get(path);
+    const cached = this.tableConfigCache.get(path);
     if (cached !== undefined) return cached;
 
     const layers = this.getApplicableLayers(path);

packages/fss/src/resolver.ts

@@ -127,10 +127,11 @@ function getNodeAttrValue(name: string, node: FsNode): string | boolean | undefi
       return node.path;
     case 'type':
       return node.type;
-    default:
+    default: {
       const meta = node.meta[name];
       if (meta === undefined) return undefined;
       return typeof meta === 'string' || typeof meta === 'boolean' ? meta : String(meta);
+    }
   }
 }
 
@@ -207,7 +208,7 @@ function gatherCandidates(sheet: CompiledStylesheet, node: FsNode): CompiledRule
   }
 
   const bKey = computeBucketKey(sheet, node);
-  let cached = sheetCache.get(bKey);
+  const cached = sheetCache.get(bKey);
   if (cached) return cached;
 
   // Use a Set to avoid duplicates (a rule might be indexed under multiple keys)

packages/terminal/tests/TerminalSession.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from "vitest";
+import { TerminalSession } from "../src";
+
+describe("TerminalSession", () => {
+  it("has correct initial status", () => {
+    const bridge = {} as any;
+    const session = new TerminalSession(
+      bridge,
+      "/home/user",
+      { id: "test", shell: "/bin/bash", label: "Test", cwdEscape: "posix", hiddenCdTemplate: " cd {{cwd}}", lineEnding: "\n" },
+      () => false,
+    );
+    const caps = session.getCapabilities();
+    expect(caps.cwd).toBe("/home/user");
+    expect(caps.profileId).toBe("test");
+  });
+});

packages/ui-focus/src/index.ts

@@ -1,15 +1,6 @@
 import { createContext, createElement, useContext, useEffect, useRef, type ReactNode } from "react";
 
-export type FocusLayer =
-  | "panel"
-  | "autocomplete"
-  | "searchResults"
-  | "menu"
-  | "commandPalette"
-  | "modal"
-  | "terminal"
-  | "editor"
-  | "viewer";
+export type FocusLayer = "panel" | "autocomplete" | "searchResults" | "menu" | "commandPalette" | "modal" | "terminal" | "editor" | "viewer";
 
 type FocusChangeCallback = (layer: FocusLayer) => void;
 type FocusStateChangeCallback = (state: FocusState) => void;