@aitty/cli 0.1.0

package/dist/cli.d.ts

@@ -0,0 +1,25 @@
+import { AittyRuntimeDependencies } from "@aitty/server";
+
+//#region src/cli.d.ts
+interface CliRuntimeDependencies extends AittyRuntimeDependencies {
+  openBrowser?: (url: string, options?: {
+    wait?: boolean;
+  }) => Promise<unknown>;
+}
+interface CliRunOptions {
+  cwd?: string;
+  env?: NodeJS.ProcessEnv;
+  loadRuntimeDependencies?: () => Promise<CliRuntimeDependencies>;
+  registerSignalHandlers?: boolean;
+  stderr?: {
+    write(chunk: string): boolean;
+  };
+  stdout?: {
+    write(chunk: string): boolean;
+  };
+  version?: string;
+}
+declare function runCli(argv?: readonly string[], options?: CliRunOptions): Promise<number>;
+declare function main(argv?: readonly string[], options?: CliRunOptions): Promise<number>;
+//#endregion
+export { main, runCli };

package/dist/cli.js

@@ -0,0 +1,269 @@
+#!/usr/bin/env node
+import { constants, readFileSync, realpathSync } from "node:fs";
+import { access, stat } from "node:fs/promises";
+import { delimiter, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createAittyServer, loadRuntimeDependencies } from "@aitty/server";
+import { createStructuredLogger } from "@aitty/server/logging";
+//#region src/cli.ts
+var CliUsageError = class extends Error {
+	exitCode = 2;
+};
+var CliRuntimeError = class extends Error {
+	exitCode;
+	constructor(message, exitCode = 1) {
+		super(message);
+		this.exitCode = exitCode;
+	}
+};
+const HELP_TEXT = [
+	"Usage: aitty exec [options] [--] command [args...]",
+	"",
+	"Options:",
+	"  --cwd <dir>           Working directory for the spawned child",
+	"  --port <port>         Listen on a specific loopback port",
+	"  --host <host>         Listen on a specific loopback host",
+	"  --buffer-size <bytes> Replay buffer size in bytes",
+	"  --theme <name>        Set the initial shell data-theme attribute",
+	"  --no-open             Do not auto-open the browser",
+	"  --verbose             Enable DEBUG logging on stderr",
+	"  --help                Show this help message",
+	"  --version             Show the package version",
+	"",
+	"Examples:",
+	"  aitty exec -- codex",
+	"  aitty exec -- claude",
+	"  aitty exec -- droid -r",
+	""
+].join("\n");
+let cachedPackageVersion;
+async function runCli(argv = process.argv.slice(2), options = {}) {
+	const stdout = options.stdout ?? process.stdout;
+	const stderr = options.stderr ?? process.stderr;
+	const env = options.env ?? process.env;
+	const currentWorkingDirectory = options.cwd ?? process.cwd();
+	try {
+		if (argv.length === 1 && (argv[0] === "--help" || argv[0] === "-h")) {
+			stdout.write(HELP_TEXT);
+			return 0;
+		}
+		if (argv.length === 1 && (argv[0] === "--version" || argv[0] === "-v")) {
+			stdout.write(`${resolvePackageVersion(options.version)}\n`);
+			return 0;
+		}
+		const config = await prepareConfig(parseCliArgs(argv, currentWorkingDirectory), env, currentWorkingDirectory);
+		const dependencies = await (options.loadRuntimeDependencies ?? loadRuntimeDependencies)();
+		const session = await createAittyServer({
+			args: config.args,
+			bufferSize: config.bufferSize,
+			command: config.command,
+			cwd: config.cwd,
+			env,
+			host: config.host,
+			port: config.port,
+			theme: config.theme,
+			verbose: config.verbose
+		}, dependencies, {
+			registerSignalHandlers: options.registerSignalHandlers,
+			stderr
+		});
+		stdout.write(`${session.url}\n`);
+		openCliBrowser(session.url, session.token, config, dependencies, stderr);
+		return session.closed;
+	} catch (error) {
+		stderr.write(formatCliError(error));
+		return resolveCliExitCode(error);
+	}
+}
+function openCliBrowser(url, token, config, dependencies, stderr) {
+	if (config.noOpen || !dependencies.openBrowser) return;
+	const logger = createStructuredLogger({
+		token,
+		verbose: config.verbose,
+		writer: stderr
+	});
+	dependencies.openBrowser(url, { wait: false }).catch((error) => {
+		const message = error instanceof Error ? error.message : String(error);
+		logger.error(`Failed to open browser: ${message}`);
+	});
+}
+async function main(argv = process.argv.slice(2), options = {}) {
+	return runCli(argv, options);
+}
+function parseCliArgs(argv, currentWorkingDirectory) {
+	if (argv[0] !== "exec") throw new CliUsageError("Missing command. Use: aitty exec -- <command> [args...]");
+	let bufferSize;
+	let cwd = currentWorkingDirectory;
+	let host = "127.0.0.1";
+	let noOpen = false;
+	let port = 0;
+	let theme;
+	let verbose = false;
+	let index = 1;
+	while (index < argv.length) {
+		const argument = argv[index];
+		if (argument === "--") return withCommand(argv.slice(index + 1));
+		if (argument === "--cwd") {
+			cwd = resolve(currentWorkingDirectory, readRequiredValue(argv, index, "--cwd"));
+			index += 2;
+			continue;
+		}
+		if (argument === "--port") {
+			port = parsePort(readRequiredValue(argv, index, "--port"));
+			index += 2;
+			continue;
+		}
+		if (argument === "--host") {
+			host = readRequiredValue(argv, index, "--host").trim();
+			index += 2;
+			continue;
+		}
+		if (argument === "--buffer-size") {
+			bufferSize = parsePositiveInteger(readRequiredValue(argv, index, "--buffer-size"), "--buffer-size");
+			index += 2;
+			continue;
+		}
+		if (argument === "--theme") {
+			theme = normalizeThemeOption(readRequiredValue(argv, index, "--theme"));
+			index += 2;
+			continue;
+		}
+		if (argument === "--no-open") {
+			noOpen = true;
+			index += 1;
+			continue;
+		}
+		if (argument === "--verbose") {
+			verbose = true;
+			index += 1;
+			continue;
+		}
+		return withCommand(argv.slice(index));
+	}
+	throw new CliUsageError("Missing command after exec");
+	function withCommand(command) {
+		if (command.length === 0) throw new CliUsageError("Missing command after exec");
+		return {
+			args: command.slice(1),
+			bufferSize,
+			command: command[0],
+			cwd,
+			host,
+			noOpen,
+			port,
+			theme,
+			verbose
+		};
+	}
+}
+function normalizeThemeOption(value) {
+	const theme = value?.trim();
+	return theme ? theme : void 0;
+}
+async function prepareConfig(config, env, currentWorkingDirectory) {
+	return {
+		...config,
+		command: await resolveExecutablePath(config.command, env, currentWorkingDirectory),
+		cwd: await validateWorkingDirectory(config.cwd)
+	};
+}
+async function validateWorkingDirectory(cwd) {
+	const resolvedDirectory = resolve(cwd);
+	if (!(await statPath(resolvedDirectory, `Configured --cwd does not exist: ${cwd}`)).isDirectory()) throw new CliRuntimeError(`Configured --cwd is not a directory: ${cwd}`);
+	return resolvedDirectory;
+}
+async function resolveExecutablePath(executable, env, currentWorkingDirectory) {
+	if (isExplicitPath(executable)) return validateExecutablePath(resolve(currentWorkingDirectory, executable), executable);
+	const resolvedExecutable = await findExecutableOnPath(executable, env.PATH, currentWorkingDirectory);
+	if (resolvedExecutable) return resolvedExecutable;
+	throw new CliRuntimeError(`Executable not found in PATH: ${executable}`, 127);
+}
+function isExplicitPath(executable) {
+	return executable.includes("/") || executable.includes("\\");
+}
+async function validateExecutablePath(resolvedExecutable, displayValue) {
+	if (!(await statPath(resolvedExecutable, `Executable does not exist: ${displayValue}`)).isFile()) throw new CliRuntimeError(`Executable is not a regular file: ${displayValue}`);
+	try {
+		await access(resolvedExecutable, constants.X_OK);
+	} catch {
+		throw new CliRuntimeError(`Executable is not executable: ${displayValue}`);
+	}
+	return resolvedExecutable;
+}
+async function findExecutableOnPath(executable, pathValue, currentWorkingDirectory) {
+	if (!pathValue) return null;
+	for (const entry of pathValue.split(delimiter)) {
+		const candidate = resolve(currentWorkingDirectory, entry.length > 0 ? entry : ".", executable);
+		try {
+			if (!(await stat(candidate)).isFile()) continue;
+			await access(candidate, constants.X_OK);
+			return candidate;
+		} catch (error) {
+			if (isNotFoundError(error) || isAccessError(error)) continue;
+			throw error;
+		}
+	}
+	return null;
+}
+async function statPath(path, missingMessage) {
+	try {
+		return await stat(path);
+	} catch (error) {
+		if (isNotFoundError(error)) throw new CliRuntimeError(missingMessage);
+		throw error;
+	}
+}
+function readRequiredValue(argv, index, flag) {
+	const value = argv[index + 1];
+	if (!value) throw new CliUsageError(`Missing value for ${flag}`);
+	return value;
+}
+function parsePort(value) {
+	if (!value) return 0;
+	return parsePositiveInteger(value, "--port");
+}
+function parsePositiveInteger(value, label) {
+	const parsed = Number(value);
+	if (!Number.isInteger(parsed) || parsed < 0) throw new CliUsageError(`Invalid ${label}: ${value}`);
+	return parsed;
+}
+function formatCliError(error) {
+	if (error instanceof CliUsageError) return `${error.message}\nTry 'aitty --help' for usage.\n`;
+	if (error instanceof Error) return `${error.message}\n`;
+	return `${String(error)}\n`;
+}
+function resolveCliExitCode(error) {
+	if (error instanceof CliUsageError || error instanceof CliRuntimeError) return error.exitCode;
+	return 1;
+}
+function isAccessError(error) {
+	return error instanceof Error && "code" in error && error.code === "EACCES";
+}
+function isNotFoundError(error) {
+	return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function resolvePackageVersion(override) {
+	if (override) return override;
+	if (!cachedPackageVersion) {
+		const packageJson = readFileSync(new URL("../package.json", import.meta.url), "utf8");
+		cachedPackageVersion = JSON.parse(packageJson).version;
+	}
+	return cachedPackageVersion;
+}
+const entrypoint = process.argv[1];
+if (entrypoint && isCliEntrypoint(entrypoint, import.meta.url)) runCli().then((exitCode) => {
+	process.exitCode = exitCode;
+}).catch((error) => {
+	const message = error instanceof Error ? error.stack ?? error.message : String(error);
+	process.stderr.write(`${message}\n`);
+	process.exitCode = resolveCliExitCode(error);
+});
+function isCliEntrypoint(entrypoint, moduleUrl) {
+	try {
+		return realpathSync(entrypoint) === realpathSync(fileURLToPath(moduleUrl));
+	} catch {
+		return false;
+	}
+}
+//#endregion
+export { main, runCli };

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@aitty/cli",
+  "version": "0.1.0",
+  "description": "Command-line launcher for aitty browser terminal sessions.",
+  "keywords": [
+    "agent",
+    "ai",
+    "browser",
+    "cli",
+    "pty",
+    "terminal"
+  ],
+  "homepage": "https://github.com/kingsword09/aitty#readme",
+  "bugs": {
+    "url": "https://github.com/kingsword09/aitty/issues"
+  },
+  "license": "Apache-2.0",
+  "author": "Kingsword kingsword09 <kingsword09@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kingsword09/aitty.git",
+    "directory": "packages/cli"
+  },
+  "type": "module",
+  "bin": {
+    "aitty": "./dist/cli.js"
+  },
+  "main": "./dist/cli.js",
+  "types": "./dist/cli.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/cli.d.ts",
+      "default": "./dist/cli.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@aitty/server": "workspace:*"
+  }
+}