enbu 0.1.0

package/dist/main.mjs

@@ -0,0 +1,1046 @@
+#!/usr/bin/env node
+import { err, fromPromise, ok } from "neverthrow";
+import { createInterface } from "node:readline";
+import { resolve } from "node:path";
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { constants } from "node:fs";
+import { glob } from "glob";
+import { checkAgentBrowser, closeSession } from "@packages/agent-browser-adapter";
+import { executeFlow, parseFlowYaml } from "@packages/core";
+
+//#region src/args-parser.ts
+/** デフォルトタイムアウト: 30秒 */
+const DEFAULT_TIMEOUT_MS = 3e4;
+/**
+* コマンドライン引数をパースする
+*
+* process.argvから渡された引数を解析し、ParsedArgs型に変換する。
+* バージョンフラグが指定されている場合は、他の引数に関わらずバージョンモードとして返す。
+* ヘルプフラグが指定されている場合は、他の引数に関わらずヘルプモードとして返す。
+* 最初の位置引数がinitの場合はinitコマンド、それ以外はrunコマンドとして扱う。
+*
+* @param argv - process.argv（インデックス2以降）
+* @returns パース済み引数、またはエラー
+*/
+const parseArgs = (argv) => {
+	if (argv.includes("-V") || argv.includes("--version")) return ok({
+		command: "run",
+		help: false,
+		version: true,
+		verbose: false,
+		files: [],
+		headed: false,
+		env: {},
+		timeout: DEFAULT_TIMEOUT_MS,
+		screenshot: false,
+		bail: false
+	});
+	if (argv.includes("-h") || argv.includes("--help")) return ok({
+		command: "run",
+		help: true,
+		version: false,
+		verbose: false,
+		files: [],
+		headed: false,
+		env: {},
+		timeout: DEFAULT_TIMEOUT_MS,
+		screenshot: false,
+		bail: false
+	});
+	const verbose = argv.includes("-v") || argv.includes("--verbose");
+	if (argv[0] === "init") return parseInitArgs(argv.slice(1), verbose);
+	return parseRunArgs(argv, verbose);
+};
+/**
+* initコマンドの引数をパースする
+*
+* initコマンドで利用可能なオプション（--force）を解析する。
+* 未知のオプションが指定された場合はエラーを返す。
+*
+* @param argv - initコマンド以降の引数配列
+* @param verbose - verboseフラグが有効かどうか
+* @returns パース済みのinit引数、またはエラー
+*/
+const parseInitArgs = (argv, verbose) => {
+	const force = argv.includes("--force");
+	for (const arg of argv) if (arg.startsWith("--")) {
+		if (arg !== "--force" && arg !== "--verbose") return err({
+			type: "invalid_args",
+			message: `Unknown option for init command: ${arg}`
+		});
+	} else if (arg.startsWith("-")) {
+		if (arg !== "-v") return err({
+			type: "invalid_args",
+			message: `Unknown option for init command: ${arg}`
+		});
+	}
+	return ok({
+		command: "init",
+		help: false,
+		version: false,
+		verbose,
+		force
+	});
+};
+/**
+* runコマンドの引数をパースする
+*
+* runコマンドで利用可能なオプション（--headed, --env, --timeout等）を解析する。
+* --envは複数回指定可能で、KEY=VALUE形式でなければならない。
+* --timeoutは正の整数値でなければならない。
+* 位置引数（オプションフラグでない引数）は全てフローファイルパスとして扱う。
+*
+* @param argv - runコマンドの引数配列
+* @param verbose - verboseフラグが有効かどうか
+* @returns パース済みのrun引数、またはエラー
+*/
+const parseRunArgs = (argv, verbose) => {
+	const state = {
+		files: [],
+		env: {},
+		headed: false,
+		timeout: DEFAULT_TIMEOUT_MS,
+		screenshot: false,
+		bail: false,
+		session: void 0
+	};
+	for (let i = 0; i < argv.length; i++) {
+		const arg = argv[i];
+		const continueResult = processRunArg(arg, argv, i, state).match((newIndex) => {
+			i = newIndex;
+			return ok(void 0);
+		}, (error) => err(error));
+		if (continueResult.isErr()) return continueResult;
+	}
+	return ok({
+		command: "run",
+		help: false,
+		version: false,
+		verbose,
+		files: state.files,
+		headed: state.headed,
+		env: state.env,
+		timeout: state.timeout,
+		screenshot: state.screenshot,
+		bail: state.bail,
+		session: state.session
+	});
+};
+/**
+* runコマンドの単一引数を処理する
+*
+* 各オプションに応じた処理を行い、新しいインデックスを返す。
+* 値を取る引数（--env, --timeout, --session）の場合はインデックスを+1する。
+*
+* @param arg - 現在の引数
+* @param argv - 全引数配列
+* @param currentIndex - 現在のインデックス
+* @param state - パース状態を保持するオブジェクト
+* @returns 成功時: 新しいインデックス、失敗時: エラー
+*/
+const processRunArg = (arg, argv, currentIndex, state) => {
+	switch (arg) {
+		case "--env": return parseEnvOption(argv, currentIndex, state);
+		case "--timeout": return parseTimeoutOption(argv, currentIndex, state);
+		case "--session": return parseSessionOption(argv, currentIndex, state);
+		default: return processFlagArg(arg, currentIndex, state);
+	}
+};
+/**
+* フラグ引数を処理する（値を取らない引数）
+*
+* @param arg - 現在の引数
+* @param currentIndex - 現在のインデックス
+* @param state - パース状態を保持するオブジェクト
+* @returns 成功時: 現在のインデックス、失敗時: エラー
+*/
+const processFlagArg = (arg, currentIndex, state) => {
+	if (arg === "--headed") {
+		state.headed = true;
+		return ok(currentIndex);
+	}
+	if (arg === "--screenshot") {
+		state.screenshot = true;
+		return ok(currentIndex);
+	}
+	if (arg === "--bail") {
+		state.bail = true;
+		return ok(currentIndex);
+	}
+	if (arg === "-v" || arg === "--verbose") return ok(currentIndex);
+	if (arg.startsWith("--")) return err({
+		type: "invalid_args",
+		message: `Unknown option: ${arg}`
+	});
+	state.files.push(arg);
+	return ok(currentIndex);
+};
+/**
+* --env オプションをパースする
+*/
+const parseEnvOption = (argv, currentIndex, state) => {
+	const nextArg = argv[currentIndex + 1];
+	if (!nextArg) return err({
+		type: "invalid_args",
+		message: "--env requires KEY=VALUE argument"
+	});
+	const envResult = parseEnvArg(nextArg);
+	if (envResult.isErr()) return err(envResult.error);
+	const [key, value] = envResult.value;
+	state.env[key] = value;
+	return ok(currentIndex + 1);
+};
+/**
+* --timeout オプションをパースする
+*/
+const parseTimeoutOption = (argv, currentIndex, state) => {
+	const nextArg = argv[currentIndex + 1];
+	if (!nextArg) return err({
+		type: "invalid_args",
+		message: "--timeout requires a number in milliseconds"
+	});
+	const timeoutNum = Number.parseInt(nextArg, 10);
+	if (Number.isNaN(timeoutNum) || timeoutNum <= 0) return err({
+		type: "invalid_args",
+		message: `--timeout must be a positive number, got: ${nextArg}`
+	});
+	state.timeout = timeoutNum;
+	return ok(currentIndex + 1);
+};
+/**
+* --session オプションをパースする
+*/
+const parseSessionOption = (argv, currentIndex, state) => {
+	const nextArg = argv[currentIndex + 1];
+	if (!nextArg) return err({
+		type: "invalid_args",
+		message: "--session requires a session name"
+	});
+	state.session = nextArg;
+	return ok(currentIndex + 1);
+};
+/**
+* --env KEY=VALUE 引数をパースする
+*
+* 環境変数の設定値をKEY=VALUE形式から解析する。
+* =が含まれていない、またはKEYが空の場合はエラーを返す。
+* VALUEは空文字列でも許可される。
+*
+* @param arg - KEY=VALUE形式の文字列
+* @returns 成功時: [KEY, VALUE]のタプル、失敗時: エラー
+*/
+const parseEnvArg = (arg) => {
+	const index = arg.indexOf("=");
+	if (index === -1) return err({
+		type: "invalid_args",
+		message: `--env argument must be in KEY=VALUE format, got: ${arg}`
+	});
+	const key = arg.slice(0, index);
+	const value = arg.slice(index + 1);
+	if (key.length === 0) return err({
+		type: "invalid_args",
+		message: `--env KEY cannot be empty, got: ${arg}`
+	});
+	return ok([key, value]);
+};
+
+//#endregion
+//#region src/output/formatter.ts
+/**
+* 出力フォーマッター
+*
+* console.log禁止のため、process.stdout.write / process.stderr.write を使用する。
+* 進捗表示やメッセージの整形を担当するクラス。
+* 状態を持つため、classとして実装することが許可されている。
+*/
+var OutputFormatter = class {
+	/** 詳細ログ出力を行うかどうか */
+	verbose;
+	/** スピナーのアニメーションフレーム */
+	spinnerFrames = [
+		"⠋",
+		"⠙",
+		"⠹",
+		"⠸",
+		"⠼",
+		"⠴",
+		"⠦",
+		"⠧",
+		"⠇",
+		"⠏"
+	];
+	/** 現在表示中のスピナーフレームのインデックス */
+	spinnerIndex = 0;
+	/** スピナーのsetIntervalのID（停止時にclearIntervalするため） */
+	spinnerIntervalId = null;
+	/** 現在表示中のスピナーメッセージ */
+	currentSpinnerMessage = "";
+	/**
+	* OutputFormatterのコンストラクタ
+	*
+	* @param verbose - 詳細ログ出力を行うかどうか
+	*/
+	constructor(verbose) {
+		this.verbose = verbose;
+	}
+	/**
+	* 通常メッセージを出力
+	*
+	* 標準出力（stdout）にメッセージを出力します。
+	* 一般的な情報や進捗状況を表示する際に使用します。
+	*
+	* @param message - 出力するメッセージ
+	*/
+	info(message) {
+		this.write("stdout", message);
+	}
+	/**
+	* エラーメッセージを出力
+	*
+	* 標準エラー出力（stderr）にメッセージを出力します。
+	* エラーや警告メッセージを表示する際に使用します。
+	*
+	* @param message - 出力するエラーメッセージ
+	*/
+	error(message) {
+		this.write("stderr", message);
+	}
+	/**
+	* デバッグメッセージを出力（verboseモード時のみ）
+	*
+	* verboseフラグがtrueの場合のみ、標準エラー出力（stderr）に
+	* デバッグメッセージを出力します。
+	* "[DEBUG]"プレフィックスが自動的に付与されます。
+	*
+	* @param message - 出力するデバッグメッセージ
+	*/
+	debug(message) {
+		if (this.verbose) this.write("stderr", `[DEBUG] ${message}`);
+	}
+	/**
+	* 成功マーク付きメッセージ
+	*
+	* チェックマーク（✓）付きの成功メッセージを出力します。
+	* オプションで実行時間（ミリ秒）を指定すると、秒単位で表示されます。
+	*
+	* @param message - 出力するメッセージ
+	* @param durationMs - 実行時間（ミリ秒、省略可）
+	*/
+	success(message, durationMs) {
+		const duration = durationMs !== void 0 ? ` (${(durationMs / 1e3).toFixed(1)}s)` : "";
+		this.info(`  ✓ ${message}${duration}`);
+	}
+	/**
+	* 失敗マーク付きメッセージ
+	*
+	* バツマーク（✗）付きの失敗メッセージを出力します。
+	* オプションで実行時間（ミリ秒）を指定すると、秒単位で表示されます。
+	*
+	* @param message - 出力するメッセージ
+	* @param durationMs - 実行時間（ミリ秒、省略可）
+	*/
+	failure(message, durationMs) {
+		const duration = durationMs !== void 0 ? ` (${(durationMs / 1e3).toFixed(1)}s)` : "";
+		this.error(`  ✗ ${message}${duration}`);
+	}
+	/**
+	* インデント付きメッセージ（エラー詳細等）
+	*
+	* 指定されたレベル分のインデント（2スペース × レベル）を付けて
+	* メッセージを標準エラー出力に出力します。
+	* エラーの詳細情報や補足説明を階層的に表示する際に使用します。
+	*
+	* @param message - 出力するメッセージ
+	* @param level - インデントレベル（デフォルト: 1）
+	*/
+	indent(message, level = 1) {
+		const indent = "  ".repeat(level);
+		this.error(`${indent}${message}`);
+	}
+	/**
+	* スピナーを開始
+	*
+	* 指定されたメッセージと共にスピナーアニメーションを開始します。
+	* スピナーは80msごとにフレームが更新されます。
+	* 既に実行中のスピナーがある場合は、停止してから新しいスピナーを開始します。
+	*
+	* 注意: 必ずstopSpinner()を呼び出してスピナーを停止してください。
+	* 停止しないとsetIntervalが残り続けます。
+	*
+	* @param message - スピナーと共に表示するメッセージ
+	*/
+	startSpinner(message) {
+		this.currentSpinnerMessage = message;
+		this.spinnerIndex = 0;
+		if (this.spinnerIntervalId !== null) clearInterval(this.spinnerIntervalId);
+		this.renderSpinner();
+		this.spinnerIntervalId = setInterval(() => {
+			this.spinnerIndex = (this.spinnerIndex + 1) % this.spinnerFrames.length;
+			this.renderSpinner();
+		}, 80);
+	}
+	/**
+	* スピナーを停止
+	*
+	* 実行中のスピナーを停止し、スピナー行をクリアします。
+	* setIntervalを適切にクリアして、リソースリークを防ぎます。
+	* スピナーが実行中でない場合は何もしません。
+	*/
+	stopSpinner() {
+		if (this.spinnerIntervalId !== null) {
+			clearInterval(this.spinnerIntervalId);
+			this.spinnerIntervalId = null;
+		}
+		this.clearLine();
+	}
+	/**
+	* セクション区切り線
+	*
+	* 視覚的にセクションを区切るための水平線を出力します。
+	* サマリー表示や大きな処理の区切りに使用します。
+	*/
+	separator() {
+		this.info("────────────────────────────────────────");
+	}
+	/**
+	* 改行
+	*
+	* 空行を出力します。
+	* メッセージ間に視覚的な余白を作る際に使用します。
+	*/
+	newline() {
+		this.write("stdout", "");
+	}
+	/**
+	* 内部：書き込み処理
+	*
+	* 指定された出力先（stdout または stderr）にメッセージを書き込みます。
+	* メッセージの末尾には自動的に改行文字が付与されます。
+	*
+	* @param target - 出力先（'stdout' または 'stderr'）
+	* @param message - 出力するメッセージ
+	*/
+	write(target, message) {
+		(target === "stdout" ? process.stdout : process.stderr).write(`${message}\n`);
+	}
+	/**
+	* 内部：スピナーを描画
+	*
+	* 現在のスピナーフレームとメッセージを画面に描画します。
+	* カーソルを行頭に戻してから描画することで、
+	* 前のフレームを上書きしてアニメーション効果を実現します。
+	*/
+	renderSpinner() {
+		const frame = this.spinnerFrames[this.spinnerIndex];
+		this.clearLine();
+		process.stdout.write(`  ${frame} ${this.currentSpinnerMessage}`);
+	}
+	/**
+	* 内部：現在行をクリア
+	*
+	* カーソルを行頭に戻し（\r）、行全体をクリア（\x1b[K）します。
+	* スピナーのアニメーションや、前の出力を上書きする際に使用します。
+	* ANSIエスケープシーケンスを使用しています。
+	*/
+	clearLine() {
+		process.stdout.write("\r\x1B[K");
+	}
+};
+/**
+* ヘルプメッセージを表示
+*
+* CLIの使用方法を標準出力に表示します。
+* コマンドラインオプション、サブコマンド、使用例などを含みます。
+* --help フラグまたは -h フラグが指定された際に呼び出されます。
+*/
+const showHelp = () => {
+	process.stdout.write(`
+enbu - CLI for agent-browser workflow automation
+
+USAGE:
+  npx enbu [command] [options] [flow-files...]
+
+COMMANDS:
+  init              Initialize a new project
+  (default)         Run flow files
+
+OPTIONS:
+  -h, --help        Show this help message
+  -V, --version     Show version number
+  -v, --verbose     Enable verbose logging
+  --headed          Show browser (disable headless mode)
+  --env KEY=VALUE   Set environment variable (can be used multiple times)
+  --timeout <ms>    Set timeout in milliseconds (default: 30000)
+  --screenshot      Save screenshot on failure
+  --bail            Stop on first failure
+  --session <name>  Set agent-browser session name
+
+EXAMPLES:
+  npx enbu init
+  npx enbu
+  npx enbu login.flow.yaml
+  npx enbu --headed --env USER=test login.flow.yaml
+  npx enbu --bail login.flow.yaml checkout.flow.yaml
+
+For more information, visit: https://github.com/9wick/enbu
+`);
+};
+/**
+* バージョン情報を表示
+*
+* CLIのバージョン番号を標準出力に表示します。
+* ビルド時に埋め込まれたバージョン情報（__VERSION__定数）を使用します。
+* --version フラグまたは -V フラグが指定された際に呼び出されます。
+*
+* 実装の詳細:
+* tsdown.config.tsのdefineオプションにより、__VERSION__定数が
+* ビルド時にpackage.jsonのバージョン情報で置換されます。
+* これにより、実行時のファイル読み込みオーバーヘッドがなく、
+* ビルド構造の変更にも影響を受けません。
+*/
+const showVersion = () => {
+	process.stdout.write(`0.1.0\n`);
+};
+
+//#endregion
+//#region src/utils/fs.ts
+/**
+* ファイルが存在するか確認
+*
+* 指定されたパスにファイルまたはディレクトリが存在するかを確認する。
+* アクセス権限がない場合もfalseを返す。
+*
+* @param path - 確認対象のファイルまたはディレクトリのパス
+* @returns ファイルが存在する場合はtrue、存在しない場合またはアクセスできない場合はfalse
+*/
+const fileExists = (path) => {
+	return access(path, constants.F_OK).then(() => true).catch(() => false);
+};
+/**
+* ディレクトリを作成（存在しない場合のみ）
+*
+* 指定されたパスにディレクトリを作成する。
+* recursive オプションにより、親ディレクトリが存在しない場合も自動的に作成される。
+* 既にディレクトリが存在する場合はエラーにならず、成功として扱われる。
+*
+* @param path - 作成するディレクトリのパス
+* @returns 成功時: void、失敗時: CliError（type: 'execution_error'）
+*/
+const createDirectory = (path) => {
+	return fromPromise(mkdir(path, { recursive: true }), (error) => ({
+		type: "execution_error",
+		message: `Failed to create directory: ${path}`,
+		cause: error
+	})).map(() => void 0);
+};
+/**
+* ファイルを書き込み
+*
+* 指定されたパスにテキストファイルを書き込む。
+* ファイルが既に存在する場合は上書きされる。
+* 親ディレクトリが存在しない場合はエラーとなるため、事前に createDirectory を実行すること。
+*
+* @param path - 書き込み先のファイルパス
+* @param content - 書き込むテキスト内容
+* @returns 成功時: void、失敗時: CliError（type: 'execution_error'）
+*/
+const writeFileContent = (path, content) => {
+	return fromPromise(writeFile(path, content, "utf-8"), (error) => ({
+		type: "execution_error",
+		message: `Failed to write file: ${path}`,
+		cause: error
+	})).map(() => void 0);
+};
+/**
+* ファイルを読み込み
+*
+* 指定されたパスからテキストファイルを読み込む。
+* ファイルが存在しない場合やアクセス権限がない場合はエラーを返す。
+* バイナリファイルの読み込みには対応していないため、UTF-8テキストファイルのみを対象とする。
+*
+* @param path - 読み込むファイルのパス
+* @returns 成功時: ファイルの内容（文字列）、失敗時: CliError（type: 'execution_error'）
+*/
+const readFileContent = (path) => {
+	return fromPromise(readFile(path, "utf-8"), (error) => ({
+		type: "execution_error",
+		message: `Failed to read file: ${path}`,
+		cause: error
+	}));
+};
+
+//#endregion
+//#region src/commands/init.ts
+/** 生成するディレクトリ */
+const ABFLOW_DIR = ".abflow";
+/** サンプルフローファイルの内容 */
+const SAMPLE_FLOW_YAML = `# enbuのサンプルフロー
+steps:
+  - open: https://example.com
+  - click: "More information..."
+  - assertVisible: "Example Domain"
+`;
+/**
+* initコマンドを実行
+*
+* プロジェクトの初期化を行い、以下の処理を実行する:
+* 1. .abflow/ ディレクトリを作成
+* 2. サンプルフローファイル example.enbu.yaml を生成
+* 3. .gitignore への追記を対話的に提案
+*
+* forceフラグがtrueの場合、既存ファイルを上書きする。
+* forceフラグがfalseの場合、既存ファイルはスキップされる。
+*
+* @param args - initコマンドの引数
+* @param args.force - 既存ファイルを強制的に上書きするかどうか
+* @param args.verbose - 詳細なログ出力を行うかどうか
+* @returns 成功時: void、失敗時: CliError
+*/
+const runInitCommand = async (args) => {
+	const formatter = new OutputFormatter(args.verbose);
+	formatter.info("Initializing enbu project...");
+	const setupResult = await setupAbflowDirectory(args.force, formatter);
+	if (setupResult.isErr()) return setupResult;
+	await promptGitignoreUpdate(formatter);
+	formatter.newline();
+	formatter.info("Initialization complete!");
+	formatter.info(`Try: npx enbu ${ABFLOW_DIR}/example.enbu.yaml`);
+	return ok(void 0);
+};
+/**
+* .abflow/ ディレクトリとサンプルファイルを作成
+*
+* .abflow/ ディレクトリを作成し、その中にサンプルフローファイルを生成する。
+* forceフラグがfalseで既存ファイルが存在する場合はスキップする。
+*
+* @param force - 既存ファイルを強制的に上書きするかどうか
+* @param formatter - 出力フォーマッター
+* @returns 成功時: void、失敗時: CliError
+*/
+const setupAbflowDirectory = async (force, formatter) => {
+	const abflowPath = resolve(process.cwd(), ABFLOW_DIR);
+	if (await fileExists(abflowPath) && !force) formatter.success(`Directory already exists: ${ABFLOW_DIR}`);
+	else {
+		const createDirResult = await createDirectory(abflowPath);
+		if (createDirResult.isErr()) return createDirResult;
+		formatter.success(`Created ${ABFLOW_DIR}/ directory`);
+	}
+	const exampleFlowPath = resolve(abflowPath, "example.enbu.yaml");
+	if (await fileExists(exampleFlowPath) && !force) formatter.success(`File already exists: ${ABFLOW_DIR}/example.enbu.yaml`);
+	else {
+		const writeResult = await writeFileContent(exampleFlowPath, SAMPLE_FLOW_YAML);
+		if (writeResult.isErr()) return writeResult;
+		formatter.success(`Created ${ABFLOW_DIR}/example.enbu.yaml`);
+	}
+	return ok(void 0);
+};
+/**
+* .gitignore への追記を対話的に提案
+*
+* ユーザーに .gitignore への追記を提案し、了承された場合に .abflow/ を追記する。
+* .gitignore の更新に失敗した場合は、エラーメッセージと手動での追記方法を表示する。
+*
+* @param formatter - 出力フォーマッター
+*/
+const promptGitignoreUpdate = async (formatter) => {
+	formatter.newline();
+	if (await askYesNo("Would you like to add .abflow/ to .gitignore? (y/N): ")) (await updateGitignore(resolve(process.cwd(), ".gitignore"))).match(() => formatter.success("Updated .gitignore"), (error) => {
+		formatter.error(`Failed to update .gitignore: ${error.message}`);
+		formatter.indent("You can manually add \".abflow/\" to your .gitignore file", 1);
+	});
+};
+/**
+* Yes/No 質問を対話的に行う
+*
+* ユーザーに質問を表示し、標準入力から回答を受け取る。
+* 'y' または 'yes'（大文字小文字を区別しない）が入力された場合にtrueを返す。
+* それ以外の入力（空文字列を含む）の場合はfalseを返す。
+*
+* readlineのcreateInterfaceを使用して対話的な入力を実現している。
+* 入力完了後は必ずrl.close()を呼び出してリソースを解放する。
+*
+* @param question - ユーザーに表示する質問文
+* @returns ユーザーが 'y' または 'yes' を入力した場合はtrue、それ以外はfalse
+*/
+const askYesNo = (question) => {
+	return new Promise((resolve$1) => {
+		const rl = createInterface({
+			input: process.stdin,
+			output: process.stdout
+		});
+		rl.question(question, (answer) => {
+			rl.close();
+			const normalized = answer.trim().toLowerCase();
+			resolve$1(normalized === "y" || normalized === "yes");
+		});
+	});
+};
+/**
+* .gitignore に .abflow/ を追記
+*
+* .gitignoreファイルに .abflow/ エントリを追加する。
+* 以下の条件に応じて処理が分岐する:
+*
+* 1. .gitignoreが存在しない場合:
+*    - 新規に.gitignoreファイルを作成し、.abflow/を記述する
+*
+* 2. .gitignoreが存在し、既に.abflow/が含まれている場合:
+*    - 何もせずに成功を返す（重複追記を防ぐ）
+*
+* 3. .gitignoreが存在し、.abflow/が含まれていない場合:
+*    - ファイル末尾に.abflow/を追記する
+*    - 元のファイルが改行で終わっていない場合は、改行を追加してから追記する
+*
+* @param path - .gitignoreファイルのパス
+* @returns 成功時: void、失敗時: CliError（type: 'execution_error'）
+*/
+const updateGitignore = async (path) => {
+	const exists = await fileExists(path);
+	const entry = ".abflow/";
+	if (!exists) return writeFileContent(path, `${entry}\n`);
+	const readResult = await readFileContent(path);
+	if (readResult.isErr()) return readResult.andThen(() => ok(void 0));
+	const content = readResult.value;
+	if (content.includes(entry)) return ok(void 0);
+	return writeFileContent(path, content.endsWith("\n") ? `${content}${entry}\n` : `${content}\n${entry}\n`);
+};
+
+//#endregion
+//#region src/commands/run.ts
+/**
+* runコマンドの実装
+*
+* フローファイルを読み込み、agent-browserで実行する。
+* 実行結果を表示し、終了コードを返す。
+*/
+/**
+* agent-browserのインストール状態を確認する
+*
+* @param formatter - 出力フォーマッター
+* @returns 成功時: void、失敗時: CliError
+*/
+const checkAgentBrowserInstallation = async (formatter) => {
+	formatter.info("Checking agent-browser...");
+	formatter.debug("Checking agent-browser installation...");
+	return (await checkAgentBrowser()).match(() => {
+		formatter.success("agent-browser is installed");
+		formatter.newline();
+		return ok(void 0);
+	}, (error) => {
+		formatter.failure("agent-browser is not installed");
+		formatter.newline();
+		formatter.error("Error: agent-browser is not installed");
+		formatter.error("Please install it with: npm install -g agent-browser");
+		return err({
+			type: "execution_error",
+			message: error.type === "not_installed" ? error.message : `${error.type}: ${error.type === "command_failed" ? error.errorMessage ?? error.stderr : ""}`
+		});
+	});
+};
+/**
+* フローファイルパスの配列を解決する
+*
+* ファイルが指定されていない場合、.abflow/ ディレクトリから検索する。
+*
+* @param files - 指定されたファイルパスの配列
+* @returns 成功時: 解決されたファイルパスの配列、失敗時: CliError
+*/
+const resolveFlowFiles = async (files) => {
+	if (files.length > 0) return ok(files.map((f) => resolve(process.cwd(), f)));
+	return fromPromise(glob(resolve(process.cwd(), ".abflow", "*.enbu.yaml")), (error) => ({
+		type: "execution_error",
+		message: "Failed to search for flow files",
+		cause: error
+	}));
+};
+/**
+* ファイルパスからフローを読み込んでパースする
+*
+* @param filePath - フローファイルのパス
+* @returns 成功時: Flowオブジェクト、失敗時: CliError
+*/
+const loadFlowFromFile = async (filePath) => {
+	const readResult = await fromPromise(readFile(filePath, "utf-8"), (error) => ({
+		type: "execution_error",
+		message: `Failed to read file: ${filePath}`,
+		cause: error
+	}));
+	if (readResult.isErr()) return err(readResult.error);
+	const yamlContent = readResult.value;
+	return parseFlowYaml(yamlContent, filePath.split("/").pop() ?? "unknown.enbu.yaml").mapErr((parseError) => ({
+		type: "execution_error",
+		message: `Failed to parse flow file: ${parseError.message}`,
+		cause: parseError
+	}));
+};
+/**
+* フローファイルを読み込む
+*
+* @param flowFiles - フローファイルパスの配列
+* @param formatter - 出力フォーマッター
+* @returns 成功時: Flowオブジェクトの配列、失敗時: CliError
+*/
+const loadFlows = async (flowFiles, formatter) => {
+	formatter.info("Loading flows...");
+	formatter.debug(`Loading flows from: ${flowFiles.join(", ")}`);
+	const flows = [];
+	for (const filePath of flowFiles) {
+		const loadResult = await loadFlowFromFile(filePath);
+		if (loadResult.isErr()) {
+			formatter.failure(`Failed to load flows: ${loadResult.error.message}`);
+			return err(loadResult.error);
+		}
+		flows.push(loadResult.value);
+	}
+	formatter.success(`Loaded ${flows.length} flow(s)`);
+	formatter.newline();
+	return ok(flows);
+};
+/**
+* コマンド説明のフォーマッター関数マップ
+*/
+const commandFormatters = {
+	open: (cmd) => `open ${"url" in cmd && cmd.url || ""}`,
+	click: (cmd) => "selector" in cmd ? `click "${cmd.selector}"${"index" in cmd && cmd.index !== void 0 ? ` [${cmd.index}]` : ""}` : "click",
+	type: (cmd) => "selector" in cmd && "value" in cmd ? `type "${cmd.selector}" = "${cmd.value}"${"clear" in cmd && cmd.clear ? " (clear)" : ""}` : "type",
+	fill: (cmd) => "selector" in cmd && "value" in cmd ? `fill "${cmd.selector}" = "${cmd.value}"` : "fill",
+	press: (cmd) => `press ${"key" in cmd ? cmd.key : ""}`,
+	hover: (cmd) => "selector" in cmd ? `hover "${cmd.selector}"` : "hover",
+	select: (cmd) => "selector" in cmd && "value" in cmd ? `select "${cmd.selector}" = "${cmd.value}"` : "select",
+	scroll: (cmd) => "direction" in cmd && "amount" in cmd ? `scroll ${cmd.direction} ${cmd.amount}px` : "scroll",
+	scrollIntoView: (cmd) => "selector" in cmd ? `scrollIntoView "${cmd.selector}"` : "scrollIntoView",
+	wait: (cmd) => "ms" in cmd ? `wait ${cmd.ms}ms` : "target" in cmd ? `wait "${cmd.target}"` : "wait",
+	screenshot: (cmd) => "path" in cmd ? `screenshot ${cmd.path}${"fullPage" in cmd && cmd.fullPage ? " (full page)" : ""}` : "screenshot",
+	snapshot: () => "snapshot",
+	eval: (cmd) => "script" in cmd ? `eval "${cmd.script.substring(0, 50)}${cmd.script.length > 50 ? "..." : ""}"` : "eval",
+	assertVisible: (cmd) => "selector" in cmd ? `assertVisible "${cmd.selector}"` : "assertVisible",
+	assertEnabled: (cmd) => "selector" in cmd ? `assertEnabled "${cmd.selector}"` : "assertEnabled",
+	assertChecked: (cmd) => "selector" in cmd ? `assertChecked "${cmd.selector}"${"checked" in cmd && cmd.checked === false ? " (unchecked)" : ""}` : "assertChecked"
+};
+/**
+* コマンドの説明を生成する
+*
+* @param command - コマンド
+* @returns コマンドの説明文字列
+*/
+const formatCommandDescription = (command) => {
+	const formatter = commandFormatters[command.command];
+	return formatter ? formatter(command) : "unknown command";
+};
+/**
+* フローを実行しながら進捗を表示する
+*
+* @param flow - 実行するフロー
+* @param args - 実行オプション
+* @param sessionName - セッション名
+* @returns 成功時: FlowResult、失敗時: CliError
+*/
+const executeFlowWithProgress = async (flow, args, sessionName) => {
+	return (await executeFlow(flow, {
+		sessionName,
+		headed: args.headed,
+		env: args.env,
+		commandTimeoutMs: args.timeout,
+		screenshot: args.screenshot,
+		bail: args.bail
+	})).mapErr((agentError) => {
+		return {
+			type: "execution_error",
+			message: agentError.type === "not_installed" ? agentError.message : agentError.type === "parse_error" ? agentError.message : agentError.type === "timeout" ? `Timeout: ${agentError.command} (${agentError.timeoutMs}ms)` : agentError.errorMessage ?? agentError.stderr,
+			cause: agentError
+		};
+	});
+};
+/**
+* 各ステップの結果を表示する（verboseモードのみ）
+*/
+const displayStepResults = (steps, formatter) => {
+	formatter.newline();
+	formatter.indent("Steps:", 1);
+	for (const step of steps) {
+		const stepDesc = formatCommandDescription(step.command);
+		const statusIcon = step.status === "passed" ? "✓" : "✗";
+		formatter.indent(`${statusIcon} Step ${step.index + 1}: ${stepDesc} (${step.duration}ms)`, 2);
+		if (step.error) formatter.indent(`Error: ${step.error.message}`, 3);
+	}
+};
+/**
+* フロー実行結果を表示する
+*
+* @param flow - 実行したフロー
+* @param result - フロー実行結果
+* @param formatter - 出力フォーマッター
+* @param verbose - verboseモードフラグ
+*/
+const displayFlowResult = (flow, result, formatter, verbose) => {
+	const duration = result.duration;
+	formatter.newline();
+	if (result.status === "passed") formatter.success(`PASSED: ${flow.name}.enbu.yaml`, duration);
+	else {
+		formatter.failure(`FAILED: ${flow.name}.enbu.yaml`, duration);
+		if (result.error) {
+			formatter.indent(`Step ${result.error.stepIndex + 1} failed: ${result.error.message}`, 1);
+			if (result.error.screenshot) formatter.indent(`Screenshot: ${result.error.screenshot}`, 1);
+		}
+	}
+	if (verbose) displayStepResults(result.steps, formatter);
+	formatter.newline();
+};
+/**
+* 全てのフローを実行する
+*
+* @param flows - 実行するフロー配列
+* @param args - 実行オプション
+* @param formatter - 出力フォーマッター
+* @returns フロー実行結果のサマリー
+*/
+const executeAllFlows = async (flows, args, formatter) => {
+	let passed = 0;
+	let failed = 0;
+	const startTime = Date.now();
+	for (const flow of flows) {
+		formatter.info(`Running: ${flow.name}.enbu.yaml`);
+		formatter.debug(`Executing flow: ${flow.name} (${flow.steps.length} steps)`);
+		const flowStartTime = Date.now();
+		const sessionName = `abf-${args.session || flow.name}-${Date.now()}`;
+		await (await executeFlowWithProgress(flow, args, sessionName)).match(async (result) => {
+			displayFlowResult(flow, result, formatter, args.verbose);
+			if (result.status === "passed") {
+				passed++;
+				(await closeSession(sessionName)).mapErr((error) => {
+					formatter.debug(`Failed to close session: ${error.type}`);
+				});
+			} else {
+				failed++;
+				formatter.info("💡 Debug: To inspect the browser state, run:");
+				formatter.indent(`npx agent-browser snapshot --session ${sessionName}`, 1);
+			}
+		}, async (error) => {
+			failed++;
+			const duration = Date.now() - flowStartTime;
+			formatter.newline();
+			formatter.failure(`FAILED: ${flow.name}.enbu.yaml`, duration);
+			formatter.indent(error.message, 1);
+			formatter.newline();
+		});
+		if (args.bail && failed > 0) {
+			formatter.error("Stopping due to --bail flag");
+			formatter.newline();
+			break;
+		}
+	}
+	formatter.separator();
+	const totalDuration = Date.now() - startTime;
+	const total = passed + failed;
+	formatter.info(`Summary: ${passed}/${total} flows passed (${(totalDuration / 1e3).toFixed(1)}s)`);
+	if (failed > 0) {
+		formatter.newline();
+		formatter.error("Exit code: 1");
+	}
+	return {
+		passed,
+		failed,
+		total
+	};
+};
+/**
+* runコマンドを実行する
+*
+* @param args - runコマンドの引数
+* @param formatter - 出力フォーマッター
+* @returns 成功時: 実行結果、失敗時: CliError
+*/
+const runFlowCommand = async (args, formatter) => {
+	formatter.debug(`Args: ${JSON.stringify(args)}`);
+	const checkResult = await checkAgentBrowserInstallation(formatter);
+	if (checkResult.isErr()) return err(checkResult.error);
+	const flowFilesResult = await resolveFlowFiles(args.files);
+	if (flowFilesResult.isErr()) return err(flowFilesResult.error);
+	const flowFiles = flowFilesResult.value;
+	if (flowFiles.length === 0) {
+		formatter.error("Error: No flow files found");
+		formatter.error("Try: npx enbu init");
+		return err({
+			type: "execution_error",
+			message: "No flow files found"
+		});
+	}
+	const loadResult = await loadFlows(flowFiles, formatter);
+	if (loadResult.isErr()) return err(loadResult.error);
+	const flows = loadResult.value;
+	return ok(await executeAllFlows(flows, args, formatter));
+};
+
+//#endregion
+//#region src/output/exit-code.ts
+/**
+* 終了コード定義
+*/
+const EXIT_CODE = {
+	SUCCESS: 0,
+	FLOW_FAILED: 1,
+	EXECUTION_ERROR: 2
+};
+/**
+* 終了コードで終了する
+*
+* @param code - 終了コード
+*/
+const exitWithCode = (code) => {
+	process.exit(code);
+};
+
+//#endregion
+//#region src/main.ts
+/**
+* CLIエントリポイント
+*
+* コマンドライン引数をパースし、適切なコマンドを実行する。
+* 実行結果に基づいて終了コードを設定する。
+*/
+const main = async () => {
+	await parseArgs(process.argv.slice(2)).match(async (args) => {
+		if (args.version) {
+			showVersion();
+			exitWithCode(EXIT_CODE.SUCCESS);
+		}
+		if (args.help) {
+			showHelp();
+			exitWithCode(EXIT_CODE.SUCCESS);
+		}
+		if (args.command === "init") (await runInitCommand({
+			force: args.force,
+			verbose: args.verbose
+		})).match(() => exitWithCode(EXIT_CODE.SUCCESS), (error) => {
+			process.stderr.write(`Error: ${error.message}\n`);
+			exitWithCode(EXIT_CODE.EXECUTION_ERROR);
+		});
+		else {
+			const formatter = new OutputFormatter(args.verbose);
+			(await runFlowCommand({
+				files: args.files,
+				headed: args.headed,
+				env: args.env,
+				timeout: args.timeout,
+				screenshot: args.screenshot,
+				bail: args.bail,
+				session: args.session,
+				verbose: args.verbose
+			}, formatter)).match((executionResult) => {
+				exitWithCode(executionResult.failed > 0 ? EXIT_CODE.FLOW_FAILED : EXIT_CODE.SUCCESS);
+			}, (error) => {
+				process.stderr.write(`Error: ${error.message}\n`);
+				exitWithCode(EXIT_CODE.EXECUTION_ERROR);
+			});
+		}
+	}, (error) => {
+		process.stderr.write(`Error: ${error.message}\n`);
+		process.stderr.write("Try: npx enbu --help\n");
+		exitWithCode(EXIT_CODE.EXECUTION_ERROR);
+	});
+};
+main();
+
+//#endregion
+export {  };
+//# sourceMappingURL=main.mjs.map