@tamer4lynx/cli 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Jordan Miller
+
+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,307 @@
+# Tamer4Lynx
+
+A CLI tool for creating, linking, and bundling Lynx native extensions. Aligned with the [Lynx Autolink RFC](https://github.com/lynx-family/lynx/discussions/2653).
+
+Inspired by [Expo](https://expo.dev) and [Expo Go](https://expo.dev/go).
+
+**Standalone app generation** follows patterns from [Lynx Explorer](https://github.com/lynx-family/lynx/tree/develop/explorer), patched for Maven-based standalone builds (no monorepo required). See [lynx#695](https://github.com/lynx-family/lynx/issues/695) for context.
+
+## Installation
+
+All Tamer packages are published under the `@tamer4lynx` scope on npm. Install the CLI globally:
+
+```bash
+npm i -g @tamer4lynx/cli
+```
+
+With pnpm or Bun:
+
+```bash
+pnpm add -g @tamer4lynx/cli
+bun add -g @tamer4lynx/cli
+```
+
+Or from GitHub (run `npm uninstall -g @tamer4lynx/cli` first if switching):
+
+```bash
+npm i -g tamer4lynx/tamer4lynx
+```
+
+Then run from your project directory (where `tamer.config.json` lives):
+
+```bash
+t4l init
+t4l start
+t4l android build --install
+```
+
+Tamer4Lynx uses configuration files to manage your project.
+
+### 1. Host Application (`tamer.config.json`)
+
+Create this file in the root of your repository to define your main application's properties.
+
+#### Quick Init (Recommended)
+
+You can interactively generate your config file using:
+
+```bash
+t4l init
+```
+Or simply run:
+```bash
+t4l
+```
+If no arguments are provided, the CLI will launch the interactive setup.
+
+The script will prompt for:
+- Android app name
+- Android package name
+- Android SDK path (supports `~`, `$ENV_VAR`)
+- Whether to use the same name and bundle ID for iOS as Android
+- iOS app name and bundle ID (if not using Android values)
+- Lynx project path (relative to project root, optional)
+
+Example output:
+```json
+{
+  "android": {
+    "appName": "MyApp",
+    "packageName": "com.example.myapp",
+    "sdk": "~/Library/Android/sdk"
+  },
+  "ios": {
+    "appName": "MyApp",
+    "bundleId": "com.example.MyApp"
+  },
+  "lynxProject": "packages/example",
+  "paths": {
+    "androidDir": "android",
+    "iosDir": "ios",
+    "lynxBundleRoot": "dist",
+    "lynxBundleFile": "main.lynx.bundle"
+  }
+}
+```
+
+**Dynamic Lynx discovery:** If `lynxProject` is omitted, Tamer4Lynx auto-discovers the Lynx project by scanning workspaces for `lynx.config.ts` or `@lynx-js/rspeedy`. Bundle output path is read from `lynx.config.ts` `output.distPath.root` when present.
+
+---
+
+### Asset Bundling
+
+**Note:** To ensure assets like images are bundled into the app, import them with the `?inline` suffix. For example:
+```js
+import logo from './assets/lynx-logo.png?inline';
+```
+This will include the asset directly in your app bundle.
+
+---
+
+### Show Help & Version
+
+```bash
+t4l --help
+t4l --version
+```
+
+### Documentation
+
+The docs site lives at `packages/docs`. From the repo root:
+
+```bash
+cd packages/docs && bun run dev
+```
+
+Build: `bun run build`. Output: `doc_build/`.
+
+---
+
+### **Extension Commands (RFC-compliant)**
+
+#### Create a Lynx Extension
+
+```bash
+t4l create
+```
+
+Scaffolds a new extension project with `lynx.ext.json`, Android/iOS native code, and optional Element/Service support.
+
+#### Code Generation
+
+```bash
+t4l codegen
+```
+
+Run from an extension package root to generate code from `@lynxmodule` declarations in `.d.ts` files.
+
+---
+
+### **Android Commands**
+
+| Command | Flags | Description |
+|---------|-------|-------------|
+| `t4l android create` | `-t, --target <host\|dev-app>` | Create Android project. Default: `host`. |
+| `t4l android link` | — | Link native modules to Gradle. Build runs this automatically. |
+| `t4l android bundle` | `-t, --target`, `-d, --debug`, `-r, --release` | Build Lynx bundle and copy to assets. Runs autolink first. |
+| `t4l android build` | `-i, --install`, `-t, --target`, `-e, --embeddable`, `-d, --debug`, `-r, --release` | Build APK. `--install` deploys to device. `--embeddable` outputs AAR to `embeddable/` for existing apps. |
+| `t4l android sync` | — | Sync dev client files from tamer.config.json. |
+| `t4l android inject` | `-f, --force` | Inject tamer-host templates. `--force` overwrites existing files. |
+
+### **iOS Commands**
+
+| Command | Flags | Description |
+|---------|-------|-------------|
+| `t4l ios create` | — | Create iOS project. |
+| `t4l ios link` | — | Link native modules to Podfile. Build runs this automatically. |
+| `t4l ios bundle` | `-t, --target`, `-d, --debug`, `-r, --release` | Build Lynx bundle and copy to iOS project. |
+| `t4l ios build` | `-t, --target`, `-e, --embeddable`, `-i, --install`, `-d, --debug`, `-r, --release` | Build iOS app. `--install` deploys to simulator. |
+| `t4l ios inject` | `-f, --force` | Inject tamer-host templates. `--force` overwrites existing files. |
+
+### **Unified Build** (`t4l build`)
+
+| Flag | Short | Default | Description |
+|------|-------|---------|-------------|
+| `--platform` | `-p` | `all` | `android`, `ios`, or `all` |
+| `--target` | `-t` | `dev-app` | `host` (production) or `dev-app` (QR scan, HMR) |
+| `--embeddable` | `-e` | — | Output to `embeddable/`: **AAR** (Android) + **CocoaPod** (iOS). Use with `--release`. |
+| `--debug` | `-d` | default | Debug build |
+| `--release` | `-r` | — | Release build (optimized) |
+| `--install` | `-i` | — | Install to device/simulator after build |
+
+### **Other Commands**
+
+| Command | Flags | Description |
+|---------|-------|-------------|
+| `t4l add [packages...]` | — | Add @tamer4lynx packages. Future: version tracking (Expo-style). |
+| `t4l add-core` | — | Add core packages (app-shell, screen, router, insets, transports, text-input, system-ui, icons). |
+| `t4l start` | `-v, --verbose` | Dev server with HMR. `--verbose` shows native + JS logs. |
+| `t4l link` | `-i, --ios`, `-a, --android`, `-s, --silent` | Link modules. `--ios`/`--android` limit to one platform. `--silent` for CI/postinstall. |
+| `t4l autolink-toggle` | — | Toggle `autolink` in tamer.config.json (postinstall linking). |
+
+See [Commands Reference](packages/docs/docs/commands.md) for full flag details.
+
+---
+
+## Automatic Linking on Install
+
+For the best experience, add a `postinstall` script to your project's `package.json`:
+
+```json
+"scripts": {
+  "postinstall": "t4l link --silent"
+}
+```
+
+---
+
+## Configuration
+
+- **Project:** `tamer.config.json` — host app (Android/iOS identity, paths, dev server). Create with `t4l init`.
+- **Component:** `tamer.config.ts` — Rsbuild plugins (routing, etc.). Used by tamer-plugin.
+- **Extension:** `lynx.ext.json` — native module registration per platform. Lives in each extension package.
+
+See [Configuration Reference](packages/docs/docs/docs/configuration.md) for field-by-field docs. lynx.ext.json follows the [Lynx Autolink RFC](https://github.com/lynx-family/lynx/discussions/2653); [contribute to the RFC](https://github.com/lynx-family/lynx/discussions/2653) if you want to help improve it.
+
+## Extension Configuration
+
+Extensions are discovered via **lynx.ext.json** (RFC standard) or **tamer.json** (legacy).
+
+### lynx.ext.json (recommended)
+
+```json
+{
+  "platforms": {
+    "android": {
+      "packageName": "com.example.mymodule",
+      "moduleClassName": "com.example.mymodule.MyModule",
+      "sourceDir": "android"
+    },
+    "ios": {
+      "podspecPath": "ios/mymodule",
+      "moduleClassName": "MyModule"
+    },
+    "web": {}
+  }
+}
+```
+
+### tamer.json (legacy, still supported)
+
+```json
+{
+  "android": {
+    "moduleClassName": "com.my-awesome-module.MyAwesomeModule",
+    "sourceDir": "android"
+  },
+  "ios": {
+    "podspecPath": "ios/mymodule",
+    "moduleClassName": "MyModule"
+  }
+}
+```
+
+---
+
+## Roadmap
+
+* [x] Fix iOS linking
+* [x] lynx.ext.json support (RFC #2653)
+* [x] create-lynx-extension command
+* [x] codegen command
+* [ ] Full codegen (Android Spec, iOS Spec, web)
+
+---
+
+## Native Module References
+
+Install from npm and run `t4l link` after adding to your app:
+
+| Package | Install | Description |
+|---------|---------|-------------|
+| [@tamer4lynx/jiggle](https://www.npmjs.com/package/@tamer4lynx/jiggle) | `npm i @tamer4lynx/jiggle` | Vibration/haptic |
+| [@tamer4lynx/lynxwebsockets](https://www.npmjs.com/package/@tamer4lynx/lynxwebsockets) | `npm i @tamer4lynx/lynxwebsockets` | WebSocket native bridge |
+| [@tamer4lynx/tamer-host](https://www.npmjs.com/package/@tamer4lynx/tamer-host) | `npm i @tamer4lynx/tamer-host` | Production Lynx host templates |
+| [tamer-dev-app](https://github.com/tamer4lynx/tamer-dev-app) | workspace | Dev app (QR scan, HMR) |
+| [@tamer4lynx/tamer-dev-client](https://www.npmjs.com/package/@tamer4lynx/tamer-dev-client) | `npm i @tamer4lynx/tamer-dev-client` | Dev launcher UI, discovery |
+| [@tamer4lynx/tamer-plugin](https://www.npmjs.com/package/@tamer4lynx/tamer-plugin) | `npm i @tamer4lynx/tamer-plugin` | Rsbuild plugin middleman |
+| [@tamer4lynx/tamer-router](https://www.npmjs.com/package/@tamer4lynx/tamer-router) | `npm i @tamer4lynx/tamer-router` | File-based routing, Stack/Tabs |
+| [@tamer4lynx/tamer-icons](https://www.npmjs.com/package/@tamer4lynx/tamer-icons) | `npm i @tamer4lynx/tamer-icons` | Icon fonts (Material, Font Awesome) |
+| [@tamer4lynx/tamer-insets](https://www.npmjs.com/package/@tamer4lynx/tamer-insets) | `npm i @tamer4lynx/tamer-insets` | System insets, keyboard state |
+| [@tamer4lynx/tamer-system-ui](https://www.npmjs.com/package/@tamer4lynx/tamer-system-ui) | `npm i @tamer4lynx/tamer-system-ui` | Status bar, navigation bar |
+| [@tamer4lynx/tamer-app-shell](https://www.npmjs.com/package/@tamer4lynx/tamer-app-shell) | `npm i @tamer4lynx/tamer-app-shell` | AppBar, TabBar, Content layout |
+| [@tamer4lynx/tamer-text-input](https://www.npmjs.com/package/@tamer4lynx/tamer-text-input) | `npm i @tamer4lynx/tamer-text-input` | React TextInput |
+| [@tamer4lynx/tamer-auth](https://www.npmjs.com/package/@tamer4lynx/tamer-auth) | `npm i @tamer4lynx/tamer-auth` | OAuth 2.0 / OIDC |
+| [@tamer4lynx/tamer-biometric](https://www.npmjs.com/package/@tamer4lynx/tamer-biometric) | `npm i @tamer4lynx/tamer-biometric` | Fingerprint, Face ID |
+| [@tamer4lynx/tamer-display-browser](https://www.npmjs.com/package/@tamer4lynx/tamer-display-browser) | `npm i @tamer4lynx/tamer-display-browser` | Open URLs in system browser |
+| [@tamer4lynx/tamer-linking](https://www.npmjs.com/package/@tamer4lynx/tamer-linking) | `npm i @tamer4lynx/tamer-linking` | Deep linking |
+| [@tamer4lynx/tamer-screen](https://www.npmjs.com/package/@tamer4lynx/tamer-screen) | `npm i @tamer4lynx/tamer-screen` | SafeArea, Screen, AvoidKeyboard |
+| [@tamer4lynx/tamer-secure-store](https://www.npmjs.com/package/@tamer4lynx/tamer-secure-store) | `npm i @tamer4lynx/tamer-secure-store` | Secure key-value storage |
+| [@tamer4lynx/tamer-transports](https://www.npmjs.com/package/@tamer4lynx/tamer-transports) | `npm i @tamer4lynx/tamer-transports` | Fetch, WebSocket, EventSource polyfills |
+
+The iOS autolinking feature runs `pod install` automatically.
+
+---
+
+## Examples
+
+- [Example LynxJS project with Jiggle and Lynx-Websockets](https://github.com/tamer4lynx/tamer4lynx/tree/main/packages/example)
+## Contributing
+
+Contributions are welcome! To develop on Tamer4Lynx:
+
+```bash
+git clone https://github.com/tamer4lynx/tamer4lynx.git
+cd tamer4lynx
+npm install
+```
+
+Please feel free to submit issues or pull requests.
+
+---
+
+## Support
+
+If you find this tool helpful, consider supporting its development. 
+
+<a href="https://ko-fi.com/nanofuxion"> <img src="https://ko-fi.com/img/githubbutton_sm.svg" alt="Support me on Ko-fi"> </a>

package/dist/android/autolink.js

@@ -0,0 +1,272 @@
+import fs from 'fs';
+import path from 'path';
+import { loadExtensionConfig, hasExtensionConfig } from '../common/config';
+import { resolveHostPaths } from '../common/hostConfig';
+import { getLynxExplorerInputSource, getAppBarElementSource, } from './coreElements';
+const autolink = () => {
+    let resolved;
+    try {
+        resolved = resolveHostPaths();
+        if (!resolved.config.android?.packageName) {
+            throw new Error('"android.packageName" must be defined in tamer.config.json');
+        }
+    }
+    catch (error) {
+        console.error(`❌ Error loading configuration: ${error.message}`);
+        process.exit(1);
+    }
+    const { androidDir: appAndroidPath, config } = resolved;
+    const packageName = config.android.packageName;
+    const projectRoot = resolved.projectRoot;
+    let nodeModulesPath = path.join(projectRoot, 'node_modules');
+    const workspaceRoot = path.join(projectRoot, '..', '..');
+    const rootNodeModules = path.join(workspaceRoot, 'node_modules');
+    if (fs.existsSync(path.join(workspaceRoot, 'package.json')) && fs.existsSync(rootNodeModules) && path.basename(path.dirname(projectRoot)) === 'packages') {
+        nodeModulesPath = rootNodeModules;
+    }
+    else if (!fs.existsSync(nodeModulesPath)) {
+        const altRoot = path.join(projectRoot, '..', '..');
+        const altNodeModules = path.join(altRoot, 'node_modules');
+        if (fs.existsSync(path.join(altRoot, 'package.json')) && fs.existsSync(altNodeModules)) {
+            nodeModulesPath = altNodeModules;
+        }
+    }
+    // --- Core Logic ---
+    /**
+     * Replaces the content of a file between specified start and end markers.
+     * @param filePath The path to the file to update.
+     * @param newContent The new content to insert between the markers.
+     * @param startMarker The starting delimiter.
+     * @param endMarker The ending delimiter.
+     */
+    function updateGeneratedSection(filePath, newContent, startMarker, endMarker) {
+        if (!fs.existsSync(filePath)) {
+            console.warn(`⚠️ File not found, skipping update: ${filePath}`);
+            return;
+        }
+        let fileContent = fs.readFileSync(filePath, 'utf8');
+        // Escape special characters in markers for RegExp
+        const escapedStartMarker = startMarker.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const escapedEndMarker = endMarker.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const regex = new RegExp(`${escapedStartMarker}[\\s\\S]*?${escapedEndMarker}`, 'g');
+        const replacementBlock = `${startMarker}\n${newContent}\n${endMarker}`;
+        if (regex.test(fileContent)) {
+            fileContent = fileContent.replace(regex, replacementBlock);
+        }
+        else {
+            console.warn(`⚠️ Could not find autolink markers in ${path.basename(filePath)}. Appending to the end of the file.`);
+            fileContent += `\n${replacementBlock}\n`;
+        }
+        fs.writeFileSync(filePath, fileContent);
+        console.log(`✅ Updated autolinked section in ${path.basename(filePath)}`);
+    }
+    function findExtensionPackages() {
+        const packages = [];
+        if (!fs.existsSync(nodeModulesPath)) {
+            console.warn('⚠️ node_modules directory not found. Skipping autolinking.');
+            return [];
+        }
+        const packageDirs = fs.readdirSync(nodeModulesPath);
+        for (const dirName of packageDirs) {
+            const fullPath = path.join(nodeModulesPath, dirName);
+            const checkPackage = (name, packagePath) => {
+                if (!hasExtensionConfig(packagePath))
+                    return;
+                const config = loadExtensionConfig(packagePath);
+                if (config?.android) {
+                    packages.push({ name, config, packagePath });
+                }
+            };
+            if (dirName.startsWith('@')) {
+                try {
+                    const scopedDirs = fs.readdirSync(fullPath);
+                    for (const scopedDirName of scopedDirs) {
+                        const scopedPackagePath = path.join(fullPath, scopedDirName);
+                        checkPackage(`${dirName}/${scopedDirName}`, scopedPackagePath);
+                    }
+                }
+                catch (e) {
+                    console.warn(`⚠️ Could not read scoped package directory ${fullPath}: ${e.message}`);
+                }
+            }
+            else {
+                checkPackage(dirName, fullPath);
+            }
+        }
+        return packages;
+    }
+    /**
+     * Generates the Gradle settings script content and updates settings.gradle.kts.
+     * @param packages The list of discovered native packages.
+     */
+    function updateSettingsGradle(packages) {
+        const settingsFilePath = path.join(appAndroidPath, 'settings.gradle.kts');
+        let scriptContent = `// This section is automatically generated by Tamer4Lynx.\n// Manual edits will be overwritten.`;
+        const androidPackages = packages.filter(p => p.config.android);
+        if (androidPackages.length > 0) {
+            androidPackages.forEach(pkg => {
+                // Sanitize package name for Gradle: @org/name -> org_name
+                const gradleProjectName = pkg.name.replace(/^@/, '').replace(/\//g, '_');
+                const sourceDir = pkg.config.android?.sourceDir || 'android';
+                // Use forward slashes for Gradle paths, even on Windows
+                const projectPath = path.join(pkg.packagePath, sourceDir).replace(/\\/g, '/');
+                const relativePath = path.relative(appAndroidPath, projectPath).replace(/\\/g, '/');
+                scriptContent += `\ninclude(":${gradleProjectName}")`;
+                scriptContent += `\nproject(":${gradleProjectName}").projectDir = file("${relativePath}")`;
+            });
+        }
+        else {
+            scriptContent += `\nprintln("No native modules found by Tamer4Lynx autolinker.")`;
+        }
+        updateGeneratedSection(settingsFilePath, scriptContent.trim(), '// GENERATED AUTOLINK START', '// GENERATED AUTOLINK END');
+    }
+    /**
+     * Generates the app-level dependencies and updates app/build.gradle.kts.
+     * @param packages The list of discovered native packages.
+     */
+    function updateAppBuildGradle(packages) {
+        const appBuildGradlePath = path.join(appAndroidPath, 'app', 'build.gradle.kts');
+        const androidPackages = packages.filter(p => p.config.android);
+        const implementationLines = androidPackages
+            .map(p => {
+            // Sanitize package name for Gradle: @org/name -> org_name
+            const gradleProjectName = p.name.replace(/^@/, '').replace(/\//g, '_');
+            return `    implementation(project(":${gradleProjectName}"))`;
+        })
+            .join('\n');
+        const scriptContent = `// This section is automatically generated by Tamer4Lynx.\n    // Manual edits will be overwritten.\n${implementationLines || '    // No native dependencies found to link.'}`;
+        updateGeneratedSection(appBuildGradlePath, scriptContent, '// GENERATED AUTOLINK DEPENDENCIES START', '// GENERATED AUTOLINK DEPENDENCIES END');
+    }
+    /**
+     * Generates a self-contained GeneratedLynxExtensions.kt file with all necessary imports and registrations.
+     * @param packages The list of discovered native packages.
+     * @param projectPackage The package name of the main Android app, from tamer.config.json.
+     */
+    function generateKotlinExtensionsFile(packages, projectPackage) {
+        const packagePath = projectPackage.replace(/\./g, '/');
+        const generatedDir = path.join(appAndroidPath, 'app', 'src', 'main', 'kotlin', packagePath, 'generated');
+        const kotlinExtensionsPath = path.join(generatedDir, 'GeneratedLynxExtensions.kt');
+        const modulePackages = packages.filter(p => p.config.android?.moduleClassName);
+        const elementPackages = packages.filter(p => p.config.android?.elements && Object.keys(p.config.android.elements).length > 0)
+            .map(p => ({
+            ...p,
+            config: {
+                ...p.config,
+                android: {
+                    ...p.config.android,
+                    elements: Object.fromEntries(Object.entries(p.config.android.elements).filter(([tag]) => tag !== 'explorer-input' && tag !== 'input')),
+                },
+            },
+        }))
+            .filter(p => Object.keys(p.config.android?.elements ?? {}).length > 0);
+        const coreElementImport = `import ${projectPackage}.core.LynxExplorerInput
+import ${projectPackage}.core.AppBarElement`;
+        const coreElementRegistration = `        LynxEnv.inst().addBehavior(object : com.lynx.tasm.behavior.Behavior("input") {
+            override fun createUI(context: com.lynx.tasm.behavior.LynxContext): com.lynx.tasm.behavior.ui.LynxUI<*> {
+                return LynxExplorerInput(context)
+            }
+        })
+        LynxEnv.inst().addBehavior(object : com.lynx.tasm.behavior.Behavior("explorer-input") {
+            override fun createUI(context: com.lynx.tasm.behavior.LynxContext): com.lynx.tasm.behavior.ui.LynxUI<*> {
+                return LynxExplorerInput(context)
+            }
+        })
+        LynxEnv.inst().addBehavior(object : com.lynx.tasm.behavior.Behavior("app-bar") {
+            override fun createUI(context: com.lynx.tasm.behavior.LynxContext): com.lynx.tasm.behavior.ui.LynxUI<*> {
+                return AppBarElement(context)
+            }
+        })`;
+        const moduleImports = modulePackages
+            .map(p => `import ${p.config.android.moduleClassName}`)
+            .join('\n');
+        const elementImports = elementPackages.flatMap(p => Object.values(p.config.android.elements).map(cls => `import ${cls}`)).filter((v, i, a) => a.indexOf(v) === i).join('\n');
+        const moduleRegistrations = modulePackages
+            .map(p => {
+            const fullClassName = p.config.android.moduleClassName;
+            const simpleClassName = fullClassName.split('.').pop();
+            return `        LynxEnv.inst().registerModule("${simpleClassName}", ${simpleClassName}::class.java)`;
+        })
+            .join('\n');
+        const behaviorRegistrations = elementPackages.flatMap(p => Object.entries(p.config.android.elements).map(([tag, fullClassName]) => {
+            const simpleClassName = fullClassName.split('.').pop();
+            return `        LynxEnv.inst().addBehavior(object : com.lynx.tasm.behavior.Behavior("${tag}") {
+            override fun createUI(context: com.lynx.tasm.behavior.LynxContext): com.lynx.tasm.behavior.ui.LynxUI<*> {
+                return ${simpleClassName}(context)
+            }
+        })`;
+        })).join('\n');
+        const allRegistrations = [moduleRegistrations, behaviorRegistrations, coreElementRegistration].filter(Boolean).join('\n');
+        const kotlinContent = `package ${projectPackage}.generated
+
+import android.content.Context
+import com.lynx.tasm.LynxEnv
+${coreElementImport}
+${moduleImports}
+${elementImports}
+
+/**
+ * This file is generated by the Tamer4Lynx autolinker.
+ * Do not edit this file manually.
+ */
+object GeneratedLynxExtensions {
+    fun register(context: Context) {
+${allRegistrations}
+    }
+}
+`;
+        // Ensure the `generated` directory exists before writing the file
+        fs.mkdirSync(generatedDir, { recursive: true });
+        fs.writeFileSync(kotlinExtensionsPath, kotlinContent.trimStart());
+        console.log(`✅ Generated Kotlin extensions at ${kotlinExtensionsPath}`);
+    }
+    // --- Main Execution ---
+    function run() {
+        console.log('🔎 Finding Lynx extension packages (lynx.ext.json / tamer.json)...');
+        const packages = findExtensionPackages();
+        if (packages.length > 0) {
+            console.log(`Found ${packages.length} package(s): ${packages.map(p => p.name).join(', ')}`);
+        }
+        else {
+            console.log('ℹ️ No Tamer4Lynx native packages found.');
+        }
+        updateSettingsGradle(packages);
+        updateAppBuildGradle(packages);
+        const coreDir = path.join(appAndroidPath, 'app', 'src', 'main', 'kotlin', packageName.replace(/\./g, '/'), 'core');
+        fs.mkdirSync(coreDir, { recursive: true });
+        fs.writeFileSync(path.join(coreDir, 'LynxExplorerInput.kt'), getLynxExplorerInputSource(packageName));
+        fs.writeFileSync(path.join(coreDir, 'AppBarElement.kt'), getAppBarElementSource(packageName));
+        console.log('✅ Synced core elements (input, explorer-input, app-bar)');
+        generateKotlinExtensionsFile(packages, packageName);
+        syncManifestPermissions(packages);
+        console.log('✨ Autolinking complete.');
+    }
+    function syncManifestPermissions(packages) {
+        const manifestPath = path.join(appAndroidPath, 'app', 'src', 'main', 'AndroidManifest.xml');
+        if (!fs.existsSync(manifestPath))
+            return;
+        const allPermissions = new Set();
+        for (const pkg of packages) {
+            const perms = pkg.config.android?.permissions;
+            if (Array.isArray(perms)) {
+                for (const p of perms) {
+                    const name = p.startsWith('android.permission.') ? p : `android.permission.${p}`;
+                    allPermissions.add(name);
+                }
+            }
+        }
+        if (allPermissions.size === 0)
+            return;
+        let manifest = fs.readFileSync(manifestPath, 'utf8');
+        const existingMatch = [...manifest.matchAll(/<uses-permission android:name="(android\.permission\.\w+)"\s*\/>/g)];
+        const existing = new Set(existingMatch.map((m) => m[1]));
+        const toAdd = [...allPermissions].filter((p) => !existing.has(p));
+        if (toAdd.length === 0)
+            return;
+        const newLines = toAdd.map((p) => `    <uses-permission android:name="${p}" />`).join('\n');
+        manifest = manifest.replace(/(\s*)(<application)/, `${newLines}\n$1$2`);
+        fs.writeFileSync(manifestPath, manifest);
+        console.log(`✅ Synced manifest permissions: ${toAdd.map((p) => p.split('.').pop()).join(', ')}`);
+    }
+    run();
+};
+export default autolink;

package/dist/android/build.js

@@ -0,0 +1,36 @@
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import { resolveHostPaths, resolveDevAppPaths } from '../common/hostConfig';
+import android_bundle from './bundle';
+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 buildApk(opts = {}) {
+    const target = opts.target ?? 'host';
+    const resolved = target === 'dev-app'
+        ? resolveDevAppPaths(findRepoRoot(process.cwd()))
+        : resolveHostPaths();
+    await android_bundle({ target });
+    const androidDir = resolved.androidDir;
+    const gradlew = path.join(androidDir, process.platform === 'win32' ? 'gradlew.bat' : 'gradlew');
+    const task = opts.install ? 'installDebug' : 'assembleDebug';
+    console.log(`\n🔨 Building ${opts.install ? 'and installing' : ''} APK...`);
+    execSync(`"${gradlew}" ${task}`, { stdio: 'inherit', cwd: androidDir });
+    console.log(`✅ APK ${opts.install ? 'installed' : 'built'} successfully.`);
+}
+export default buildApk;