@putdotio/taizn 1.2.0 → 1.4.0

package/dist/taizn.mjs

@@ -1,72 +1,207 @@
 #!/usr/bin/env node
-import { Command } from "@effect/cli";
-import { NodeContext, NodeRuntime } from "@effect/platform-node";
-import { Effect } from "effect";
-import { copyFileSync, cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import * as ParseResult from "effect/ParseResult";
-import * as Schema from "effect/Schema";
-import { execFileSync } from "node:child_process";
+import { NodeRuntime, NodeServices } from "@effect/platform-node";
+import { Argument, CliError, Command, Flag } from "effect/unstable/cli";
+import { Console, Context, Effect, FileSystem, Layer, Option, Schema, Stream } from "effect";
+import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
-import { isAbsolute, join } from "node:path";
+import { existsSync } from "node:fs";
+import { dirname, isAbsolute, join } from "node:path";
+import WebSocket from "ws";
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+//#region src/errors.ts
+var ConfigNotFound = class extends Schema.TaggedErrorClass()("ConfigNotFound", { path: Schema.String }) {
+	get message() {
+		return `Config file not found: ${this.path}`;
+	}
+};
+var InvalidConfig = class extends Schema.TaggedErrorClass()("InvalidConfig", { details: Schema.String }) {
+	get message() {
+		return `Invalid taizn.json:\n${this.details}`;
+	}
+};
+var InvalidEnvironment = class extends Schema.TaggedErrorClass()("InvalidEnvironment", { details: Schema.String }) {
+	get message() {
+		return `Invalid TAIZN environment:\n${this.details}`;
+	}
+};
+var InvalidJson = class extends Schema.TaggedErrorClass()("InvalidJson", {
+	file: Schema.String,
+	details: Schema.String
+}) {
+	get message() {
+		return `Invalid ${this.file}: ${this.details}`;
+	}
+};
+var MissingFile = class extends Schema.TaggedErrorClass()("MissingFile", {
+	label: Schema.String,
+	path: Schema.String
+}) {
+	get message() {
+		return `${this.label} not found: ${this.path}`;
+	}
+};
+var FileSystemFailure = class extends Schema.TaggedErrorClass()("FileSystemFailure", {
+	operation: Schema.String,
+	path: Schema.String,
+	cause: Schema.Defect
+}) {
+	get message() {
+		return `File system ${this.operation} failed for ${this.path}`;
+	}
+};
+var CommandFailed = class extends Schema.TaggedErrorClass()("CommandFailed", {
+	command: Schema.String,
+	args: Schema.Array(Schema.String)
+}) {
+	get message() {
+		return `Command failed: ${this.command} ${this.args.join(" ")}`;
+	}
+};
+var PackageNotProduced = class extends Schema.TaggedErrorClass()("PackageNotProduced", { outputDir: Schema.String }) {
+	get message() {
+		return `No .wgt package was produced in ${this.outputDir}`;
+	}
+};
+var MissingPassword = class extends Schema.TaggedErrorClass()("MissingPassword", {
+	variable: Schema.String,
+	action: Schema.String
+}) {
+	get message() {
+		return `${this.variable} is required to ${this.action}.`;
+	}
+};
+var SecretReadInterrupted = class extends Schema.TaggedErrorClass()("SecretReadInterrupted", {}) {
+	get message() {
+		return "Secret prompt interrupted.";
+	}
+};
+var MultipleTargetsConnected = class extends Schema.TaggedErrorClass()("MultipleTargetsConnected", { targets: Schema.Array(Schema.String) }) {
+	get message() {
+		return `Multiple Tizen targets are connected: ${this.targets.join(", ")}. Set TAIZN_TARGET explicitly.`;
+	}
+};
+var MissingTizenTarget = class extends Schema.TaggedErrorClass()("MissingTizenTarget", {}) {
+	get message() {
+		return "No Tizen target is connected. Set TAIZN_TARGET or connect exactly one device.";
+	}
+};
+var MissingTvRemoteHost = class extends Schema.TaggedErrorClass()("MissingTvRemoteHost", {}) {
+	get message() {
+		return "Samsung TV host is required. Set TAIZN_TV_HOST or TAIZN_TARGET.";
+	}
+};
+var MissingTvRemoteToken = class extends Schema.TaggedErrorClass()("MissingTvRemoteToken", {}) {
+	get message() {
+		return "Samsung TV remote token is required. Run `taizn tv pair` or set TAIZN_TV_TOKEN.";
+	}
+};
+var TvRemoteConnectionFailed = class extends Schema.TaggedErrorClass()("TvRemoteConnectionFailed", {
+	cause: Schema.Defect,
+	target: Schema.String
+}) {
+	get message() {
+		return `Samsung TV remote connection failed: ${this.target}`;
+	}
+};
+var TvRemoteProtocolError = class extends Schema.TaggedErrorClass()("TvRemoteProtocolError", { details: Schema.String }) {
+	get message() {
+		return `Samsung TV remote protocol error: ${this.details}`;
+	}
+};
+var TvRemoteTimeout = class extends Schema.TaggedErrorClass()("TvRemoteTimeout", { target: Schema.String }) {
+	get message() {
+		return `Timed out waiting for Samsung TV remote response: ${this.target}`;
+	}
+};
+var TvRemoteUnauthorized = class extends Schema.TaggedErrorClass()("TvRemoteUnauthorized", { target: Schema.String }) {
+	get message() {
+		return `Samsung TV denied remote control access: ${this.target}`;
+	}
+};
+const renderError = (error) => error.message;
+//#endregion
 //#region src/runtime.ts
-const appDir = process.cwd();
-const configPath = join(appDir, "taizn.json");
-const taiznDir = join(appDir, ".taizn");
-const envPath = join(taiznDir, ".env");
-const stageDir = join(taiznDir, "build", "stage");
-const outputDir = join(taiznDir, "build", "output");
-const appPath = (path) => isAbsolute(path) ? path : join(appDir, path);
-const loadLocalEnv = () => {
-	if (existsSync(envPath)) process.loadEnvFile(envPath);
+var TaiznSystem = class TaiznSystem extends Context.Service()("taizn/TaiznSystem") {
+	static Live = Layer.succeed(TaiznSystem)({
+		cwd: Effect.sync(() => process.cwd()),
+		env: Effect.sync(() => process.env),
+		homeDir: Effect.sync(() => homedir()),
+		loadEnvFile: (path) => Effect.sync(() => {
+			if (existsSync(path)) process.loadEnvFile(path);
+		}),
+		readSecret: (prompt) => Effect.tryPromise({
+			try: () => readSecret(prompt),
+			catch: () => SecretReadInterrupted.make({})
+		})
+	});
 };
-const fail = (message) => {
-	console.error(message);
-	process.exit(1);
+const makePaths = (appDir) => {
+	const taiznDir = join(appDir, ".taizn");
+	return {
+		appDir,
+		configPath: join(appDir, "taizn.json"),
+		envPath: join(taiznDir, ".env"),
+		outputDir: join(taiznDir, "build", "output"),
+		remoteStatePath: join(taiznDir, "remote.json"),
+		stageDir: join(taiznDir, "build", "stage"),
+		taiznDir
+	};
 };
-const requireFile = (path, label) => {
-	if (!existsSync(path)) fail(`${label} not found: ${path}`);
+const getPaths = Effect.fn("getPaths")(function* () {
+	return makePaths(yield* (yield* TaiznSystem).cwd);
+});
+const appPath = (appDir, path) => isAbsolute(path) ? path : join(appDir, path);
+const loadLocalEnv = Effect.fn("loadLocalEnv")(function* () {
+	const paths = yield* getPaths();
+	yield* (yield* TaiznSystem).loadEnvFile(paths.envPath);
+});
+const requireFile = Effect.fn("requireFile")(function* (path, label) {
+	if (!(yield* (yield* FileSystem.FileSystem).exists(path).pipe(Effect.mapError((cause) => FileSystemFailure.make({
+		cause,
+		operation: "exists",
+		path
+	}))))) return yield* MissingFile.make({
+		label,
+		path
+	});
 	return path;
-};
-const baseChildEnv = () => {
-	const env = { ...process.env };
+});
+const baseChildEnv = Effect.fn("baseChildEnv")(function* () {
+	const env = { ...yield* (yield* TaiznSystem).env };
 	delete env.DYLD_INSERT_LIBRARIES;
 	return env;
-};
-const appBuildEnv = () => {
-	const env = baseChildEnv();
+});
+const appBuildEnv = Effect.fn("appBuildEnv")(function* () {
+	const env = yield* baseChildEnv();
 	for (const key of Object.keys(env)) if (key.startsWith("TAIZN_") || key.startsWith("TIZEN_")) delete env[key];
 	delete env.SDB;
 	return env;
-};
-const run = (command, args, options = {}) => {
-	const env = options.env || baseChildEnv();
-	try {
-		execFileSync(command, args, {
-			cwd: options.cwd || appDir,
-			env: {
-				...env,
-				PATH: `${join(homedir(), "tizen-studio/tools/ide/bin")}:${join(homedir(), "tizen-studio/tools")}:${env.PATH || ""}`
-			},
-			stdio: options.stdio || "inherit"
-		});
-	} catch {
-		fail(`Command failed: ${command} ${redactCommandArgs(args).join(" ")}`);
-	}
-};
-const tizenCli = (path) => requireFile(path || join(homedir(), "tizen-studio/tools/ide/bin/tizen"), "Tizen CLI");
-const sdb = (path) => requireFile(path || join(homedir(), "tizen-studio/tools/sdb"), "sdb");
-const readPassword = async (value, prompt) => {
+});
+const withTizenPath = Effect.fn("withTizenPath")(function* (env) {
+	const home = yield* (yield* TaiznSystem).homeDir;
+	return {
+		...env,
+		PATH: `${join(home, "tizen-studio/tools/ide/bin")}:${join(home, "tizen-studio/tools")}:${env.PATH ?? ""}`
+	};
+});
+const defaultTizenCli = Effect.fn("defaultTizenCli")(function* () {
+	return join(yield* (yield* TaiznSystem).homeDir, "tizen-studio/tools/ide/bin/tizen");
+});
+const defaultSdb = Effect.fn("defaultSdb")(function* () {
+	return join(yield* (yield* TaiznSystem).homeDir, "tizen-studio/tools/sdb");
+});
+const readPassword = Effect.fn("readPassword")(function* (value, prompt) {
 	if (value) return value;
-	return readSecret(prompt);
-};
+	return yield* (yield* TaiznSystem).readSecret(prompt);
+});
 const redactCommandArgs = (args) => {
 	const sensitiveValueFlags = new Set(["-p", "-dp"]);
 	return args.map((arg, index) => {
-		if (index > 0 && sensitiveValueFlags.has(args[index - 1])) return "[redacted]";
+		if (index > 0 && sensitiveValueFlags.has(args[index - 1] ?? "")) return "[redacted]";
 		return arg;
 	});
 };
-const readSecret = (prompt) => new Promise((resolve) => {
+const readSecret = (prompt) => new Promise((resolve, reject) => {
 	if (!process.stdin.isTTY) {
 		resolve("");
 		return;
@@ -76,15 +211,20 @@ const readSecret = (prompt) => new Promise((resolve) => {
 	process.stdin.setRawMode(true);
 	process.stdin.resume();
 	process.stdin.setEncoding("utf8");
+	const cleanup = () => {
+		process.stdin.setRawMode(false);
+		process.stdin.pause();
+		process.stdin.off("data", onData);
+	};
 	const onData = (char) => {
 		if (char === "") {
+			cleanup();
 			process.stdout.write("\n");
-			process.exit(130);
+			reject(/* @__PURE__ */ new Error("interrupted"));
+			return;
 		}
 		if (char === "\r" || char === "\n") {
-			process.stdin.setRawMode(false);
-			process.stdin.pause();
-			process.stdin.off("data", onData);
+			cleanup();
 			process.stdout.write("\n");
 			resolve(value);
 			return;
@@ -99,7 +239,7 @@ const readSecret = (prompt) => new Promise((resolve) => {
 });
 //#endregion
 //#region src/config.ts
-const TizenVariantSchema = Schema.Struct({
+var TizenVariant = class extends Schema.Class("TizenVariant")({
 	applicationId: Schema.NonEmptyString,
 	bundleName: Schema.NonEmptyString,
 	excludeFiles: Schema.optional(Schema.Array(Schema.NonEmptyString)),
@@ -109,82 +249,440 @@ const TizenVariantSchema = Schema.Struct({
 	name: Schema.NonEmptyString,
 	packageId: Schema.NonEmptyString,
 	rewriteAssetUrls: Schema.optional(Schema.Boolean)
+}) {};
+var BuildConfig = class extends Schema.Class("BuildConfig")({
+	command: Schema.NonEmptyArray(Schema.NonEmptyString),
+	output: Schema.NonEmptyString,
+	requiredFiles: Schema.optional(Schema.Array(Schema.NonEmptyString))
+}) {};
+var SigningConfig = class extends Schema.Class("SigningConfig")({
+	certificateDir: Schema.NonEmptyString,
+	profile: Schema.NonEmptyString
+}) {};
+var WidgetVariants = class extends Schema.Class("WidgetVariants")({
+	development: TizenVariant,
+	production: TizenVariant
+}) {};
+var WidgetConfig = class extends Schema.Class("WidgetConfig")({
+	configXml: Schema.NonEmptyString,
+	excludeFiles: Schema.optional(Schema.Array(Schema.NonEmptyString)),
+	indexHtml: Schema.NonEmptyString,
+	injectWebapis: Schema.optional(Schema.Boolean),
+	rewriteAssetUrls: Schema.optional(Schema.Boolean),
+	variants: WidgetVariants
+}) {};
+var TizenConfig = class extends Schema.Class("TizenConfig")({
+	build: BuildConfig,
+	signing: SigningConfig,
+	widget: WidgetConfig
+}) {};
+const loadConfig = Effect.fn("loadConfig")(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const paths = yield* getPaths();
+	if (!(yield* fs.exists(paths.configPath).pipe(Effect.mapError((cause) => FileSystemFailure.make({
+		cause,
+		operation: "exists",
+		path: paths.configPath
+	}))))) return yield* ConfigNotFound.make({ path: paths.configPath });
+	return yield* decodeConfig(yield* fs.readFileString(paths.configPath).pipe(Effect.mapError((cause) => FileSystemFailure.make({
+		cause,
+		operation: "read",
+		path: paths.configPath
+	}))));
 });
-const TizenConfigSchema = Schema.Struct({
-	build: Schema.Struct({
-		command: Schema.NonEmptyArray(Schema.NonEmptyString),
-		output: Schema.NonEmptyString,
-		requiredFiles: Schema.optional(Schema.Array(Schema.NonEmptyString))
-	}),
-	signing: Schema.Struct({
-		certificateDir: Schema.NonEmptyString,
-		profile: Schema.NonEmptyString
-	}),
-	widget: Schema.Struct({
-		configXml: Schema.NonEmptyString,
-		excludeFiles: Schema.optional(Schema.Array(Schema.NonEmptyString)),
-		indexHtml: Schema.NonEmptyString,
-		injectWebapis: Schema.optional(Schema.Boolean),
-		rewriteAssetUrls: Schema.optional(Schema.Boolean),
-		variants: Schema.Struct({
-			development: TizenVariantSchema,
-			production: TizenVariantSchema
+const decodeConfig = Effect.fn("decodeConfig")(function* (source) {
+	const json = yield* Effect.try({
+		try: () => JSON.parse(source),
+		catch: (cause) => InvalidJson.make({
+			details: causeToMessage$1(cause),
+			file: "taizn.json"
 		})
-	})
+	});
+	return yield* Schema.decodeUnknownEffect(TizenConfig)(json, { errors: "all" }).pipe(Effect.mapError((error) => InvalidConfig.make({ details: error.message })));
 });
-const loadConfig = () => {
-	if (!existsSync(configPath)) fail(`Config file not found: ${configPath}`);
-	return decodeConfig(readFileSync(configPath, "utf8"));
-};
-const decodeConfig = (source) => {
-	try {
-		return Schema.decodeUnknownSync(Schema.parseJson(TizenConfigSchema), { errors: "all" })(source);
-	} catch (error) {
-		if (ParseResult.isParseError(error)) return fail(`Invalid taizn.json:\n${formatParseIssues$1(error)}`);
-		return fail(`Invalid taizn.json: ${error instanceof Error ? error.message : String(error)}`);
-	}
-};
-const formatParseIssues$1 = (error) => ParseResult.ArrayFormatter.formatErrorSync(error).map((issue) => {
-	return `- ${issue.path.length > 0 ? issue.path.join(".") : "taizn.json"}: ${issue.message}`;
-}).join("\n");
+const causeToMessage$1 = (cause) => cause instanceof Error ? cause.message : String(cause);
 //#endregion
 //#region src/env.ts
-const TaiznEnvSchema = Schema.Struct({
+const RawTaiznEnv = Schema.Struct({
 	certPassword: Schema.optional(Schema.String),
 	distPassword: Schema.optional(Schema.String),
 	sdb: Schema.optional(Schema.String),
 	target: Schema.optional(Schema.String),
 	tizenCli: Schema.optional(Schema.String),
-	variant: Schema.optional(Schema.Literal("development", "production"))
+	tvHost: Schema.optional(Schema.String),
+	tvInfoPort: Schema.optional(Schema.String),
+	tvName: Schema.optional(Schema.String),
+	tvPort: Schema.optional(Schema.String),
+	tvProtocol: Schema.optional(Schema.Literals(["ws", "wss"])),
+	tvTimeoutMs: Schema.optional(Schema.String),
+	tvToken: Schema.optional(Schema.String),
+	variant: Schema.optional(Schema.Literals(["development", "production"]))
 });
-const loadEnv = () => {
-	try {
-		const env = Schema.decodeUnknownSync(TaiznEnvSchema)({
-			certPassword: process.env.TAIZN_CERT_PASSWORD,
-			distPassword: process.env.TAIZN_DIST_PASSWORD,
-			sdb: process.env.TAIZN_SDB,
-			target: process.env.TAIZN_TARGET,
-			tizenCli: process.env.TAIZN_TIZEN_CLI,
-			variant: process.env.TAIZN_VARIANT
-		});
-		return {
-			...env,
-			variant: env.variant ?? "development"
+var TaiznEnv = class extends Schema.Class("TaiznEnv")({
+	certPassword: Schema.optional(Schema.String),
+	distPassword: Schema.optional(Schema.String),
+	sdb: Schema.optional(Schema.String),
+	target: Schema.optional(Schema.String),
+	tizenCli: Schema.optional(Schema.String),
+	tvHost: Schema.optional(Schema.String),
+	tvInfoPort: Schema.optional(Schema.Number),
+	tvName: Schema.optional(Schema.String),
+	tvPort: Schema.optional(Schema.Number),
+	tvProtocol: Schema.optional(Schema.Literals(["ws", "wss"])),
+	tvTimeoutMs: Schema.optional(Schema.Number),
+	tvToken: Schema.optional(Schema.String),
+	variant: Schema.Literals(["development", "production"])
+}) {};
+const loadEnv = Effect.fn("loadEnv")(function* () {
+	const env = yield* (yield* TaiznSystem).env;
+	const raw = yield* Schema.decodeUnknownEffect(RawTaiznEnv)({
+		certPassword: env.TAIZN_CERT_PASSWORD,
+		distPassword: env.TAIZN_DIST_PASSWORD,
+		sdb: env.TAIZN_SDB,
+		target: env.TAIZN_TARGET,
+		tizenCli: env.TAIZN_TIZEN_CLI,
+		tvHost: env.TAIZN_TV_HOST,
+		tvInfoPort: env.TAIZN_TV_INFO_PORT,
+		tvName: env.TAIZN_TV_NAME,
+		tvPort: env.TAIZN_TV_PORT,
+		tvProtocol: env.TAIZN_TV_PROTOCOL,
+		tvTimeoutMs: env.TAIZN_TV_TIMEOUT_MS,
+		tvToken: env.TAIZN_TV_TOKEN,
+		variant: env.TAIZN_VARIANT
+	}, { errors: "all" }).pipe(Effect.mapError((error) => InvalidEnvironment.make({ details: error.message })));
+	const tvInfoPort = raw.tvInfoPort ? yield* parsePort(raw.tvInfoPort, "TAIZN_TV_INFO_PORT") : void 0;
+	const tvPort = raw.tvPort ? yield* parseTvPort(raw.tvPort) : void 0;
+	const tvTimeoutMs = raw.tvTimeoutMs ? yield* parsePositiveInteger(raw.tvTimeoutMs, "TAIZN_TV_TIMEOUT_MS") : void 0;
+	return TaiznEnv.make({
+		...raw,
+		tvInfoPort,
+		tvPort,
+		tvTimeoutMs,
+		variant: raw.variant ?? "development"
+	});
+});
+const parseTvPort = Effect.fn("parseTvPort")(function* (value) {
+	return yield* parsePort(value, "TAIZN_TV_PORT");
+});
+const parsePort = Effect.fn("parsePort")(function* (value, variable) {
+	const port = Number(value);
+	if (!/^\d+$/.test(value) || !Number.isInteger(port) || port < 1 || port > 65535) return yield* InvalidEnvironment.make({ details: `${variable} must be an integer between 1 and 65535. Received: ${value}` });
+	return port;
+});
+const parsePositiveInteger = Effect.fn("parsePositiveInteger")(function* (value, variable) {
+	const parsed = Number(value);
+	if (!/^\d+$/.test(value) || !Number.isInteger(parsed) || parsed < 1) return yield* InvalidEnvironment.make({ details: `${variable} must be a positive integer. Received: ${value}` });
+	return parsed;
+});
+//#endregion
+//#region src/context.ts
+const loadContext = Effect.fn("loadContext")(function* () {
+	return {
+		config: yield* loadConfig(),
+		env: yield* loadEnv()
+	};
+});
+//#endregion
+//#region src/remote.ts
+const DEFAULT_REMOTE_NAME = "taizn";
+const DEFAULT_REMOTE_PORT = 8002;
+const DEFAULT_REMOTE_PROTOCOL = "wss";
+const DEFAULT_TIMEOUT_MS = 3e4;
+const TV_INFO_PORT = 8001;
+var RemoteClientAttributes = class extends Schema.Class("RemoteClientAttributes")({
+	name: Schema.optional(Schema.String),
+	token: Schema.optional(Schema.String)
+}) {};
+var RemoteClient = class extends Schema.Class("RemoteClient")({
+	attributes: Schema.optional(RemoteClientAttributes),
+	deviceName: Schema.optional(Schema.String),
+	id: Schema.String,
+	isHost: Schema.Boolean
+}) {};
+var RemoteEventData = class extends Schema.Class("RemoteEventData")({
+	clients: Schema.optional(Schema.Array(RemoteClient)),
+	id: Schema.optional(Schema.String),
+	token: Schema.optional(Schema.String)
+}) {};
+var RemoteEvent = class extends Schema.Class("RemoteEvent")({
+	data: Schema.optional(RemoteEventData),
+	event: Schema.String
+}) {};
+var TvInfoDevice = class extends Schema.Class("TvInfoDevice")({
+	TokenAuthSupport: Schema.optional(Schema.String),
+	developerIP: Schema.optional(Schema.String),
+	developerMode: Schema.optional(Schema.String),
+	ip: Schema.optional(Schema.String),
+	modelName: Schema.optional(Schema.String),
+	name: Schema.optional(Schema.String)
+}) {};
+var TvInfo = class extends Schema.Class("TvInfo")({
+	device: TvInfoDevice,
+	isSupport: Schema.optional(Schema.String),
+	name: Schema.String,
+	remote: Schema.optional(Schema.String),
+	type: Schema.optional(Schema.String),
+	uri: Schema.optional(Schema.String)
+}) {};
+var TvRemoteState = class extends Schema.Class("TvRemoteState")({
+	host: Schema.String,
+	name: Schema.String,
+	port: Schema.Number,
+	protocol: Schema.Literals(["ws", "wss"]),
+	token: Schema.String
+}) {};
+const pairSamsungTvRemote = Effect.fn("pairSamsungTvRemote")(function* (env) {
+	const options = yield* resolveRemoteOptions(env, { ignoreToken: true });
+	yield* Console.log(`Pairing Samsung TV remote: ${remoteTarget(options)}`);
+	yield* Console.log("Accept the remote control prompt on the TV if it appears.");
+	const token = yield* connectRemote(options);
+	yield* saveRemoteState({
+		...options,
+		token
+	});
+	yield* Console.log(`Saved Samsung TV remote token to .taizn/remote.json`);
+	yield* Console.log(`TAIZN_TV_TOKEN=${token}`);
+});
+Effect.fn("sendSamsungTvKey")(function* (env, key) {
+	yield* sendSamsungTvKeys(env, [key]);
+});
+const sendSamsungTvKeys = Effect.fn("sendSamsungTvKeys")(function* (env, keys, pressOptions) {
+	const remoteOptions = yield* resolveRemoteOptions(env, { requireToken: true });
+	if (!remoteOptions.token) return yield* MissingTvRemoteToken.make({});
+	yield* connectRemote(remoteOptions, {
+		delayMs: Math.max(0, pressOptions?.delayMs ?? 250),
+		keys
+	});
+	yield* Console.log(keys.length === 1 ? `Sent Samsung TV remote key: ${keys[0]}` : `Sent Samsung TV remote keys: ${keys.join(", ")}`);
+});
+const showSamsungTvInfo = Effect.fn("showSamsungTvInfo")(function* (env) {
+	const options = yield* resolveRemoteOptions(env);
+	const info = yield* fetchSamsungTvInfo(options.host, {
+		port: env.tvInfoPort,
+		timeoutMs: options.timeoutMs
+	});
+	const support = info.isSupport ? parseSupport(info.isSupport) : void 0;
+	yield* Console.log(`Samsung TV: ${decodeHtml(info.name)}`);
+	yield* Console.log(`model: ${info.device.modelName ?? "unknown"}`);
+	yield* Console.log(`ip: ${info.device.ip ?? options.host}`);
+	yield* Console.log(`remote: ${info.remote ?? "unknown"}`);
+	yield* Console.log(`remote_available: ${support?.remote_available ?? "unknown"}`);
+	yield* Console.log(`token_auth: ${info.device.TokenAuthSupport ?? "unknown"}`);
+	yield* Console.log(`developer_ip: ${info.device.developerIP ?? "unknown"}`);
+	yield* Console.log(`developer_mode: ${info.device.developerMode ?? "unknown"}`);
+});
+const resolveRemoteOptions = Effect.fn("resolveRemoteOptions")(function* (env, options) {
+	const targetHost = hostFromTarget(env.target);
+	const state = !env.tvHost && !targetHost || Boolean(options?.requireToken && !options.ignoreToken && !env.tvToken) ? yield* readRemoteState() : void 0;
+	const host = env.tvHost ?? state?.host ?? targetHost;
+	if (!host) return yield* MissingTvRemoteHost.make({});
+	const token = options?.ignoreToken ? void 0 : env.tvToken ?? state?.token;
+	if (options?.requireToken && !token) return yield* MissingTvRemoteToken.make({});
+	return {
+		host,
+		name: env.tvName ?? state?.name ?? DEFAULT_REMOTE_NAME,
+		port: env.tvPort ?? state?.port ?? DEFAULT_REMOTE_PORT,
+		protocol: env.tvProtocol ?? state?.protocol ?? DEFAULT_REMOTE_PROTOCOL,
+		timeoutMs: env.tvTimeoutMs ?? DEFAULT_TIMEOUT_MS,
+		token
+	};
+});
+const readRemoteState = Effect.fn("readRemoteState")(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const paths = yield* getPaths();
+	if (!(yield* fs.exists(paths.remoteStatePath).pipe(Effect.mapError((cause) => FileSystemFailure.make({
+		cause,
+		operation: "exists",
+		path: paths.remoteStatePath
+	}))))) return;
+	const source = yield* fs.readFileString(paths.remoteStatePath).pipe(Effect.mapError((cause) => FileSystemFailure.make({
+		cause,
+		operation: "read",
+		path: paths.remoteStatePath
+	})));
+	const json = yield* Effect.try({
+		try: () => JSON.parse(source),
+		catch: (cause) => InvalidJson.make({
+			details: causeToMessage(cause),
+			file: paths.remoteStatePath
+		})
+	});
+	return yield* Schema.decodeUnknownEffect(TvRemoteState)(json, { errors: "all" }).pipe(Effect.mapError((error) => InvalidJson.make({
+		details: error.message,
+		file: paths.remoteStatePath
+	})));
+});
+const saveRemoteState = Effect.fn("saveRemoteState")(function* (options) {
+	const fs = yield* FileSystem.FileSystem;
+	const paths = yield* getPaths();
+	const state = TvRemoteState.make({
+		host: options.host,
+		name: options.name,
+		port: options.port,
+		protocol: options.protocol,
+		token: options.token
+	});
+	yield* fs.makeDirectory(dirname(paths.remoteStatePath), { recursive: true }).pipe(Effect.mapError((cause) => FileSystemFailure.make({
+		cause,
+		operation: "mkdir",
+		path: dirname(paths.remoteStatePath)
+	})));
+	yield* fs.writeFileString(paths.remoteStatePath, `${JSON.stringify(state, null, 2)}\n`).pipe(Effect.mapError((cause) => FileSystemFailure.make({
+		cause,
+		operation: "write",
+		path: paths.remoteStatePath
+	})));
+});
+const connectRemote = Effect.fn("connectRemote")(function* (options, sequence) {
+	return yield* Effect.tryPromise({
+		try: () => connectRemotePromise(options, sequence),
+		catch: (cause) => normalizeRemoteError(cause, options)
+	});
+});
+const connectRemotePromise = (options, sequence) => new Promise((resolve, reject) => {
+	const ws = new WebSocket(remoteUrl(options), {
+		handshakeTimeout: options.timeoutMs,
+		rejectUnauthorized: false
+	});
+	const timer = setTimeout(() => {
+		reject(TvRemoteTimeout.make({ target: remoteTarget(options) }));
+		ws.terminate();
+	}, options.timeoutMs);
+	let settled = false;
+	const succeed = (token) => {
+		if (settled) return;
+		settled = true;
+		clearTimeout(timer);
+		resolve(token);
+		ws.close();
+	};
+	const fail = (error) => {
+		if (settled) return;
+		settled = true;
+		clearTimeout(timer);
+		reject(error);
+		ws.close();
+	};
+	const sendSequence = (token) => {
+		const keys = sequence?.keys ?? [];
+		if (keys.length === 0) {
+			succeed(token);
+			return;
+		}
+		let index = 0;
+		const sendNext = () => {
+			const key = keys[index];
+			if (!key) {
+				succeed(token);
+				return;
+			}
+			ws.send(JSON.stringify(remoteKeyPayload(key)));
+			index += 1;
+			if (index >= keys.length) {
+				setTimeout(() => succeed(token), 500);
+				return;
+			}
+			setTimeout(sendNext, sequence?.delayMs ?? 250);
 		};
-	} catch (error) {
-		if (ParseResult.isParseError(error)) return fail(`Invalid TAIZN environment:\n${formatParseIssues(error)}`);
-		return fail(`Invalid TAIZN environment: ${error instanceof Error ? error.message : String(error)}`);
+		sendNext();
+	};
+	ws.on("message", (data) => {
+		let event;
+		try {
+			event = parseRemoteEvent(data.toString(), options);
+		} catch (cause) {
+			fail(normalizeRemoteError(cause, options));
+			return;
+		}
+		if (event.event === "ms.channel.unauthorized") {
+			fail(TvRemoteUnauthorized.make({ target: remoteTarget(options) }));
+			return;
+		}
+		if (event.event !== "ms.channel.connect") return;
+		const token = remoteEventToken(event) ?? options.token;
+		if (!token) {
+			fail(TvRemoteProtocolError.make({ details: "connect event did not include a token" }));
+			return;
+		}
+		sendSequence(token);
+	});
+	ws.on("error", (cause) => {
+		fail(TvRemoteConnectionFailed.make({
+			cause,
+			target: remoteTarget(options)
+		}));
+	});
+	ws.on("close", () => {
+		if (!settled) fail(TvRemoteConnectionFailed.make({
+			cause: /* @__PURE__ */ new Error("remote websocket closed before connecting"),
+			target: remoteTarget(options)
+		}));
+	});
+});
+const fetchSamsungTvInfo = Effect.fn("fetchSamsungTvInfo")(function* (host, options) {
+	const url = `http://${host}:${options?.port ?? TV_INFO_PORT}/api/v2/`;
+	const json = yield* Effect.tryPromise({
+		try: async () => {
+			const response = await fetch(url, { signal: AbortSignal.timeout(options?.timeoutMs ?? DEFAULT_TIMEOUT_MS) });
+			if (!response.ok) throw new Error(`HTTP ${response.status}`);
+			return await response.json();
+		},
+		catch: (cause) => isAbortError(cause) ? TvRemoteTimeout.make({ target: url }) : TvRemoteConnectionFailed.make({
+			cause,
+			target: url
+		})
+	});
+	return yield* Schema.decodeUnknownEffect(TvInfo)(json, { errors: "all" }).pipe(Effect.mapError((error) => TvRemoteProtocolError.make({ details: error.message })));
+});
+const isAbortError = (cause) => cause instanceof Error && (cause.name === "AbortError" || cause.name === "TimeoutError");
+const parseRemoteEvent = (source, options) => {
+	try {
+		return Schema.decodeUnknownSync(RemoteEvent)(JSON.parse(source));
+	} catch (cause) {
+		throw TvRemoteProtocolError.make({ details: `${remoteTarget(options)} sent an unexpected message: ${causeToMessage(cause)}` });
 	}
 };
-const formatParseIssues = (error) => ParseResult.ArrayFormatter.formatErrorSync(error).map((issue) => {
-	return `- ${issue.path.length > 0 ? issue.path.join(".") : "TAIZN environment"}: ${issue.message}`;
-}).join("\n");
-//#endregion
-//#region src/context.ts
-const loadContext = () => ({
-	config: loadConfig(),
-	env: loadEnv()
+const parseSupport = (source) => {
+	try {
+		return Schema.decodeUnknownSync(Schema.Struct({ remote_available: Schema.optional(Schema.String) }))(JSON.parse(source));
+	} catch {
+		return;
+	}
+};
+const remoteUrl = (options) => {
+	const params = new URLSearchParams({ name: Buffer.from(options.name).toString("base64") });
+	if (options.token) params.set("token", options.token);
+	return `${options.protocol}://${options.host}:${options.port}/api/v2/channels/samsung.remote.control?${params.toString()}`;
+};
+const remoteTarget = (options) => `${options.protocol}://${options.host}:${options.port}`;
+const remoteKeyPayload = (key) => ({
+	method: "ms.remote.control",
+	params: {
+		Cmd: "Click",
+		DataOfCmd: key,
+		Option: "false",
+		TypeOfRemote: "SendRemoteKey"
+	}
 });
+const remoteEventToken = (event) => {
+	const data = event.data;
+	if (!data) return;
+	const matchingClientToken = data.id ? data.clients?.find((client) => client.id === data.id)?.attributes?.token : void 0;
+	return data.token ?? matchingClientToken ?? data.clients?.find((client) => client.attributes?.token)?.attributes?.token;
+};
+const normalizeRemoteError = (cause, options) => {
+	if (cause instanceof MissingTvRemoteHost || cause instanceof MissingTvRemoteToken || cause instanceof TvRemoteConnectionFailed || cause instanceof TvRemoteProtocolError || cause instanceof TvRemoteTimeout || cause instanceof TvRemoteUnauthorized) return cause;
+	return TvRemoteConnectionFailed.make({
+		cause,
+		target: remoteTarget(options)
+	});
+};
+const hostFromTarget = (target) => {
+	if (!target) return;
+	return target.split(":").at(0);
+};
+const causeToMessage = (cause) => cause instanceof Error ? cause.message : String(cause);
+const decodeHtml = (value) => value.replaceAll("&quot;", "\"").replaceAll("&amp;", "&");
 //#endregion
 //#region src/xml.ts
 const escapeXml = (value) => value.replaceAll("&", "&amp;").replaceAll("\"", "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
@@ -196,25 +694,28 @@ const setXmlAttribute = (tag, attribute, value) => {
 };
 //#endregion
 //#region src/tizen.ts
-const checkTizen = (env) => {
-	const tizenPath = tizenCli(env.tizenCli);
-	const sdbPath = sdb(env.sdb);
-	const devices = listSdbDevices(sdbPath);
-	console.log(`Tizen CLI: ${tizenPath}`);
-	console.log(`sdb: ${sdbPath}`);
+const checkTizen = Effect.fn("checkTizen")(function* (env) {
+	const tizenPath = yield* resolveTizenCli(env);
+	const sdbPath = yield* resolveSdb(env);
+	const devices = yield* listSdbDevices(sdbPath);
+	yield* Console.log(`Tizen CLI: ${tizenPath}`);
+	yield* Console.log(`sdb: ${sdbPath}`);
 	if (devices.length === 0) {
-		console.log("connected targets: none");
+		yield* Console.log("connected targets: none");
 		return;
 	}
-	console.log("connected targets:");
-	for (const device of devices) console.log(`- ${device.id}${device.label ? ` (${device.label})` : ""}`);
-};
-const createProfile = async ({ config, env }) => {
-	const password = await readPassword(env.certPassword, "Tizen certificate password: ");
-	if (!password) fail("TAIZN_CERT_PASSWORD is required to create the signing profile.");
-	const certificates = getCertificates(config);
-	const distributorPassword = env.distPassword || password;
-	run(tizenCli(env.tizenCli), [
+	yield* Console.log("connected targets:");
+	for (const device of devices) yield* Console.log(`- ${device.id}${device.label ? ` (${device.label})` : ""}`);
+});
+const createProfile = Effect.fn("createProfile")(function* ({ config, env }) {
+	const password = yield* readPassword(env.certPassword, "Tizen certificate password: ");
+	if (!password) return yield* MissingPassword.make({
+		action: "create the signing profile",
+		variable: "TAIZN_CERT_PASSWORD"
+	});
+	const certificates = yield* getCertificates(config);
+	const distributorPassword = env.distPassword ?? password;
+	yield* run$1(yield* resolveTizenCli(env), [
 		"security-profiles",
 		"add",
 		"-f",
@@ -229,43 +730,102 @@ const createProfile = async ({ config, env }) => {
 		certificates.distributor,
 		"-dp",
 		distributorPassword
-	]);
-	console.log(`Configured active Tizen signing profile: ${config.signing.profile}`);
-};
-const packageWidget = ({ config, env }) => {
+	], { env: yield* baseChildEnv() });
+	yield* Console.log(`Configured active Tizen signing profile: ${config.signing.profile}`);
+});
+const packageWidget = Effect.fn("packageWidget")(function* ({ config, env }) {
 	const [command, ...args] = config.build.command;
+	const tizenPath = yield* resolveTizenCli(env);
+	const paths = yield* getPaths();
 	const variant = getVariant(config, env.variant);
-	run(command, args, { env: appBuildEnv() });
-	stageWidget(config, variant);
-	run(tizenCli(env.tizenCli), [
+	yield* run$1(command, args, { env: yield* appBuildEnv() });
+	yield* stageWidget(config, variant);
+	yield* run$1(tizenPath, [
 		"package",
 		"-t",
 		"wgt",
 		"-s",
 		config.signing.profile,
 		"-o",
-		outputDir,
+		paths.outputDir,
 		"--",
-		stageDir
-	]);
-	const built = findBuiltWidget();
-	const installable = join(outputDir, `${variant.bundleName}.wgt`);
-	if (built !== installable) copyFileSync(built, installable);
-	console.log(`Packaged ${installable}`);
+		paths.stageDir
+	], { env: yield* baseChildEnv() });
+	const built = yield* findBuiltWidget();
+	const installable = join(paths.outputDir, `${variant.bundleName}.wgt`);
+	if (built !== installable) yield* (yield* FileSystem.FileSystem).copyFile(built, installable).pipe(Effect.mapError((cause) => FileSystemFailure.make({
+		cause,
+		operation: "copy",
+		path: installable
+	})));
+	yield* Console.log(`Packaged ${installable}`);
 	return installable;
-};
-const installWidget = (context) => {
-	const built = packageWidget(context);
-	const target = resolveInstallTarget(context.env);
-	if (context.env.target) run(sdb(context.env.sdb), ["connect", context.env.target]);
-	const installArgs = [
+});
+const installWidget = Effect.fn("installWidget")(function* (context) {
+	const built = yield* packageWidget(context);
+	const target = yield* resolveInstallTarget(context.env);
+	const sdbPath = yield* resolveSdb(context.env);
+	const tizenPath = yield* resolveTizenCli(context.env);
+	if (context.env.target) yield* run$1(sdbPath, ["connect", context.env.target], { env: yield* baseChildEnv() });
+	yield* run$1(tizenPath, target ? [
+		"install",
+		"-n",
+		built,
+		"-s",
+		target
+	] : [
 		"install",
 		"-n",
 		built
-	];
-	if (target) installArgs.push("-s", target);
-	run(tizenCli(context.env.tizenCli), installArgs);
-};
+	], { env: yield* baseChildEnv() });
+});
+const runWidget = Effect.fn("runWidget")(function* ({ config, env }) {
+	const variant = getVariant(config, env.variant);
+	const sdbPath = yield* resolveSdb(env);
+	const tizenPath = yield* resolveTizenCli(env);
+	if (env.target) yield* run$1(sdbPath, ["connect", env.target], { env: yield* baseChildEnv() });
+	const target = yield* resolveRunTarget(env, sdbPath);
+	yield* run$1(tizenPath, target ? [
+		"run",
+		"-p",
+		variant.applicationId,
+		target.flag,
+		target.value
+	] : [
+		"run",
+		"-p",
+		variant.applicationId
+	], { env: yield* baseChildEnv() });
+	yield* Console.log(`Launched ${variant.applicationId}`);
+});
+const listInstalledApplications = Effect.fn("listInstalledApplications")(function* (env, query) {
+	const sdbPath = yield* resolveSdb(env);
+	if (env.target) yield* run$1(sdbPath, ["connect", env.target], { env: yield* baseChildEnv() });
+	const target = yield* resolveRequiredSdbTarget(env, sdbPath);
+	const output = yield* capture(sdbPath, [
+		"-s",
+		target,
+		"shell",
+		"0",
+		"applist"
+	]);
+	const queryLabel = query?.trim();
+	const normalizedQuery = normalizeQuery(queryLabel);
+	const applications = parseInstalledApplications(output).filter((application) => matchesApplicationQuery(application, normalizedQuery));
+	const suffix = queryLabel ? ` matching "${queryLabel}"` : "";
+	yield* Console.log(`Installed Tizen applications${suffix} on ${target}:`);
+	if (applications.length === 0) {
+		yield* Console.log("none");
+		return;
+	}
+	for (const application of applications) yield* Console.log(`- ${application.name} (${application.applicationId})`);
+});
+const resolveTizenCli = Effect.fn("resolveTizenCli")(function* (env) {
+	return yield* requireFile(env.tizenCli ?? (yield* defaultTizenCli()), "Tizen CLI");
+});
+const resolveSdb = Effect.fn("resolveSdb")(function* (env) {
+	return yield* requireFile(env.sdb ?? (yield* defaultSdb()), "sdb");
+});
 const getVariant = (config, variant) => config.widget.variants[variant];
 const getWidgetStageOptions = (config, variant) => ({
 	excludeFiles: [...config.widget.excludeFiles ?? [], ...variant.excludeFiles ?? []],
@@ -273,82 +833,133 @@ const getWidgetStageOptions = (config, variant) => ({
 	injectWebapis: variant.injectWebapis ?? config.widget.injectWebapis,
 	rewriteAssetUrls: variant.rewriteAssetUrls ?? config.widget.rewriteAssetUrls
 });
-const getCertificates = (config) => {
-	const certificatesDir = appPath(config.signing.certificateDir);
+const getCertificates = Effect.fn("getCertificates")(function* (config) {
+	const certificatesDir = appPath((yield* getPaths()).appDir, config.signing.certificateDir);
 	return {
-		author: requireFile(join(certificatesDir, "author.p12"), "Author certificate"),
-		distributor: requireFile(join(certificatesDir, "distributor.p12"), "Distributor certificate")
+		author: yield* requireFile(join(certificatesDir, "author.p12"), "Author certificate"),
+		distributor: yield* requireFile(join(certificatesDir, "distributor.p12"), "Distributor certificate")
 	};
-};
-const rewriteConfigForWidget = (variant) => {
-	const targetPath = join(stageDir, "config.xml");
-	let widgetConfig = readFileSync(targetPath, "utf8");
-	widgetConfig = widgetConfig.replace(/<tizen:application\b[^>]*\/>/, (tag) => setXmlAttribute(setXmlAttribute(tag, "id", variant.applicationId), "package", variant.packageId));
-	widgetConfig = widgetConfig.replace(/<name>[^<]*<\/name>/, `<name>${escapeXml(variant.name)}</name>`);
-	writeFileSync(targetPath, widgetConfig);
-};
-const rewriteIndexForWidget = (options) => {
-	const targetPath = join(stageDir, "index.html");
+});
+const rewriteConfigForWidget = Effect.fn("rewriteConfigForWidget")(function* (variant) {
+	const fs = yield* FileSystem.FileSystem;
+	const targetPath = join((yield* getPaths()).stageDir, "config.xml");
+	const rewritten = (yield* fs.readFileString(targetPath).pipe(Effect.mapError((cause) => FileSystemFailure.make({
+		cause,
+		operation: "read",
+		path: targetPath
+	})))).replace(/<tizen:application\b[^>]*\/>/, (tag) => setXmlAttribute(setXmlAttribute(tag, "id", variant.applicationId), "package", variant.packageId)).replace(/<name>[^<]*<\/name>/, `<name>${escapeXml(variant.name)}</name>`);
+	yield* fs.writeFileString(targetPath, rewritten).pipe(Effect.mapError((cause) => FileSystemFailure.make({
+		cause,
+		operation: "write",
+		path: targetPath
+	})));
+});
+const rewriteIndexForWidget = Effect.fn("rewriteIndexForWidget")(function* (options) {
+	const fs = yield* FileSystem.FileSystem;
+	const paths = yield* getPaths();
+	const targetPath = join(paths.stageDir, "index.html");
 	const webapisScript = "<script src=\"$WEBAPIS/webapis/webapis.js\"><\/script>";
-	let html = readFileSync(appPath(options.indexHtml), "utf8");
-	if (options.rewriteAssetUrls) html = html.replaceAll("href=\"/", "href=\"./").replaceAll("src=\"/", "src=\"./");
-	if (options.injectWebapis !== false && !html.includes("$WEBAPIS/webapis/webapis.js")) html = html.replace("</head>", `${webapisScript}</head>`);
-	writeFileSync(targetPath, html);
-};
-const assertBuildOutput = (config) => {
-	const sourceDir = appPath(config.build.output);
-	requireFile(sourceDir, "Tizen build output");
-	for (const requiredFile of config.build.requiredFiles || []) requireFile(join(sourceDir, requiredFile), `Tizen build output ${requiredFile}`);
+	const indexPath = appPath(paths.appDir, options.indexHtml);
+	const source = yield* fs.readFileString(indexPath).pipe(Effect.mapError((cause) => FileSystemFailure.make({
+		cause,
+		operation: "read",
+		path: indexPath
+	})));
+	const withAssets = options.rewriteAssetUrls ? source.replaceAll("href=\"/", "href=\"./").replaceAll("src=\"/", "src=\"./") : source;
+	const html = options.injectWebapis !== false && !withAssets.includes("$WEBAPIS/webapis/webapis.js") ? withAssets.replace("</head>", `${webapisScript}</head>`) : withAssets;
+	yield* fs.writeFileString(targetPath, html).pipe(Effect.mapError((cause) => FileSystemFailure.make({
+		cause,
+		operation: "write",
+		path: targetPath
+	})));
+});
+const assertBuildOutput = Effect.fn("assertBuildOutput")(function* (config) {
+	const sourceDir = appPath((yield* getPaths()).appDir, config.build.output);
+	yield* requireFile(sourceDir, "Tizen build output");
+	for (const requiredFile of config.build.requiredFiles ?? []) yield* requireFile(join(sourceDir, requiredFile), `Tizen build output ${requiredFile}`);
 	return sourceDir;
-};
-const removeExcludedStageFiles = (excludeFiles) => {
-	for (const file of excludeFiles) rmSync(join(stageDir, file), {
-		force: true,
-		recursive: true
-	});
-};
-const stageWidget = (config, variant) => {
-	const sourceDir = assertBuildOutput(config);
+});
+const removeExcludedStageFiles = Effect.fn("removeExcludedStageFiles")(function* (excludeFiles) {
+	const fs = yield* FileSystem.FileSystem;
+	const paths = yield* getPaths();
+	for (const file of excludeFiles) {
+		const path = join(paths.stageDir, file);
+		yield* fs.remove(path, {
+			force: true,
+			recursive: true
+		}).pipe(Effect.mapError((cause) => FileSystemFailure.make({
+			cause,
+			operation: "remove",
+			path
+		})));
+	}
+});
+const stageWidget = Effect.fn("stageWidget")(function* (config, variant) {
+	const fs = yield* FileSystem.FileSystem;
+	const paths = yield* getPaths();
+	const sourceDir = yield* assertBuildOutput(config);
 	const options = getWidgetStageOptions(config, variant);
-	rmSync(stageDir, {
+	const configXml = appPath(paths.appDir, config.widget.configXml);
+	const icon = yield* requireFile(appPath(paths.appDir, variant.icon), "Tizen widget icon");
+	yield* fs.remove(paths.stageDir, {
 		force: true,
 		recursive: true
-	});
-	rmSync(outputDir, {
+	}).pipe(Effect.mapError((cause) => FileSystemFailure.make({
+		cause,
+		operation: "remove",
+		path: paths.stageDir
+	})));
+	yield* fs.remove(paths.outputDir, {
 		force: true,
 		recursive: true
-	});
-	mkdirSync(stageDir, { recursive: true });
-	mkdirSync(outputDir, { recursive: true });
-	cpSync(sourceDir, stageDir, { recursive: true });
-	copyFileSync(appPath(config.widget.configXml), join(stageDir, "config.xml"));
-	copyFileSync(requireFile(appPath(variant.icon), "Tizen widget icon"), join(stageDir, "icon.png"));
-	removeExcludedStageFiles(options.excludeFiles);
-	rewriteConfigForWidget(variant);
-	rewriteIndexForWidget(options);
-};
-const findBuiltWidget = () => {
-	const built = execFileSync("find", [
-		outputDir,
-		"-maxdepth",
-		"1",
-		"-name",
-		"*.wgt",
-		"-print"
-	], { encoding: "utf8" }).trim().split("\n").filter(Boolean).at(0);
-	if (typeof built === "string") return built;
-	return fail(`No .wgt package was produced in ${outputDir}`);
-};
-const listSdbDevices = (sdbPath) => {
-	return execFileSync(sdb(sdbPath), ["devices"], {
-		cwd: appDir,
-		encoding: "utf8",
-		env: {
-			...baseChildEnv(),
-			PATH: `${join(homedir(), "tizen-studio/tools")}:${process.env.PATH || ""}`
-		}
-	}).split("\n").slice(1).map((line) => line.trim()).filter(Boolean).map(parseSdbDevice).filter((device) => device.id && device.state === "device");
-};
+	}).pipe(Effect.mapError((cause) => FileSystemFailure.make({
+		cause,
+		operation: "remove",
+		path: paths.outputDir
+	})));
+	yield* fs.makeDirectory(paths.stageDir, { recursive: true }).pipe(Effect.mapError((cause) => FileSystemFailure.make({
+		cause,
+		operation: "mkdir",
+		path: paths.stageDir
+	})));
+	yield* fs.makeDirectory(paths.outputDir, { recursive: true }).pipe(Effect.mapError((cause) => FileSystemFailure.make({
+		cause,
+		operation: "mkdir",
+		path: paths.outputDir
+	})));
+	yield* fs.copy(sourceDir, paths.stageDir).pipe(Effect.mapError((cause) => FileSystemFailure.make({
+		cause,
+		operation: "copy",
+		path: paths.stageDir
+	})));
+	yield* fs.copyFile(configXml, join(paths.stageDir, "config.xml")).pipe(Effect.mapError((cause) => FileSystemFailure.make({
+		cause,
+		operation: "copy",
+		path: configXml
+	})));
+	yield* fs.copyFile(icon, join(paths.stageDir, "icon.png")).pipe(Effect.mapError((cause) => FileSystemFailure.make({
+		cause,
+		operation: "copy",
+		path: icon
+	})));
+	yield* removeExcludedStageFiles(options.excludeFiles);
+	yield* rewriteConfigForWidget(variant);
+	yield* rewriteIndexForWidget(options);
+});
+const findBuiltWidget = Effect.fn("findBuiltWidget")(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const paths = yield* getPaths();
+	const built = (yield* fs.readDirectory(paths.outputDir).pipe(Effect.mapError((cause) => FileSystemFailure.make({
+		cause,
+		operation: "readDirectory",
+		path: paths.outputDir
+	})))).filter((entry) => entry.endsWith(".wgt")).map((entry) => join(paths.outputDir, entry)).at(0);
+	if (built) return built;
+	return yield* PackageNotProduced.make({ outputDir: paths.outputDir });
+});
+const listSdbDevices = Effect.fn("listSdbDevices")(function* (sdbPath) {
+	return (yield* capture(sdbPath, ["devices"])).split("\n").slice(1).map((line) => line.trim()).filter(Boolean).map(parseSdbDevice).filter((device) => device.id && device.state === "device");
+});
 const parseSdbDevice = (line) => {
 	const [id = "", state = "", label = ""] = line.split(/\s+/, 3);
 	return {
@@ -357,61 +968,177 @@ const parseSdbDevice = (line) => {
 		state
 	};
 };
-const resolveInstallTarget = (env) => {
+const resolveInstallTarget = Effect.fn("resolveInstallTarget")(function* (env) {
 	if (env.target) return env.target;
-	const devices = listSdbDevices(env.sdb);
+	const devices = yield* listSdbDevices(yield* resolveSdb(env));
 	if (devices.length === 1) {
-		const [device] = devices;
-		console.log(`Using connected Tizen target: ${device.id}${device.label ? ` (${device.label})` : ""}`);
-		return device.id;
+		const device = devices[0];
+		if (device) {
+			yield* Console.log(`Using connected Tizen target: ${device.id}${device.label ? ` (${device.label})` : ""}`);
+			return device.id;
+		}
 	}
-	if (devices.length > 1) fail(`Multiple Tizen targets are connected: ${devices.map((device) => device.id).join(", ")}. Set TAIZN_TARGET explicitly.`);
-	return null;
-};
+	if (devices.length > 1) return yield* MultipleTargetsConnected.make({ targets: devices.map((device) => device.id) });
+});
+const resolveRunTarget = Effect.fn("resolveRunTarget")(function* (env, sdbPath) {
+	if (env.target) return {
+		flag: "-s",
+		value: env.target
+	};
+	const devices = yield* listSdbDevices(sdbPath);
+	if (devices.length === 1) {
+		const device = devices[0];
+		if (device) {
+			yield* Console.log(`Using connected Tizen target: ${device.id}${device.label ? ` (${device.label})` : ""}`);
+			return {
+				flag: "-s",
+				value: device.id
+			};
+		}
+	}
+	if (devices.length > 1) return yield* MultipleTargetsConnected.make({ targets: devices.map((device) => device.id) });
+});
+const resolveRequiredSdbTarget = Effect.fn("resolveRequiredSdbTarget")(function* (env, sdbPath) {
+	if (env.target) return env.target;
+	const devices = yield* listSdbDevices(sdbPath);
+	if (devices.length === 1) {
+		const device = devices[0];
+		if (device) {
+			yield* Console.log(`Using connected Tizen target: ${device.id}${device.label ? ` (${device.label})` : ""}`);
+			return device.id;
+		}
+	}
+	if (devices.length > 1) return yield* MultipleTargetsConnected.make({ targets: devices.map((device) => device.id) });
+	return yield* MissingTizenTarget.make({});
+});
+const parseInstalledApplications = (output) => output.split("\n").flatMap((line) => {
+	const match = line.match(/^\s*'([^']*)'\s+'([^']*)'\s*$/);
+	const name = match?.[1]?.trim();
+	const applicationId = match?.[2]?.trim();
+	return name && applicationId ? [{
+		applicationId,
+		name
+	}] : [];
+});
+const normalizeQuery = (query) => query?.trim().toLowerCase();
+const matchesApplicationQuery = (application, normalizedQuery) => !normalizedQuery || application.name.toLowerCase().includes(normalizedQuery) || application.applicationId.toLowerCase().includes(normalizedQuery);
+const run$1 = Effect.fn("run")(function* (command, args, options) {
+	const paths = yield* getPaths();
+	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+	const env = yield* withTizenPath(options.env ?? (yield* baseChildEnv()));
+	if ((yield* spawner.exitCode(ChildProcess.make(command, args, {
+		cwd: options.cwd ?? paths.appDir,
+		env,
+		stderr: "inherit",
+		stdin: "inherit",
+		stdout: "inherit"
+	})).pipe(Effect.mapError(() => CommandFailed.make({
+		args: redactCommandArgs(args),
+		command
+	})))) !== 0) return yield* CommandFailed.make({
+		args: redactCommandArgs(args),
+		command
+	});
+});
+const capture = Effect.fn("capture")(function* (command, args) {
+	const output = yield* Effect.scoped(Effect.gen(function* () {
+		const paths = yield* getPaths();
+		const env = yield* withTizenPath(yield* baseChildEnv());
+		const process = yield* ChildProcess.make(command, args, {
+			cwd: paths.appDir,
+			env,
+			stderr: "inherit"
+		}).pipe(Effect.mapError(() => CommandFailed.make({
+			args: redactCommandArgs(args),
+			command
+		})));
+		const output = yield* process.stdout.pipe(Stream.decodeText, Stream.mkString).pipe(Effect.mapError(() => CommandFailed.make({
+			args: redactCommandArgs(args),
+			command
+		})));
+		return {
+			exitCode: yield* process.exitCode.pipe(Effect.mapError(() => CommandFailed.make({
+				args: redactCommandArgs(args),
+				command
+			}))),
+			output
+		};
+	}));
+	if (output.exitCode !== 0) return yield* CommandFailed.make({
+		args: redactCommandArgs(args),
+		command
+	});
+	return output.output;
+});
 //#endregion
 //#region src/cli.ts
-const runSync = (operation) => Effect.sync(() => {
-	operation(loadContext());
-});
-const runEnvSync = (operation) => Effect.sync(() => {
-	operation(loadEnv());
+const withContext = (operation) => Effect.gen(function* () {
+	yield* operation(yield* loadContext());
 });
-const taizn = Command.make("taizn", {}, () => runSync((context) => {
-	packageWidget(context);
+const taizn = Command.make("taizn", {}, () => withContext((context) => packageWidget(context).pipe(Effect.asVoid)));
+const check = Command.make("check", {}, () => Effect.gen(function* () {
+	yield* checkTizen(yield* loadEnv());
 }));
-const check = Command.make("check", {}, () => runEnvSync((env) => {
-	checkTizen(env);
+const apps = Command.make("apps", { query: Argument.string("query").pipe(Argument.optional) }, ({ query }) => Effect.gen(function* () {
+	yield* listInstalledApplications(yield* loadEnv(), Option.getOrUndefined(query));
 }));
-const profile = Command.make("profile", {}, () => Effect.promise(async () => {
-	await createProfile(loadContext());
+const profile = Command.make("profile", {}, () => withContext((context) => createProfile(context)));
+const pack = Command.make("package", {}, () => withContext((context) => packageWidget(context).pipe(Effect.asVoid)));
+const install = Command.make("install", {}, () => withContext((context) => installWidget(context)));
+const run = Command.make("run", {}, () => withContext((context) => runWidget(context)));
+const tvPair = Command.make("pair", {}, () => Effect.gen(function* () {
+	yield* pairSamsungTvRemote(yield* loadEnv());
 }));
-const pack = Command.make("package", {}, () => runSync((context) => {
-	packageWidget(context);
+const tvPress = Command.make("press", {
+	delayMs: Flag.integer("delay-ms").pipe(Flag.withDefault(250)),
+	keys: Argument.string("key").pipe(Argument.variadic({ min: 1 }))
+}, ({ delayMs, keys }) => Effect.gen(function* () {
+	yield* sendSamsungTvKeys(yield* loadEnv(), keys, { delayMs });
 }));
-const install = Command.make("install", {}, () => runSync((context) => {
-	installWidget(context);
+const tvInfo = Command.make("info", {}, () => Effect.gen(function* () {
+	yield* showSamsungTvInfo(yield* loadEnv());
 }));
+const tv = Command.make("tv", {}).pipe(Command.withSubcommands([
+	tvPair,
+	tvPress,
+	tvInfo
+]));
 const command = taizn.pipe(Command.withSubcommands([
+	apps,
 	check,
 	profile,
 	pack,
-	install
+	install,
+	run,
+	tv
 ]));
 //#endregion
 //#region src/taizn.ts
-const PackageJsonSchema = Schema.Struct({ version: Schema.String });
-loadLocalEnv();
-Command.run(command, {
-	name: "taizn",
-	version: getPackageVersion()
-})(process.argv).pipe(Effect.provide(NodeContext.layer), NodeRuntime.runMain);
-function getPackageVersion() {
-	try {
-		return Schema.decodeUnknownSync(Schema.parseJson(PackageJsonSchema))(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
-	} catch (error) {
-		if (ParseResult.isParseError(error)) return "0.0.0";
-		return "0.0.0";
+var PackageJson = class extends Schema.Class("PackageJson")({ version: Schema.String }) {};
+const appLayer = Layer.mergeAll(NodeServices.layer, TaiznSystem.Live);
+const getPackageVersion = Effect.fn("getPackageVersion")(function* () {
+	const source = yield* (yield* FileSystem.FileSystem).readFileString(fileURLToPath(new URL("../package.json", import.meta.url)));
+	const json = yield* Effect.try({
+		try: () => JSON.parse(source),
+		catch: () => void 0
+	});
+	return (yield* Schema.decodeUnknownEffect(PackageJson)(json).pipe(Effect.catch(() => Effect.succeed(PackageJson.make({ version: "0.0.0" }))))).version;
+}, Effect.catch(() => Effect.succeed("0.0.0")));
+const program = Effect.gen(function* () {
+	yield* loadLocalEnv();
+	const version = yield* getPackageVersion();
+	yield* Command.run(command, { version });
+}).pipe(Effect.catch(handleMainError), Effect.provide(appLayer));
+NodeRuntime.runMain(program);
+function handleMainError(error) {
+	if (CliError.isCliError(error)) {
+		if (error._tag === "ShowHelp" && error.errors.length === 0) return Effect.void;
+		return markFailed;
 	}
+	return Console.error(renderError(error)).pipe(Effect.andThen(markFailed));
 }
+const markFailed = Effect.sync(() => {
+	process.exitCode = 1;
+});
 //#endregion
 export {};