@akterjs/cli 0.0.0-stage → 0.1.0

package/dist/Boolean-kILIvmhE.mjs

@@ -0,0 +1,26 @@
+import { bn as dual } from "./Option-DkxSnBhp.mjs";
+globalThis.Boolean;
+/**
+* Chooses between two lazy branches based on a boolean value.
+*
+* **When to use**
+*
+* Use to choose between two lazy branches based on a boolean value.
+*
+* **Example** (Pattern matching on booleans)
+*
+* ```ts import.meta.vitest
+* import { Boolean } from "effect"
+*
+* Boolean.match(true, {
+*   onFalse: () => "It's false!",
+*   onTrue: () => "It's true!"
+* }) // => "It's true!"
+* ```
+*
+* @stability stable
+* @category pattern matching
+* @since 2.0.0
+*/
+const match = /*#__PURE__*/ dual(2, (value, options) => value ? options.onTrue() : options.onFalse());
+export { match as t };

package/dist/ChildProcess-BCIwxPGc.mjs

@@ -0,0 +1,577 @@
+import { B as flatMap, Gt as scoped, Nt as raceFirst, aa as Service, bt as never, dt as map, fa as getUnsafe, o as andThen, va as Prototype } from "./Effect-CKFpqbmw.mjs";
+import { Q as getOrThrow, Y as fail, at as succeed } from "./Array-B4kuTQeW.mjs";
+import { w as some, xt as BaseProto } from "./Option-DkxSnBhp.mjs";
+import { B as runCollect, K as splitLines, M as mkString, V as runDrain, i as decodeText, nt as unwrap$1, s as drainFork } from "./Stream-bK9QIETN.mjs";
+import { i as TaggedError } from "./Data-CeCULr0-.mjs";
+import { i as value, n as make$2, t as isRedacted } from "./Redacted-RkJrG5Me.mjs";
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/Brand.js
+/**
+* Returns a `Constructor` that **does not apply any runtime checks** and just
+* returns the provided value.
+*
+* **When to use**
+*
+* Use to create nominal types that allow distinguishing between two values
+* of the same type but with different meanings.
+*
+* @see {@link make} for constructing branded values with validation.
+* @see {@link check} for constructing branded values from schema checks.
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+function nominal() {
+	return Object.assign((input) => input, {
+		option: (input) => some(input),
+		result: (input) => succeed(input),
+		is: (_) => true
+	});
+}
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/process/ChildProcessSpawner.js
+/**
+* Service boundary for starting and controlling child processes.
+*
+* `ChildProcessSpawner` is the service used by `ChildProcess` commands to start
+* operating-system processes. A spawner turns a command description into a
+* handle that can write to stdin, read stdout and stderr, wait for exit, kill
+* the process, and manage whether the process keeps its parent alive. Platform
+* backends implement this service, while most application code uses the higher
+* level `ChildProcess` module.
+*
+* @stability unstable
+* @since 4.0.0
+*/
+/**
+* Constructs branded child process `ExitCode` values.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const ExitCode = /*#__PURE__*/ nominal();
+/**
+* Constructs branded child process `ProcessId` values.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const ProcessId = /*#__PURE__*/ nominal();
+const HandleTypeId = "~effect/process/ChildProcessSpawner/ChildProcessHandle";
+const HandleProto = {
+	[HandleTypeId]: HandleTypeId,
+	...BaseProto,
+	toJSON() {
+		return {
+			_id: "ChildProcessHandle",
+			pid: this.pid
+		};
+	}
+};
+/**
+* Constructs a new `ChildProcessHandle`.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const makeHandle = (params) => Object.setPrototypeOf({ ...params }, HandleProto);
+/**
+* Creates a `ChildProcessSpawner` service from a `spawn` function, deriving
+* helpers for exit codes and output collection from that implementation.
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const make$1 = (spawn) => {
+	const streamString = (command, options) => spawn(command).pipe(map((handle) => decodeText(options?.includeStderr === true ? handle.all : drainFork(handle.stdout, handle.stderr))), unwrap$1);
+	const streamLines = (command, options) => splitLines(streamString(command, options));
+	return ChildProcessSpawner.of({
+		spawn,
+		exitCode: (command) => scoped(flatMap(spawn(command), (handle) => raceFirst(handle.exitCode, andThen(runDrain(handle.all), never)))),
+		streamString,
+		streamLines,
+		lines: (command, options) => runCollect(streamLines(command, options)),
+		string: (command, options) => mkString(streamString(command, options))
+	});
+};
+/**
+* Service tag for child process spawning.
+*
+* @stability unstable
+* @category services
+* @since 4.0.0
+*/
+var ChildProcessSpawner = class extends (/*#__PURE__*/ Service()("effect/process/ChildProcessSpawner")) {};
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/process/CommandLine.js
+/**
+* Builds command lines, the single strings that a shell or a Windows program
+* turns back into arguments, and argument lists from templates. It is
+* unrelated to `effect/cli`, which parses the arguments of your own program.
+*
+* The rules depend on what parses the string, not on the platform that builds
+* it, so `quote`, `join` and `display` take an explicit `format`:
+*
+* - `"posix"` (the default) for `sh`, `dash`, `bash` and `zsh`. Quoted output
+*   is also read the same way by `fish`.
+* - `"powershell"` for PowerShell 7.3 or later.
+* - `"windows"` for the Microsoft C runtime rules that most Windows programs
+*   use to split their command line.
+*
+* SSH sends one command line to the login shell of the remote account, so the
+* format must match that shell. The remote shell must be a POSIX shell or
+* PowerShell: Windows OpenSSH uses `cmd.exe` by default, which no format
+* supports, so set its `DefaultShell` to PowerShell. Docker and Kubernetes exec
+* take argument lists and need no command line at all.
+*
+* Arguments can be `Redacted` strings. `quote` and `join` include their values,
+* because their output is meant to run, while `display` replaces them with
+* `<redacted>`.
+*
+* @stability unstable
+* @since 4.0.7
+*/
+/**
+* Error returned when a command line or a template cannot be built.
+*
+* **Details**
+*
+* - `NulCharacter`: an argument passed to {@link quote} or {@link join}
+*   contains a NUL character, which no command line can carry.
+* - `InvalidArgument`: the format cannot carry an argument: a Windows program
+*   name with a double quote, or the argument `--%`, which PowerShell drops
+*   when it calls a native program.
+* - `InvalidEscape`: template text ends with a backslash that escapes nothing,
+*   or contains an invalid JavaScript escape sequence.
+* - `UnterminatedQuote`: a quoted section of a template is not closed.
+* - `UnsupportedSyntax`: template text contains shell syntax that cannot work
+*   without a shell, such as operators, expansions, globs, comments or
+*   variable assignments, or an interpolated array is not a separate argument.
+*
+* Messages never include the input, which may contain secrets.
+*
+* @stability unstable
+* @category errors
+* @since 4.0.7
+*/
+var CommandLineError = class extends (/*#__PURE__*/ TaggedError("CommandLineError")) {};
+/**
+* Renders a command for logs and error messages.
+*
+* **When to use**
+*
+* Use when you show a command to a person, for example in an error message,
+* and secrets and control characters must not reach the output.
+*
+* **Details**
+*
+* - Quotes like {@link join}, so commands without control characters or
+*   secrets can be copied into a terminal of the given format.
+* - Replaces `Redacted` arguments with `<redacted>`.
+* - Writes control characters and Unicode line separators as escapes such as
+*   `\n` or `\u001b`, so output cannot move the cursor or inject terminal
+*   sequences.
+* - Never fails: input that {@link join} rejects is rendered anyway.
+*
+* **Gotchas**
+*
+* The output is for reading only. It is not a reliable command line: escapes
+* and `<redacted>` change what a shell would run.
+*
+* **Example** (Showing a command with a secret)
+*
+* ```ts import.meta.vitest
+* import { Redacted } from "effect"
+* import { CommandLine } from "effect/process"
+*
+* const token = Redacted.make("hunter2")
+*
+* CommandLine.display(["curl", "-H", token, "https://x.dev/a b"]) // => "curl -H <redacted> 'https://x.dev/a b'"
+* ```
+*
+* @see {@link join} for building a command line to run
+*
+* @stability unstable
+* @category encoding
+* @since 4.0.7
+*/
+const display = (words, options) => {
+	if (words.length === 0) return "";
+	const format = options?.format ?? "posix";
+	return joinWords(format, words.map((word, i) => isRedacted(word) ? "<redacted>" : escapeControlCharacters(quoteWord(format, word, i === 0))));
+};
+/**
+* Builds an argument list from a template literal.
+*
+* **When to use**
+*
+* Use to write a command as it would look in a shell while keeping every
+* interpolated value a literal argument.
+*
+* **Details**
+*
+* - The template text is split into words as a POSIX shell does: spaces,
+*   tabs and line breaks separate words, and quotes and backslash escapes are
+*   removed. A long command can span several lines.
+* - Text that would need a shell fails with `UnsupportedSyntax`: operators
+*   (`| & ; < > ( )`), expansions (`$NAME`, `${...}`, `$(...)`, backticks, a
+*   leading `~`, braces such as `{a,b}`, and a leading `=` that `zsh`
+*   expands), globs (`* ? [`), comments (`#` at the start of a word), and a
+*   variable assignment in the program position. Quote such characters to
+*   pass them literally.
+* - No shell runs, so a program such as `if` or `time` names an executable.
+* - Each `${}` value is inserted literally, without splitting or quote
+*   processing. Next to other text or inside quotes, it becomes part of the
+*   surrounding argument.
+* - An array adds one argument per element and must stand alone as a whole
+*   argument.
+* - Numbers and booleans are converted with `String`.
+* - An argument that contains a `Redacted` value becomes `Redacted` as a
+*   whole.
+*
+* **Gotchas**
+*
+* - An invalid JavaScript escape sequence in the text, such as `\u` without
+*   hex digits, fails with `InvalidEscape`. Use `String.raw` or a `${}` value
+*   for backslashes.
+* - Neither the text nor the values are checked for NUL characters.
+*   {@link join} and the child process spawners reject them where they would
+*   truncate an argument.
+*
+* **Example** (Building arguments with interpolated values)
+*
+* ```ts import.meta.vitest
+* import { Redacted, Result } from "effect"
+* import { CommandLine } from "effect/process"
+*
+* const msg = "fix: handle $HOME"
+* const files = ["a.ts", "b.ts"]
+*
+* CommandLine.template`git commit -m ${msg} ${files}` // => Result.succeed(["git", "commit", "-m", msg, ...files])
+*
+* const password = Redacted.make("hunter2")
+* const words = Result.getOrThrow(CommandLine.template`psql "--password=${password}"`)
+*
+* CommandLine.display(words) // => "psql <redacted>"
+* ```
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.7
+*/
+const template = (strings, ...expressions) => {
+	const index = strings.findIndex((text) => text === void 0);
+	if (index !== -1) return fail(new CommandLineError({
+		reason: "InvalidEscape",
+		message: `Template part ${index} contains an invalid escape sequence`
+	}));
+	return parseTemplate$1(strings, expressions);
+};
+const unwrap = (item) => isRedacted(item) ? value(item) : String(item);
+const toWord = (item) => isRedacted(item) ? item : String(item);
+const reservedWords = /*#__PURE__*/ new Set([
+	"!",
+	"{",
+	"}",
+	"and",
+	"begin",
+	"case",
+	"coproc",
+	"do",
+	"done",
+	"elif",
+	"else",
+	"end",
+	"esac",
+	"fi",
+	"for",
+	"foreach",
+	"function",
+	"if",
+	"in",
+	"nocorrect",
+	"not",
+	"or",
+	"repeat",
+	"select",
+	"switch",
+	"then",
+	"time",
+	"until",
+	"while"
+]);
+const quoteWord = (format, value, program) => {
+	switch (format) {
+		case "posix": return program && reservedWords.has(value) ? `'${value}'` : quotePosix(value);
+		case "powershell": return quotePowerShell(value);
+		case "windows": return program && !value.includes("\"") ? quoteWindowsProgram(value) : quoteWindowsArgument(value);
+	}
+};
+const joinWords = (format, quoted) => format === "powershell" ? `& ${quoted.join(" ")}` : quoted.join(" ");
+const posixSafe = /^[A-Za-z0-9_@+:,./-]+$/;
+const quotePosix = (value) => posixSafe.test(value) ? value : `'${value.replace(/['\\]/g, (char) => `'\\${char}'`)}'`;
+const quotePowerShell = (value) => `'${value.replace(/['\u2018\u2019\u201A\u201B]/g, "$&$&")}'`;
+const windowsNeedsQuotes = /[ \t\n\v"]/;
+const quoteWindowsArgument = (value) => {
+	if (value.length > 0 && !windowsNeedsQuotes.test(value)) return value;
+	let out = "\"";
+	let backslashes = 0;
+	for (const char of value) if (char === "\\") backslashes++;
+	else if (char === "\"") {
+		out += "\\".repeat(backslashes * 2 + 1) + "\"";
+		backslashes = 0;
+	} else {
+		out += "\\".repeat(backslashes) + char;
+		backslashes = 0;
+	}
+	return out + "\\".repeat(backslashes * 2) + "\"";
+};
+const quoteWindowsProgram = (value) => value.length > 0 && !/[ \t]/.test(value) ? value : `"${value}"`;
+const controlCharacters = /[\u0000-\u001f\u007f-\u009f\u2028\u2029]/g;
+const controlEscapes = {
+	"\n": "\\n",
+	"\r": "\\r",
+	"	": "\\t"
+};
+const escapeControlCharacters = (value) => value.replace(controlCharacters, (char) => controlEscapes[char] ?? `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}`);
+const operators = "|&;<>()";
+const globs = "*?[";
+const expansionStart = /[A-Za-z_0-9{(@*#?$!'"-]/;
+const quotedExpansionStart = /[A-Za-z_0-9{(@*#?$!-]/;
+const assignmentName = /^[A-Za-z_][A-Za-z0-9_]*\+?$/;
+const isBlank = (char) => char === " " || char === "	" || char === "\n";
+const unsupportedSyntax = (char, next, wordStart) => {
+	if (operators.includes(char)) return `The operator "${char}" needs a shell`;
+	if (char === "`") return "Command substitution needs a shell";
+	if (char === "$" && next !== void 0 && expansionStart.test(next)) return `The expansion "$${next}" needs a shell`;
+	if (globs.includes(char)) return `The glob character "${char}" needs a shell`;
+	if (!wordStart) return void 0;
+	if (char === "#") return "A comment needs a shell";
+	if (char === "~") return "Tilde expansion needs a shell";
+	if (char === "=" && next !== void 0 && !isBlank(next)) return "A leading \"=\" is expanded by zsh";
+};
+const parseTemplate$1 = (texts, values) => {
+	const words = [];
+	let word = [];
+	let plain = true;
+	let braceDepth = 0;
+	let quote = void 0;
+	let quotePart = 0;
+	let part = 0;
+	const error = (reason, message, at = part) => fail(new CommandLineError({
+		reason,
+		message: `${message} in template part ${at}`
+	}));
+	const endWord = () => {
+		if (word.length === 0) return;
+		const value = word.map(unwrap).join("");
+		words.push(word.length === 1 && isRedacted(word[0]) ? word[0] : word.some(isRedacted) ? make$2(value) : value);
+		word = [];
+		plain = true;
+		braceDepth = 0;
+	};
+	const scan = (text) => {
+		for (let i = 0; i < text.length; i++) {
+			const char = text[i];
+			const next = text[i + 1];
+			if (quote === "'") {
+				if (char === "'") quote = void 0;
+				else word.push(char);
+			} else if (quote === "\"") {
+				if (char === "\"") quote = void 0;
+				else if (char === "\\" && next !== void 0 && "$`\"\\\n".includes(next)) {
+					if (next !== "\n") word.push(next);
+					i++;
+				} else if (char === "`") return error("UnsupportedSyntax", "Command substitution needs a shell");
+				else if (char === "$" && next !== void 0 && quotedExpansionStart.test(next)) return error("UnsupportedSyntax", `The expansion "$${next}" needs a shell`);
+				else word.push(char);
+			} else if (isBlank(char)) endWord();
+			else if (char === "\\") {
+				if (next === void 0) return error("InvalidEscape", "A trailing backslash escapes nothing");
+				if (next !== "\n") {
+					word.push(next);
+					plain = false;
+				}
+				i++;
+			} else if (char === "'" || char === "\"") {
+				quote = char;
+				quotePart = part;
+				word.push("");
+				plain = false;
+			} else {
+				const unsupported = unsupportedSyntax(char, next, word.length === 0);
+				if (unsupported !== void 0) return error("UnsupportedSyntax", unsupported);
+				if (char === "{") braceDepth++;
+				else if (char === "}") {
+					if (braceDepth > 0) braceDepth--;
+				} else if (braceDepth > 0 && (char === "," || char === "." && next === ".")) return error("UnsupportedSyntax", "Brace expansion needs a shell");
+				else if (char === "=" && words.length === 0 && plain && assignmentName.test(word.join(""))) return error("UnsupportedSyntax", "A variable assignment needs a shell");
+				word.push(char);
+			}
+		}
+	};
+	for (; part < texts.length; part++) {
+		const failure = scan(texts[part]);
+		if (failure !== void 0) return failure;
+		if (part === values.length) break;
+		const expression = values[part];
+		if (Array.isArray(expression)) {
+			const after = texts[part + 1][0];
+			if (word.length > 0 || (after === void 0 ? part + 1 < values.length : !isBlank(after))) return error("UnsupportedSyntax", "An interpolated array must be a separate argument");
+			for (const item of expression) words.push(toWord(item));
+		} else {
+			word.push(toWord(expression));
+			plain = false;
+		}
+	}
+	if (quote !== void 0) return error("UnterminatedQuote", "The quote is not closed", quotePart);
+	endWord();
+	return succeed(words);
+};
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/process/ChildProcess.js
+/**
+* Describes child processes before they are started.
+*
+* A `Command` stores the executable, arguments, environment, standard streams,
+* working directory, and other process options. Commands can also be piped
+* together. A command is an `Effect`; running it asks the
+* `ChildProcessSpawner` service to start the process and returns a
+* `ChildProcessHandle`.
+*
+* @stability unstable
+* @since 4.0.0
+*/
+const TypeId = "~effect/process/ChildProcess";
+const Proto = {
+	.../*#__PURE__*/ Prototype({
+		label: "Command",
+		evaluate(fiber) {
+			return getUnsafe(fiber.context, ChildProcessSpawner).spawn(this);
+		}
+	}),
+	[TypeId]: TypeId
+};
+const makeStandardCommand = (command, args, options) => Object.assign(Object.create(Proto), {
+	_tag: "StandardCommand",
+	command,
+	args,
+	options
+});
+/**
+* Create a command from a template literal, options + template, or array form.
+*
+* **Details**
+*
+* This function supports three calling conventions:
+* 1. Template literal: `make\`npm run build\``
+* 2. Options + template literal: `make({ cwd: "/app" })\`npm run build\``
+* 3. Array form: `make("npm", ["run", "build"], options?)`
+*
+* Templates are split with `CommandLine.template`: quotes group words, each
+* `${}` value is one literal argument, and an argument that contains a
+* `Redacted` value stays `Redacted`. Arguments in the array form can be
+* `Redacted` too.
+*
+* With the `shell` option, the template text is the shell script and is kept
+* as written.
+*
+* **Gotchas**
+*
+* - A template is parsed when `make` is called. Shell syntax such as `|`,
+*   `$HOME`, `*` or `~` throws a `CommandLine.CommandLineError`: quote it, or
+*   pass the value with `${}`.
+* - A template with the `shell` option cannot contain `${}` values, because
+*   their quoting depends on the shell. Build the script with
+*   `CommandLine.quote` and pass it as a string.
+* - The program name, the first word, cannot be `Redacted`.
+* - A NUL character in the command, an argument or an `env` value fails with
+*   a `BadArgument` error when the command is spawned.
+*
+* **Example** (Creating commands)
+*
+* ```ts import.meta.vitest
+* import { ChildProcess } from "effect/process"
+*
+* // Template literal form; quotes group words
+* const cmd1 = ChildProcess.make`echo "hello world"`
+*
+* // With options
+* const cmd2 = ChildProcess.make({ cwd: "/tmp" })`ls -la`
+*
+* // Array form
+* const cmd3 = ChildProcess.make("git", ["status"])
+*
+* const result = [cmd1.args[0], cmd2.options.cwd, cmd3.args[0]] // => ["hello world", "/tmp", "status"]
+* ```
+*
+* @stability unstable
+* @category constructors
+* @since 4.0.0
+*/
+const make = function make(...args) {
+	if (isTemplateString(args[0])) {
+		const [templates, ...expressions] = args;
+		const [command, cmdArgs] = parseTemplate(templates, expressions);
+		return makeStandardCommand(command, cmdArgs, {});
+	}
+	if (typeof args[0] === "object" && !Array.isArray(args[0]) && !isTemplateString(args[0])) {
+		const options = args[0];
+		return function(templates, ...expressions) {
+			if (options.shell !== void 0 && options.shell !== false) return makeStandardCommand(shellScript(templates, expressions), [], options);
+			const [command, cmdArgs] = parseTemplate(templates, expressions);
+			return makeStandardCommand(command, cmdArgs, options);
+		};
+	}
+	if (typeof args[0] === "string" && !Array.isArray(args[1])) {
+		const [command, options = {}] = args;
+		return makeStandardCommand(command, [], options);
+	}
+	const [command, cmdArgs = [], options = {}] = args;
+	return makeStandardCommand(command, cmdArgs, options);
+};
+const isTemplateString = (u) => Array.isArray(u) && "raw" in u && Array.isArray(u.raw);
+/**
+* Parses an fd name like "fd3" to its numeric index.
+* Returns undefined if the name is invalid.
+*
+* @stability unstable
+* @category converting
+* @since 4.0.0
+*/
+const parseFdName = (name) => {
+	const match = /^fd(\d+)$/.exec(name);
+	if (match === null) return void 0;
+	const fd = parseInt(match[1], 10);
+	return fd >= 3 ? fd : void 0;
+};
+/**
+* Create an fd name from its numeric index.
+*
+* @stability unstable
+* @category converting
+* @since 4.0.0
+*/
+const fdName = (fd) => `fd${fd}`;
+const parseTemplate = (templates, expressions) => {
+	const [program = "", ...args] = getOrThrow(template(templates, ...expressions));
+	if (typeof program !== "string") throw new CommandLineError({
+		reason: "InvalidArgument",
+		message: "The program name of a command cannot be Redacted"
+	});
+	return [program, args];
+};
+const shellScript = (templates, expressions) => {
+	if (expressions.length > 0) throw new CommandLineError({
+		reason: "UnsupportedSyntax",
+		message: "A shell template cannot interpolate values; build the script with CommandLine.quote"
+	});
+	const script = templates[0];
+	if (script === void 0) throw new CommandLineError({
+		reason: "InvalidEscape",
+		message: "Template part 0 contains an invalid escape sequence"
+	});
+	return script;
+};
+export { ChildProcessSpawner as a, make$1 as c, display as i, makeHandle as l, make as n, ExitCode as o, parseFdName as r, ProcessId as s, fdName as t };