@tamer4lynx/cli 0.0.1

package/dist/common/devServer.js

@@ -0,0 +1,231 @@
+import { spawn } from 'child_process';
+import fs from 'fs';
+import http from 'http';
+import os from 'os';
+import path from 'path';
+import { WebSocketServer } from 'ws';
+import { discoverNativeExtensions } from './config';
+import { resolveHostPaths, resolveIconPaths } from './hostConfig';
+const DEFAULT_PORT = 3000;
+function getLanIp() {
+    const nets = os.networkInterfaces();
+    for (const name of Object.keys(nets)) {
+        const addrs = nets[name];
+        if (!addrs)
+            continue;
+        for (const a of addrs) {
+            if (a.family === 'IPv4' && !a.internal)
+                return a.address;
+        }
+    }
+    return 'localhost';
+}
+async function startDevServer() {
+    const resolved = resolveHostPaths();
+    const { projectRoot, lynxProjectDir, lynxBundlePath, lynxBundleFile, config } = resolved;
+    const distDir = path.dirname(lynxBundlePath);
+    const port = config.devServer?.port ?? config.devServer?.httpPort ?? DEFAULT_PORT;
+    let buildProcess = null;
+    function runBuild() {
+        return new Promise((resolve, reject) => {
+            buildProcess = spawn('npm', ['run', 'build'], {
+                cwd: lynxProjectDir,
+                stdio: 'pipe',
+            });
+            let stderr = '';
+            buildProcess.stderr?.on('data', (d) => { stderr += d.toString(); });
+            buildProcess.on('close', (code) => {
+                buildProcess = null;
+                if (code === 0)
+                    resolve();
+                else
+                    reject(new Error(stderr || `Build exited ${code}`));
+            });
+        });
+    }
+    const projectName = path.basename(lynxProjectDir);
+    const basePath = `/${projectName}`;
+    const iconPaths = resolveIconPaths(projectRoot, config);
+    let iconFilePath = null;
+    if (iconPaths?.source && fs.statSync(iconPaths.source).isFile()) {
+        iconFilePath = iconPaths.source;
+    }
+    else if (iconPaths?.android) {
+        const androidIcon = path.join(iconPaths.android, 'mipmap-xxxhdpi', 'ic_launcher.png');
+        if (fs.existsSync(androidIcon))
+            iconFilePath = androidIcon;
+    }
+    else if (iconPaths?.ios) {
+        const iosIcon = path.join(iconPaths.ios, 'Icon-1024.png');
+        if (fs.existsSync(iosIcon))
+            iconFilePath = iosIcon;
+    }
+    const iconExt = iconFilePath ? path.extname(iconFilePath) || '.png' : '';
+    const iconMime = {
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.webp': 'image/webp',
+        '.ico': 'image/x-icon',
+    };
+    const httpServer = http.createServer((req, res) => {
+        let reqPath = (req.url || '/').split('?')[0];
+        if (reqPath === `${basePath}/status`) {
+            res.setHeader('Content-Type', 'text/plain');
+            res.setHeader('Access-Control-Allow-Origin', '*');
+            res.end('packager-status:running');
+            return;
+        }
+        if (reqPath === `${basePath}/meta.json`) {
+            const lanIp = getLanIp();
+            const nativeModules = discoverNativeExtensions(projectRoot);
+            const meta = {
+                name: projectName,
+                slug: projectName,
+                bundleUrl: `http://${lanIp}:${port}${basePath}/${lynxBundleFile}`,
+                bundleFile: lynxBundleFile,
+                hostUri: `http://${lanIp}:${port}${basePath}`,
+                debuggerHost: `${lanIp}:${port}`,
+                developer: { tool: 'tamer4lynx' },
+                packagerStatus: 'running',
+                nativeModules: nativeModules.map((m) => ({ packageName: m.packageName, moduleClassName: m.moduleClassName })),
+            };
+            if (iconFilePath) {
+                meta.icon = `http://${lanIp}:${port}${basePath}/icon${iconExt}`;
+            }
+            res.setHeader('Content-Type', 'application/json');
+            res.setHeader('Access-Control-Allow-Origin', '*');
+            res.end(JSON.stringify(meta, null, 2));
+            return;
+        }
+        if (iconFilePath && (reqPath === `${basePath}/icon` || reqPath === `${basePath}/icon${iconExt}`)) {
+            fs.readFile(iconFilePath, (err, data) => {
+                if (err) {
+                    res.writeHead(404);
+                    res.end();
+                    return;
+                }
+                res.setHeader('Content-Type', iconMime[iconExt] ?? 'image/png');
+                res.setHeader('Access-Control-Allow-Origin', '*');
+                res.end(data);
+            });
+            return;
+        }
+        if (reqPath === '/' || reqPath === basePath || reqPath === `${basePath}/`) {
+            reqPath = `${basePath}/${lynxBundleFile}`;
+        }
+        else if (!reqPath.startsWith(basePath)) {
+            reqPath = basePath + (reqPath.startsWith('/') ? reqPath : '/' + reqPath);
+        }
+        const relPath = reqPath.replace(basePath, '').replace(/^\//, '') || lynxBundleFile;
+        const filePath = path.resolve(distDir, relPath);
+        const distResolved = path.resolve(distDir);
+        if (!filePath.startsWith(distResolved + path.sep) && filePath !== distResolved) {
+            res.writeHead(403);
+            res.end();
+            return;
+        }
+        fs.readFile(filePath, (err, data) => {
+            if (err) {
+                res.writeHead(404);
+                res.end('Not found');
+                return;
+            }
+            res.setHeader('Access-Control-Allow-Origin', '*');
+            res.setHeader('Content-Type', reqPath.endsWith('.bundle') ? 'application/octet-stream' : 'application/javascript');
+            res.end(data);
+        });
+    });
+    const wss = new WebSocketServer({ noServer: true });
+    httpServer.on('upgrade', (request, socket, head) => {
+        if (request.url === `${basePath}/__hmr` || request.url === '/__hmr') {
+            wss.handleUpgrade(request, socket, head, (ws) => wss.emit('connection', ws, request));
+        }
+        else {
+            socket.destroy();
+        }
+    });
+    wss.on('connection', (ws) => {
+        ws.send(JSON.stringify({ type: 'connected' }));
+    });
+    function broadcastReload() {
+        wss.clients.forEach((client) => {
+            if (client.readyState === 1)
+                client.send(JSON.stringify({ type: 'reload' }));
+        });
+    }
+    let chokidar = null;
+    try {
+        chokidar = await import('chokidar');
+    }
+    catch {
+        /* optional */
+    }
+    if (chokidar) {
+        const watchPaths = [
+            path.join(lynxProjectDir, 'src'),
+            path.join(lynxProjectDir, 'lynx.config.ts'),
+            path.join(lynxProjectDir, 'lynx.config.js'),
+        ].filter((p) => fs.existsSync(p));
+        if (watchPaths.length > 0) {
+            const watcher = chokidar.watch(watchPaths, { ignoreInitial: true });
+            watcher.on('change', async () => {
+                try {
+                    await runBuild();
+                    broadcastReload();
+                    console.log('🔄 Rebuilt, clients notified');
+                }
+                catch (e) {
+                    console.error('Build failed:', e.message);
+                }
+            });
+        }
+    }
+    try {
+        await runBuild();
+    }
+    catch (e) {
+        console.error('❌ Initial build failed:', e.message);
+        process.exit(1);
+    }
+    let stopBonjour;
+    httpServer.listen(port, '0.0.0.0', () => {
+        void import('dnssd-advertise').then(({ advertise }) => {
+            stopBonjour = advertise({
+                name: projectName,
+                type: 'tamer',
+                protocol: 'tcp',
+                port,
+                txt: {
+                    name: projectName.slice(0, 255),
+                    path: basePath.slice(0, 255),
+                },
+            });
+        }).catch(() => { });
+        const lanIp = getLanIp();
+        const devUrl = `http://${lanIp}:${port}${basePath}`;
+        const wsUrl = `ws://${lanIp}:${port}${basePath}/__hmr`;
+        console.log(`\n🚀 Tamer4Lynx dev server (${projectName})`);
+        console.log(`   Bundle:  ${devUrl}/${lynxBundleFile}`);
+        console.log(`   Meta:    ${devUrl}/meta.json`);
+        console.log(`   HMR WS:  ${wsUrl}`);
+        if (stopBonjour)
+            console.log(`   mDNS:    _tamer._tcp (discoverable on LAN)`);
+        console.log(`\n   Scan QR or enter in app: ${devUrl}\n`);
+        void import('qrcode-terminal').then((mod) => {
+            const qrcode = mod.default ?? mod;
+            qrcode.generate(devUrl, { small: true });
+        }).catch(() => { });
+    });
+    const cleanup = async () => {
+        buildProcess?.kill();
+        await stopBonjour?.();
+        httpServer.close();
+        wss.close();
+        process.exit(0);
+    };
+    process.on('SIGINT', () => { void cleanup(); });
+    process.on('SIGTERM', () => { void cleanup(); });
+    await new Promise(() => { });
+}
+export default startDevServer;

package/dist/common/hostConfig.js

@@ -0,0 +1,256 @@
+import fs from 'fs';
+import path from 'path';
+const TAMER_CONFIG = 'tamer.config.json';
+const LYNX_CONFIG_FILES = ['lynx.config.ts', 'lynx.config.js', 'lynx.config.mjs'];
+const DEFAULT_ANDROID_DIR = 'android';
+const DEFAULT_IOS_DIR = 'ios';
+const DEFAULT_BUNDLE_FILE = 'main.lynx.bundle';
+const DEFAULT_BUNDLE_ROOT = 'dist';
+function findProjectRoot(start) {
+    let dir = path.resolve(start);
+    const root = path.parse(dir).root;
+    while (dir !== root) {
+        const p = path.join(dir, TAMER_CONFIG);
+        if (fs.existsSync(p))
+            return dir;
+        dir = path.dirname(dir);
+    }
+    return start;
+}
+function loadTamerConfig(cwd) {
+    const p = path.join(cwd, TAMER_CONFIG);
+    if (!fs.existsSync(p))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(p, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function extractDistPathRoot(configPath) {
+    try {
+        const content = fs.readFileSync(configPath, 'utf8');
+        const rootMatch = content.match(/distPath\s*:\s*\{\s*root\s*:\s*['"]([^'"]+)['"]/);
+        if (rootMatch?.[1])
+            return rootMatch[1];
+        const rootMatch2 = content.match(/root\s*:\s*['"]([^'"]+)['"]/);
+        if (rootMatch2?.[1])
+            return rootMatch2[1];
+    }
+    catch {
+        /* ignore */
+    }
+    return null;
+}
+function findLynxConfigInDir(dir) {
+    for (const name of LYNX_CONFIG_FILES) {
+        const p = path.join(dir, name);
+        if (fs.existsSync(p))
+            return p;
+    }
+    return null;
+}
+function hasRspeedy(pkgDir) {
+    const pkgJsonPath = path.join(pkgDir, 'package.json');
+    if (!fs.existsSync(pkgJsonPath))
+        return false;
+    try {
+        const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        return Object.keys(deps).some(k => k === '@lynx-js/rspeedy');
+    }
+    catch {
+        return false;
+    }
+}
+function discoverLynxProject(cwd, explicitPath) {
+    if (explicitPath) {
+        const resolved = path.isAbsolute(explicitPath) ? explicitPath : path.join(cwd, explicitPath);
+        if (fs.existsSync(resolved)) {
+            const lynxConfig = findLynxConfigInDir(resolved);
+            const bundleRoot = lynxConfig ? (extractDistPathRoot(lynxConfig) ?? DEFAULT_BUNDLE_ROOT) : DEFAULT_BUNDLE_ROOT;
+            return { dir: resolved, bundleRoot };
+        }
+    }
+    const rootPkgPath = path.join(cwd, 'package.json');
+    if (fs.existsSync(rootPkgPath)) {
+        try {
+            const rootPkg = JSON.parse(fs.readFileSync(rootPkgPath, 'utf8'));
+            const lynxConfig = findLynxConfigInDir(cwd);
+            if (lynxConfig || (rootPkg.dependencies?.['@lynx-js/rspeedy'] || rootPkg.devDependencies?.['@lynx-js/rspeedy'])) {
+                const bundleRoot = lynxConfig ? (extractDistPathRoot(lynxConfig) ?? DEFAULT_BUNDLE_ROOT) : DEFAULT_BUNDLE_ROOT;
+                return { dir: cwd, bundleRoot };
+            }
+            const workspaces = rootPkg.workspaces;
+            if (Array.isArray(workspaces)) {
+                for (const ws of workspaces) {
+                    const isGlob = typeof ws === 'string' && ws.includes('*');
+                    const dirsToCheck = isGlob
+                        ? (() => {
+                            const parentDir = path.join(cwd, ws.replace(/\/\*$/, ''));
+                            if (!fs.existsSync(parentDir))
+                                return [];
+                            return fs.readdirSync(parentDir, { withFileTypes: true })
+                                .filter(e => e.isDirectory())
+                                .map(e => path.join(parentDir, e.name));
+                        })()
+                        : [path.join(cwd, ws)];
+                    for (const pkgDir of dirsToCheck) {
+                        if (!fs.existsSync(pkgDir))
+                            continue;
+                        const lynxConfig = findLynxConfigInDir(pkgDir);
+                        if (lynxConfig || hasRspeedy(pkgDir)) {
+                            const bundleRoot = lynxConfig ? (extractDistPathRoot(lynxConfig) ?? DEFAULT_BUNDLE_ROOT) : DEFAULT_BUNDLE_ROOT;
+                            return { dir: pkgDir, bundleRoot };
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    const lynxConfig = findLynxConfigInDir(cwd);
+    if (lynxConfig) {
+        const bundleRoot = extractDistPathRoot(lynxConfig) ?? DEFAULT_BUNDLE_ROOT;
+        return { dir: cwd, bundleRoot };
+    }
+    return null;
+}
+function findDevAppPackage(projectRoot) {
+    const candidates = [
+        path.join(projectRoot, 'node_modules', 'tamer-dev-app'),
+        path.join(projectRoot, 'packages', 'tamer-dev-app'),
+    ];
+    for (const pkg of candidates) {
+        if (fs.existsSync(pkg) && fs.existsSync(path.join(pkg, 'package.json'))) {
+            return pkg;
+        }
+    }
+    return null;
+}
+export function findDevClientPackage(projectRoot) {
+    const candidates = [
+        path.join(projectRoot, 'node_modules', 'tamer-dev-client'),
+        path.join(projectRoot, 'packages', 'tamer-dev-client'),
+    ];
+    for (const pkg of candidates) {
+        if (fs.existsSync(pkg) && fs.existsSync(path.join(pkg, 'package.json'))) {
+            return pkg;
+        }
+    }
+    return null;
+}
+export function resolveHostPaths(cwd = process.cwd()) {
+    const projectRoot = findProjectRoot(cwd);
+    const config = loadTamerConfig(projectRoot) ?? {};
+    const paths = config.paths ?? {};
+    const androidDirRel = paths.androidDir ?? DEFAULT_ANDROID_DIR;
+    const iosDirRel = paths.iosDir ?? DEFAULT_IOS_DIR;
+    const packageName = config.android?.packageName ?? 'com.example.app';
+    const explicitLynx = config.lynxProject ?? paths.lynxProject;
+    const discovered = discoverLynxProject(projectRoot, explicitLynx);
+    const lynxProjectDir = discovered?.dir ?? cwd;
+    const bundleRoot = paths.lynxBundleRoot ?? discovered?.bundleRoot ?? DEFAULT_BUNDLE_ROOT;
+    const bundleFile = paths.lynxBundleFile ?? DEFAULT_BUNDLE_FILE;
+    const lynxBundlePath = path.join(lynxProjectDir, bundleRoot, bundleFile);
+    const androidDir = path.join(projectRoot, androidDirRel);
+    const devMode = resolveDevMode(config);
+    const devAppDir = devMode === 'embedded' ? findDevAppPackage(projectRoot) : null;
+    const devClientPkg = findDevClientPackage(projectRoot);
+    const devClientBundleInClient = devClientPkg
+        ? path.join(devClientPkg, DEFAULT_BUNDLE_ROOT, 'dev-client.lynx.bundle')
+        : null;
+    const devClientBundleInApp = devAppDir
+        ? path.join(devAppDir, DEFAULT_BUNDLE_ROOT, 'dev-client.lynx.bundle')
+        : null;
+    const devClientBundlePath = devMode === 'embedded'
+        ? (devClientBundleInClient && fs.existsSync(devClientBundleInClient)
+            ? devClientBundleInClient
+            : devClientBundleInApp ?? undefined)
+        : undefined;
+    return {
+        projectRoot,
+        androidDir,
+        iosDir: path.join(projectRoot, iosDirRel),
+        androidAppDir: path.join(projectRoot, androidDirRel, 'app'),
+        androidAssetsDir: path.join(projectRoot, androidDirRel, 'app', 'src', 'main', 'assets'),
+        androidKotlinDir: path.join(projectRoot, androidDirRel, 'app', 'src', 'main', 'kotlin', packageName.replace(/\./g, '/')),
+        lynxProjectDir,
+        lynxBundlePath,
+        lynxBundleFile: bundleFile,
+        devMode,
+        devClientBundlePath,
+        config,
+    };
+}
+export function resolveDevMode(config) {
+    const explicit = config.dev?.mode;
+    if (explicit)
+        return explicit;
+    if (config.devServer)
+        return 'embedded';
+    return 'off';
+}
+export function loadHostConfig(cwd = process.cwd()) {
+    const cfg = loadTamerConfig(cwd);
+    if (!cfg)
+        throw new Error('tamer.config.json not found in the project root.');
+    return cfg;
+}
+export function resolveIconPaths(projectRoot, config) {
+    const raw = config.icon;
+    if (!raw)
+        return null;
+    const join = (p) => (path.isAbsolute(p) ? p : path.join(projectRoot, p));
+    if (typeof raw === 'string') {
+        const p = join(raw);
+        return fs.existsSync(p) ? { source: p } : null;
+    }
+    const out = {};
+    if (raw.source) {
+        const p = join(raw.source);
+        if (fs.existsSync(p))
+            out.source = p;
+    }
+    if (raw.android) {
+        const p = join(raw.android);
+        if (fs.existsSync(p))
+            out.android = p;
+    }
+    if (raw.ios) {
+        const p = join(raw.ios);
+        if (fs.existsSync(p))
+            out.ios = p;
+    }
+    return Object.keys(out).length ? out : null;
+}
+export function resolveDevAppPaths(repoRoot) {
+    const devAppDir = path.join(repoRoot, 'packages', 'tamer-dev-app');
+    const configPath = path.join(devAppDir, 'tamer.config.json');
+    if (!fs.existsSync(configPath)) {
+        throw new Error('packages/tamer-dev-app/tamer.config.json not found.');
+    }
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    const packageName = config.android?.packageName ?? 'com.nanofuxion.tamerdevapp';
+    const androidDirRel = config.paths?.androidDir ?? 'android';
+    const androidDir = path.join(devAppDir, androidDirRel);
+    const devClientDir = findDevClientPackage(repoRoot) ?? path.join(repoRoot, 'packages', 'tamer-dev-client');
+    const lynxBundlePath = path.join(devClientDir, DEFAULT_BUNDLE_ROOT, 'dev-client.lynx.bundle');
+    return {
+        projectRoot: devAppDir,
+        androidDir,
+        iosDir: path.join(devAppDir, 'ios'),
+        androidAppDir: path.join(androidDir, 'app'),
+        androidAssetsDir: path.join(androidDir, 'app', 'src', 'main', 'assets'),
+        androidKotlinDir: path.join(androidDir, 'app', 'src', 'main', 'kotlin', packageName.replace(/\./g, '/')),
+        lynxProjectDir: devClientDir,
+        lynxBundlePath,
+        lynxBundleFile: 'dev-client.lynx.bundle',
+        devMode: 'embedded',
+        devClientBundlePath: undefined,
+        config,
+    };
+}

package/dist/common/init.js

@@ -0,0 +1,65 @@
+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 init() {
+    process.removeAllListeners('warning');
+    console.log("Tamer4Lynx Init: Let's set up your tamer.config.json\n");
+    // Android
+    const androidAppName = await ask("Android app name: ");
+    const androidPackageName = await ask("Android package name (e.g. com.example.app): ");
+    let androidSdk = await ask("Android SDK path (e.g. ~/Library/Android/sdk or $ANDROID_HOME): ");
+    // Normalize SDK path if starts with $ and is all caps
+    if (androidSdk.startsWith("$") && /^[A-Z0-9_]+$/.test(androidSdk.slice(1))) {
+        const envVar = androidSdk.slice(1);
+        const envValue = process.env[envVar];
+        if (envValue) {
+            androidSdk = envValue;
+            console.log(`Resolved ${androidSdk} from $${envVar}`);
+        }
+        else {
+            console.warn(`Environment variable $${envVar} not found. SDK path will be left as-is.`);
+        }
+    }
+    // Ask if user wants to use same name/bundle id for iOS as Android
+    const useSame = await ask("Use same name and bundle ID for iOS as Android? (y/N): ");
+    let iosAppName;
+    let iosBundleId;
+    if (/^y(es)?$/i.test(useSame)) {
+        iosAppName = androidAppName;
+        iosBundleId = androidPackageName;
+    }
+    else {
+        iosAppName = await ask("iOS app name: ");
+        iosBundleId = await ask("iOS bundle ID (e.g. com.example.app): ");
+    }
+    // Ask for lynxProject path
+    const lynxProject = await ask("Lynx project path (relative to project root, e.g. packages/example) [optional]: ");
+    const config = {
+        android: {
+            appName: androidAppName || undefined,
+            packageName: androidPackageName || undefined,
+            sdk: androidSdk || undefined
+        },
+        ios: {
+            appName: iosAppName || undefined,
+            bundleId: iosBundleId || undefined
+        },
+        paths: { androidDir: "android", iosDir: "ios" }
+    };
+    if (lynxProject)
+        config.lynxProject = lynxProject;
+    const configPath = path.join(process.cwd(), "tamer.config.json");
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    console.log(`\n✅ Generated tamer.config.json at ${configPath}`);
+    rl.close();
+}
+export default init;

package/dist/common/postinstall.js

@@ -0,0 +1,39 @@
+import fs from 'fs';
+import path from 'path';
+import alink from "../android/autolink";
+import ilink from "../ios/autolink";
+import { resolveHostPaths } from './hostConfig';
+(() => {
+    const configPath = path.join(process.cwd(), 'tamer.config.json');
+    let config = {};
+    if (fs.existsSync(configPath)) {
+        config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    }
+    else {
+        console.warn('⚠️ tamer.config.json not found. Skipping autolinking.');
+        return;
+    }
+    if (config.autolink) {
+        try {
+            const { androidDir, iosDir } = resolveHostPaths();
+            if (fs.existsSync(androidDir))
+                alink();
+            if (process.platform === 'darwin' && fs.existsSync(iosDir))
+                ilink();
+        }
+        catch {
+            const androidRoot = path.join(process.cwd(), 'android');
+            if (fs.existsSync(androidRoot))
+                alink();
+            if (process.platform === 'darwin') {
+                const iosRoot = path.join(process.cwd(), 'ios');
+                if (fs.existsSync(iosRoot))
+                    ilink();
+            }
+        }
+        console.log('Autolinking complete.');
+    }
+    else {
+        console.log('Autolinking not enabled in tamer.config.json.');
+    }
+})();

package/dist/common/start.js

@@ -0,0 +1,5 @@
+import devServer from './devServer';
+async function start() {
+    await devServer();
+}
+export default start;

package/dist/explorer/devLauncher.js

@@ -0,0 +1,47 @@
+export function getDevServerPrefs(vars) {
+    return `package ${vars.packageName}
+
+import android.content.Context
+import android.content.SharedPreferences
+import org.json.JSONArray
+
+object DevServerPrefs {
+    private const val PREFS = "tamer_dev_server"
+    private const val KEY_URL = "dev_server_url"
+    private const val KEY_RECENT = "dev_server_recent"
+
+    fun getUrl(context: Context): String? {
+        return prefs(context).getString(KEY_URL, null)
+    }
+
+    fun setUrl(context: Context, url: String) {
+        prefs(context).edit().putString(KEY_URL, url).apply()
+        addRecent(context, url)
+    }
+
+    fun getRecentUrls(context: Context): List<String> {
+        val json = prefs(context).getString(KEY_RECENT, "[]") ?: "[]"
+        return try {
+            val arr = JSONArray(json)
+            (0 until arr.length()).map { arr.getString(it) }.distinct().take(10)
+        } catch (_: Exception) { emptyList() }
+    }
+
+    fun addRecent(context: Context, url: String) {
+        val current = getRecentUrls(context).filter { it != url }
+        val updated = listOf(url) + current
+        prefs(context).edit()
+            .putString(KEY_RECENT, JSONArray(updated.take(10)).toString())
+            .apply()
+    }
+
+    fun clear(context: Context) {
+        prefs(context).edit().clear().apply()
+    }
+
+    private fun prefs(context: Context): SharedPreferences {
+        return context.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
+    }
+}
+`;
+}