@putdotio/taizn 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 put.io
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,120 @@
+<div align="center">
+  <p>
+    <img src="https://static.put.io/images/putio-boncuk.png" width="72">
+  </p>
+
+  <h1>taizn</h1>
+
+  <p>A tiny CLI companion for interacting with Tizen ecosystem.</p>
+
+  <p>
+    <a href="https://github.com/putdotio/taizn/actions/workflows/ci.yml?query=branch%3Amain" style="text-decoration:none;"><img src="https://img.shields.io/github/actions/workflow/status/putdotio/taizn/ci.yml?branch=main&style=flat&label=ci&colorA=000000&colorB=000000" alt="CI"></a>
+    <a href="https://www.npmjs.com/package/@putdotio/taizn" style="text-decoration:none;"><img src="https://img.shields.io/npm/v/%40putdotio%2Ftaizn?style=flat&label=npm&logo=npm&colorA=000000&colorB=000000" alt="npm version"></a>
+    <a href="https://github.com/putdotio/taizn/blob/main/LICENSE" style="text-decoration:none;"><img src="https://img.shields.io/github/license/putdotio/taizn?style=flat&label=license&colorA=000000&colorB=000000" alt="License"></a>
+  </p>
+</div>
+
+## Install
+
+```bash
+pnpm add -D @putdotio/taizn
+```
+
+Install the Tizen command-line tools and make sure `tizen` and `sdb` work
+locally.
+
+## Usage
+
+Create `taizn.json` in the app directory, keep `.taizn/` ignored, then run:
+
+```bash
+pnpm exec taizn package
+pnpm exec taizn install
+```
+
+Project files:
+
+- `taizn.json`: app build, widget, signing, and variant config
+- `.taizn/.env`: optional local secrets read by Node
+- `.taizn/certificates/`: optional local author/distributor certs for `taizn profile`
+- `.taizn/build/`: generated package staging and output
+
+## Commands
+
+```bash
+taizn profile
+taizn package
+taizn install
+taizn --version
+```
+
+`profile` imports `.taizn/certificates/author.p12` and
+`.taizn/certificates/distributor.p12` into a Tizen security profile.
+`package` builds and signs a `.wgt`. `install` packages and sideloads it.
+
+## Environment
+
+```bash
+TAIZN_CERT_PASSWORD=...
+TAIZN_DIST_PASSWORD=...
+TAIZN_VARIANT=development
+TAIZN_TARGET=<tv-ip>:26101
+TAIZN_TIZEN_CLI=~/tizen-studio/tools/ide/bin/tizen
+TAIZN_SDB=~/tizen-studio/tools/sdb
+```
+
+## Config
+
+```json
+{
+  "build": {
+    "command": ["pnpm", "build"],
+    "output": "dist",
+    "requiredFiles": ["main.css", "main.js"]
+  },
+  "signing": {
+    "certificateDir": ".taizn/certificates",
+    "profile": "my-tizen-profile"
+  },
+  "widget": {
+    "configXml": "platforms/tizen/config.xml",
+    "indexHtml": "platforms/tizen/index.html",
+    "injectWebapis": true,
+    "rewriteAssetUrls": false,
+    "variants": {
+      "development": {
+        "applicationId": "ExampleDev.app",
+        "bundleName": "example-dev",
+        "icon": "platforms/tizen/icons/dev.png",
+        "name": "Example Dev",
+        "packageId": "ExampleDev"
+      },
+      "production": {
+        "applicationId": "Example.app",
+        "bundleName": "example",
+        "icon": "platforms/tizen/icon.png",
+        "name": "Example",
+        "packageId": "Example"
+      }
+    }
+  }
+}
+```
+
+## Docs
+
+- [Contributing](./CONTRIBUTING.md)
+- [Distribution](./docs/DISTRIBUTION.md)
+- [Security](./SECURITY.md)
+
+## Repo Internals
+
+- [Agent guide](./AGENTS.md)
+
+## Contributing
+
+See [Contributing](./CONTRIBUTING.md) for setup, checks, and pull request flow.
+
+## License
+
+[MIT](./LICENSE)

package/dist/taizn.mjs

@@ -0,0 +1,377 @@
+#!/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 { homedir } from "node:os";
+import { isAbsolute, join } from "node:path";
+//#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);
+};
+const fail = (message) => {
+	console.error(message);
+	process.exit(1);
+};
+const requireFile = (path, label) => {
+	if (!existsSync(path)) fail(`${label} not found: ${path}`);
+	return path;
+};
+const baseChildEnv = () => {
+	const env = { ...process.env };
+	delete env.DYLD_INSERT_LIBRARIES;
+	return env;
+};
+const appBuildEnv = () => {
+	const env = 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) => {
+	if (value) return value;
+	return 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]";
+		return arg;
+	});
+};
+const readSecret = (prompt) => new Promise((resolve) => {
+	if (!process.stdin.isTTY) {
+		resolve("");
+		return;
+	}
+	let value = "";
+	process.stdout.write(prompt);
+	process.stdin.setRawMode(true);
+	process.stdin.resume();
+	process.stdin.setEncoding("utf8");
+	const onData = (char) => {
+		if (char === "") {
+			process.stdout.write("\n");
+			process.exit(130);
+		}
+		if (char === "\r" || char === "\n") {
+			process.stdin.setRawMode(false);
+			process.stdin.pause();
+			process.stdin.off("data", onData);
+			process.stdout.write("\n");
+			resolve(value);
+			return;
+		}
+		if (char === "") {
+			value = value.slice(0, -1);
+			return;
+		}
+		value += char;
+	};
+	process.stdin.on("data", onData);
+});
+//#endregion
+//#region src/config.ts
+const TizenVariantSchema = Schema.Struct({
+	applicationId: Schema.NonEmptyString,
+	bundleName: Schema.NonEmptyString,
+	icon: Schema.NonEmptyString,
+	name: Schema.NonEmptyString,
+	packageId: Schema.NonEmptyString
+});
+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,
+		indexHtml: Schema.NonEmptyString,
+		injectWebapis: Schema.optional(Schema.Boolean),
+		rewriteAssetUrls: Schema.optional(Schema.Boolean),
+		variants: Schema.Struct({
+			development: TizenVariantSchema,
+			production: TizenVariantSchema
+		})
+	})
+});
+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");
+//#endregion
+//#region src/env.ts
+const TaiznEnvSchema = 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"))
+});
+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"
+		};
+	} 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)}`);
+	}
+};
+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()
+});
+//#endregion
+//#region src/xml.ts
+const escapeXml = (value) => value.replaceAll("&", "&amp;").replaceAll("\"", "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+const setXmlAttribute = (tag, attribute, value) => {
+	const escapedValue = escapeXml(value);
+	const attributePattern = new RegExp(`\\b${attribute}="[^"]*"`);
+	if (attributePattern.test(tag)) return tag.replace(attributePattern, `${attribute}="${escapedValue}"`);
+	return tag.replace(/\/?>$/, ` ${attribute}="${escapedValue}"$&`);
+};
+//#endregion
+//#region src/tizen.ts
+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), [
+		"security-profiles",
+		"add",
+		"-f",
+		"-A",
+		"-n",
+		config.signing.profile,
+		"-a",
+		certificates.author,
+		"-p",
+		password,
+		"-d",
+		certificates.distributor,
+		"-dp",
+		distributorPassword
+	]);
+	console.log(`Configured active Tizen signing profile: ${config.signing.profile}`);
+};
+const packageWidget = ({ config, env }) => {
+	const [command, ...args] = config.build.command;
+	run(command, args, { env: appBuildEnv() });
+	stageWidget(config, getVariant(config, env.variant));
+	run(tizenCli(env.tizenCli), [
+		"package",
+		"-t",
+		"wgt",
+		"-s",
+		config.signing.profile,
+		"-o",
+		outputDir,
+		"--",
+		stageDir
+	]);
+	const built = findBuiltWidget();
+	const installable = join(outputDir, `${getVariant(config, env.variant).bundleName}.wgt`);
+	if (built !== installable) copyFileSync(built, installable);
+	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 = [
+		"install",
+		"-n",
+		built
+	];
+	if (target) installArgs.push("-s", target);
+	run(tizenCli(context.env.tizenCli), installArgs);
+};
+const getVariant = (config, variant) => config.widget.variants[variant];
+const getCertificates = (config) => {
+	const certificatesDir = appPath(config.signing.certificateDir);
+	return {
+		author: requireFile(join(certificatesDir, "author.p12"), "Author certificate"),
+		distributor: 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 = (config) => {
+	const targetPath = join(stageDir, "index.html");
+	const webapisScript = "<script src=\"$WEBAPIS/webapis/webapis.js\"><\/script>";
+	let html = readFileSync(appPath(config.widget.indexHtml), "utf8");
+	if (config.widget.rewriteAssetUrls) html = html.replaceAll("href=\"/", "href=\"./").replaceAll("src=\"/", "src=\"./");
+	if (config.widget.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}`);
+	return sourceDir;
+};
+const stageWidget = (config, variant) => {
+	const sourceDir = assertBuildOutput(config);
+	rmSync(stageDir, {
+		force: true,
+		recursive: true
+	});
+	rmSync(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"));
+	rewriteConfigForWidget(variant);
+	rewriteIndexForWidget(config);
+};
+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");
+};
+const parseSdbDevice = (line) => {
+	const [id = "", state = "", label = ""] = line.split(/\s+/, 3);
+	return {
+		id,
+		label,
+		state
+	};
+};
+const resolveInstallTarget = (env) => {
+	if (env.target) return env.target;
+	const devices = listSdbDevices(env.sdb);
+	if (devices.length === 1) {
+		const [device] = devices;
+		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;
+};
+//#endregion
+//#region src/cli.ts
+const runSync = (operation) => Effect.sync(() => {
+	operation(loadContext());
+});
+const taizn = Command.make("taizn", {}, () => runSync((context) => {
+	packageWidget(context);
+}));
+const profile = Command.make("profile", {}, () => Effect.promise(async () => {
+	await createProfile(loadContext());
+}));
+const pack = Command.make("package", {}, () => runSync((context) => {
+	packageWidget(context);
+}));
+const install = Command.make("install", {}, () => runSync((context) => {
+	installWidget(context);
+}));
+const command = taizn.pipe(Command.withSubcommands([
+	profile,
+	pack,
+	install
+]));
+//#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";
+	}
+}
+//#endregion
+export {};

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@putdotio/taizn",
+  "version": "1.0.1",
+  "description": "A tiny CLI companion for interacting with Tizen ecosystem.",
+  "keywords": [
+    "cli",
+    "samsung",
+    "tizen",
+    "widget"
+  ],
+  "homepage": "https://github.com/putdotio/taizn#readme",
+  "bugs": {
+    "url": "https://github.com/putdotio/taizn/issues"
+  },
+  "license": "MIT",
+  "author": "put.io <devs@put.io>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/putdotio/taizn.git"
+  },
+  "bin": {
+    "taizn": "dist/taizn.mjs"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "vp pack src/taizn.ts",
+    "check": "vp check .",
+    "clean": "rm -rf .turbo coverage dist",
+    "dev": "vp pack src/taizn.ts --watch",
+    "live:test": "vp pack src/taizn.ts && node live-test/run-live-test.ts",
+    "live:test:install": "vp pack src/taizn.ts && node live-test/run-live-test.ts --install",
+    "live:test:profile": "vp pack src/taizn.ts && node live-test/run-live-test.ts --profile",
+    "prepack": "vp pack src/taizn.ts",
+    "smoke": "vp pack src/taizn.ts && node dist/taizn.mjs --version && node dist/taizn.mjs --help >/dev/null",
+    "test": "vp test --passWithNoTests",
+    "typecheck": "tsc --noEmit",
+    "verify": "vp check . && tsc --noEmit && vp pack src/taizn.ts && vp test --passWithNoTests && npm pack --dry-run"
+  },
+  "dependencies": {
+    "@effect/cli": "^0.75.1",
+    "@effect/platform": "^0.96.1",
+    "@effect/platform-node": "^0.106.0",
+    "@effect/printer": "^0.49.0",
+    "@effect/printer-ansi": "^0.49.0",
+    "effect": "^3.21.2"
+  },
+  "devDependencies": {
+    "@types/node": "^24.12.2",
+    "typescript": "^6.0.2",
+    "vite-plus": "^0.1.20",
+    "vitest": "^4.1.5"
+  },
+  "engines": {
+    "node": ">=24.14.0 <25"
+  },
+  "packageManager": "pnpm@11.0.0"
+}