@tamer4lynx/cli 0.0.1

package/dist/android/getGradle.js

@@ -0,0 +1,92 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { execSync } from 'child_process';
+import fetch from 'node-fetch';
+import AdmZip from 'adm-zip';
+/**
+ * Downloads and extracts a specific version of Gradle.
+ * @param gradleVersion The version of Gradle to download.
+ */
+export async function downloadGradle(gradleVersion) {
+    const gradleBaseUrl = `https://services.gradle.org/distributions/gradle-${gradleVersion}-bin.zip`;
+    // Place the gradle directory in the current working directory of the project
+    const downloadDir = path.join(process.cwd(), 'gradle');
+    const zipPath = path.join(downloadDir, `gradle-${gradleVersion}.zip`);
+    const extractedPath = path.join(downloadDir, `gradle-${gradleVersion}`);
+    // Check if Gradle is already downloaded and extracted
+    if (fs.existsSync(extractedPath)) {
+        console.log(`✅ Gradle ${gradleVersion} already exists at ${extractedPath}. Skipping download.`);
+        return;
+    }
+    if (!fs.existsSync(downloadDir)) {
+        fs.mkdirSync(downloadDir, { recursive: true });
+    }
+    console.log(`📥 Downloading Gradle ${gradleVersion} from ${gradleBaseUrl}...`);
+    const response = await fetch(gradleBaseUrl);
+    if (!response.ok || !response.body) {
+        throw new Error(`Failed to download: ${response.statusText}`);
+    }
+    const fileStream = fs.createWriteStream(zipPath);
+    await new Promise((resolve, reject) => {
+        response.body?.pipe(fileStream);
+        response.body?.on('error', reject);
+        fileStream.on('finish', resolve);
+    });
+    console.log('✅ Download complete. Extracting...');
+    try {
+        const zip = new AdmZip(zipPath);
+        zip.extractAllTo(downloadDir, true);
+    }
+    catch (err) {
+        console.error(`❌ Failed to extract Gradle zip: ${err}`);
+        throw err;
+    }
+    // Clean up the downloaded zip file
+    fs.unlinkSync(zipPath);
+    console.log(`✅ Gradle ${gradleVersion} extracted to ${extractedPath}`);
+}
+/**
+ * Sets up the Gradle wrapper for the project, detecting the OS for the correct executable.
+ * @param rootDir The root directory of the Android project.
+ * @param gradleVersion The version of Gradle to use.
+ */
+export async function setupGradleWrapper(rootDir, gradleVersion) {
+    try {
+        console.log("📦 Setting up Gradle wrapper...");
+        await downloadGradle(gradleVersion);
+        const gradleBinDir = path.join(process.cwd(), "gradle", `gradle-${gradleVersion}`, "bin");
+        // Detect OS and use the appropriate executable
+        const gradleExecutable = os.platform() === 'win32' ? 'gradle.bat' : 'gradle';
+        const gradleExecutablePath = path.join(gradleBinDir, gradleExecutable);
+        if (!fs.existsSync(gradleExecutablePath)) {
+            throw new Error(`Gradle executable not found at ${gradleExecutablePath}`);
+        }
+        // Make the gradle script executable on non-Windows systems
+        if (os.platform() !== 'win32') {
+            fs.chmodSync(gradleExecutablePath, "755");
+        }
+        console.log(`🚀 Executing Gradle wrapper in: ${rootDir}`);
+        execSync(`"${gradleExecutablePath}" wrapper`, {
+            cwd: rootDir,
+            stdio: "inherit",
+        });
+        console.log("✅ Gradle wrapper created successfully.");
+    }
+    catch (err) {
+        console.error("❌ Failed to create Gradle wrapper.", err.message);
+        // Exit the process if wrapper creation fails, as it's a critical step
+        process.exit(1);
+    }
+}
+/**
+ * Fetches the latest version of Gradle.
+ * @returns A promise that resolves to the latest Gradle version string.
+ */
+async function getLatestGradleVersion() {
+    const res = await fetch('https://services.gradle.org/versions/current');
+    if (!res.ok)
+        throw new Error(`Failed to get version: ${res.statusText}`);
+    const data = await res.json();
+    return data.version;
+}

package/dist/android/postinstall-and.js

@@ -0,0 +1,7 @@
+import fs from 'fs';
+import link from "./autolink";
+import path from 'path';
+const androidRoot = path.join(process.cwd(), 'android');
+if (fs.existsSync(androidRoot)) {
+    link();
+}

package/dist/android/postinstall.js

@@ -0,0 +1,7 @@
+import fs from 'fs';
+import link from "./autolink";
+import path from 'path';
+const androidRoot = path.join(process.cwd(), 'android');
+if (fs.existsSync(androidRoot)) {
+    link();
+}

package/dist/android/syncDevClient.js

@@ -0,0 +1,70 @@
+import fs from "fs";
+import path from "path";
+import { resolveHostPaths } from "../common/hostConfig";
+import { fetchAndPatchTemplateProvider, getDevClientManager, getProjectActivity, getStandaloneMainActivity, } from "../explorer/patches";
+import { getDevServerPrefs } from "../explorer/devLauncher";
+async function syncDevClient() {
+    let resolved;
+    try {
+        resolved = resolveHostPaths();
+    }
+    catch (error) {
+        console.error(`❌ Error loading configuration: ${error.message}`);
+        process.exit(1);
+    }
+    const { config, androidDir: rootDir } = resolved;
+    const packageName = config.android?.packageName;
+    const appName = config.android?.appName;
+    const packagePath = packageName.replace(/\./g, "/");
+    const javaDir = path.join(rootDir, "app", "src", "main", "java", packagePath);
+    const kotlinDir = path.join(rootDir, "app", "src", "main", "kotlin", packagePath);
+    if (!fs.existsSync(javaDir) || !fs.existsSync(kotlinDir)) {
+        console.error("❌ Android project not found. Run `tamer android create` first.");
+        process.exit(1);
+    }
+    const devMode = resolved.devMode;
+    const devServer = config.devServer
+        ? {
+            host: config.devServer.host ?? "10.0.2.2",
+            port: config.devServer.port ?? config.devServer.httpPort ?? 3000,
+        }
+        : undefined;
+    const vars = { packageName, appName, devMode, devServer, projectRoot: resolved.lynxProjectDir };
+    const [templateProviderSource] = await Promise.all([
+        fetchAndPatchTemplateProvider(vars),
+    ]);
+    fs.writeFileSync(path.join(javaDir, "TemplateProvider.java"), templateProviderSource);
+    fs.writeFileSync(path.join(kotlinDir, "MainActivity.kt"), getStandaloneMainActivity(vars));
+    const appDir = path.join(rootDir, "app");
+    const mainDir = path.join(appDir, "src", "main");
+    const manifestPath = path.join(mainDir, "AndroidManifest.xml");
+    const devClientManagerSource = getDevClientManager(vars);
+    if (devClientManagerSource) {
+        fs.writeFileSync(path.join(kotlinDir, "DevClientManager.kt"), devClientManagerSource);
+        fs.writeFileSync(path.join(kotlinDir, "DevServerPrefs.kt"), getDevServerPrefs(vars));
+        fs.writeFileSync(path.join(kotlinDir, "ProjectActivity.kt"), getProjectActivity(vars));
+        let manifest = fs.readFileSync(manifestPath, "utf-8");
+        const projectActivityEntry = '        <activity android:name=".ProjectActivity" android:exported="false" android:taskAffinity="" android:launchMode="singleTask" android:documentLaunchMode="always" />';
+        if (!manifest.includes("ProjectActivity")) {
+            manifest = manifest.replace(/(\s*)(<\/application>)/, `${projectActivityEntry}\n$1$2`);
+        }
+        else {
+            manifest = manifest.replace(/\s*<activity android:name="\.ProjectActivity"[^\/]*\/>\n?/g, projectActivityEntry + "\n");
+        }
+        fs.writeFileSync(manifestPath, manifest);
+        console.log("✅ Synced dev client (TemplateProvider, MainActivity, ProjectActivity, DevClientManager)");
+    }
+    else {
+        for (const f of ["DevClientManager.kt", "DevServerPrefs.kt", "ProjectActivity.kt"]) {
+            try {
+                fs.rmSync(path.join(kotlinDir, f));
+            }
+            catch { /* ignore */ }
+        }
+        let manifest = fs.readFileSync(manifestPath, "utf-8");
+        manifest = manifest.replace(/\s*<activity android:name="\.ProjectActivity"[^\/]*\/>\n?/g, "");
+        fs.writeFileSync(manifestPath, manifest);
+        console.log("✅ Synced (dev client disabled - set dev.mode: \"embedded\" in tamer.config.json to enable)");
+    }
+}
+export default syncDevClient;

package/dist/common/buildDevApp.js

@@ -0,0 +1,43 @@
+import fs from 'fs';
+import path from 'path';
+import { findDevClientPackage } from './hostConfig';
+import android_bundle from '../android/bundle';
+import android_build from '../android/build';
+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 buildDevApp(opts = {}) {
+    const cwd = process.cwd();
+    const repoRoot = findRepoRoot(cwd);
+    const devClientPkg = findDevClientPackage(repoRoot) ?? findDevClientPackage(cwd);
+    if (!devClientPkg) {
+        console.error('❌ tamer-dev-client is not installed in this project.');
+        console.error('   Add it as a dependency or ensure packages/tamer-dev-client exists in the repo.');
+        process.exit(1);
+    }
+    const platform = opts.platform ?? 'all';
+    if (platform === 'ios' || platform === 'all') {
+        console.log('⚠️  iOS dev-app build is not yet implemented. Skipping.');
+        if (platform === 'ios')
+            process.exit(0);
+    }
+    if (platform === 'android' || platform === 'all') {
+        await android_bundle({ target: 'dev-app' });
+        await android_build({ target: 'dev-app', install: opts.install });
+    }
+}
+export default buildDevApp;

package/dist/common/codegen.js

@@ -0,0 +1,69 @@
+import fs from 'fs';
+import path from 'path';
+import { loadExtensionConfig } from './config';
+function codegen() {
+    const cwd = process.cwd();
+    const config = loadExtensionConfig(cwd);
+    if (!config) {
+        console.error('❌ No lynx.ext.json or tamer.json found. Run from an extension package root.');
+        process.exit(1);
+    }
+    const srcDir = path.join(cwd, 'src');
+    const generatedDir = path.join(cwd, 'generated');
+    fs.mkdirSync(generatedDir, { recursive: true });
+    const dtsFiles = findDtsFiles(srcDir);
+    const modules = extractLynxModules(dtsFiles);
+    if (modules.length === 0) {
+        console.log('ℹ️ No @lynxmodule declarations found in src/. Add /** @lynxmodule */ to your module class.');
+        return;
+    }
+    for (const mod of modules) {
+        const tsContent = `export type { ${mod} } from '../src/index.js';
+`;
+        const outPath = path.join(generatedDir, `${mod}.ts`);
+        fs.writeFileSync(outPath, tsContent);
+        console.log(`✅ Generated ${outPath}`);
+    }
+    if (config.android) {
+        const androidGenerated = path.join(cwd, 'android', 'src', 'main', 'kotlin', config.android.moduleClassName.replace(/\./g, '/').replace(/[^/]+$/, ''), 'generated');
+        fs.mkdirSync(androidGenerated, { recursive: true });
+        console.log(`ℹ️ Android generated dir: ${androidGenerated} (spec generation coming soon)`);
+    }
+    if (config.ios) {
+        const iosGenerated = path.join(cwd, 'ios', 'generated');
+        fs.mkdirSync(iosGenerated, { recursive: true });
+        console.log(`ℹ️ iOS generated dir: ${iosGenerated} (spec generation coming soon)`);
+    }
+    console.log('✨ Codegen complete.');
+}
+function findDtsFiles(dir) {
+    const result = [];
+    if (!fs.existsSync(dir))
+        return result;
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const e of entries) {
+        const full = path.join(dir, e.name);
+        if (e.isDirectory())
+            result.push(...findDtsFiles(full));
+        else if (e.name.endsWith('.d.ts'))
+            result.push(full);
+    }
+    return result;
+}
+function extractLynxModules(files) {
+    const modules = [];
+    const seen = new Set();
+    for (const file of files) {
+        const content = fs.readFileSync(file, 'utf8');
+        const regex = /\/\*\*\s*@lynxmodule\s*\*\/\s*export\s+declare\s+class\s+(\w+)/g;
+        let m;
+        while ((m = regex.exec(content)) !== null) {
+            if (!seen.has(m[1])) {
+                seen.add(m[1]);
+                modules.push(m[1]);
+            }
+        }
+    }
+    return modules;
+}
+export default codegen;

package/dist/common/config.js

@@ -0,0 +1,113 @@
+import fs from 'fs';
+import path from 'path';
+const LYNX_EXT_JSON = 'lynx.ext.json';
+const TAMER_JSON = 'tamer.json';
+function loadLynxExtJson(packagePath) {
+    const p = path.join(packagePath, LYNX_EXT_JSON);
+    if (!fs.existsSync(p))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(p, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function loadTamerJson(packagePath) {
+    const p = path.join(packagePath, TAMER_JSON);
+    if (!fs.existsSync(p))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(p, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function loadExtensionConfig(packagePath) {
+    const lynxExt = loadLynxExtJson(packagePath);
+    const tamer = loadTamerJson(packagePath);
+    const raw = lynxExt ?? tamer;
+    if (!raw)
+        return null;
+    const normalized = {};
+    if (raw.platforms?.android || raw.android) {
+        const a = raw.platforms?.android ?? raw.android;
+        const moduleClassName = a?.moduleClassName ?? raw.android?.moduleClassName;
+        const elements = a?.elements ?? raw.android?.elements;
+        const permissions = a?.permissions ?? raw.android?.permissions;
+        if (moduleClassName || elements || permissions) {
+            normalized.android = {
+                ...(moduleClassName && { moduleClassName }),
+                sourceDir: a?.sourceDir ?? raw.android?.sourceDir ?? 'android',
+                ...(elements && Object.keys(elements).length > 0 && { elements }),
+                ...(permissions && Array.isArray(permissions) && permissions.length > 0 && { permissions }),
+            };
+        }
+    }
+    if (raw.platforms?.ios || raw.ios) {
+        const i = raw.platforms?.ios ?? raw.ios;
+        const moduleClassName = i?.moduleClassName ?? raw.ios?.moduleClassName;
+        if (moduleClassName) {
+            normalized.ios = {
+                moduleClassName,
+                podspecPath: i?.podspecPath ?? raw.ios?.podspecPath ?? '.',
+            };
+        }
+    }
+    if (Object.keys(normalized).length === 0)
+        return null;
+    return normalized;
+}
+export function hasExtensionConfig(packagePath) {
+    return fs.existsSync(path.join(packagePath, LYNX_EXT_JSON)) ||
+        fs.existsSync(path.join(packagePath, TAMER_JSON));
+}
+export function getNodeModulesPath(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;
+        }
+    }
+    return nodeModulesPath;
+}
+export function discoverNativeExtensions(projectRoot) {
+    const nodeModulesPath = getNodeModulesPath(projectRoot);
+    const result = [];
+    if (!fs.existsSync(nodeModulesPath))
+        return result;
+    const packageDirs = fs.readdirSync(nodeModulesPath);
+    const check = (name, packagePath) => {
+        if (!hasExtensionConfig(packagePath))
+            return;
+        const config = loadExtensionConfig(packagePath);
+        const className = config?.android?.moduleClassName;
+        if (className)
+            result.push({ packageName: name, moduleClassName: className });
+    };
+    for (const dirName of packageDirs) {
+        const fullPath = path.join(nodeModulesPath, dirName);
+        if (dirName.startsWith('@')) {
+            try {
+                for (const scopedDirName of fs.readdirSync(fullPath)) {
+                    check(`${dirName}/${scopedDirName}`, path.join(fullPath, scopedDirName));
+                }
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        else {
+            check(dirName, fullPath);
+        }
+    }
+    return result;
+}

package/dist/common/create.js

@@ -0,0 +1,170 @@
+import fs from 'fs';
+import path from 'path';
+import readline from 'readline';
+const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+function ask(question) {
+    return new Promise(resolve => rl.question(question, answer => resolve(answer.trim())));
+}
+async function create() {
+    console.log('Tamer4Lynx: Create Lynx Extension\n');
+    console.log('Select extension types (space to toggle, enter to confirm):');
+    console.log('  [ ] Native Module');
+    console.log('  [ ] Element');
+    console.log('  [ ] Service\n');
+    const includeModule = /^y(es)?$/i.test(await ask('Include Native Module? (Y/n): ') || 'y');
+    const includeElement = /^y(es)?$/i.test(await ask('Include Element? (y/N): ') || 'n');
+    const includeService = /^y(es)?$/i.test(await ask('Include Service? (y/N): ') || 'n');
+    if (!includeModule && !includeElement && !includeService) {
+        console.error('❌ At least one extension type is required.');
+        rl.close();
+        process.exit(1);
+    }
+    const extName = await ask('Extension package name (e.g. my-lynx-module): ');
+    if (!extName || !/^[a-z0-9-_]+$/.test(extName)) {
+        console.error('❌ Invalid package name. Use lowercase letters, numbers, hyphens, underscores.');
+        rl.close();
+        process.exit(1);
+    }
+    const packageName = await ask('Android package name (e.g. com.example.mymodule): ') || `com.example.${extName.replace(/-/g, '')}`;
+    const simpleModuleName = extName.split('-').map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join('') + 'Module';
+    const fullModuleClassName = `${packageName}.${simpleModuleName}`;
+    const cwd = process.cwd();
+    const root = path.join(cwd, extName);
+    if (fs.existsSync(root)) {
+        console.error(`❌ Directory ${extName} already exists.`);
+        rl.close();
+        process.exit(1);
+    }
+    fs.mkdirSync(root, { recursive: true });
+    const lynxExt = {
+        platforms: {
+            android: {
+                packageName,
+                moduleClassName: fullModuleClassName,
+                sourceDir: 'android',
+            },
+            ios: {
+                podspecPath: `ios/${extName}`,
+                moduleClassName: simpleModuleName,
+            },
+            web: {},
+        },
+    };
+    fs.writeFileSync(path.join(root, 'lynx.ext.json'), JSON.stringify(lynxExt, null, 2));
+    const pkg = {
+        name: extName,
+        version: '0.0.1',
+        type: 'module',
+        main: 'index.js',
+        description: `Lynx extension: ${extName}`,
+        scripts: { codegen: 't4l codegen' },
+        devDependencies: { typescript: '^5' },
+        peerDependencies: { typescript: '^5' },
+        engines: { node: '>=18' },
+    };
+    if (includeModule)
+        pkg.types = 'src/index.d.ts';
+    fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify(pkg, null, 2));
+    const pkgPath = packageName.replace(/\./g, '/');
+    if (includeModule) {
+        fs.mkdirSync(path.join(root, 'src'), { recursive: true });
+        fs.writeFileSync(path.join(root, 'src', 'index.d.ts'), `/** @lynxmodule */
+export declare class ${simpleModuleName} {
+  // Add your module methods here
+}
+`);
+        fs.mkdirSync(path.join(root, 'android', 'src', 'main', 'kotlin', pkgPath), { recursive: true });
+        fs.writeFileSync(path.join(root, 'android', 'build.gradle.kts'), `plugins {
+    id("com.android.library")
+    id("org.jetbrains.kotlin.android")
+}
+
+android {
+    namespace = "${packageName}"
+    compileSdk = 35
+    defaultConfig { minSdk = 28 }
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+    kotlinOptions { jvmTarget = "17" }
+}
+
+dependencies {
+    implementation(libs.lynx)
+    implementation(libs.lynx.jssdk)
+}
+`);
+        fs.writeFileSync(path.join(root, 'android', 'src', 'main', 'AndroidManifest.xml'), `<?xml version="1.0" encoding="utf-8"?>
+<manifest />
+`);
+        const ktContent = `package ${packageName}
+
+import android.content.Context
+import com.lynx.jsbridge.LynxMethod
+import com.lynx.jsbridge.LynxModule
+
+class ${simpleModuleName}(context: Context) : LynxModule(context) {
+
+    @LynxMethod
+    fun example(): String {
+        return "Hello from ${extName}"
+    }
+}
+`;
+        fs.writeFileSync(path.join(root, 'android', 'src', 'main', 'kotlin', pkgPath, `${simpleModuleName}.kt`), ktContent);
+        fs.mkdirSync(path.join(root, 'ios', extName, extName, 'Classes'), { recursive: true });
+        const podspec = `Pod::Spec.new do |s|
+  s.name             = '${extName}'
+  s.version          = '0.0.1'
+  s.summary          = 'Lynx extension: ${extName}'
+  s.homepage         = ''
+  s.license          = { :type => 'MIT' }
+  s.author           = ''
+  s.source           = { :git => '' }
+  s.platform         = :ios, '12.0'
+  s.source_files     = 'Classes/**/*'
+  s.dependency       'Lynx'
+end
+`;
+        fs.writeFileSync(path.join(root, 'ios', extName, `${extName}.podspec`), podspec);
+        const swiftContent = `import Foundation
+
+@objc public class ${simpleModuleName}: NSObject {
+    @objc public func example() -> String {
+        return "Hello from ${extName}"
+    }
+}
+`;
+        fs.writeFileSync(path.join(root, 'ios', extName, extName, 'Classes', `${simpleModuleName}.swift`), swiftContent);
+    }
+    fs.writeFileSync(path.join(root, 'index.js'), `'use strict';
+module.exports = {};
+`);
+    fs.writeFileSync(path.join(root, 'tsconfig.json'), JSON.stringify({
+        compilerOptions: { target: 'ES2020', module: 'ESNext', moduleResolution: 'bundler', strict: true },
+        include: ['src'],
+    }, null, 2));
+    fs.writeFileSync(path.join(root, 'README.md'), `# ${extName}
+
+Lynx extension for ${extName}.
+
+## Usage
+
+\`\`\`bash
+npm install ${extName}
+\`\`\`
+
+## Configuration
+
+This package uses \`lynx.ext.json\` (RFC-compliant) for autolinking.
+`);
+    console.log(`\n✅ Created extension at ${root}`);
+    console.log('\nNext steps:');
+    console.log(`  cd ${extName}`);
+    console.log('  npm install');
+    if (includeModule)
+        console.log('  npm run codegen');
+    rl.close();
+}
+export default create;