@golba98/codexa 1.0.2 → 1.0.3

package/src/app.tsx

@@ -17,6 +17,7 @@ import {
 import type { LaunchArgs } from "./config/launchArgs.js";
 import { loadSettings, saveSettings } from "./config/persistence.js";
 import {
+  APP_VERSION,
   type AuthPreference,
   type AvailableBackend,
   type AvailableMode,
@@ -110,15 +111,11 @@ import {
   getPromptWorkspaceGuardMessage,
   getShellWorkspaceGuardMessage,
 } from "./core/workspaceGuard.js";
-import {
-  type ModelSpec,
-} from "./core/models/modelSpecs.js";
-import {
-  contextMetadataToModelSpec,
-  formatContextCompact,
-  formatContextLength,
-  resolveModelContextLength,
-  type ModelContextMetadata,
+import {
+  formatContextCompact,
+  formatContextLength,
+  resolveModelContextLength,
+  type ModelContextMetadata,
 } from "./core/providerRuntime/contextMetadata.js";
 import { captureWorkspaceSnapshot, createWorkspaceActivityTracker, diffWorkspaceSnapshots } from "./core/workspaceActivity.js";
 import { resolveWorkspaceRoot } from "./core/workspaceRoot.js";
@@ -214,10 +211,12 @@ import { ReasoningPicker } from "./ui/ReasoningPicker.js";
 import { AttachmentImportPanel, type PendingImportFile } from "./ui/AttachmentImportPanel.js";
 import { SelectionPanel } from "./ui/SelectionPanel.js";
 import { SettingsPanel } from "./ui/SettingsPanel.js";
+import { UpdatePromptPanel } from "./ui/UpdatePromptPanel.js";
 import { measureTextEntryPanelRows, TextEntryPanel } from "./ui/TextEntryPanel.js";
 import { ThemePicker } from "./ui/ThemePicker.js";
 import { getFocusTargetForScreen, FOCUS_IDS } from "./ui/focus.js";
-import { ThemeProvider, THEMES } from "./ui/theme.js";
+import { ThemeProvider, THEMES } from "./ui/theme.js";
+import { buildActiveRuntimeDisplay, runtimeDisplayToSummary } from "./ui/runtimeDisplay.js";
 import {
   cancelThemeSelection,
   commitThemeSelection,
@@ -228,7 +227,8 @@ import {
 } from "./ui/themeFlow.js";
 import { isBusy as isUiBusy } from "./session/types.js";
 import { AppShell } from "./ui/AppShell.js";
-import { checkForUpdates, formatUpdateInstructions, type UpdateCheckResult } from "./core/updateCheck.js";
+import { checkForUpdates, formatLocalDevUpdateStatus, formatUpdateInstructions, shouldRunStartupUpdateCheck, type UpdateCheckResult } from "./core/updateCheck.js";
+import { isLocalDevChannel } from "./core/channel.js";
 import {
   isCacheValid,
   loadUpdateCheckCache,
@@ -307,6 +307,9 @@ export function App({ launchArgs }: AppProps) {
     ? projectInstructionsLoad.instructions
     : null;
   const initialSettings = useRef(loadSettings());
+  const skippedUpdateVersionRef = useRef<string | null>(
+    initialSettings.current.updateCheck.skippedUpdateVersion ?? null,
+  );
   const initialProviderWorkspaceConfig = useRef<ProviderWorkspaceConfig>(loadProviderWorkspaceConfig(workspaceRoot));
   const initialLayeredConfig = useRef<LayeredConfigResult | null>(null);
   if (initialLayeredConfig.current === null) {
@@ -765,16 +768,22 @@ export function App({ launchArgs }: AppProps) {
     [planFlow],
   );
 
-  const currentModelSpec = useMemo<ModelSpec>(() => {
-    return contextMetadataToModelSpec(activeContextMetadata ?? {
-      providerId: activeProviderRoute.providerId,
-      modelId: activeProviderRoute.modelId,
-      contextLength: null,
-      source: "unknown",
-      confidence: "unknown",
-      error: "Context length unavailable for this model.",
-    });
-  }, [activeContextMetadata, activeProviderRoute.modelId, activeProviderRoute.providerId]);
+  const activeRuntimeDisplay = useMemo(() => buildActiveRuntimeDisplay({
+    route: activeProviderRoute,
+    reasoningLevel,
+    mode,
+    tokensUsed: estimateTokens(conversationChars),
+    modelCapability: currentModelCapability,
+    contextMetadata: activeContextMetadata,
+  }), [
+    activeContextMetadata,
+    activeProviderRoute,
+    conversationChars,
+    currentModelCapability,
+    mode,
+    reasoningLevel,
+  ]);
+  const currentModelSpec = activeRuntimeDisplay.modelSpec;
 
   const hasUserPrompt = useMemo(
     () => staticEvents.some((e) => e.type === "user") || activeEvents.some((e) => e.type === "user"),
@@ -1363,33 +1372,41 @@ export function App({ launchArgs }: AppProps) {
   // Non-blocking background update check — runs once at startup.
   useEffect(() => {
     const ucSettings = initialSettings.current.updateCheck ?? DEFAULT_UPDATE_CHECK_SETTINGS;
-    if (!ucSettings.enabled) return;
+    if (!shouldRunStartupUpdateCheck(process.env, ucSettings.enabled)) return;
 
     const timer = setTimeout(() => {
       void (async () => {
         try {
           const cache = loadUpdateCheckCache();
-          if (cache && isCacheValid(cache, ucSettings.intervalHours)) {
-            if (cache.updateAvailable) {
-              setUpdateCheckResult({
-                status: "update-available",
-                currentVersion: cache.currentVersion,
-                latestVersion: cache.latestVersion,
-                checkedAt: cache.lastChecked,
-              });
-            }
+          if (cache && isCacheValid(cache, ucSettings.intervalHours, APP_VERSION)) {
+            if (cache.updateAvailable && cache.latestVersion) {
+              setUpdateCheckResult({
+                status: "update-available",
+                currentVersion: cache.currentVersion,
+                latestVersion: cache.latestVersion,
+                checkedAt: cache.lastChecked,
+              });
+              if (cache.latestVersion !== skippedUpdateVersionRef.current) {
+                setScreen("update-prompt");
+              }
+            }
             return;
           }
-          const result = await checkForUpdates({ enabled: true });
-          if (result.status !== "error") {
-            setUpdateCheckResult(result);
-            saveUpdateCheckCache({
-              lastChecked: result.checkedAt,
-              currentVersion: result.currentVersion,
-              latestVersion: result.latestVersion,
-              updateAvailable: result.status === "update-available",
-            });
-          }
+          const result = await checkForUpdates({ enabled: true });
+          if (result.status !== "error") {
+            setUpdateCheckResult(result);
+            saveUpdateCheckCache({
+              lastChecked: result.checkedAt,
+              currentVersion: result.currentVersion,
+              latestVersion: result.latestVersion,
+              updateAvailable: result.status === "update-available",
+            });
+            if (result.status === "update-available" && result.latestVersion) {
+              if (result.latestVersion !== skippedUpdateVersionRef.current) {
+                setScreen("update-prompt");
+              }
+            }
+          }
         } catch {
           // Never crash the TUI on a failed update check.
         }
@@ -1898,6 +1915,33 @@ export function App({ launchArgs }: AppProps) {
     setScreen("main");
   }, [applyWorkspaceDisplayMode, showBusyLoader, terminalMouseMode, terminalTitleMode, workspaceDisplayMode]);
 
+  const handleSkipUpdateForSession = useCallback(() => {
+    setScreen("main");
+  }, []);
+
+  const handleSkipUpdateVersion = useCallback((version: string) => {
+    initialSettings.current.updateCheck = {
+      ...initialSettings.current.updateCheck,
+      skippedUpdateVersion: version,
+    };
+    saveSettings({
+      ui: {
+        layoutStyle: initialSettings.current.ui.layoutStyle,
+        theme: themeSelection.committedTheme,
+        workspaceDisplayMode,
+        terminalTitleMode,
+        showBusyLoader,
+        terminalMouseMode,
+        customTheme,
+      },
+      auth: { preference: authPreference },
+      header: headerConfig,
+      updateCheck: initialSettings.current.updateCheck,
+    });
+    skippedUpdateVersionRef.current = version;
+    setScreen("main");
+  }, [authPreference, customTheme, headerConfig, showBusyLoader, terminalMouseMode, terminalTitleMode, themeSelection.committedTheme, workspaceDisplayMode]);
+
   const setApprovalPolicyWithNotice = useCallback((nextValue: RuntimeApprovalPolicy) => {
     const gate = guardConfigMutation("mode", busy);
     if (!gate.allowed) {
@@ -4051,6 +4095,10 @@ export function App({ launchArgs }: AppProps) {
           return;
         case "update": {
           const arg = commandResult.value ?? "status";
+          if (isLocalDevChannel() && arg !== "check") {
+            appendSystemEvent("Update", formatLocalDevUpdateStatus());
+            return;
+          }
           void (async () => {
             let freshResult = updateCheckResult;
             if (arg === "check" || freshResult === null) {
@@ -4058,18 +4106,22 @@ export function App({ launchArgs }: AppProps) {
                 freshResult = await checkForUpdates({ enabled: true });
                 setUpdateCheckResult(freshResult);
                 if (freshResult.status !== "error") {
-                  saveUpdateCheckCache({
-                    lastChecked: freshResult.checkedAt,
-                    currentVersion: freshResult.currentVersion,
-                    latestVersion: freshResult.latestVersion,
-                    updateAvailable: freshResult.status === "update-available",
-                  });
-                }
+                  saveUpdateCheckCache({
+                    lastChecked: freshResult.checkedAt,
+                    currentVersion: freshResult.currentVersion,
+                    latestVersion: freshResult.latestVersion,
+                    updateAvailable: freshResult.status === "update-available",
+                  });
+                }
               } catch {
                 freshResult = null;
               }
             }
-            appendSystemEvent("Update", formatUpdateInstructions(freshResult));
+            if (freshResult?.status === "update-available" && freshResult.latestVersion) {
+              setScreen("update-prompt");
+            } else {
+              appendSystemEvent("Update", formatUpdateInstructions(freshResult));
+            }
           })();
           return;
         }
@@ -4202,58 +4254,19 @@ export function App({ launchArgs }: AppProps) {
     workspaceRoot,
   ]);
 
-  const modelDisplayName = useMemo(() => {
-    if (activeProviderRoute.providerId === "anthropic") {
-      const modelLabel = currentModelCapability?.label ?? activeProviderRoute.modelId;
-      return `Claude Code CLI / ${modelLabel} / reasoning: ${formatReasoningLabel(activeProviderRoute.reasoning ?? reasoningLevel)}`;
-    }
-    if (activeProviderRoute.providerId === "google" && activeProviderRoute.modelSelection) {
-      if (activeProviderRoute.modelSelection.kind === "auto") {
-        return `auto ${activeProviderRoute.modelSelection.family === "gemini-3" ? "Gemini 3" : "Gemini 2.5"}`;
-      }
-    }
-    if (activeProviderRoute.providerId === "local") {
-      return activeProviderRoute.modelId;
-    }
-    return model;
-  }, [
-    activeProviderRoute.modelId,
-    activeProviderRoute.modelSelection,
-    activeProviderRoute.providerId,
-    activeProviderRoute.reasoning,
-    currentModelCapability?.label,
-    model,
-    reasoningLevel,
-  ]);
-  const composerReasoningLevel = activeProviderRoute.providerId === "anthropic"
-    ? ""
-    : activeProviderRoute.reasoning ?? reasoningLevel;
-  const headerRuntimeSummary = useMemo(() => {
-    const contextLabel = activeContextMetadata?.contextLength != null
-      ? `${formatContextCompact(estimateTokens(conversationChars))} / ${activeContextMetadata.confidence === "estimated" ? "~" : ""}${formatContextCompact(activeContextMetadata.contextLength)}`
-      : "Unknown";
-
-    return {
-      ...runtimeSummary,
-      providerLabel: activeRouteProvider?.displayName ?? runtimeSummary.providerLabel,
-      modelLabel: modelDisplayName,
-      contextLabel,
-    };
-  }, [
-    activeContextMetadata?.confidence,
-    activeContextMetadata?.contextLength,
-    activeRouteProvider?.displayName,
-    conversationChars,
-    modelDisplayName,
-    runtimeSummary,
-  ]);
-  const effectiveHeaderConfig = useMemo<HeaderConfig>(() => ({
-    ...headerConfig,
-    showProvider: true,
-    showModel: false,
-    showReasoning: false,
-    showContext: false,
-  }), [headerConfig]);
+  const modelDisplayName = activeRuntimeDisplay.modelDisplay;
+  const composerReasoningLevel = "";
+  const headerRuntimeSummary = useMemo(
+    () => runtimeDisplayToSummary(activeRuntimeDisplay, runtimeSummary),
+    [activeRuntimeDisplay, runtimeSummary],
+  );
+  const effectiveHeaderConfig = useMemo<HeaderConfig>(() => ({
+    ...headerConfig,
+    showProvider: true,
+    showModel: false,
+    showReasoning: false,
+    showContext: false,
+  }), [headerConfig]);
 
   // Memoize the composer element so AppShell's memo check (prev.composer ===
   // next.composer) passes during streaming. Without this, a new JSX element is
@@ -4263,7 +4276,7 @@ export function App({ launchArgs }: AppProps) {
     if (planFlow.kind === "awaiting_action") {
       if (!hasVisibleTranscriptPlan) {
         return (
-          <Text color={activeTheme.MUTED}>
+          <Text color={activeTheme.textMuted}>
             Plan could not be displayed. Please ask Codexa to regenerate the plan.
           </Text>
         );
@@ -4300,12 +4313,14 @@ export function App({ launchArgs }: AppProps) {
       <MemoizedBottomComposer
         key={composerInstanceKey}
         layout={terminalLayout}
-        uiState={uiState}
-        mode={mode}
-        model={modelDisplayName}
-        themeName={activeThemeName}
-        reasoningLevel={composerReasoningLevel}
-        planMode={planMode}
+        uiState={uiState}
+        mode={mode}
+        model={modelDisplayName}
+        footerModelDisplay={activeRuntimeDisplay.footerModelDisplay}
+        themeName={activeThemeName}
+        reasoningLevel={composerReasoningLevel}
+        contextDisplay={activeRuntimeDisplay.contextDisplay}
+        planMode={planMode}
         showBusyLoader={showBusyLoader}
         tokensUsed={estimateTokens(conversationChars)}
         modelSpec={currentModelSpec}
@@ -4339,13 +4354,15 @@ export function App({ launchArgs }: AppProps) {
     handleCancel,
     handlePlanFeedbackSubmit,
     hasVisibleTranscriptPlan,
-    activeTheme.MUTED,
+    activeTheme.textMuted,
     composerInstanceKey,
     terminalLayout,
     uiState,
-    mode,
-    modelDisplayName,
-    activeThemeName,
+    mode,
+    modelDisplayName,
+    activeRuntimeDisplay.footerModelDisplay,
+    activeRuntimeDisplay.contextDisplay,
+    activeThemeName,
     composerReasoningLevel,
     planMode,
     showBusyLoader,
@@ -4368,9 +4385,10 @@ export function App({ launchArgs }: AppProps) {
     togglePlanModeWithNotice,
     handleClear,
     cycleModeWithNotice,
-    handleQuit,
-    activeProviderRoute.providerId,
-  ]);
+    handleQuit,
+    activeProviderRoute.providerId,
+    sessionState.externalCliStatus,
+  ]);
 
   // ─── Render ──────────────────────────────────────────────────────────────────
 
@@ -4395,7 +4413,11 @@ export function App({ launchArgs }: AppProps) {
         selectionProfile={selectionProfile}
         clearCount={sessionState.clearCount}
         headerConfig={effectiveHeaderConfig}
-        updateCheckResult={updateCheckResult}
+        updateAvailable={
+          updateCheckResult?.status === "update-available" && updateCheckResult.latestVersion
+            ? { latestVersion: updateCheckResult.latestVersion, currentVersion: updateCheckResult.currentVersion }
+            : null
+        }
         panel={
           <>
             {screen === "backend-picker" && (
@@ -4644,6 +4666,16 @@ export function App({ launchArgs }: AppProps) {
                 onCancel={handleImportCancel}
               />
             )}
+
+            {screen === "update-prompt" && updateCheckResult?.status === "update-available" && updateCheckResult.latestVersion && (
+              <UpdatePromptPanel
+                focusId={FOCUS_IDS.updatePrompt}
+                currentVersion={updateCheckResult.currentVersion}
+                latestVersion={updateCheckResult.latestVersion}
+                onSkip={handleSkipUpdateForSession}
+                onSkipUntilNextVersion={handleSkipUpdateVersion}
+              />
+            )}
           </>
         }
         mainPanel={null}
@@ -4652,7 +4684,7 @@ export function App({ launchArgs }: AppProps) {
         composerRows={composerRows}
         panelHint={screen !== "main" && screen !== "model-picker" ? (
           <Box marginTop={1} paddingX={1}>
-            <Text color={activeTheme.DIM}>Close the active panel with Esc to return to the composer.</Text>
+            <Text color={activeTheme.textDim}>Close the active panel with Esc to return to the composer.</Text>
           </Box>
         ) : null}
       />

package/src/commands/handler.ts

@@ -398,10 +398,10 @@ function buildHelpMessage(context: CommandContext): string {
     "  /copy              Copy last response to clipboard",
     "  /update [check]    Show update status and instructions for updating Codexa",
     "  /help              Show this help",
-    "",
-    "Install on Windows:",
-    "  npm link           Make the codexa command available",
-    "  where codexa       Verify the command resolves",
+    "",
+    "Local development:",
+    "  npm run install:dev-bin  Install the codexa-dev command",
+    "  codexa-dev               Run this repo without replacing codexa",
     "",
     "Shortcuts:",
     "  Ctrl+B    Open backend picker",

package/src/config/buildInfo.ts

@@ -1,3 +1,3 @@
 // Generated by scripts/gen-build-info.mjs — do not edit manually.
-export const BUILD_COMMIT = "6ef3a8a85efef3a525472973403a628a84804c4d" as const;
-export const BUILD_VERSION = "1.0.2" as const;
+export const BUILD_COMMIT = "f4940aa066eae20c0b8decb1fb70f02aca0f2dc0" as const;
+export const APP_VERSION = "1.0.3" as const;

package/src/config/persistence.ts

@@ -50,6 +50,7 @@ export interface AuthSettings {
 export interface UpdateCheckSettings {
   enabled: boolean;
   intervalHours: number;
+  skippedUpdateVersion?: string | null;
 }
 
 export const DEFAULT_UPDATE_CHECK_SETTINGS: UpdateCheckSettings = {
@@ -125,6 +126,7 @@ function normalizeUpdateCheckSettings(
     intervalHours: typeof input?.intervalHours === "number" && input.intervalHours > 0
       ? input.intervalHours
       : DEFAULT_UPDATE_CHECK_SETTINGS.intervalHours,
+    skippedUpdateVersion: input?.skippedUpdateVersion ?? null,
   };
 }
 
@@ -269,6 +271,11 @@ export function parseSettingsData(data: unknown): AppSettings {
         : typeof updateCheckSource.interval_hours === "number"
           ? updateCheckSource.interval_hours
           : undefined,
+      skippedUpdateVersion: typeof updateCheckSource.skippedUpdateVersion === "string"
+        ? updateCheckSource.skippedUpdateVersion
+        : typeof updateCheckSource.skipped_update_version === "string"
+          ? updateCheckSource.skipped_update_version
+          : null,
     }),
   };
 }
@@ -299,6 +306,9 @@ export function serializeSettings(settings: AppSettings): Record<string, unknown
     update_check: {
       enabled: settings.updateCheck.enabled,
       interval_hours: settings.updateCheck.intervalHours,
+      ...(settings.updateCheck.skippedUpdateVersion != null
+        ? { skipped_update_version: settings.updateCheck.skippedUpdateVersion }
+        : {}),
     },
   };
 }

package/src/config/settings.ts

@@ -1,6 +1,5 @@
-import { homedir } from "os";
-import { basename, join, parse, win32 } from "path";
-import { BUILD_VERSION } from "./buildInfo.js";
+import { homedir } from "os";
+import { basename, join, parse, win32 } from "path";
 
 function isWindowsStylePath(p: string): boolean {
   return /^[A-Za-z]:[\\/]/.test(p) || /^\\\\/.test(p);
@@ -10,14 +9,14 @@ function smartJoin(base: string, ...parts: string[]): string {
   return isWindowsStylePath(base) ? win32.join(base, ...parts) : join(base, ...parts);
 }
 
-export const APP_NAME = "Codexa";
-export const APP_VERSION = BUILD_VERSION;
+export { APP_VERSION } from "./buildInfo.js";
+export const APP_NAME = "Codexa";
 export const DEFAULT_BACKEND = "codex-subprocess";
 export const DEFAULT_MODEL = "gpt-5.4";
 export const DEFAULT_MODE = "full-auto";
 export const DEFAULT_REASONING_LEVEL = "high";
 export const DEFAULT_LAYOUT_STYLE = "gemini-shell";
-export const DEFAULT_THEME = "mono";
+export const DEFAULT_THEME = "dark";
 export const DEFAULT_WORKSPACE_DISPLAY_MODE = "dir";
 export const DEFAULT_TERMINAL_TITLE_MODE = "dir";
 export const DEFAULT_SHOW_BUSY_LOADER = true;
@@ -265,21 +264,14 @@ export function formatReasoningLabel(reasoning: string): string {
 }
 
 export const AVAILABLE_THEMES = [
+  { id: "dark", label: "Codexa Dark" },
   { id: "purple", label: "Midnight Purple" },
   { id: "mono", label: "Black & White" },
-  { id: "dark", label: "Modern Dark" },
   { id: "black", label: "Codex the Black" },
-  { id: "emerald", label: "Emerald Night" },
-  { id: "solar", label: "Solar Flare" },
-  { id: "cyber", label: "Cyberpunk Neon" },
-  { id: "ocean", label: "Deep Oceanic" },
   { id: "nordic", label: "Nordic Frost" },
-  { id: "green", label: "Terminal Green" },
-  { id: "amber", label: "Terminal Amber" },
-  { id: "vaporwave", label: "Vaporwave Dream" },
   { id: "dracula", label: "Dracula Night" },
   { id: "gruvbox", label: "Gruvbox Hard" },
-  { id: "synthwave", label: "Synthwave '84" },
+  { id: "ocean", label: "Deep Oceanic" },
   { id: "custom", label: "Customize..." },
 ] as const;
 

package/src/config/updateCheckCache.ts

@@ -39,7 +39,25 @@ export function saveUpdateCheckCache(cache: UpdateCheckCache): void {
   }
 }
 
-export function isCacheValid(cache: UpdateCheckCache, intervalHours: number): boolean {
+function stripV(v: string): string {
+  return v.startsWith("v") ? v.slice(1) : v;
+}
+
+/**
+ * Returns true only when the cache is still usable:
+ * - `runningVersion` matches the version the cache was written for (version-mismatch = stale)
+ * - The cache was written within `intervalHours`
+ */
+export function isCacheValid(
+  cache: UpdateCheckCache,
+  intervalHours: number,
+  runningVersion?: string,
+): boolean {
+  if (runningVersion !== undefined) {
+    if (stripV(cache.currentVersion) !== stripV(runningVersion)) {
+      return false;
+    }
+  }
   const maxAgeMs = intervalHours * 60 * 60 * 1000;
   return Date.now() - cache.lastChecked < maxAgeMs;
 }

package/src/core/channel.ts

@@ -0,0 +1,23 @@
+import { APP_VERSION } from "../config/settings.js";
+
+export const CODEXA_CHANNEL_ENV = "CODEXA_CHANNEL";
+export const LOCAL_DEV_CHANNEL = "local-dev";
+
+export function getCodexaChannel(env: NodeJS.ProcessEnv = process.env): string {
+  return env[CODEXA_CHANNEL_ENV]?.trim() || "published";
+}
+
+export function isLocalDevChannel(env: NodeJS.ProcessEnv = process.env): boolean {
+  return getCodexaChannel(env) === LOCAL_DEV_CHANNEL;
+}
+
+export function formatCodexaVersionLabel(
+  version: string = APP_VERSION,
+  env: NodeJS.ProcessEnv = process.env,
+): string {
+  return isLocalDevChannel(env) ? `${version}-dev local` : version;
+}
+
+export function formatCodexaBrandLabel(env: NodeJS.ProcessEnv = process.env): string {
+  return `Codexa v${formatCodexaVersionLabel(APP_VERSION, env)}`;
+}

package/src/core/executables/codexExecutable.ts

@@ -101,6 +101,7 @@ export function spawnCodexProcess(
   options: SpawnOptions,
 ): ReturnType<typeof spawn> {
   const spec = buildSpawnSpec(executable, args);
+  if (!spec.executable) throw new Error("Codex executable path is empty.");
   return spawn(spec.executable, spec.args, { ...options, shell: false });
 }