projen
Version:
CDK for software projects
198 lines • 26.8 kB
JavaScript
;
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.npx = exports.npm = exports.node = exports.poetry = exports.uv = exports.git = exports.MAX_BUFFER = void 0;
exports.tool = tool;
const child_process = __importStar(require("child_process"));
const fs = __importStar(require("fs"));
const os = __importStar(require("os"));
const path = __importStar(require("path"));
const dax_1 = require("./dax");
const logging = __importStar(require("../logging"));
exports.MAX_BUFFER = 10 * 1024 * 1024;
function spawnOpts(options) {
return {
maxBuffer: exports.MAX_BUFFER,
cwd: options.cwd,
env: options.env ? { ...process.env, ...options.env } : undefined,
// run the program directly, without going through a shell
shell: false,
};
}
/**
* Runs a program with the given arguments, inheriting stdout. Throws if the
* command exits with a non-zero status.
*/
function run(file, args, options) {
logging.debug(`${file} ${args.join(" ")} (cwd: ${options.cwd})`);
child_process.execFileSync(file, args, {
...spawnOpts(options),
// By default the child's stdout is redirected to STDERR (to keep the
// parent's STDOUT clean) and its STDERR is piped so it surfaces in
// exceptions. `inheritStdio` instead streams both straight to the parent.
stdio: options.inheritStdio ? "inherit" : ["inherit", 2, "pipe"],
});
}
/**
* Runs a program and returns its trimmed STDOUT (or STDOUT+STDERR interleaved
* in their original write order, if `captureStderr` is set). Throws if the
* command exits with a non-zero status.
*/
function capture(file, args, options) {
logging.debug(`${file} ${args.join(" ")} (cwd: ${options.cwd})`);
if (options.captureStderr) {
// Same fd for both streams so they interleave in write order. A shared
// in-memory Writable won't work here - execFileSync only accepts stdio
// streams backed by a real fd (tty/file/socket/pipe).
const combinedFile = path.join(fs.mkdtempSync(path.join(os.tmpdir(), "projen-capture-")), "output");
const fd = fs.openSync(combinedFile, "w+");
try {
try {
child_process.execFileSync(file, args, {
...spawnOpts(options),
stdio: ["inherit", fd, fd],
});
}
catch (e) {
// mirrors execFileSync's own behavior of attaching output to the error
e.stdout = fs.readFileSync(combinedFile);
throw e;
}
return fs.readFileSync(combinedFile, "utf-8").trim();
}
finally {
fs.closeSync(fd);
fs.rmSync(path.dirname(combinedFile), { recursive: true, force: true });
}
}
return child_process
.execFileSync(file, args, {
...spawnOpts(options),
stdio: ["inherit", "pipe", "pipe"], // "pipe" for STDERR means it appears in exceptions
})
.toString("utf-8")
.trim();
}
/**
* Runs a program and returns its trimmed STDOUT (or STDOUT+STDERR interleaved
* in their original write order, if `captureStderr` is set), or `undefined`
* if the command failed or produced no output.
*/
function tryCapture(file, args, options) {
try {
const value = capture(file, args, options);
// an empty string is the same as undefined
return value || undefined;
}
catch {
return undefined;
}
}
/**
* Creates a shell-free {@link Tool} for the given program.
*
* @example const git = tool("git"); git.run(["tag", "--delete", tag], { cwd });
*/
function tool(file) {
return {
run: (args, options) => run(file, args, options),
capture: (args, options) => capture(file, args, options),
tryCapture: (args, options) => tryCapture(file, args, options),
};
}
/**
* Shell-free helper for invoking `git`.
*
* @example git.run(["tag", "--delete", tag], { cwd });
*/
exports.git = tool("git");
/**
* Shell-free helper for invoking `uv` (ships as a native binary on all
* platforms).
*/
exports.uv = tool("uv");
/**
* Shell-free helper for invoking `poetry`.
*/
exports.poetry = tool("poetry");
/**
* Shell-free helper for invoking the current Node.js executable
* (`process.execPath`).
*/
exports.node = tool(process.execPath);
/**
* Creates an {@link AsyncTool} that invokes `file` via dax, resolving Windows
* `.cmd`/`.bat` shims and escaping every argument (so each value is passed as
* a single literal argument).
*
* @example await npx.run(["commit-and-tag-version@^12"], { cwd });
*/
function shimTool(file) {
const build = (args, options) => {
const cmd = (0, dax_1.$) `${file} ${args}`.cwd(options.cwd).stderr("piped").noThrow();
return options.env ? cmd.env(options.env) : cmd;
};
const ensureOk = (args, result) => {
if (result.code !== 0) {
// Mimic the `child_process` error shape (`status`, `stderr`) so callers
// can inspect stderr (e.g. to detect ENOENT/E404 from npm).
const error = new Error(`Command failed (exit code ${result.code}): ${file} ${args.join(" ")}`);
error.status = result.code;
error.stderr = Buffer.from(result.stderr);
throw error;
}
};
return {
run: async (args, options) => {
logging.debug(`${file} ${args.join(" ")} (cwd: ${options.cwd})`);
ensureOk(args, await build(args, options));
},
capture: async (args, options) => {
logging.debug(`${file} ${args.join(" ")} (cwd: ${options.cwd})`);
const result = await build(args, options).stdout("piped");
ensureOk(args, result);
return result.stdout.trim();
},
};
}
/**
* Cross-platform helper for `npm` (a Windows `.cmd` shim).
*/
exports.npm = shimTool("npm");
/**
* Cross-platform helper for `npx` (a Windows `.cmd` shim).
*/
exports.npx = shimTool("npx");
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"exec.js","sourceRoot":"","sources":["../../src/util/exec.ts"],"names":[],"mappings":"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","sourcesContent":["import * as child_process from \"child_process\";\nimport * as fs from \"fs\";\nimport * as os from \"os\";\nimport * as path from \"path\";\nimport { $ } from \"./dax\";\nimport * as logging from \"../logging\";\n\nexport const MAX_BUFFER = 10 * 1024 * 1024;\n\n//\n// ---------------------------------------------------------------------------\n// Shell-free execution (execFileSync, shell: false).\n//\n// The program and each argument are passed to the OS directly without going\n// through a shell, so there is no quoting to get right and no differences\n// between platform shells to account for when commands include values derived\n// from files, git output, configuration, etc.\n//\n// Only per-tool helpers are exported (e.g. `git`); the generic primitives are\n// kept private so call sites are explicit about which tool they invoke.\n// ---------------------------------------------------------------------------\n//\n\n/**\n * Options for shell-free command execution.\n */\nexport interface ExecFileOptions {\n  /**\n   * Working directory for the command.\n   */\n  readonly cwd: string;\n\n  /**\n   * Additional environment variables, merged on top of `process.env`.\n   */\n  readonly env?: Record<string, string | undefined>;\n\n  /**\n   * For `capture`/`tryCapture`: interleave STDERR into the captured output\n   * instead of only capturing STDOUT.\n   *\n   * @default false\n   */\n  readonly captureStderr?: boolean;\n}\n\n/**\n * Options for {@link Tool.run}.\n */\nexport interface RunOptions extends ExecFileOptions {\n  /**\n   * Stream the child's stdout and stderr straight to the parent's stdout and\n   * stderr (full inheritance), instead of redirecting stdout to stderr and\n   * capturing stderr (the default).\n   *\n   * Use this when launching a child process whose stdout is meaningful and\n   * whose output should stream live to the user (e.g. the projen CLI).\n   *\n   * @default false\n   */\n  readonly inheritStdio?: boolean;\n}\n\nfunction spawnOpts(options: ExecFileOptions) {\n  return {\n    maxBuffer: MAX_BUFFER,\n    cwd: options.cwd,\n    env: options.env ? { ...process.env, ...options.env } : undefined,\n    // run the program directly, without going through a shell\n    shell: false as const,\n  };\n}\n\n/**\n * Runs a program with the given arguments, inheriting stdout. Throws if the\n * command exits with a non-zero status.\n */\nfunction run(file: string, args: string[], options: RunOptions): void {\n  logging.debug(`${file} ${args.join(\" \")} (cwd: ${options.cwd})`);\n\n  child_process.execFileSync(file, args, {\n    ...spawnOpts(options),\n    // By default the child's stdout is redirected to STDERR (to keep the\n    // parent's STDOUT clean) and its STDERR is piped so it surfaces in\n    // exceptions. `inheritStdio` instead streams both straight to the parent.\n    stdio: options.inheritStdio ? \"inherit\" : [\"inherit\", 2, \"pipe\"],\n  });\n}\n\n/**\n * Runs a program and returns its trimmed STDOUT (or STDOUT+STDERR interleaved\n * in their original write order, if `captureStderr` is set). Throws if the\n * command exits with a non-zero status.\n */\nfunction capture(\n  file: string,\n  args: string[],\n  options: ExecFileOptions,\n): string {\n  logging.debug(`${file} ${args.join(\" \")} (cwd: ${options.cwd})`);\n\n  if (options.captureStderr) {\n    // Same fd for both streams so they interleave in write order. A shared\n    // in-memory Writable won't work here - execFileSync only accepts stdio\n    // streams backed by a real fd (tty/file/socket/pipe).\n    const combinedFile = path.join(\n      fs.mkdtempSync(path.join(os.tmpdir(), \"projen-capture-\")),\n      \"output\",\n    );\n    const fd = fs.openSync(combinedFile, \"w+\");\n    try {\n      try {\n        child_process.execFileSync(file, args, {\n          ...spawnOpts(options),\n          stdio: [\"inherit\", fd, fd],\n        });\n      } catch (e: any) {\n        // mirrors execFileSync's own behavior of attaching output to the error\n        e.stdout = fs.readFileSync(combinedFile);\n        throw e;\n      }\n      return fs.readFileSync(combinedFile, \"utf-8\").trim();\n    } finally {\n      fs.closeSync(fd);\n      fs.rmSync(path.dirname(combinedFile), { recursive: true, force: true });\n    }\n  }\n\n  return child_process\n    .execFileSync(file, args, {\n      ...spawnOpts(options),\n      stdio: [\"inherit\", \"pipe\", \"pipe\"], // \"pipe\" for STDERR means it appears in exceptions\n    })\n    .toString(\"utf-8\")\n    .trim();\n}\n\n/**\n * Runs a program and returns its trimmed STDOUT (or STDOUT+STDERR interleaved\n * in their original write order, if `captureStderr` is set), or `undefined`\n * if the command failed or produced no output.\n */\nfunction tryCapture(\n  file: string,\n  args: string[],\n  options: ExecFileOptions,\n): string | undefined {\n  try {\n    const value = capture(file, args, options);\n\n    // an empty string is the same as undefined\n    return value || undefined;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * A shell-free handle for invoking a single program by name or path.\n *\n * Each argument is passed to the program verbatim (no shell parsing), so there\n * is no quoting to get right for values such as tags, versions, branch names\n * or file paths.\n *\n * Note: the program is executed directly, without a shell. On Windows this\n * means it must be a real executable - `.cmd`/`.bat` shims (such as\n * npm-installed CLIs like npm/npx/yarn/pnpm) cannot be invoked this way.\n */\nexport interface Tool {\n  /**\n   * Runs `<tool> <args>`, inheriting stdout. Throws on non-zero exit.\n   */\n  run(args: string[], options: RunOptions): void;\n\n  /**\n   * Runs `<tool> <args>` and returns its trimmed STDOUT. Throws on non-zero exit.\n   */\n  capture(args: string[], options: ExecFileOptions): string;\n\n  /**\n   * Runs `<tool> <args>` and returns its trimmed STDOUT, or `undefined` if the\n   * command failed or produced no output.\n   */\n  tryCapture(args: string[], options: ExecFileOptions): string | undefined;\n}\n\n/**\n * Creates a shell-free {@link Tool} for the given program.\n *\n * @example const git = tool(\"git\"); git.run([\"tag\", \"--delete\", tag], { cwd });\n */\nexport function tool(file: string): Tool {\n  return {\n    run: (args, options) => run(file, args, options),\n    capture: (args, options) => capture(file, args, options),\n    tryCapture: (args, options) => tryCapture(file, args, options),\n  };\n}\n\n/**\n * Shell-free helper for invoking `git`.\n *\n * @example git.run([\"tag\", \"--delete\", tag], { cwd });\n */\nexport const git = tool(\"git\");\n\n/**\n * Shell-free helper for invoking `uv` (ships as a native binary on all\n * platforms).\n */\nexport const uv = tool(\"uv\");\n\n/**\n * Shell-free helper for invoking `poetry`.\n */\nexport const poetry = tool(\"poetry\");\n\n/**\n * Shell-free helper for invoking the current Node.js executable\n * (`process.execPath`).\n */\nexport const node = tool(process.execPath);\n\n//\n// ---------------------------------------------------------------------------\n// Cross-platform execution via dax (for binaries that may be `.cmd` shims).\n//\n// `tool` above uses `execFileSync` with `shell: false`, which cannot launch\n// Windows `.cmd`/`.bat` shims such as `npx` or `npm`. `shimTool` runs through\n// dax, which resolves those shims cross-platform. Arguments are interpolated\n// through dax's escaping (NOT `$.raw`), so each value is passed as a single\n// literal argument with no quoting to get right. dax is asynchronous, so\n// these helpers are only usable from async call sites.\n// ---------------------------------------------------------------------------\n//\n\n/**\n * Async, dax-backed equivalent of {@link Tool} for programs that may be a\n * Windows `.cmd`/`.bat` shim (e.g. `npx`, `npm`).\n */\nexport interface AsyncTool {\n  /**\n   * Runs `<tool> <args>`, inheriting stdout. Rejects on non-zero exit.\n   */\n  run(args: string[], options: ExecFileOptions): Promise<void>;\n\n  /**\n   * Runs `<tool> <args>` and resolves its trimmed STDOUT. Rejects on non-zero\n   * exit.\n   */\n  capture(args: string[], options: ExecFileOptions): Promise<string>;\n}\n\n/**\n * Creates an {@link AsyncTool} that invokes `file` via dax, resolving Windows\n * `.cmd`/`.bat` shims and escaping every argument (so each value is passed as\n * a single literal argument).\n *\n * @example await npx.run([\"commit-and-tag-version@^12\"], { cwd });\n */\nfunction shimTool(file: string): AsyncTool {\n  const build = (args: string[], options: ExecFileOptions) => {\n    const cmd = $`${file} ${args}`.cwd(options.cwd).stderr(\"piped\").noThrow();\n    return options.env ? cmd.env(options.env) : cmd;\n  };\n  const ensureOk = (\n    args: string[],\n    result: { code: number; stderr: string },\n  ) => {\n    if (result.code !== 0) {\n      // Mimic the `child_process` error shape (`status`, `stderr`) so callers\n      // can inspect stderr (e.g. to detect ENOENT/E404 from npm).\n      const error: any = new Error(\n        `Command failed (exit code ${result.code}): ${file} ${args.join(\" \")}`,\n      );\n      error.status = result.code;\n      error.stderr = Buffer.from(result.stderr);\n      throw error;\n    }\n  };\n  return {\n    run: async (args, options) => {\n      logging.debug(`${file} ${args.join(\" \")} (cwd: ${options.cwd})`);\n      ensureOk(args, await build(args, options));\n    },\n    capture: async (args, options) => {\n      logging.debug(`${file} ${args.join(\" \")} (cwd: ${options.cwd})`);\n      const result = await build(args, options).stdout(\"piped\");\n      ensureOk(args, result);\n      return result.stdout.trim();\n    },\n  };\n}\n\n/**\n * Cross-platform helper for `npm` (a Windows `.cmd` shim).\n */\nexport const npm = shimTool(\"npm\");\n\n/**\n * Cross-platform helper for `npx` (a Windows `.cmd` shim).\n */\nexport const npx = shimTool(\"npx\");\n"]}