@adhdev/daemon-core 0.9.82-rc.312 → 0.9.82-rc.314

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.312",
+  "version": "0.9.82-rc.314",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -46,7 +46,7 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.312",
+    "@adhdev/mesh-shared": "0.9.82-rc.314",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/commands/upgrade-helper.ts

@@ -321,42 +321,64 @@ function removeDaemonPidFile(): void {
   }
 }
 
-function cleanupStaleGlobalInstallDirs(pkgName: string, surface: CurrentGlobalInstallSurface): void {
-  const prefixArgs = surface.installPrefix ? ['--prefix', surface.installPrefix] : [];
-  const npmRoot = String(execNpmCommandSync(['root', '-g', ...prefixArgs], { encoding: 'utf8' }, surface)).trim();
-  if (!npmRoot) return;
-  const npmPrefix = surface.installPrefix
-    || String(execNpmCommandSync(['prefix', '-g', ...prefixArgs], { encoding: 'utf8' }, surface)).trim();
-  const binDir = process.platform === 'win32' ? npmPrefix : path.join(npmPrefix, 'bin');
-  const packageBaseName = pkgName.startsWith('@') ? pkgName.split('/')[1] : pkgName;
-  const binNames = new Set<string>([packageBaseName]);
-  if (pkgName === '@adhdev/daemon-standalone') {
-    binNames.add('adhdev-standalone');
+/**
+ * Best-effort removal of a leftover npm staging entry.
+ *
+ * A stale staging dir can hold a locked native binary — e.g. `ghostty-vt.dll`
+ * from `@adhdev/ghostty-vt-node` still mapped by a lingering session-host
+ * process — which makes `rmSync` throw `EPERM` on Windows. Staging cleanup is
+ * only housekeeping: the leftover is inert and npm creates its own fresh
+ * staging dir for the real install, so a lock on an old leftover must NOT abort
+ * the upgrade. Log and continue instead of letting the error propagate.
+ */
+export function safeRemoveStaleEntry(target: string, label: string): void {
+  try {
+    fs.rmSync(target, { recursive: true, force: true });
+    appendUpgradeLog(`${label}: ${target}`);
+  } catch (error: any) {
+    appendUpgradeLog(`Skipped locked stale entry (${error?.code || 'error'}): ${target} — ${error?.message || String(error)}`);
   }
+}
 
-  if (pkgName.startsWith('@')) {
-    const [scope, name] = pkgName.split('/');
-    const scopeDir = path.join(npmRoot, scope);
-    if (!fs.existsSync(scopeDir)) return;
-    for (const entry of fs.readdirSync(scopeDir)) {
-      if (!entry.startsWith(`.${name}-`)) continue;
-      fs.rmSync(path.join(scopeDir, entry), { recursive: true, force: true });
-      appendUpgradeLog(`Removed stale scoped staging dir: ${path.join(scopeDir, entry)}`);
+export function cleanupStaleGlobalInstallDirs(pkgName: string, surface: CurrentGlobalInstallSurface): void {
+  // The whole routine is housekeeping — never let it throw out and abort the
+  // upgrade (npm root/prefix probing or readdir can fail for unrelated reasons).
+  try {
+    const prefixArgs = surface.installPrefix ? ['--prefix', surface.installPrefix] : [];
+    const npmRoot = String(execNpmCommandSync(['root', '-g', ...prefixArgs], { encoding: 'utf8' }, surface)).trim();
+    if (!npmRoot) return;
+    const npmPrefix = surface.installPrefix
+      || String(execNpmCommandSync(['prefix', '-g', ...prefixArgs], { encoding: 'utf8' }, surface)).trim();
+    const binDir = process.platform === 'win32' ? npmPrefix : path.join(npmPrefix, 'bin');
+    const packageBaseName = pkgName.startsWith('@') ? pkgName.split('/')[1] : pkgName;
+    const binNames = new Set<string>([packageBaseName]);
+    if (pkgName === '@adhdev/daemon-standalone') {
+      binNames.add('adhdev-standalone');
     }
-  } else {
-    for (const entry of fs.readdirSync(npmRoot)) {
-      if (!entry.startsWith(`.${pkgName}-`)) continue;
-      fs.rmSync(path.join(npmRoot, entry), { recursive: true, force: true });
-      appendUpgradeLog(`Removed stale staging dir: ${path.join(npmRoot, entry)}`);
+
+    if (pkgName.startsWith('@')) {
+      const [scope, name] = pkgName.split('/');
+      const scopeDir = path.join(npmRoot, scope);
+      if (!fs.existsSync(scopeDir)) return;
+      for (const entry of fs.readdirSync(scopeDir)) {
+        if (!entry.startsWith(`.${name}-`)) continue;
+        safeRemoveStaleEntry(path.join(scopeDir, entry), 'Removed stale scoped staging dir');
+      }
+    } else {
+      for (const entry of fs.readdirSync(npmRoot)) {
+        if (!entry.startsWith(`.${pkgName}-`)) continue;
+        safeRemoveStaleEntry(path.join(npmRoot, entry), 'Removed stale staging dir');
+      }
     }
-  }
 
-  if (fs.existsSync(binDir)) {
-    for (const entry of fs.readdirSync(binDir)) {
-      if (!Array.from(binNames).some((name) => entry.startsWith(`.${name}-`))) continue;
-      fs.rmSync(path.join(binDir, entry), { recursive: true, force: true });
-      appendUpgradeLog(`Removed stale bin staging entry: ${path.join(binDir, entry)}`);
+    if (fs.existsSync(binDir)) {
+      for (const entry of fs.readdirSync(binDir)) {
+        if (!Array.from(binNames).some((name) => entry.startsWith(`.${name}-`))) continue;
+        safeRemoveStaleEntry(path.join(binDir, entry), 'Removed stale bin staging entry');
+      }
     }
+  } catch (error: any) {
+    appendUpgradeLog(`Stale staging cleanup skipped (${error?.code || 'error'}): ${error?.message || String(error)}`);
   }
 }
 

package/src/providers/provider-loader.ts

@@ -22,6 +22,7 @@ import { LOG } from '../logging/logger.js';
 import { VersionArchive } from './version-archive.js';
 import type {
   ProviderCompatibilityEntry,
+  ProviderControlDef,
   ProviderModule,
   ProviderCategory,
   ProviderScripts,
@@ -87,6 +88,70 @@ export interface MachineProviderConfig {
   lastVerification?: MachineProviderCheckResult;
 }
 
+/**
+ * Translate a spec `control_bar` array into the web-facing
+ * `ProviderControlDef[]` shape the dashboard renders.
+ *
+ * The two shapes are distinct: `control_bar` entries are daemon-side
+ * `{ id, label, visible_when_state, action }` records driving
+ * SpecCliAdapter.invokeScript, while the dashboard's chat bar reads
+ * `ProviderControlDef` (`{ id, type, label, placement, ... }`). Spec
+ * providers (claude-cli / codex-cli) historically declared *only*
+ * `control_bar`, so the dashboard saw no controls at all — the Model / Mode
+ * pickers never rendered. This bridges that gap without changing how the
+ * controls actually dispatch.
+ *
+ * Script-name contract: the dashboard sends the control's
+ * `listScript` / `setScript` / `invokeScript` name through
+ * `invoke_provider_script`, which gates on `provider.scripts[<name>]` and then
+ * routes to `SpecCliAdapter.invokeScript(<name>)` — which matches the name
+ * against `control_bar[].id`. So every synthesized script name MUST equal the
+ * control id (the loader stubs `provider.scripts[id]` from the same source).
+ *
+ * Mapping:
+ *   open_picker  → select (dynamic): list + set both keyed on the control id;
+ *                  the adapter distinguishes LIST vs SELECT by the presence of
+ *                  a choice arg, so one id serves both roles.
+ *   send_keys    → action: one-shot keystroke (stop, cycle_mode).
+ *   attach_image → skipped: it needs an image blob from a file picker, not a
+ *                  bare bar button; surfacing it as an `action` would only
+ *                  produce a button that errors with "requires args.blob".
+ */
+function synthesizeControlsFromControlBar(specControls: any[]): ProviderControlDef[] {
+  const out: ProviderControlDef[] = [];
+  specControls.forEach((ctl, index) => {
+    const id = typeof ctl?.id === 'string' ? ctl.id.trim() : '';
+    const actionType = ctl?.action?.type;
+    if (!id || !actionType) return;
+    const label = typeof ctl?.label === 'string' && ctl.label.trim() ? ctl.label : id;
+    if (actionType === 'open_picker') {
+      out.push({
+        id,
+        type: 'select',
+        label,
+        placement: 'bar',
+        dynamic: true,
+        listScript: id,
+        setScript: id,
+        readFrom: id,
+        order: index,
+      });
+    } else if (actionType === 'send_keys') {
+      out.push({
+        id,
+        type: 'action',
+        label,
+        placement: 'bar',
+        invokeScript: id,
+        resultDisplay: 'none',
+        order: index,
+      });
+    }
+    // attach_image intentionally skipped — see fn doc.
+  });
+  return out;
+}
+
 type CliDetectionEntry = {
   id: string;
   displayName: string;
@@ -1271,6 +1336,19 @@ export class ProviderLoader {
                 });
               }
             }
+            // Bridge the spec control_bar into the web-facing controls schema so
+            // the dashboard chat bar actually renders Model/Mode pickers. Only
+            // synthesize when the provider hasn't already declared its own
+            // `controls` in provider.v1.json (e.g. hermes-cli) — an explicit
+            // declaration wins and must not be clobbered.
+            const hasDeclaredControls = Array.isArray((resolved as any).controls)
+              && (resolved as any).controls.length > 0;
+            if (!hasDeclaredControls) {
+              const synthesized = synthesizeControlsFromControlBar(specControls);
+              if (synthesized.length > 0) {
+                resolved.controls = synthesized;
+              }
+            }
           }
           if (nh) {
             let reader: ((input: any) => any) | null = null;

package/src/providers/spec/cli-adapter.ts

@@ -355,8 +355,14 @@ export class SpecCliAdapter implements CliAdapter {
             const choiceIndex = typeof flat.choiceIndex === 'number' ? flat.choiceIndex
                 : typeof flat.choiceIndex === 'string' && flat.choiceIndex.trim() ? Number(flat.choiceIndex)
                 : undefined;
+            // `value` is the arg the dashboard's generic value-control set path
+            // sends ({ value: <chosen option> }). control_bar pickers are
+            // surfaced to the dashboard as dynamic `select` controls whose
+            // option values are the screen-parsed labels, so a bare `value`
+            // is just a label to match against the live choices.
             const choiceLabel = typeof flat.choiceLabel === 'string' ? flat.choiceLabel
                 : typeof flat.choice === 'string' ? flat.choice
+                : typeof flat.value === 'string' ? flat.value
                 : undefined;
             if ((typeof choiceIndex === 'number' && Number.isFinite(choiceIndex)) || (choiceLabel && choiceLabel.trim())) {
                 return this.selectPickerChoice(ctl, action, choiceIndex, choiceLabel);