@pablopunk/tau 0.0.0-stage → 0.1.0

package/dist/serve-BcVZj5e2.js

@@ -0,0 +1 @@
+export { t as serveInForeground } from "./serve-92lMbcls.js";

package/dist/service-command-BVr33vlP.js

@@ -0,0 +1 @@
+export { t as runServiceCommand } from "./service-command-C7WDeeR2.js";

package/dist/service-command-C7WDeeR2.js

@@ -0,0 +1,621 @@
+import { t as cliEntry } from "./cli-entry-DcDpQ30L.js";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { delimiter, dirname, join, resolve } from "node:path";
+import { homedir, release, userInfo } from "node:os";
+import { parseArgs } from "node:util";
+import { createHash } from "node:crypto";
+import { spawn, spawnSync } from "node:child_process";
+//#region src/service/entry-guard.ts
+const TEMPORARY_RUNNER_FOLDERS = [
+	/[\\/]_npx[\\/]/,
+	/[\\/]dlx-[^\\/]+[\\/]/,
+	/[\\/]pnpm[\\/]dlx[\\/]/,
+	/[\\/]\.bun[\\/]install[\\/]cache[\\/]/
+];
+const isTemporaryRunnerEntry = (entry) => TEMPORARY_RUNNER_FOLDERS.some((folder) => folder.test(entry));
+var TemporaryEntryError = class extends Error {
+	constructor(entry) {
+		super(`tau runs from a temporary cache (${entry}). Install tau globally first: npm i -g @pablopunk/tau.`);
+		this.name = "TemporaryEntryError";
+	}
+};
+function refuseTemporaryEntry(entry) {
+	if (isTemporaryRunnerEntry(entry)) throw new TemporaryEntryError(entry);
+}
+//#endregion
+//#region src/service/runner.ts
+const realRunner = {
+	async run(command, args) {
+		const result = spawnSync(command, [...args], { encoding: "utf8" });
+		return {
+			code: result.status ?? 1,
+			stdout: result.stdout ?? "",
+			stderr: result.stderr ?? result.error?.message ?? ""
+		};
+	},
+	async spawnDetached(command, args, options = {}) {
+		const child = spawn(command, [...args], {
+			detached: true,
+			stdio: "ignore",
+			windowsHide: true,
+			env: options.env ?? process.env
+		});
+		child.unref();
+		return child.pid;
+	}
+};
+//#endregion
+//#region src/service/context.ts
+function isAlive(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error.code === "EPERM";
+	}
+}
+const windowsBuildOf = () => process.platform === "win32" ? Number(release().split(".")[2]) : void 0;
+function realContext(env = process.env) {
+	return {
+		platform: process.platform,
+		uid: process.getuid?.() ?? 0,
+		username: userInfo().username,
+		osHome: homedir(),
+		defaultHome: join(homedir(), ".tau"),
+		xdgRuntimeDir: env.XDG_RUNTIME_DIR,
+		windowsBuild: windowsBuildOf(),
+		env,
+		runner: realRunner,
+		isAlive,
+		kill: (pid) => process.kill(pid, "SIGTERM")
+	};
+}
+//#endregion
+//#region src/service/names.ts
+const hashOf = (home) => createHash("sha256").update(resolve(home)).digest("hex").slice(0, 8);
+/** The default home keeps the plain names; any other home gets its own, so dev homes never replace the user's service. */
+function serviceNames(home, defaultHome) {
+	if (resolve(home) === resolve(defaultHome)) return {
+		launchdLabel: "dev.tau.server",
+		systemdUnit: "tau.service",
+		taskName: "tau"
+	};
+	const hash = hashOf(home);
+	return {
+		launchdLabel: `dev.tau.server.${hash}`,
+		systemdUnit: `tau-${hash}.service`,
+		taskName: `tau-${hash}`
+	};
+}
+//#endregion
+//#region src/service/path-capture.ts
+const miseShimsOf = (osHome) => join(osHome, ".local", "share", "mise", "shims");
+/** The user's PATH with the mise shims folder first, so a removed tool version does not break agents. */
+function captureServicePath(pathValue, osHome, exists = existsSync, separator = delimiter) {
+	const shims = miseShimsOf(osHome);
+	const entries = pathValue.split(separator).filter((entry) => entry !== "" && entry !== shims);
+	return (exists(shims) ? [shims, ...entries] : entries).join(separator);
+}
+//#endregion
+//#region src/service/spec.ts
+const serviceArgs = (home, isDefaultHome) => [
+	"serve",
+	"--service",
+	"--no-open",
+	...isDefaultHome ? [] : ["--home", home]
+];
+function buildSpec(context, cli, home) {
+	const names = serviceNames(home, context.defaultHome);
+	return {
+		names,
+		home,
+		node: cli.node,
+		entry: cli.entry,
+		path: captureServicePath(context.env.PATH ?? "", context.osHome),
+		args: serviceArgs(home, names.launchdLabel === "dev.tau.server")
+	};
+}
+const recordFileOf = (home) => join(home, "service.json");
+const pidFileOf = (home) => join(home, "service.pid");
+const wrapperOf = (home) => join(home, "bin", "tau-service.cmd");
+//#endregion
+//#region src/service/detached.ts
+function readPid(file) {
+	try {
+		const pid = Number(readFileSync(file, "utf8").trim());
+		return Number.isInteger(pid) && pid > 0 ? pid : void 0;
+	} catch {
+		return;
+	}
+}
+/** A plain background process: used when the OS has no usable service manager, or for a home with no service. */
+function createDetachedBackend(context) {
+	const livePid = (spec) => {
+		const pid = readPid(pidFileOf(spec.home));
+		return pid !== void 0 && context.isAlive(pid) ? pid : void 0;
+	};
+	async function start(spec) {
+		if (livePid(spec) !== void 0) return;
+		const pid = await context.runner.spawnDetached(spec.node, [spec.entry, ...spec.args], { env: {
+			...context.env,
+			PATH: spec.path
+		} });
+		if (pid === void 0) return;
+		mkdirSync(dirname(pidFileOf(spec.home)), { recursive: true });
+		writeFileSync(pidFileOf(spec.home), String(pid));
+	}
+	async function stop(spec) {
+		const pid = livePid(spec);
+		if (pid !== void 0) context.kill(pid);
+		rmSync(pidFileOf(spec.home), { force: true });
+	}
+	return {
+		kind: "detached",
+		files: () => [],
+		isInstalled: async () => false,
+		async install(spec) {
+			await start(spec);
+			return { warnings: [] };
+		},
+		uninstall: stop,
+		reload: async (spec) => {
+			await stop(spec);
+			await start(spec);
+		},
+		start,
+		stop,
+		async restart(spec) {
+			await stop(spec);
+			await start(spec);
+		},
+		async state(spec) {
+			const pid = livePid(spec);
+			return {
+				active: pid !== void 0,
+				pid
+			};
+		},
+		list: async () => []
+	};
+}
+//#endregion
+//#region src/service/backend.ts
+var ServiceCommandError = class extends Error {
+	constructor(command, stderr) {
+		super(`${command} failed: ${stderr.trim() || "no output"}`);
+		this.name = "ServiceCommandError";
+	}
+};
+//#endregion
+//#region src/service/render.ts
+const xmlEscape = (text) => text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;");
+function renderPlist(spec) {
+	const programArguments = [
+		spec.node,
+		spec.entry,
+		...spec.args
+	].map((argument) => `    <string>${xmlEscape(argument)}</string>`).join("\n");
+	return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${xmlEscape(spec.names.launchdLabel)}</string>
+  <key>ProgramArguments</key>
+  <array>
+${programArguments}
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${xmlEscape(spec.path)}</string>
+  </dict>
+</dict>
+</plist>
+`;
+}
+const systemdQuote = (text) => `"${text.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"").replaceAll("%", "%%")}"`;
+function renderSystemdUnit(spec) {
+	return `[Unit]
+Description=tau server
+
+[Service]
+ExecStart=${[
+		spec.node,
+		spec.entry,
+		...spec.args
+	].map(systemdQuote).join(" ")}
+Restart=always
+RestartSec=5
+Environment=${systemdQuote(`PATH=${spec.path}`)}
+
+[Install]
+WantedBy=default.target
+`;
+}
+function renderTaskXml(wrapperPath) {
+	return `<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.4" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <Triggers>
+    <LogonTrigger>
+      <Enabled>true</Enabled>
+    </LogonTrigger>
+  </Triggers>
+  <Principals>
+    <Principal id="Author">
+      <LogonType>InteractiveToken</LogonType>
+      <RunLevel>LeastPrivilege</RunLevel>
+    </Principal>
+  </Principals>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <ExecutionTimeLimit>PT0S</ExecutionTimeLimit>
+    <RestartOnFailure>
+      <Interval>PT1M</Interval>
+      <Count>999</Count>
+    </RestartOnFailure>
+    <StartWhenAvailable>true</StartWhenAvailable>
+    <AllowStartOnDemand>true</AllowStartOnDemand>
+    <Hidden>true</Hidden>
+    <Enabled>true</Enabled>
+  </Settings>
+  <Actions Context="Author">
+    <Exec>
+      <Command>conhost.exe</Command>
+      <Arguments>--headless "${xmlEscape(wrapperPath)}"</Arguments>
+    </Exec>
+  </Actions>
+</Task>
+`;
+}
+const cmdQuote = (text) => `"${text.replaceAll("%", "%%")}"`;
+function renderCmdWrapper(spec) {
+	const command = [
+		spec.node,
+		spec.entry,
+		...spec.args
+	].map(cmdQuote).join(" ");
+	return `@echo off\r
+set "PATH=${spec.path.replaceAll("%", "%%")}"\r
+${command}\r
+exit /b %ERRORLEVEL%\r
+`;
+}
+//#endregion
+//#region src/service/launchd.ts
+const plistDirOf = (context) => join(context.osHome, "Library", "LaunchAgents");
+const plistPathOf = (context, spec) => join(plistDirOf(context), `${spec.names.launchdLabel}.plist`);
+const PID_LINE = /^\s*pid = (\d+)/m;
+function createLaunchdBackend(context) {
+	const launchctl = (...args) => context.runner.run("launchctl", args);
+	const domains = [`gui/${context.uid}`, `user/${context.uid}`];
+	async function liveDomain() {
+		for (const domain of domains) if ((await launchctl("print", domain)).code === 0) return domain;
+	}
+	const targetOf = async (spec) => `${await liveDomain() ?? domains[0]}/${spec.names.launchdLabel}`;
+	async function bootstrap(spec) {
+		for (const domain of domains) if ((await launchctl("bootstrap", domain, plistPathOf(context, spec))).code === 0) return true;
+		return false;
+	}
+	return {
+		kind: "launchd",
+		files: (spec) => [{
+			path: plistPathOf(context, spec),
+			content: renderPlist(spec)
+		}],
+		isInstalled: async (spec) => existsSync(plistPathOf(context, spec)),
+		async install(spec) {
+			await launchctl("bootout", await targetOf(spec));
+			if (await bootstrap(spec)) return { warnings: [] };
+			return {
+				warnings: ["launchd refused the service (no GUI session?). tau runs detached and will not survive a reboot."],
+				fellBack: true
+			};
+		},
+		async reload(spec) {
+			await launchctl("bootout", await targetOf(spec));
+			if (!await bootstrap(spec)) throw new ServiceCommandError("launchctl bootstrap", "the job could not be loaded");
+		},
+		async uninstall(spec) {
+			await launchctl("bootout", await targetOf(spec));
+		},
+		async start(spec) {
+			if (await bootstrap(spec)) return;
+			throw new ServiceCommandError("launchctl bootstrap", "the job could not be loaded");
+		},
+		async stop(spec) {
+			await launchctl("bootout", await targetOf(spec));
+		},
+		async restart(spec) {
+			const result = await launchctl("kickstart", "-k", await targetOf(spec));
+			if (result.code !== 0) throw new ServiceCommandError("launchctl kickstart", result.stderr);
+		},
+		async state(spec) {
+			const result = await launchctl("print", await targetOf(spec));
+			if (result.code !== 0) return { active: false };
+			const pid = PID_LINE.exec(result.stdout)?.[1];
+			return {
+				active: pid !== void 0,
+				pid: pid === void 0 ? void 0 : Number(pid)
+			};
+		},
+		async list() {
+			const dir = plistDirOf(context);
+			if (!existsSync(dir)) return [];
+			return readdirSync(dir).filter((file) => /^dev\.tau\.server(\.[0-9a-f]+)?\.plist$/.test(file)).map((file) => file.replace(/\.plist$/, ""));
+		}
+	};
+}
+//#endregion
+//#region src/service/schtasks.ts
+const CONHOST_HEADLESS_BUILD = 17763;
+const hasHeadlessConhost = (context) => (context.windowsBuild ?? 0) >= CONHOST_HEADLESS_BUILD;
+const utf16WithBom = (text) => Buffer.from(`\ufeff${text}`, "utf16le");
+const taskXmlPathOf = (spec) => join(spec.home, "bin", `${spec.names.taskName}.xml`);
+function createSchtasksBackend(context) {
+	const schtasks = (...args) => context.runner.run("schtasks", args);
+	const must = async (...args) => {
+		const result = await schtasks(...args);
+		if (result.code !== 0) throw new ServiceCommandError(`schtasks ${args[0]}`, result.stderr);
+	};
+	const queryOf = (spec) => schtasks("/query", "/tn", spec.names.taskName, "/fo", "csv", "/nh");
+	return {
+		kind: "schtasks",
+		files: (spec) => [{
+			path: wrapperOf(spec.home),
+			content: renderCmdWrapper(spec)
+		}, {
+			path: taskXmlPathOf(spec),
+			content: utf16WithBom(renderTaskXml(wrapperOf(spec.home)))
+		}],
+		isInstalled: async (spec) => (await queryOf(spec)).code === 0,
+		async install(spec) {
+			await must("/create", "/tn", spec.names.taskName, "/xml", taskXmlPathOf(spec), "/f");
+			await must("/run", "/tn", spec.names.taskName);
+			return { warnings: [] };
+		},
+		async uninstall(spec) {
+			await schtasks("/end", "/tn", spec.names.taskName);
+			await schtasks("/delete", "/tn", spec.names.taskName, "/f");
+		},
+		async reload(spec) {
+			await must("/create", "/tn", spec.names.taskName, "/xml", taskXmlPathOf(spec), "/f");
+			await schtasks("/end", "/tn", spec.names.taskName);
+			await must("/run", "/tn", spec.names.taskName);
+		},
+		start: (spec) => must("/run", "/tn", spec.names.taskName),
+		stop: (spec) => must("/end", "/tn", spec.names.taskName),
+		async restart(spec) {
+			await schtasks("/end", "/tn", spec.names.taskName);
+			await must("/run", "/tn", spec.names.taskName);
+		},
+		async state(spec) {
+			const result = await queryOf(spec);
+			return { active: result.code === 0 && /Running/i.test(result.stdout) };
+		},
+		async list() {
+			return (await schtasks("/query", "/fo", "csv", "/nh")).stdout.split(/\r?\n/).map((line) => /^"\\?(tau(?:-[0-9a-f]+)?)"/.exec(line)?.[1]).filter((name) => name !== void 0);
+		}
+	};
+}
+//#endregion
+//#region src/service/systemd.ts
+const unitDirOf = (context) => join(context.osHome, ".config", "systemd", "user");
+const unitPathOf = (context, spec) => join(unitDirOf(context), spec.names.systemdUnit);
+const hasUserSystemd = (context) => Boolean(context.xdgRuntimeDir);
+function createSystemdBackend(context) {
+	const systemctl = (...args) => context.runner.run("systemctl", ["--user", ...args]);
+	const must = async (...args) => {
+		const result = await systemctl(...args);
+		if (result.code !== 0) throw new ServiceCommandError(`systemctl --user ${args[0]}`, result.stderr);
+	};
+	async function enableLinger() {
+		return (await context.runner.run("loginctl", ["enable-linger", context.username])).code === 0 ? [] : ["Could not enable linger: tau will not start after a reboot until you log in."];
+	}
+	return {
+		kind: "systemd",
+		files: (spec) => [{
+			path: unitPathOf(context, spec),
+			content: renderSystemdUnit(spec)
+		}],
+		isInstalled: async (spec) => existsSync(unitPathOf(context, spec)),
+		async install(spec) {
+			await must("daemon-reload");
+			await must("enable", "--now", spec.names.systemdUnit);
+			return { warnings: await enableLinger() };
+		},
+		async reload(spec) {
+			await must("daemon-reload");
+			await must("restart", spec.names.systemdUnit);
+		},
+		async uninstall(spec) {
+			await systemctl("disable", "--now", spec.names.systemdUnit);
+		},
+		start: (spec) => must("start", spec.names.systemdUnit),
+		stop: (spec) => must("stop", spec.names.systemdUnit),
+		restart: (spec) => must("restart", spec.names.systemdUnit),
+		async state(spec) {
+			const result = await systemctl("show", spec.names.systemdUnit, "-p", "MainPID", "-p", "ActiveState");
+			const active = /ActiveState=active/.test(result.stdout);
+			const pid = Number(/MainPID=(\d+)/.exec(result.stdout)?.[1] ?? 0);
+			return {
+				active,
+				pid: pid > 0 ? pid : void 0
+			};
+		},
+		async list() {
+			const dir = unitDirOf(context);
+			if (!existsSync(dir)) return [];
+			return readdirSync(dir).filter((file) => /^tau(-[0-9a-f]+)?\.service$/.test(file));
+		}
+	};
+}
+//#endregion
+//#region src/service/pick-backend.ts
+/** The OS service manager for this machine, or undefined when it cannot host one. */
+function nativeBackendOf(context) {
+	if (context.platform === "darwin") return createLaunchdBackend(context);
+	if (context.platform === "linux") return hasUserSystemd(context) ? createSystemdBackend(context) : void 0;
+	if (context.platform === "win32") return hasHeadlessConhost(context) ? createSchtasksBackend(context) : void 0;
+}
+const FALLBACK_WARNING = "No usable service manager here. tau runs detached and will not survive a reboot.";
+const detachedBackendOf = createDetachedBackend;
+//#endregion
+//#region src/service/provider-keys.ts
+const PROVIDER_KEY_VARIABLES = [
+	"ANTHROPIC_API_KEY",
+	"OPENAI_API_KEY",
+	"GEMINI_API_KEY",
+	"GOOGLE_API_KEY",
+	"OPENROUTER_API_KEY",
+	"XAI_API_KEY",
+	"GROQ_API_KEY",
+	"MISTRAL_API_KEY"
+];
+/** Provider keys that exist only as shell variables: the service cannot see them. */
+const shellOnlyProviderKeys = (env) => PROVIDER_KEY_VARIABLES.filter((name) => Boolean(env[name]));
+const providerKeyNotice = (names) => names.length === 0 ? void 0 : `Not copied to the service: ${names.join(", ")}. Save these in Settings → Providers.`;
+//#endregion
+//#region src/service/manager.ts
+function writeFiles(files) {
+	let changed = false;
+	for (const file of files) {
+		const current = existsSync(file.path) ? readFileSync(file.path) : void 0;
+		const next = Buffer.from(file.content);
+		if (current?.equals(next)) continue;
+		mkdirSync(dirname(file.path), { recursive: true });
+		writeFileSync(file.path, next);
+		changed = true;
+	}
+	return changed;
+}
+function readRecord(home) {
+	try {
+		const value = JSON.parse(readFileSync(recordFileOf(home), "utf8"));
+		return typeof value.node === "string" && typeof value.entry === "string" ? {
+			node: value.node,
+			entry: value.entry
+		} : void 0;
+	} catch {
+		return;
+	}
+}
+function createServiceManager(context, cli, home) {
+	const spec = buildSpec(context, cli, home);
+	const native = nativeBackendOf(context);
+	const detached = detachedBackendOf(context);
+	const installed = async () => native ? native.isInstalled(spec) : false;
+	const activeBackend = async () => await installed() && native ? native : detached;
+	function record() {
+		mkdirSync(home, { recursive: true });
+		writeFileSync(recordFileOf(home), JSON.stringify({
+			node: spec.node,
+			entry: spec.entry
+		}));
+	}
+	async function installNatively(backend) {
+		writeFiles(backend.files(spec));
+		const outcome = await backend.install(spec);
+		if (!outcome.fellBack) return [...outcome.warnings];
+		for (const file of backend.files(spec)) rmSync(file.path, { force: true });
+		await detached.install(spec);
+		return [...outcome.warnings];
+	}
+	return {
+		spec,
+		installed,
+		recorded: () => readRecord(home),
+		async needsRepair() {
+			if (!await installed()) return false;
+			const recorded = readRecord(home);
+			return recorded?.node !== spec.node || recorded?.entry !== spec.entry;
+		},
+		async install() {
+			refuseTemporaryEntry(spec.entry);
+			record();
+			const warnings = [providerKeyNotice(shellOnlyProviderKeys(context.env))];
+			if (!native) {
+				await detached.install(spec);
+				return [FALLBACK_WARNING, ...warnings].filter((line) => line !== void 0);
+			}
+			return [...await installNatively(native), ...warnings].filter((line) => line !== void 0);
+		},
+		async uninstall() {
+			await detached.stop(spec);
+			if (native) {
+				await native.uninstall(spec);
+				for (const file of native.files(spec)) rmSync(file.path, { force: true });
+			}
+			rmSync(recordFileOf(home), { force: true });
+		},
+		async start() {
+			await (await activeBackend()).start(spec);
+		},
+		async stop() {
+			await (await activeBackend()).stop(spec);
+		},
+		async restart() {
+			if (!await installed() || !native) return (await activeBackend()).restart(spec);
+			refuseTemporaryEntry(spec.entry);
+			const changed = writeFiles(native.files(spec));
+			record();
+			await (changed ? native.reload(spec) : native.restart(spec));
+		},
+		async state() {
+			const backend = await activeBackend();
+			return {
+				...await backend.state(spec),
+				kind: backend.kind
+			};
+		}
+	};
+}
+/** Every tau service of this user, dev homes included. */
+async function listServices(context) {
+	return await nativeBackendOf(context)?.list() ?? [];
+}
+/** Removes the service of one home without needing the current CLI paths. */
+async function uninstallHome(context, home) {
+	await createServiceManager(context, {
+		node: "",
+		entry: ""
+	}, home).uninstall();
+}
+//#endregion
+//#region src/service/service-command.ts
+const USAGE = "Usage: tau service install | uninstall [--home <path>] | list";
+/** `tau service install | uninstall [--home <path>] | list`. `argv` starts after the word `service`. */
+async function runServiceCommandWith(deps, argv) {
+	const { positionals, values } = parseArgs({
+		args: [...argv],
+		allowPositionals: true,
+		options: { home: { type: "string" } }
+	});
+	const home = values.home ?? deps.context.env.TAU_HOME ?? deps.context.defaultHome;
+	const [action] = positionals;
+	if (action === "install") {
+		const warnings = await createServiceManager(deps.context, cliEntry(), home).install();
+		for (const warning of warnings) deps.out(`warning: ${warning}`);
+		deps.out("tau service installed.");
+	} else if (action === "uninstall") {
+		await uninstallHome(deps.context, home);
+		deps.out("tau service removed.");
+	} else if (action === "list") {
+		const names = await listServices(deps.context);
+		deps.out(names.length === 0 ? "No tau services." : names.join("\n"));
+	} else throw new Error(USAGE);
+}
+async function runServiceCommand(argv) {
+	await runServiceCommandWith({
+		context: realContext(),
+		out: (message) => console.log(message)
+	}, argv);
+}
+//#endregion
+export { TemporaryEntryError as a, realContext as i, runServiceCommandWith as n, createServiceManager as r, runServiceCommand as t };