@empirical-gauzza/cli 1.0.31 → 1.0.33

package/lib/alertBanner.js

@@ -23,6 +23,16 @@ function colorize(code, text) {
   return `${code}${text}${ANSI.reset}`;
 }
 
+// Due times are shown in this terminal's own time zone, never the server's UTC sentence.
+function localDueLine(alert) {
+  if (!alert || !alert.dueAt) return alert ? alert.body : '';
+  const d = new Date(alert.dueAt);
+  if (Number.isNaN(d.getTime())) return alert.body;
+  const when = d.toLocaleString(undefined, { weekday: 'short', month: 'short', day: 'numeric', hour: 'numeric', minute: '2-digit', timeZoneName: 'short' });
+  const rest = String(alert.body || '').replace(/^Due [^\n]*? UTC\.\s*/, '');
+  return `Due ${when}.${rest ? ` ${rest}` : ''}`;
+}
+
 function reminderMemoryId(alert) {
   const key = String(alert && alert.alertKey || '');
   return key.startsWith('reminder_') ? key.slice('reminder_'.length) : null;
@@ -37,7 +47,7 @@ function renderOneAlert(alert) {
     // A reminder the user set. Whoever reads this, person or agent, should surface it first;
     // the agent case was observed being skipped when the banner read like a footnote.
     lines.push(colorize(`${ANSI.bold}${color}`, `REMINDER DUE - tell the user now: ${alert.title.replace(/^Reminder:\s*/, '')}`));
-    lines.push(`  ${alert.body}`);
+    lines.push(`  ${localDueLine(alert)}`);
     for (const action of alert.actions || []) {
       lines.push(`  → ${action.label}: ${action.href}`);
     }

package/lib/installers/nativePlugin.js

@@ -23,19 +23,119 @@ function runPluginCommand(command, args, options = {}) {
   return runResolvedCommand(command, args, { stdio: 'inherit', ...options });
 }
 
+// Install/update commands are run with their output captured (and echoed back so the user still
+// sees the host CLI's own progress) because the failure text is what tells a locked plugin folder
+// apart from a real install failure -- see installOneOrKeepExisting below.
+function runPluginInstallCommand(command, args) {
+  const result = runResolvedCommand(command, args, { stdio: 'pipe' });
+  if (result && result.stdout) process.stdout.write(result.stdout);
+  if (result && result.stderr) process.stderr.write(result.stderr);
+  return result;
+}
+
 function assertPluginInstallSucceeded(agentId, result) {
   if (result && result.status === 0) return;
   const detail = result ? summarizeProcessOutput(result) : 'no process result';
   throw new Error(`${agentId} plugin installation failed.${detail ? ` Details: ${detail}` : ''}`);
 }
 
+// ─── Locked plugin folder (Windows) ───────────────────────────────────────────
+// Reproduced 2026-09-17: on Windows, a host CLI replaces an installed plugin by renaming its
+// folder, and Windows refuses to rename a folder any process has open. One open handle -- a
+// running Copilot CLI session, or the Copilot extension in VS Code watching that folder -- is
+// enough, and the host reports it as "Access is denied. (os error 5)". Users read that as a
+// permissions problem and reach for admin rights, which does nothing. Upstream: copilot-cli
+// #4151 / #4095. So when an install fails that way:
+//   - if the plugin is already installed, keep it and carry on (the rest of the install -- the
+//     instructions block, the hooks -- must not be held hostage to a refresh), and say so;
+//   - if it is not installed, fail with the one instruction that fixes it, naming the programs
+//     we can see running, instead of the host CLI's bare "Access is denied".
+const LOCKED_FOLDER_PATTERN = /access is denied|os error 5\b|EBUSY|EPERM|being used by another process/i;
+
+// Process names (as Windows reports them) that are known to hold plugin folders open per host.
+const LOCK_HOLDER_PROCESS_NAMES = {
+  copilot: ['copilot', 'Code'],
+  claude: ['claude', 'Code'],
+  codex: ['codex', 'Code']
+};
+
+const LOCK_HOLDER_LABELS = {
+  copilot: 'GitHub Copilot CLI',
+  claude: 'Claude Code',
+  codex: 'Codex CLI',
+  Code: 'VS Code'
+};
+
+function looksLikeLockedPluginFolder(result) {
+  if (!result) return false;
+  const text = `${result.stdout || ''}\n${result.stderr || ''}\n${result.error ? result.error.message || result.error : ''}`;
+  return LOCKED_FOLDER_PATTERN.test(text);
+}
+
+function detectLockHolders(agentId) {
+  if (process.platform !== 'win32') return [];
+  const names = LOCK_HOLDER_PROCESS_NAMES[agentId] || [];
+  if (!names.length) return [];
+  try {
+    const { spawnSync } = require('child_process');
+    const script = `Get-Process -Name ${names.join(',')} -ErrorAction SilentlyContinue | Select-Object -ExpandProperty ProcessName -Unique`;
+    const probe = spawnSync('pwsh', ['-NoProfile', '-Command', script], { encoding: 'utf8', timeout: 5000 });
+    return String(probe.stdout || '').split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
+  } catch (_error) {
+    return [];
+  }
+}
+
+function describeLockHolders(agentId, holders) {
+  const seen = holders.map((name) => LOCK_HOLDER_LABELS[name] || name);
+  const hostLabel = LOCK_HOLDER_LABELS[agentId] || agentId;
+  if (seen.length) {
+    return `Running now: ${seen.join(', ')}. Close ${seen.length === 1 ? 'it' : 'them'} (every window and terminal session)`;
+  }
+  return `Close every ${hostLabel} session and every VS Code window`;
+}
+
+function currentlyInstalledVersion(agentId, name) {
+  try {
+    // Lazy: pluginUpdateCheck requires this module, so a top-level require would be a cycle.
+    const { readInstalledVersions } = require('../pluginUpdateCheck');
+    const versions = readInstalledVersions(agentId, [name]);
+    return versions && versions[name] ? versions[name] : null;
+  } catch (_error) {
+    return null;
+  }
+}
+
+/**
+ * Runs one plugin install and interprets the result. Returns { name, refreshed, keptVersion? }.
+ * Throws only for a genuine failure, or for a locked folder when the plugin is not installed at
+ * all (there is nothing to keep, and the user must act).
+ */
+function installOneOrKeepExisting(agentId, name, runInstall) {
+  const result = runInstall();
+  if (result && result.status === 0) return { name, refreshed: true };
+  if (!looksLikeLockedPluginFolder(result)) assertPluginInstallSucceeded(agentId, result);
+
+  const holders = detectLockHolders(agentId);
+  const action = describeLockHolders(agentId, holders);
+  const keptVersion = currentlyInstalledVersion(agentId, name);
+  if (keptVersion) {
+    warn(`  - ${LOCK_HOLDER_LABELS[agentId] || agentId} could not replace the ${name} plugin folder because another program has it open (Windows reported "Access is denied"; this is not a permissions problem). Kept the installed ${name}@${keptVersion} and continued. ${action}, then run: empirical plugin install ${agentId} to update it.`);
+    return { name, refreshed: false, keptVersion, lockedBy: holders };
+  }
+
+  throw new Error(
+    `${agentId} plugin installation failed: ${LOCK_HOLDER_LABELS[agentId] || agentId} could not write the ${name} plugin folder because another program has it open `
+    + `(Windows reported "Access is denied"; running as administrator will not help). ${action}, then run: empirical install`
+  );
+}
+
 function updateOrInstall(agentId, command, updateArgs, installArgs) {
-  const updateResult = runPluginCommand(command, updateArgs);
-  if (updateResult && updateResult.status === 0) return updateResult;
+  const updateResult = runPluginInstallCommand(command, updateArgs);
+  if (updateResult && updateResult.status === 0) return { refreshed: true };
 
-  const installResult = runPluginCommand(command, installArgs);
-  assertPluginInstallSucceeded(agentId, installResult);
-  return installResult;
+  const name = String(installArgs[2] || '').split('@')[0];
+  return installOneOrKeepExisting(agentId, name, () => runPluginInstallCommand(command, installArgs));
 }
 
 function normalizePluginNames(pluginNames = [CORE_PLUGIN_NAME]) {
@@ -92,21 +192,23 @@ function installNativePlugin(agentId, pluginNames = [CORE_PLUGIN_NAME], integrat
     applySkillModeVariant(agentId, resolvedIntegrationMode);
   };
 
+  const outcomes = [];
+
   if (agentId === 'claude') {
     // Marketplace registration is intentionally best-effort: native Claude returns non-zero
     // when the same Git marketplace is already registered, but the install command is still
     // authoritative and idempotent.
     runPluginCommand('claude', ['plugin', 'marketplace', 'add', EMPIRICAL_PLUGIN_SOURCE], { stdio: 'pipe' });
     for (const name of names) {
-      updateOrInstall(
+      outcomes.push(updateOrInstall(
         agentId,
         'claude',
         ['plugin', 'update', `${name}@empirical-memory`, '--scope', 'user'],
         ['plugin', 'install', name, '--scope', 'user']
-      );
+      ));
     }
     applyVariantIfCore();
-    return;
+    return { outcomes };
   }
 
   if (agentId === 'codex') {
@@ -114,11 +216,10 @@ function installNativePlugin(agentId, pluginNames = [CORE_PLUGIN_NAME], integrat
     // Refresh the Git marketplace snapshot before reinstalling an existing plugin.
     runPluginCommand('codex', ['plugin', 'marketplace', 'upgrade', 'empirical-memory'], { stdio: 'pipe' });
     for (const name of names) {
-      const result = runPluginCommand('codex', ['plugin', 'add', `${name}@empirical-memory`]);
-      assertPluginInstallSucceeded(agentId, result);
+      outcomes.push(installOneOrKeepExisting(agentId, name, () => runPluginInstallCommand('codex', ['plugin', 'add', `${name}@empirical-memory`])));
     }
     applyVariantIfCore();
-    return;
+    return { outcomes };
   }
 
   if (agentId === 'copilot') {
@@ -127,11 +228,10 @@ function installNativePlugin(agentId, pluginNames = [CORE_PLUGIN_NAME], integrat
     runPluginCommand('copilot', ['plugin', 'marketplace', 'add', EMPIRICAL_PLUGIN_SOURCE], { stdio: 'pipe' });
     runPluginCommand('copilot', ['plugin', 'marketplace', 'update', 'empirical-memory'], { stdio: 'pipe' });
     for (const name of names) {
-      const result = runPluginCommand('copilot', ['plugin', 'install', `${name}@empirical-memory`]);
-      assertPluginInstallSucceeded(agentId, result);
+      outcomes.push(installOneOrKeepExisting(agentId, name, () => runPluginInstallCommand('copilot', ['plugin', 'install', `${name}@empirical-memory`])));
     }
     applyVariantIfCore();
-    return;
+    return { outcomes };
   }
 
   throw new Error(`Unsupported plugin target: ${agentId}`);
@@ -143,5 +243,6 @@ module.exports = {
   OPTIONAL_PLUGIN_NAMES,
   normalizePluginNames,
   installNativePlugin,
-  applySkillModeVariant
+  applySkillModeVariant,
+  looksLikeLockedPluginFolder
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@empirical-gauzza/cli",
-  "version": "1.0.31",
+  "version": "1.0.33",
   "description": "Persistent cross-tool memory for AI agents. Give Claude Code, Codex, Copilot, Cursor, and ChatGPT one shared memory: save project context once, recall it everywhere via CLI or MCP.",
   "keywords": [
     "memory",