@tamer4lynx/cli 0.0.1

package/dist/android/bundle.js

@@ -0,0 +1,99 @@
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import { resolveHostPaths, resolveDevAppPaths } from '../common/hostConfig';
+import android_autolink from './autolink';
+import android_create from './create';
+import android_syncDevClient from './syncDevClient';
+function findRepoRoot(start) {
+    let dir = path.resolve(start);
+    const root = path.parse(dir).root;
+    while (dir !== root) {
+        const pkgPath = path.join(dir, 'package.json');
+        if (fs.existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+                if (pkg.workspaces)
+                    return dir;
+            }
+            catch { }
+        }
+        dir = path.dirname(dir);
+    }
+    return start;
+}
+async function bundleAndDeploy(opts = {}) {
+    const target = (opts.target ?? 'host');
+    const origCwd = process.cwd();
+    let resolved;
+    try {
+        if (target === 'dev-app') {
+            const repoRoot = findRepoRoot(origCwd);
+            resolved = resolveDevAppPaths(repoRoot);
+            const devAppDir = resolved.projectRoot;
+            const androidDir = resolved.androidDir;
+            if (!fs.existsSync(androidDir)) {
+                console.log('📱 Creating Tamer Dev App Android project...');
+                await android_create({ target: 'dev-app' });
+            }
+            process.chdir(devAppDir);
+        }
+        else {
+            resolved = resolveHostPaths();
+        }
+    }
+    catch (error) {
+        console.error(`❌ Error loading configuration: ${error.message}`);
+        process.exit(1);
+    }
+    const { lynxProjectDir, lynxBundlePath, androidAssetsDir, devClientBundlePath, devMode } = resolved;
+    const destinationDir = androidAssetsDir;
+    android_autolink();
+    if (devMode === 'embedded') {
+        await android_syncDevClient();
+    }
+    try {
+        console.log('📦 Building Lynx project...');
+        execSync('npm run build', { stdio: 'inherit', cwd: lynxProjectDir });
+        console.log('✅ Build completed successfully.');
+    }
+    catch (error) {
+        console.error('❌ Build process failed.');
+        process.exit(1);
+    }
+    if (target === 'dev-app') {
+        process.chdir(origCwd);
+    }
+    if (target !== 'dev-app' && devMode === 'embedded' && devClientBundlePath && !fs.existsSync(devClientBundlePath)) {
+        const devClientDir = path.dirname(path.dirname(devClientBundlePath));
+        try {
+            console.log('📦 Building dev launcher (tamer-dev-client)...');
+            execSync('npm run build', { stdio: 'inherit', cwd: devClientDir });
+            console.log('✅ Dev launcher build completed.');
+        }
+        catch (error) {
+            console.error('❌ Dev launcher build failed.');
+            process.exit(1);
+        }
+    }
+    try {
+        fs.mkdirSync(destinationDir, { recursive: true });
+        if (target !== 'dev-app' && devMode === 'embedded' && devClientBundlePath && fs.existsSync(devClientBundlePath)) {
+            fs.copyFileSync(devClientBundlePath, path.join(destinationDir, 'dev-client.lynx.bundle'));
+            console.log(`✨ Copied dev-client.lynx.bundle to assets`);
+        }
+        if (!fs.existsSync(lynxBundlePath)) {
+            console.error(`❌ Build output not found at: ${lynxBundlePath}`);
+            process.exit(1);
+        }
+        fs.copyFileSync(lynxBundlePath, path.join(destinationDir, resolved.lynxBundleFile));
+        console.log(`✨ Copied ${resolved.lynxBundleFile} to assets`);
+    }
+    catch (error) {
+        console.error(`❌ Failed to copy bundle: ${error.message}`);
+        process.exit(1);
+    }
+}
+export default bundleAndDeploy;
+// // --- Main Execution ---
+// bundleAndDeploy();

package/dist/android/coreElements.js

@@ -0,0 +1,129 @@
+export function getLynxExplorerInputSource(packageName) {
+    return `package ${packageName}.core
+
+import android.content.Context
+import android.graphics.Color
+import android.text.Editable
+import android.text.TextWatcher
+import android.util.TypedValue
+import android.view.Gravity
+import android.view.View
+import android.view.inputmethod.EditorInfo
+import android.view.inputmethod.InputMethodManager
+import androidx.appcompat.widget.AppCompatEditText
+import com.lynx.react.bridge.Callback
+import com.lynx.react.bridge.ReadableMap
+import com.lynx.tasm.behavior.LynxContext
+import com.lynx.tasm.behavior.LynxProp
+import com.lynx.tasm.behavior.LynxUIMethod
+import com.lynx.tasm.behavior.LynxUIMethodConstants
+import com.lynx.tasm.behavior.ui.LynxUI
+import com.lynx.tasm.event.LynxCustomEvent
+
+class LynxExplorerInput(context: LynxContext) : LynxUI<AppCompatEditText>(context) {
+
+    override fun createView(context: Context): AppCompatEditText {
+        val view = AppCompatEditText(context)
+        view.setLines(1)
+        view.isSingleLine = true
+        view.gravity = Gravity.CENTER_VERTICAL
+        view.background = null
+        view.imeOptions = EditorInfo.IME_ACTION_NONE
+        view.setHorizontallyScrolling(true)
+        view.setPadding(0, 0, 0, 0)
+        view.setTextSize(TypedValue.COMPLEX_UNIT_SP, 16f)
+        view.minHeight = TypedValue.applyDimension(
+            TypedValue.COMPLEX_UNIT_DIP,
+            52f,
+            context.resources.displayMetrics
+        ).toInt()
+        view.setTextColor(Color.WHITE)
+        view.setHintTextColor(Color.argb(160, 255, 255, 255))
+        view.includeFontPadding = false
+        view.isFocusableInTouchMode = true
+        view.addTextChangedListener(object : TextWatcher {
+            override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) {}
+            override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) {}
+            override fun afterTextChanged(s: Editable?) {
+                emitEvent("input", mapOf("value" to (s?.toString() ?: "")))
+            }
+        })
+        view.setOnFocusChangeListener { _: View?, hasFocus: Boolean ->
+            if (!hasFocus) emitEvent("blur", null)
+        }
+        return view
+    }
+
+    override fun onLayoutUpdated() {
+        super.onLayoutUpdated()
+        val paddingTop = mPaddingTop + mBorderTopWidth
+        val paddingBottom = mPaddingBottom + mBorderBottomWidth
+        val paddingLeft = mPaddingLeft + mBorderLeftWidth
+        val paddingRight = mPaddingRight + mBorderRightWidth
+        mView.setPadding(paddingLeft, paddingTop, paddingRight, paddingBottom)
+    }
+
+    @LynxProp(name = "value")
+    fun setValue(value: String) {
+        if (value != mView.text.toString()) {
+            mView.setText(value)
+        }
+    }
+
+    @LynxProp(name = "placeholder")
+    fun setPlaceholder(value: String) {
+        mView.hint = value
+    }
+
+    @LynxUIMethod
+    fun focus(params: ReadableMap?, callback: Callback) {
+        if (mView.requestFocus()) {
+            if (showSoftInput()) {
+                callback.invoke(LynxUIMethodConstants.SUCCESS)
+            } else {
+                callback.invoke(LynxUIMethodConstants.UNKNOWN, "fail to show keyboard")
+            }
+        } else {
+            callback.invoke(LynxUIMethodConstants.UNKNOWN, "fail to focus")
+        }
+    }
+
+    private fun showSoftInput(): Boolean {
+        val imm = lynxContext.getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager
+            ?: return false
+        return imm.showSoftInput(mView, InputMethodManager.SHOW_IMPLICIT, null)
+    }
+
+    private fun emitEvent(name: String, detail: Map<String, Any>?) {
+        val event = LynxCustomEvent(sign, name)
+        detail?.forEach { (k, v) -> event.addDetail(k, v) }
+        lynxContext.eventEmitter.sendCustomEvent(event)
+    }
+}
+`;
+}
+export function getAppBarElementSource(packageName) {
+    return `package ${packageName}.core
+
+import android.content.Context
+import android.view.View
+import androidx.core.view.ViewCompat
+import androidx.core.view.WindowInsetsCompat
+import com.lynx.tasm.behavior.LynxContext
+import com.lynx.tasm.behavior.ui.LynxUI
+
+class AppBarElement(context: LynxContext) : LynxUI<View>(context) {
+    override fun createView(context: Context): View {
+        return View(context).apply {
+            minimumHeight = (56 * context.resources.displayMetrics.density).toInt()
+            ViewCompat.setOnApplyWindowInsetsListener(this) { v, insets ->
+                val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars())
+                v.setPadding(systemBars.left, systemBars.top, systemBars.right, 0)
+                insets
+            }
+            requestApplyInsets()
+        }
+    }
+}
+`;
+}

package/dist/android/create.js

@@ -0,0 +1,423 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { setupGradleWrapper } from "./getGradle";
+import { loadHostConfig, resolveDevMode, resolveHostPaths, resolveIconPaths } from "../common/hostConfig";
+import { fetchAndPatchApplication, fetchAndPatchTemplateProvider, getDevClientManager, getProjectActivity, getStandaloneMainActivity, } from "../explorer/patches";
+import { getDevServerPrefs } from "../explorer/devLauncher";
+import { getLynxExplorerInputSource } from "./coreElements";
+function findRepoRoot(start) {
+    let dir = path.resolve(start);
+    const root = path.parse(dir).root;
+    while (dir !== root) {
+        const pkgPath = path.join(dir, "package.json");
+        if (fs.existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+                if (pkg.workspaces)
+                    return dir;
+            }
+            catch { }
+        }
+        dir = path.dirname(dir);
+    }
+    return start;
+}
+const create = async (opts = {}) => {
+    const target = opts.target ?? "host";
+    const origCwd = process.cwd();
+    if (target === "dev-app") {
+        const repoRoot = findRepoRoot(origCwd);
+        const devAppDir = path.join(repoRoot, "packages", "tamer-dev-app");
+        if (!fs.existsSync(path.join(devAppDir, "tamer.config.json"))) {
+            console.error("❌ packages/tamer-dev-app/tamer.config.json not found.");
+            process.exit(1);
+        }
+        process.chdir(devAppDir);
+    }
+    let appName;
+    let packageName;
+    let androidSdk;
+    let config;
+    try {
+        config = loadHostConfig();
+        packageName = config.android?.packageName;
+        appName = config.android?.appName;
+        androidSdk = config.android?.sdk;
+        if (androidSdk && androidSdk.startsWith("~")) {
+            androidSdk = androidSdk.replace(/^~/, os.homedir());
+        }
+        if (!appName || !packageName) {
+            throw new Error('"android.appName" and "android.packageName" must be defined in tamer.config.json');
+        }
+    }
+    catch (error) {
+        console.error(`❌ Error loading configuration: ${error.message}`);
+        process.exit(1);
+    }
+    const packagePath = packageName.replace(/\./g, "/");
+    const gradleVersion = "8.14.2";
+    const androidDir = config.paths?.androidDir ?? "android";
+    const rootDir = path.join(process.cwd(), androidDir);
+    const appDir = path.join(rootDir, "app");
+    const mainDir = path.join(appDir, "src", "main");
+    const javaDir = path.join(mainDir, "java", packagePath);
+    const kotlinDir = path.join(mainDir, "kotlin", packagePath);
+    const kotlinGeneratedDir = path.join(kotlinDir, "generated");
+    const assetsDir = path.join(mainDir, "assets");
+    const themesDir = path.join(mainDir, "res", "values");
+    const gradleDir = path.join(rootDir, "gradle");
+    function writeFile(filePath, content, options) {
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, content.trimStart(), options?.encoding ?? "utf8");
+    }
+    // Clean up previous generation if it exists
+    if (fs.existsSync(rootDir)) {
+        console.log(`🧹 Removing existing directory: ${rootDir}`);
+        fs.rmSync(rootDir, { recursive: true, force: true });
+    }
+    console.log(`🚀 Creating a new Tamer4Lynx project in: ${rootDir}`);
+    // --- Start File Generation ---
+    // gradle/libs.versions.toml
+    writeFile(path.join(gradleDir, "libs.versions.toml"), `
+[versions]
+agp = "8.9.1"
+commonsCompress = "1.26.1"
+commonsLang3 = "3.14.0"
+fresco = "2.3.0"
+kotlin = "2.0.21"
+coreKtx = "1.10.1"
+junit = "4.13.2"
+junitVersion = "1.1.5"
+espressoCore = "3.5.1"
+appcompat = "1.6.1"
+lynx = "3.3.1"
+material = "1.10.0"
+activity = "1.8.0"
+constraintlayout = "2.1.4"
+okhttp = "4.9.0"
+primjs = "2.12.0"
+zxing = "4.3.0"
+
+[libraries]
+androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
+animated-base = { module = "com.facebook.fresco:animated-base", version.ref = "fresco" }
+animated-gif = { module = "com.facebook.fresco:animated-gif", version.ref = "fresco" }
+animated-webp = { module = "com.facebook.fresco:animated-webp", version.ref = "fresco" }
+commons-compress = { module = "org.apache.commons:commons-compress", version.ref = "commonsCompress" }
+commons-lang3 = { module = "org.apache.commons:commons-lang3", version.ref = "commonsLang3" }
+fresco = { module = "com.facebook.fresco:fresco", version.ref = "fresco" }
+junit = { group = "junit", name = "junit", version.ref = "junit" }
+androidx-junit = { group = "androidx.test.ext", name = "junit", version.ref = "junitVersion" }
+androidx-espresso-core = { group = "androidx.test.espresso", name = "espresso-core", version.ref = "espressoCore" }
+androidx-appcompat = { group = "androidx.appcompat", name = "appcompat", version.ref = "appcompat" }
+lynx = { module = "org.lynxsdk.lynx:lynx", version.ref = "lynx" }
+lynx-jssdk = { module = "org.lynxsdk.lynx:lynx-jssdk", version.ref = "lynx" }
+lynx-processor = { module = "org.lynxsdk.lynx:lynx-processor", version.ref = "lynx" }
+lynx-service-http = { module = "org.lynxsdk.lynx:lynx-service-http", version.ref = "lynx" }
+lynx-service-image = { module = "org.lynxsdk.lynx:lynx-service-image", version.ref = "lynx" }
+lynx-service-log = { module = "org.lynxsdk.lynx:lynx-service-log", version.ref = "lynx" }
+lynx-trace = { module = "org.lynxsdk.lynx:lynx-trace", version.ref = "lynx" }
+material = { group = "com.google.android.material", name = "material", version.ref = "material" }
+androidx-activity = { group = "androidx.activity", name = "activity", version.ref = "activity" }
+androidx-constraintlayout = { group = "androidx.constraintlayout", name = "constraintlayout", version.ref = "constraintlayout" }
+okhttp = { module = "com.squareup.okhttp3:okhttp", version.ref = "okhttp" }
+primjs = { module = "org.lynxsdk.lynx:primjs", version.ref = "primjs" }
+webpsupport = { module = "com.facebook.fresco:webpsupport", version.ref = "fresco" }
+zxing = { module = "com.journeyapps:zxing-android-embedded", version.ref = "zxing" }
+
+[plugins]
+android-application = { id = "com.android.application", version.ref = "agp" }
+kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
+kotlin-kapt = { id = "org.jetbrains.kotlin.kapt", version.ref = "kotlin" }
+`);
+    // settings.gradle.kts (with GENERATED block)
+    writeFile(path.join(rootDir, "settings.gradle.kts"), `
+pluginManagement {
+    repositories {
+        google {
+            content {
+                includeGroupByRegex("com\\\\.android.*")
+                includeGroupByRegex("com\\\\.google.*")
+                includeGroupByRegex("androidx.*")
+            }
+        }
+        mavenCentral()
+        gradlePluginPortal()
+    }
+}
+dependencyResolutionManagement {
+    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+
+rootProject.name = "${appName}"
+include(":app")
+
+// GENERATED AUTOLINK START
+// This section is automatically generated by Tamer4Lynx.
+// Manual edits will be overwritten.
+println("If you have native modules please run tamer android link")
+// GENERATED AUTOLINK END
+`);
+    // Root build.gradle
+    writeFile(path.join(rootDir, "build.gradle.kts"), `
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+plugins {
+    alias(libs.plugins.android.application) apply false
+    alias(libs.plugins.kotlin.android) apply false
+}
+`);
+    // gradle.properties
+    writeFile(path.join(rootDir, "gradle.properties"), `
+org.gradle.jvmargs=-Xmx2048m
+android.useAndroidX=true
+kotlin.code.style=official
+android.enableJetifier=true
+`);
+    // app/build.gradle.kts (UPDATED)
+    writeFile(path.join(appDir, "build.gradle.kts"), `
+plugins {
+    alias(libs.plugins.android.application)
+    alias(libs.plugins.kotlin.android)
+    id("org.jetbrains.kotlin.kapt")
+}
+
+android {
+    namespace = "${packageName}"
+    compileSdk = 35
+
+    defaultConfig {
+        applicationId = "${packageName}"
+        minSdk = 28
+        targetSdk = 35
+        versionCode = 1
+        versionName = "1.0"
+        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+        ndk {
+            abiFilters += listOf("armeabi-v7a", "arm64-v8a")
+        }
+    }
+
+    buildTypes {
+        release {
+            isMinifyEnabled = false
+            proguardFiles(
+                getDefaultProguardFile("proguard-android-optimize.txt"),
+                "proguard-rules.pro"
+            )
+        }
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = "17"
+    }
+
+    buildFeatures {
+        buildConfig = true
+    }
+
+    sourceSets {
+        getByName("main") {
+            jniLibs.srcDirs("src/main/jniLibs")
+        }
+    }
+}
+
+dependencies {
+    implementation(libs.androidx.core.ktx)
+    implementation(libs.androidx.appcompat)
+    implementation(libs.material)
+    implementation(libs.androidx.activity)
+    implementation(libs.androidx.constraintlayout)
+    testImplementation(libs.junit)
+    androidTestImplementation(libs.androidx.junit)
+    androidTestImplementation(libs.androidx.espresso.core)
+    implementation(libs.lynx)
+    implementation(libs.lynx.jssdk)
+    implementation(libs.lynx.trace)
+    implementation(libs.primjs)
+    implementation(libs.lynx.service.image)
+    implementation(libs.fresco)
+    implementation(libs.animated.gif)
+    implementation(libs.animated.webp)
+    implementation(libs.webpsupport)
+    implementation(libs.animated.base)
+    implementation(libs.lynx.service.log)
+    implementation(libs.lynx.service.http)
+    implementation(libs.okhttp)
+    implementation(libs.zxing)
+    kapt(libs.lynx.processor)
+    implementation(libs.commons.lang3)
+    implementation(libs.commons.compress)
+
+    // GENERATED AUTOLINK DEPENDENCIES START
+    // This section is automatically generated by Tamer4Lynx.
+    // Manual edits will be overwritten.
+    // GENERATED AUTOLINK DEPENDENCIES END
+}
+`);
+    // themes.xml
+    writeFile(path.join(themesDir, "themes.xml"), `
+<resources>
+    <style name="Theme.MyApp" parent="Theme.AppCompat.Light.NoActionBar">
+        <item name="android:statusBarColor">@android:color/transparent</item>
+        <item name="android:windowLightStatusBar">false</item>
+        <item name="android:navigationBarColor">@android:color/transparent</item>
+    </style>
+</resources>
+`);
+    const devMode = resolveDevMode(config);
+    const hasDevLauncher = devMode === "embedded";
+    const manifestActivities = hasDevLauncher
+        ? `
+        <activity android:name=".MainActivity" android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+        <activity android:name=".ProjectActivity" android:exported="false" android:taskAffinity="" android:launchMode="singleTask" android:documentLaunchMode="always" />
+`
+        : `
+        <activity android:name=".MainActivity" android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+`;
+    const manifestPermissions = hasDevLauncher
+        ? `    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.CAMERA" />`
+        : `    <uses-permission android:name="android.permission.INTERNET" />`;
+    const iconPaths = resolveIconPaths(process.cwd(), config);
+    const manifestIconAttrs = iconPaths
+        ? "        android:icon=\"@mipmap/ic_launcher\"\n        android:roundIcon=\"@mipmap/ic_launcher\"\n"
+        : "";
+    writeFile(path.join(mainDir, "AndroidManifest.xml"), `
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+${manifestPermissions}
+    <application
+        android:name=".App"
+        android:label="${appName}"
+${manifestIconAttrs}        android:usesCleartextTraffic="true"
+        android:theme="@style/Theme.MyApp">${manifestActivities}
+    </application>
+</manifest>
+`);
+    // Placeholder GeneratedLynxExtensions.kt
+    writeFile(path.join(kotlinGeneratedDir, "GeneratedLynxExtensions.kt"), `
+package ${packageName}.generated
+
+import android.content.Context
+import com.lynx.tasm.LynxEnv
+
+/**
+ * This file is generated by the Tamer4Lynx autolinker.
+ * Do not edit this file manually.
+ */
+object GeneratedLynxExtensions {
+    fun register(context: Context) {
+        // This will be populated by the autolinker.
+    }
+}
+`);
+    const devServer = config.devServer
+        ? {
+            host: config.devServer.host ?? "10.0.2.2",
+            port: config.devServer.port ?? config.devServer.httpPort ?? 3000,
+        }
+        : undefined;
+    const resolved = resolveHostPaths(process.cwd());
+    const vars = { packageName, appName, devMode, devServer, projectRoot: resolved.lynxProjectDir };
+    const [applicationSource, templateProviderSource] = await Promise.all([
+        fetchAndPatchApplication(vars),
+        fetchAndPatchTemplateProvider(vars),
+    ]);
+    writeFile(path.join(javaDir, "App.java"), applicationSource);
+    writeFile(path.join(javaDir, "TemplateProvider.java"), templateProviderSource);
+    writeFile(path.join(kotlinDir, "MainActivity.kt"), getStandaloneMainActivity(vars));
+    if (hasDevLauncher) {
+        writeFile(path.join(kotlinDir, "ProjectActivity.kt"), getProjectActivity(vars));
+    }
+    const coreDir = path.join(kotlinDir, "core");
+    writeFile(path.join(coreDir, "LynxExplorerInput.kt"), getLynxExplorerInputSource(packageName));
+    const devClientManagerSource = getDevClientManager(vars);
+    if (devClientManagerSource) {
+        writeFile(path.join(kotlinDir, "DevClientManager.kt"), devClientManagerSource);
+        writeFile(path.join(kotlinDir, "DevServerPrefs.kt"), getDevServerPrefs(vars));
+    }
+    if (iconPaths) {
+        const resDir = path.join(mainDir, "res");
+        if (iconPaths.android) {
+            const src = iconPaths.android;
+            const entries = fs.readdirSync(src, { withFileTypes: true });
+            for (const e of entries) {
+                const dest = path.join(resDir, e.name);
+                if (e.isDirectory()) {
+                    fs.cpSync(path.join(src, e.name), dest, { recursive: true });
+                }
+                else {
+                    fs.mkdirSync(resDir, { recursive: true });
+                    fs.copyFileSync(path.join(src, e.name), dest);
+                }
+            }
+            console.log("✅ Copied Android icon from tamer.config.json icon.android");
+        }
+        else if (iconPaths.source) {
+            const mipmapDensities = ["mdpi", "hdpi", "xhdpi", "xxhdpi", "xxxhdpi"];
+            for (const d of mipmapDensities) {
+                const dir = path.join(resDir, `mipmap-${d}`);
+                fs.mkdirSync(dir, { recursive: true });
+                fs.copyFileSync(iconPaths.source, path.join(dir, "ic_launcher.png"));
+            }
+            console.log("✅ Copied app icon from tamer.config.json icon.source");
+        }
+    }
+    // Create an empty assets directory so the project builds correctly
+    fs.mkdirSync(assetsDir, { recursive: true });
+    fs.writeFileSync(path.join(assetsDir, ".gitkeep"), "");
+    console.log(`✅ Android Kotlin project created at ${rootDir}`);
+    async function finalizeProjectSetup() {
+        if (androidSdk) {
+            try {
+                const sdkDirContent = `sdk.dir=${androidSdk.replace(/\\/g, "/")}`;
+                writeFile(path.join(rootDir, "local.properties"), sdkDirContent);
+                console.log("📦 Created local.properties from tamer.config.json.");
+            }
+            catch (err) {
+                console.error(`❌ Failed to create local.properties: ${err.message}`);
+            }
+        }
+        else {
+            const localPropsPath = path.join(process.cwd(), "local.properties");
+            if (fs.existsSync(localPropsPath)) {
+                try {
+                    fs.copyFileSync(localPropsPath, path.join(rootDir, "local.properties"));
+                    console.log("📦 Copied existing local.properties to the android project.");
+                }
+                catch (err) {
+                    console.error("❌ Failed to copy local.properties:", err);
+                }
+            }
+            else {
+                console.warn("⚠️ `android.sdk` not found in tamer.config.json. You may need to create local.properties manually.");
+            }
+        }
+        // The Gradle wrapper setup logic is now handled by the imported function
+        await setupGradleWrapper(rootDir, gradleVersion);
+    }
+    await finalizeProjectSetup();
+    if (target === "dev-app")
+        process.chdir(origCwd);
+};
+export default create;