@alexjbarnes/cockpit 0.3.1 → 0.4.0

package/dist/src/server/notifications.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dispatchNotification = dispatchNotification;
 exports.sendTestNotification = sendTestNotification;
+const debug_logger_1 = require("./debug-logger");
 const notification_settings_1 = require("./notification-settings");
 function buildFullUrl(path, baseUrl) {
     if (!path)
@@ -17,11 +18,57 @@ function formatPlainMessage(payload, baseUrl) {
     const link = url ? `\n\n${url}` : "";
     return `${prefix}${payload.title}\n\n${payload.body}${link}`;
 }
+const MAX_NOTIFY_ATTEMPTS = 3;
+const NOTIFY_TIMEOUT_MS = 10_000;
+function notifyBackoffMs(attempt) {
+    // No backoff under vitest so retry tests stay fast.
+    if (process.env.VITEST || process.env.NODE_ENV === "test")
+        return 0;
+    return 300 * 2 ** (attempt - 1);
+}
+/**
+ * POST a notification with a per-attempt timeout and bounded retry.
+ * dispatchNotification fires this without awaiting, so without it a single
+ * transient failure — a hung keep-alive socket (no timeout means it hangs
+ * forever and never even logs), an ntfy rate-limit, a network blip — silently
+ * drops the push while the inbox entry has already persisted. Retries network
+ * and timeout errors plus 429/5xx; fails fast on other 4xx (config errors that
+ * will not recover by retrying).
+ */
+async function postWithRetry(label, url, init) {
+    let lastErr;
+    for (let attempt = 1; attempt <= MAX_NOTIFY_ATTEMPTS; attempt++) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), NOTIFY_TIMEOUT_MS);
+        let permanent = false;
+        try {
+            const res = await fetch(url, { ...init, signal: controller.signal });
+            if (res.ok)
+                return;
+            const body = await res.text().catch(() => "");
+            lastErr = new Error(`${label} ${res.status}: ${body}`);
+            permanent = res.status < 500 && res.status !== 429;
+        }
+        catch (err) {
+            lastErr = err; // network error or timeout abort — retryable
+        }
+        finally {
+            clearTimeout(timer);
+        }
+        if (permanent)
+            break;
+        if (attempt < MAX_NOTIFY_ATTEMPTS) {
+            (0, debug_logger_1.debugLog)(`[notifications] ${label} attempt ${attempt}/${MAX_NOTIFY_ATTEMPTS} failed, retrying: ${lastErr instanceof Error ? lastErr.message : String(lastErr)}`);
+            await new Promise((r) => setTimeout(r, notifyBackoffMs(attempt)));
+        }
+    }
+    throw lastErr instanceof Error ? lastErr : new Error(`${label}: ${String(lastErr)}`);
+}
 const telegramProvider = {
     async send(payload, config, baseUrl) {
         const text = formatPlainMessage(payload, baseUrl);
         const url = `https://api.telegram.org/bot${config.botToken}/sendMessage`;
-        const res = await fetch(url, {
+        await postWithRetry("Telegram API", url, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
             body: JSON.stringify({
@@ -30,10 +77,6 @@ const telegramProvider = {
                 disable_web_page_preview: true,
             }),
         });
-        if (!res.ok) {
-            const body = await res.text();
-            throw new Error(`Telegram API ${res.status}: ${body}`);
-        }
     },
 };
 const ntfyProvider = {
@@ -51,15 +94,11 @@ const ntfyProvider = {
         if (fullUrl) {
             headers.Click = fullUrl;
         }
-        const res = await fetch(url, {
+        await postWithRetry("ntfy", url, {
             method: "POST",
             headers,
             body: payload.body,
         });
-        if (!res.ok) {
-            const body = await res.text();
-            throw new Error(`ntfy ${res.status}: ${body}`);
-        }
     },
 };
 function getProvider(type) {
@@ -100,7 +139,9 @@ function dispatchNotification(payload) {
         if (!provider)
             continue;
         provider.send(payload, entry.config, settings.baseUrl).catch((err) => {
+            const message = err instanceof Error ? err.message : String(err);
             console.error(`[notifications] ${entry.type}/${entry.name} failed:`, err);
+            (0, debug_logger_1.debugLog)(`[notifications] ${entry.type}/${entry.name} failed after retries: ${message}`);
         });
     }
 }

package/dist/src/server/plugins.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coercePluginScope = coercePluginScope;
+exports.runClaudePlugin = runClaudePlugin;
+exports.listPlugins = listPlugins;
+exports.listMarketplaces = listMarketplaces;
+exports.setPluginEnabled = setPluginEnabled;
+exports.uninstallPlugin = uninstallPlugin;
+exports.installPlugin = installPlugin;
+exports.updatePlugin = updatePlugin;
+exports.addMarketplace = addMarketplace;
+exports.removeMarketplace = removeMarketplace;
+exports.updateMarketplace = updateMarketplace;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const claude_bin_1 = require("../server/claude-bin");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+// Marketplace refresh and `install`/`update` shell out to git, which can be slow
+// on a cold cache. Read commands are sub-second, but share the same ceiling.
+const PLUGIN_CMD_TIMEOUT_MS = 120_000;
+// The `--available` catalog JSON is ~110KB today (200+ plugins); leave headroom.
+const PLUGIN_CMD_MAX_BUFFER = 32 * 1024 * 1024;
+const PLUGIN_SCOPES = new Set(["user", "project", "local"]);
+/** Narrow an arbitrary string to a PluginScope, or undefined to let the CLI decide. */
+function coercePluginScope(value) {
+    return value && PLUGIN_SCOPES.has(value) ? value : undefined;
+}
+/**
+ * Run `claude plugin <args...>` non-interactively and capture its output.
+ * Never throws on a non-zero exit -- the caller inspects `ok` and `stderr` so
+ * CLI errors surface to the UI instead of crashing the route.
+ */
+async function runClaudePlugin(args) {
+    try {
+        const { stdout, stderr } = await execFileAsync((0, claude_bin_1.getClaudeBin)(), ["plugin", ...args], {
+            encoding: "utf-8",
+            timeout: PLUGIN_CMD_TIMEOUT_MS,
+            maxBuffer: PLUGIN_CMD_MAX_BUFFER,
+        });
+        return { ok: true, stdout, stderr };
+    }
+    catch (err) {
+        const e = err;
+        return { ok: false, stdout: e.stdout ?? "", stderr: e.stderr || e.message || "plugin command failed" };
+    }
+}
+/** Installed plugins plus the full marketplace catalog, in one CLI call. */
+async function listPlugins() {
+    const res = await runClaudePlugin(["list", "--available", "--json"]);
+    if (!res.ok)
+        throw new Error(res.stderr);
+    const parsed = JSON.parse(res.stdout);
+    return { installed: parsed.installed ?? [], available: parsed.available ?? [] };
+}
+async function listMarketplaces() {
+    const res = await runClaudePlugin(["marketplace", "list", "--json"]);
+    if (!res.ok)
+        throw new Error(res.stderr);
+    return JSON.parse(res.stdout);
+}
+/** Enable or disable an installed plugin. Scope defaults to the CLI's auto-detect. */
+async function setPluginEnabled(id, enabled, scope) {
+    const args = [enabled ? "enable" : "disable", id];
+    if (scope)
+        args.push("-s", scope);
+    return runClaudePlugin(args);
+}
+/** Uninstall a plugin. `-y` is required because cockpit runs the CLI without a TTY. */
+async function uninstallPlugin(id, scope) {
+    const args = ["uninstall", id, "-y"];
+    if (scope)
+        args.push("-s", scope);
+    return runClaudePlugin(args);
+}
+/** Install a plugin (id is "name@marketplace"). Clones from the marketplace source, so it can be slow. */
+async function installPlugin(id, scope = "user") {
+    return runClaudePlugin(["install", id, "-s", scope]);
+}
+/** Update an installed plugin from its marketplace source. Runs git pull on the plugin's source. */
+async function updatePlugin(id) {
+    return runClaudePlugin(["update", id]);
+}
+/** Add a marketplace from a URL, path, or GitHub repo. Clones from the source, so it can be slow. Scope defaults to user. */
+async function addMarketplace(source, scope) {
+    const args = ["marketplace", "add", source];
+    if (scope)
+        args.push("--scope", scope);
+    return runClaudePlugin(args);
+}
+/** Remove a configured marketplace. Omitting scope removes its declaration from every settings scope. */
+async function removeMarketplace(name, scope) {
+    const args = ["marketplace", "remove", name];
+    if (scope)
+        args.push("--scope", scope);
+    return runClaudePlugin(args);
+}
+/** Update one marketplace from its source, or all when name is omitted. Hits git, so it can be slow. */
+async function updateMarketplace(name) {
+    const args = ["marketplace", "update"];
+    if (name)
+        args.push(name);
+    return runClaudePlugin(args);
+}

package/dist/src/server/providers.js

@@ -35,6 +35,21 @@ function buildAnthropicProvider() {
     };
 }
 let cache = null;
+// mtime of providers.json at the last load. Cockpit runs as two separate module
+// graphs — the custom server (dist/, which spawns sessions) and the Next.js API
+// routes (settings CRUD) — so a provider added/edited via settings only resets
+// that graph's `cache`, never the spawner's, leaving new sessions on a stale list
+// until restart. Gating the cache on the file mtime makes either graph (and a
+// hand-edit of the file) reload when the file changes.
+let cacheMtimeMs = 0;
+function providersMtimeMs() {
+    try {
+        return (0, node_fs_1.statSync)(providersFile()).mtimeMs;
+    }
+    catch {
+        return 0; // file absent — no custom providers yet
+    }
+}
 function loadCustom() {
     try {
         return JSON.parse((0, node_fs_1.readFileSync)(providersFile(), "utf-8"));
@@ -53,8 +68,10 @@ function saveCustom(providers) {
     }
 }
 function getProviders() {
-    if (!cache) {
+    const mtime = providersMtimeMs();
+    if (cache === null || mtime !== cacheMtimeMs) {
         cache = [buildAnthropicProvider(), ...loadCustom()];
+        cacheMtimeMs = mtime;
     }
     return cache;
 }
@@ -69,6 +86,7 @@ function addProvider(provider) {
     custom.push(newProvider);
     saveCustom(custom);
     cache = [buildAnthropicProvider(), ...custom];
+    cacheMtimeMs = providersMtimeMs();
     return newProvider;
 }
 function updateProvider(id, partial) {
@@ -84,6 +102,7 @@ function updateProvider(id, partial) {
     custom[idx] = merged;
     saveCustom(custom);
     cache = [buildAnthropicProvider(), ...custom];
+    cacheMtimeMs = providersMtimeMs();
     return custom[idx];
 }
 function deleteProvider(id) {
@@ -96,6 +115,7 @@ function deleteProvider(id) {
     }
     saveCustom(custom);
     cache = [buildAnthropicProvider(), ...custom];
+    cacheMtimeMs = providersMtimeMs();
 }
 function setProviders(providers) {
     const custom = providers.filter((p) => !p.isBuiltin);
@@ -103,6 +123,7 @@ function setProviders(providers) {
         validateProvider(p);
     saveCustom(custom);
     cache = [buildAnthropicProvider(), ...custom];
+    cacheMtimeMs = providersMtimeMs();
 }
 function resolveProviderModel(modelId) {
     if (!modelId)
@@ -110,7 +131,9 @@ function resolveProviderModel(modelId) {
     const colon = modelId.indexOf(":");
     if (colon > 0) {
         const providerId = modelId.slice(0, colon);
-        const bareModel = modelId.slice(colon + 1);
+        // Strip a legacy context suffix (e.g. "deepseek-v4-pro[1m]") so a job whose
+        // stored model still carries one resolves to the cleaned provider model.
+        const bareModel = modelId.slice(colon + 1).replace(/\[.*\]$/, "");
         const provider = getProvider(providerId);
         if (provider) {
             const model = provider.models.find((m) => m.modelId === bareModel);

package/dist/src/server/pty-runtime.js

@@ -4,8 +4,10 @@ exports.PtyRuntime = void 0;
 const uuid_1 = require("uuid");
 const claude_settings_1 = require("./claude-settings");
 const cli_init_fetch_1 = require("./cli-init-fetch");
+const debug_logger_1 = require("./debug-logger");
 const hook_event_translator_1 = require("./hook-event-translator");
 const pty_session_1 = require("./pty-session");
+const transcript_1 = require("./transcript");
 /**
  * Owns a claude PTY process plus its HookRouter registration. Translates
  * hook payloads into ParsedEvents and pumps them through opts.onEvents so
@@ -25,6 +27,8 @@ class PtyRuntime {
     pendingPermissions = new Map();
     exited = false;
     cleaned = false;
+    /** Resolver armed by deliverInitialPrompt; fired when UserPromptSubmit confirms the first prompt landed. */
+    promptAccepted = null;
     ptyOutputBuffer = "";
     errorDebounce = null;
     constructor(opts) {
@@ -38,6 +42,8 @@ class PtyRuntime {
     }
     async start(initialText) {
         const { sessionId, cwd, hookRouter } = this.opts;
+        const startAt = Date.now();
+        (0, debug_logger_1.logDiag)(sessionId, "pty:start-enter", { hasInitialText: !!initialText });
         const token = hookRouter.register(sessionId, this.buildHandler());
         const { settingsPath, env } = await (0, claude_settings_1.prepareHookSettings)({
             sessionId,
@@ -47,6 +53,7 @@ class PtyRuntime {
             denyList: this.opts.denyList,
         });
         this.settingsPath = settingsPath;
+        (0, debug_logger_1.logDiag)(sessionId, "pty:hooks-ready", { elapsedMs: Date.now() - startAt });
         this.pty = new pty_session_1.PtySession({
             cwd,
             settingsPath,
@@ -67,29 +74,103 @@ class PtyRuntime {
             await this.pty.start();
         }
         catch (err) {
+            (0, debug_logger_1.logDiag)(sessionId, "pty:process-start-failed", {
+                elapsedMs: Date.now() - startAt,
+                error: err instanceof Error ? err.message : String(err),
+            });
             await this.cleanup();
             throw err;
         }
+        (0, debug_logger_1.logDiag)(sessionId, "pty:process-started", { pid: this.pid, elapsedMs: Date.now() - startAt });
         if (initialText) {
-            await this.pty.sendText(initialText);
+            await this.deliverInitialPrompt(initialText);
         }
+        (0, debug_logger_1.logDiag)(sessionId, "pty:start-complete", { elapsedMs: Date.now() - startAt });
         this.fetchInitData();
     }
+    /**
+     * Type the first prompt into the freshly spawned TUI and confirm the CLI
+     * accepted it. waitForReplReady is only a heuristic (first 100 bytes plus a
+     * 2s settle), so on a slow or quiet machine the input box may not be live
+     * when the keystrokes land and they are swallowed with no error. Without a
+     * check the turn never starts and the only backstop is the caller's watchdog,
+     * which for scheduled jobs is a silent 30-60 minute timeout with an empty
+     * transcript. Resend until the UserPromptSubmit hook confirms acceptance,
+     * then fail fast so the job reports an error instead of hanging.
+     */
+    async deliverInitialPrompt(text) {
+        const { sessionId } = this.opts;
+        const MAX_ATTEMPTS = 4;
+        const CONFIRM_TIMEOUT_MS = 8000;
+        // A submitted prompt writes a user turn to the JSONL transcript. Growth past
+        // this baseline proves the CLI accepted the prompt even when the
+        // UserPromptSubmit hook never arrives — that hook is the only other
+        // acceptance signal, and its loss used to fail an actively-working run (it
+        // resent the 7KB prompt into a live turn, then killed the process). The
+        // transcript is hook- and echo-independent, so we check it at the end of
+        // each attempt's window before resending or failing.
+        const baselineMsgs = (0, transcript_1.countTranscriptMessages)(this.opts.cliSessionId, this.opts.cwd);
+        const turnStarted = () => (0, transcript_1.countTranscriptMessages)(this.opts.cliSessionId, this.opts.cwd) > baselineMsgs;
+        (0, debug_logger_1.logDiag)(sessionId, "pty:deliver-begin", { textLen: text.length, maxAttempts: MAX_ATTEMPTS, baselineMsgs });
+        for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+            const pty = this.pty;
+            if (this.exited || !pty) {
+                (0, debug_logger_1.logDiag)(sessionId, "pty:deliver-aborted", { attempt, exited: this.exited, hasPty: !!pty });
+                throw new Error("claude exited before the initial prompt was delivered");
+            }
+            let timer = null;
+            const accepted = new Promise((resolve) => {
+                this.promptAccepted = () => resolve(true);
+                timer = setTimeout(() => resolve(false), CONFIRM_TIMEOUT_MS);
+            });
+            const attemptAt = Date.now();
+            (0, debug_logger_1.logDiag)(sessionId, "pty:deliver-attempt", { attempt, screenBefore: this.recentScreen() });
+            await pty.sendText(text);
+            const ok = await accepted;
+            if (timer)
+                clearTimeout(timer);
+            this.promptAccepted = null;
+            if (ok) {
+                (0, debug_logger_1.logDiag)(sessionId, "pty:deliver-accepted", { attempt, waitedMs: Date.now() - attemptAt });
+                return;
+            }
+            // The hook did not fire in this window. It can be lost even though the CLI
+            // accepted the prompt and started working, so before resending or failing,
+            // check whether a turn has actually started. If it has, the prompt landed;
+            // do not resend into a live turn or kill a working run.
+            if (turnStarted()) {
+                (0, debug_logger_1.logDiag)(sessionId, "pty:deliver-accepted-via-transcript", { attempt, waitedMs: Date.now() - attemptAt });
+                return;
+            }
+            (0, debug_logger_1.logDiag)(sessionId, "pty:deliver-timeout", { attempt, waitedMs: Date.now() - attemptAt, screenAfter: this.recentScreen() });
+            console.log(`[pty-runtime] initial prompt not confirmed for ${sessionId.slice(0, 8)} (attempt ${attempt}/${MAX_ATTEMPTS}), resending`);
+        }
+        (0, debug_logger_1.logDiag)(sessionId, "pty:deliver-failed", { attempts: MAX_ATTEMPTS });
+        throw new Error(`claude did not accept the initial prompt after ${MAX_ATTEMPTS} attempts`);
+    }
     fetchInitData() {
-        const sid = this.opts.sessionId.slice(0, 8);
+        const { sessionId } = this.opts;
+        const sid = sessionId.slice(0, 8);
         console.log(`[pty-runtime] fetching CLI init data for session ${sid}`);
+        (0, debug_logger_1.logDiag)(sessionId, "pty:init-fetch-begin");
         (0, cli_init_fetch_1.fetchCliInitData)({ cwd: this.opts.cwd, bin: this.opts.claudeBin })
             .then((initData) => {
             if (initData && !this.exited) {
                 console.log(`[pty-runtime] emitting init event for session ${sid}: ${initData.slashCommands.length} commands`);
+                (0, debug_logger_1.logDiag)(sessionId, "pty:init-fetch-done", {
+                    slashCommands: initData.slashCommands.length,
+                    mcpServers: initData.mcpServers?.length ?? 0,
+                });
                 this.emit([{ type: "init", initData }]);
             }
             else {
                 console.log(`[pty-runtime] init fetch returned ${initData ? "data but session exited" : "null"} for session ${sid}`);
+                (0, debug_logger_1.logDiag)(sessionId, "pty:init-fetch-empty", { exited: this.exited, hadData: !!initData });
             }
         })
             .catch((err) => {
             console.log(`[pty-runtime] init fetch failed for session ${sid}: ${err}`);
+            (0, debug_logger_1.logDiag)(sessionId, "pty:init-fetch-failed", { error: err instanceof Error ? err.message : String(err) });
         });
     }
     async sendText(text) {
@@ -136,9 +217,16 @@ class PtyRuntime {
     /** Called by SessionManager.respondToPermission when this session is on the pty runtime. */
     notifyPermissionDecision(requestId, decision) {
         const resolver = this.pendingPermissions.get(requestId);
-        if (!resolver)
+        if (!resolver) {
+            (0, debug_logger_1.logDiag)(this.opts.sessionId, "pty:permission-decision-unmatched", { requestId, behavior: decision.behavior });
             return false;
+        }
         this.pendingPermissions.delete(requestId);
+        (0, debug_logger_1.logDiag)(this.opts.sessionId, "pty:permission-decision", {
+            requestId,
+            behavior: decision.behavior,
+            pending: this.pendingPermissions.size,
+        });
         resolver(decision);
         return true;
     }
@@ -182,11 +270,14 @@ class PtyRuntime {
             onUserPromptSubmit: (payload) => {
                 this.cancelErrorDebounce();
                 this.ptyOutputBuffer = "";
+                (0, debug_logger_1.logDiag)(this.opts.sessionId, "pty:hook-user-prompt-submit", { armed: !!this.promptAccepted });
+                this.promptAccepted?.();
                 this.emit((0, hook_event_translator_1.translateHookEvent)("UserPromptSubmit", payload));
             },
             onUserPromptExpansion: (payload) => {
                 this.cancelErrorDebounce();
                 this.ptyOutputBuffer = "";
+                this.promptAccepted?.();
                 const cmd = typeof payload.command_name === "string" ? payload.command_name : "unknown";
                 const sid = this.opts.sessionId.slice(0, 8);
                 console.log(`[pty-runtime] UserPromptExpansion: command=${cmd}, session=${sid}`);
@@ -243,6 +334,7 @@ class PtyRuntime {
             toolInput: toolInput ? JSON.stringify(toolInput) : "",
             rawToolInput: toolInput,
         };
+        (0, debug_logger_1.logDiag)(this.opts.sessionId, "pty:permission-request", { requestId, toolName });
         return new Promise((resolve) => {
             this.pendingPermissions.set(requestId, resolve);
             try {
@@ -250,6 +342,7 @@ class PtyRuntime {
             }
             catch (err) {
                 this.pendingPermissions.delete(requestId);
+                (0, debug_logger_1.logDiag)(this.opts.sessionId, "pty:permission-handler-error", { requestId, toolName, error: String(err) });
                 resolve({ behavior: "deny", message: `cockpit handler error: ${String(err)}` });
             }
         });
@@ -271,6 +364,22 @@ class PtyRuntime {
             this.errorDebounce = null;
         }
     }
+    /**
+     * ANSI/control-stripped, whitespace-collapsed tail of the recent PTY output.
+     * Debug aid for diagnosing why an initial prompt isn't accepted — shows what
+     * the TUI is actually displaying (input box, a startup interstitial, a stuck
+     * dialog) at the moment we type or time out.
+     */
+    recentScreen(maxChars = 600) {
+        const clean = this.ptyOutputBuffer
+            .replace(ANSI_RE, "")
+            // biome-ignore lint/suspicious/noControlCharactersInRegex: strip terminal control chars
+            .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, "")
+            .replace(/[ \t]+/g, " ")
+            .replace(/\n{2,}/g, "\n")
+            .trim();
+        return clean.length > maxChars ? clean.slice(-maxChars) : clean;
+    }
     scanForErrors(chunk) {
         this.ptyOutputBuffer += chunk;
         if (this.ptyOutputBuffer.length > 8 * 1024) {

package/dist/src/server/pty-session.js

@@ -29,12 +29,15 @@ class PtySession {
             throw new Error("PtySession already started");
         const bin = this.opts.bin ?? "claude";
         const args = ["--verbose", "--settings", this.opts.settingsPath, ...(this.opts.extraArgs ?? [])];
-        const env = {
-            ...process.env,
-            ...(this.opts.env ?? {}),
-        };
+        const env = { ...process.env };
         delete env.CLAUDECODE;
         delete env.CLAUDE_CODE_ENTRYPOINT;
+        // Drop any inherited 1M-context override BEFORE applying the caller's env, so a
+        // CLAUDE_CODE_DISABLE_1M_CONTEXT sitting in cockpit's own environment can't pin
+        // every session to 200k and defeat a 1m pick. The caller sets it per-session
+        // via opts.env (200k → "1"; 1m → absent), which is applied on top here.
+        delete env.CLAUDE_CODE_DISABLE_1M_CONTEXT;
+        Object.assign(env, this.opts.env ?? {});
         const spawnFile = process.platform === "darwin" ? "/bin/zsh" : bin;
         const spawnArgs = process.platform === "darwin" ? ["-l", "-c", `exec ${[bin, ...args].map(shellQuote).join(" ")}`] : args;
         let diagInfo = `platform=${process.platform}, file=${spawnFile}, cwd=${this.opts.cwd}`;