@lumpcode/core 0.0.12 → 0.0.14

package/dist/index.js

@@ -6,7 +6,6 @@ import { extname, dirname } from 'node:path';
 import * as fs$1 from 'node:fs/promises';
 import { readFile, mkdir, writeFile } from 'node:fs/promises';
 import ignore from 'ignore';
-import z from 'zod';
 
 function set(object, path, value) {
     const keys = Array.isArray(path) ? path : [path];
@@ -65,6 +64,10 @@ const DEFAULT_WINDOWS_PATHEXT = [
     '.WSH',
     '.MSC',
 ];
+/** Matches a quoted script path using %dp0% / %~dp0 relative to a Windows .cmd shim. */
+const WINDOWS_DP0_SCRIPT_RE = /"(?:%dp0%|%~dp0)\\?((?:[^"\r\n])+?\.(?:js|mjs|cjs))"/i;
+/** Absolute Windows path to a Node script in quotes. */
+const WINDOWS_ABS_SCRIPT_RE = /"([A-Za-z]:\\[^"\r\n]+\.(?:js|mjs|cjs))"/i;
 function windowsPathext() {
     const fromEnv = process.env.PATHEXT?.split(';').map((entry) => entry.trim()).filter(Boolean);
     return fromEnv?.length ? fromEnv : DEFAULT_WINDOWS_PATHEXT;
@@ -130,9 +133,83 @@ function wrapWindowsCmdShim(resolvedPath, args) {
         args: ['/d', '/s', '/c', resolvedPath, ...args],
     };
 }
+function resolveWindowsJsPathFromShim(shimDir, relativeOrAbsolute) {
+    if (/^[A-Za-z]:[\\/]/.test(relativeOrAbsolute)) {
+        return path.resolve(relativeOrAbsolute);
+    }
+    // Normalize Windows separators so stubbed-win32 tests on POSIX still resolve.
+    const parts = relativeOrAbsolute.replace(/^[\\/]+/, '').split(/[/\\]+/).filter(Boolean);
+    return path.resolve(shimDir, ...parts);
+}
+/**
+ * Prefer a real Node binary — never a .cmd/.bat shim (those reintroduce cmd.exe),
+ * and never the host SEA/`lumpcode` binary via process.execPath.
+ * Returns bare `"node"` as last resort so spawn fails with ENOENT instead of
+ * silently falling back to cmd.exe after a Node entry was identified.
+ */
+function resolveNodeExecutable(preferredDir) {
+    if (preferredDir != null) {
+        const bundledNode = path.join(preferredDir, 'node.exe');
+        if (fileExists(bundledNode)) {
+            return bundledNode;
+        }
+    }
+    for (const name of ['node.exe', 'node']) {
+        const found = resolveOnPath(name);
+        if (!found)
+            continue;
+        const ext = path.extname(found).toLowerCase();
+        if (ext === '.cmd' || ext === '.bat')
+            continue;
+        return found;
+    }
+    const base = path.basename(process.execPath).toLowerCase();
+    if (base === 'node' || base === 'node.exe') {
+        return process.execPath;
+    }
+    return 'node';
+}
+/**
+ * Parse an npm/yarn-style Windows `.cmd` shim to `node <script.js>`.
+ * Returns null only when the file is not a recognizable Node cmd-shim
+ * (caller may wrap with cmd.exe). Once a script path is found, never falls
+ * back to cmd.exe — missing Node uses bare `"node"` for a clear spawn failure.
+ */
+function tryUnwrapWindowsNpmCmdShim(cmdPath) {
+    let body;
+    try {
+        body = fs.readFileSync(cmdPath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+    const shimDir = path.dirname(cmdPath);
+    const lines = body.split(/\r?\n/);
+    // Windows npm-cmd-shim ends with `%*` pass-through; prefer that line for the script path.
+    const passThroughLine = [...lines].reverse().find((line) => /%\*\s*$/.test(line));
+    const searchOrder = passThroughLine != null ? [passThroughLine, body] : [body];
+    for (const searchIn of searchOrder) {
+        const dp0Match = searchIn.match(WINDOWS_DP0_SCRIPT_RE);
+        if (dp0Match?.[1]) {
+            const candidate = resolveWindowsJsPathFromShim(shimDir, dp0Match[1]);
+            if (fileExists(candidate)) {
+                return { scriptPath: candidate };
+            }
+        }
+        const absMatch = searchIn.match(WINDOWS_ABS_SCRIPT_RE);
+        if (absMatch?.[1] && fileExists(absMatch[1])) {
+            return { scriptPath: absMatch[1] };
+        }
+    }
+    return null;
+}
 /**
  * Resolves bare executable names on Windows so npm-style `.cmd` shims and
  * extensionless Node entrypoints work with `child_process.spawn` (no shell).
+ *
+ * For Node agent CLIs installed via npm (copilot.cmd, cursor-agent.cmd, …),
+ * unwraps the shim to `node <entry.js> …args` so prompt argv is not mangled by
+ * cmd.exe / `%*`. Unrecognized `.cmd`/`.bat` files still wrap through cmd.exe.
  */
 function resolveSpawnExecutable(executable, args) {
     if (process.platform !== 'win32') {
@@ -153,17 +230,52 @@ function resolveSpawnExecutable(executable, args) {
     }
     const ext = path.extname(resolved).toLowerCase();
     if (ext === '.cmd' || ext === '.bat') {
+        const unwrapped = tryUnwrapWindowsNpmCmdShim(resolved);
+        if (unwrapped != null) {
+            return {
+                executable: resolveNodeExecutable(path.dirname(resolved)),
+                args: [unwrapped.scriptPath, ...args],
+            };
+        }
         return wrapWindowsCmdShim(resolved, args);
     }
     if (isNodeScript(resolved)) {
         return {
-            executable: process.execPath,
+            executable: resolveNodeExecutable(path.dirname(resolved)),
             args: [resolved, ...args],
         };
     }
     return { executable: resolved, args };
 }
 
+/**
+ * Minimal Windows npm-cmd-shim `.cmd` body (modern `"%_prog%"` + `"%dp0%\\…\\.js" %*` form).
+ * Shared by core spawn tests and CLI e2e path-agent install — do not duplicate.
+ */
+function windowsNpmCmdShimBody(relativeJsFromShimDir) {
+    const target = relativeJsFromShimDir.replace(/\//g, '\\');
+    return [
+        '@ECHO off',
+        'GOTO start',
+        ':find_dp0',
+        'SET dp0=%~dp0',
+        'EXIT /b',
+        ':start',
+        'SETLOCAL',
+        'CALL :find_dp0',
+        '',
+        'IF EXIST "%dp0%\\node.exe" (',
+        '  SET "_prog=%dp0%\\node.exe"',
+        ') ELSE (',
+        '  SET "_prog=node"',
+        '  SET PATHEXT=%PATHEXT:;.JS;=;%',
+        ')',
+        '',
+        `endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & set PATHEXT=%PATHEXT:;.JS;=;% & "%_prog%"  "%dp0%\\${target}" %*`,
+        '',
+    ].join('\r\n');
+}
+
 function formatMessage(prefix, message) {
     if (!prefix)
         return message;
@@ -3591,7 +3703,10 @@ async function executeStepsForContextList({ baseBranch, branchFn, lumpVariables,
                     }
                 }
                 if (postCommandExecFn) {
-                    await postCommandExecFn(postCommandExecFnInput);
+                    const returnedSteps = await postCommandExecFn(postCommandExecFnInput);
+                    if (returnedSteps != null && returnedSteps.length > 0) {
+                        await walkAndExecuteSteps(returnedSteps, nextCallHeadIndex);
+                    }
                 }
             }
         }
@@ -3730,7 +3845,8 @@ async function scanDirectory({ dirPath, allPaths, gitignoresMap, projectRoot, lo
 }
 
 async function getContextStatus(params) {
-    const { contextName, gitCommitMessageFn, projectRoot, baseBranch, lumpVariables = {}, contextVariables = {}, remoteName = "origin", logger, } = params;
+    const { contextName, gitCommitMessageFn, projectRoot, baseBranch, lumpVariables: lumpVariablesInput, contextVariables = {}, remoteName = "origin", logger, } = params;
+    const lumpVariables = (lumpVariablesInput ?? {});
     const commitMessage = gitCommitMessageFn({
         context: { name: contextName, variables: contextVariables },
         lumpVariables,
@@ -3850,7 +3966,6 @@ async function getToDoContextList(params) {
 }
 
 const contextStatus = ['toDo', 'branchPushed', 'finished'];
-const contextStatusSchema = z.enum(contextStatus);
 
 const defaultGitCommitMessageFn = ({ context }) => {
     return `LUMP:${context.name}`;
@@ -3900,7 +4015,8 @@ const defaultSetupWorkspaceFnWithWorktree = async (input) => {
 };
 
 async function runLump(input) {
-    const { baseBranch, branchFn, lumpVariables = {}, getContextListFn, gitAddCommandFn = defaultGitAddCommandFn, gitCommitCommandFn = defaultGitCommitCommandFn, gitCommitMessageFn = defaultGitCommitMessageFn, gitPushCommandFn = defaultGitPushCommandFn, numberOfContextsPerBranch = 1, projectRoot, steps, setupFn = () => ({ contextRunState: {} }), setupWorkspaceFn = defaultSetupWorkspaceFn, teardownFn = () => undefined, teardownWorkspaceFn = defaultTeardownWorkspaceFn, getKeepHistoryFilePathFn = () => undefined, logger: loggerInput, } = input;
+    const { baseBranch, branchFn, lumpVariables: lumpVariablesInput, getContextListFn, gitAddCommandFn = defaultGitAddCommandFn, gitCommitCommandFn = defaultGitCommitCommandFn, gitCommitMessageFn = defaultGitCommitMessageFn, gitPushCommandFn = defaultGitPushCommandFn, numberOfContextsPerBranch = 1, projectRoot, steps, setupFn = () => ({ contextRunState: {} }), setupWorkspaceFn = defaultSetupWorkspaceFn, teardownFn = () => undefined, teardownWorkspaceFn = defaultTeardownWorkspaceFn, getKeepHistoryFilePathFn = () => undefined, logger: loggerInput, } = input;
+    const lumpVariables = (lumpVariablesInput ?? {});
     const logger = loggerInput ?? createConsoleLogger({});
     const contextListToDoResult = await getToDoContextList({
         getContextListFn,
@@ -3954,5 +4070,5 @@ async function runLump(input) {
     });
 }
 
-export { appendHistoryEntry, collectStepsForContext, contextStatus, contextStatusSchema, createConsoleLogger, defaultGitAddCommandFn, defaultGitCommitCommandFn, defaultGitCommitMessageFn, defaultGitPushCommandFn, defaultSetupWorkspaceFn, defaultSetupWorkspaceFnWithWorktree, defaultTeardownWorkspaceFn, defaultTeardownWorkspaceFnWithWorktree, execAsync, execBinary, executeStepsForContextList, failure, formatExecFailureMessage, getCodeBasePaths, getContextStatus, getToDoContextList, historyFormatFromPath, parseGitLogHashSubjectLines, pathExists, readHistoryFile, resolveSpawnExecutable, runLump, set, shellSingleQuote, success, validateContextListNames, writeHistoryFile };
+export { appendHistoryEntry, collectStepsForContext, contextStatus, createConsoleLogger, defaultGitAddCommandFn, defaultGitCommitCommandFn, defaultGitCommitMessageFn, defaultGitPushCommandFn, defaultSetupWorkspaceFn, defaultSetupWorkspaceFnWithWorktree, defaultTeardownWorkspaceFn, defaultTeardownWorkspaceFnWithWorktree, execAsync, execBinary, executeStepsForContextList, failure, formatExecFailureMessage, getCodeBasePaths, getContextStatus, getToDoContextList, historyFormatFromPath, parseGitLogHashSubjectLines, pathExists, readHistoryFile, resolveSpawnExecutable, runLump, set, shellSingleQuote, success, validateContextListNames, windowsNpmCmdShimBody, writeHistoryFile };
 //# sourceMappingURL=index.js.map