@nebula-rn/cli 0.0.1

package/bin/nebula.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const Module = require('module');
+const ts = require('typescript');
+
+const compileTypeScriptModule = (module, filename) => {
+  const source = fs.readFileSync(filename, 'utf8');
+  const compiled = ts.transpileModule(source, {
+    compilerOptions: {
+      module: ts.ModuleKind.CommonJS,
+      target: ts.ScriptTarget.ES2020,
+      esModuleInterop: true,
+      jsx: ts.JsxEmit.React,
+    },
+    fileName: filename,
+  });
+  module._compile(compiled.outputText, filename);
+};
+
+require.extensions['.ts'] = compileTypeScriptModule;
+require.extensions['.tsx'] = compileTypeScriptModule;
+
+const entryPath = path.join(__dirname, '../src/cli.ts');
+const runtimeModule = new Module(entryPath, module.parent ?? module);
+runtimeModule.filename = entryPath;
+runtimeModule.paths = Module._nodeModulePaths(path.dirname(entryPath));
+compileTypeScriptModule(runtimeModule, entryPath);

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const create_1 = require("./create");
+const miniapp_1 = require("./miniapp");
+const platform_1 = require("./platform");
+const utils_1 = require("./utils");
+async function main() {
+    const [, , scope, action, ...extraArgs] = process.argv;
+    if (scope === 'create' &&
+        (action === 'host' || action === 'miniapp' || action === 'runner')) {
+        const flags = (0, utils_1.parseFlags)(extraArgs);
+        const projectName = (0, utils_1.omitFlags)(extraArgs, [
+            'directory',
+            'app-id',
+            'display-name',
+            'bundle-id',
+        ])[0];
+        if (!projectName) {
+            (0, utils_1.exitWithError)(`Usage: nebula create ${action} <name> [--directory <path>] [--app-id <id>] [--display-name <name>] [--bundle-id <id>]`);
+        }
+        const result = (0, create_1.createProject)(action, {
+            appId: flags['app-id'],
+            bundleId: flags['bundle-id'],
+            directory: flags.directory,
+            displayName: flags['display-name'],
+            name: projectName,
+        });
+        console.log(`[nebula] Created ${action} project at ${result.targetDir}`);
+        return;
+    }
+    if (scope === 'config' && action === 'server') {
+        (0, platform_1.configureServer)(extraArgs);
+        return;
+    }
+    if (scope === 'auth' && action === 'login') {
+        await (0, platform_1.loginPlatform)(extraArgs);
+        return;
+    }
+    if (scope === 'auth' && action === 'logout') {
+        (0, platform_1.logoutPlatform)();
+        return;
+    }
+    if (scope === 'miniapp' && action === 'upload') {
+        await (0, platform_1.uploadMiniApp)(extraArgs);
+        return;
+    }
+    if (scope === 'miniapp') {
+        await (0, miniapp_1.runMiniApp)(action, extraArgs);
+        return;
+    }
+    (0, utils_1.exitWithError)('Usage: nebula create <host|miniapp|runner> <name> [...args], nebula miniapp <dev|build|upload> [...args], nebula auth <login|logout> [...args], or nebula config server [--url <url>|--clear]');
+}
+main().catch(error => {
+    const message = error instanceof Error ? error.message : String(error);
+    (0, utils_1.exitWithError)(message);
+});

package/dist/create.d.ts

@@ -0,0 +1,12 @@
+type CreateProjectKind = 'host' | 'miniapp' | 'runner';
+type CreateProjectOptions = {
+    name: string;
+    directory?: string;
+    appId?: string;
+    displayName?: string;
+    bundleId?: string;
+};
+export declare function createProject(kind: CreateProjectKind, options: CreateProjectOptions): {
+    targetDir: string;
+};
+export {};

package/dist/create.js

@@ -0,0 +1,213 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProject = createProject;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const TEMPLATE_PACKAGE_ROOT = path.resolve(__dirname, '../../template');
+const TEXT_TEMPLATE_EXTENSIONS = new Set([
+    '.js',
+    '.jsx',
+    '.ts',
+    '.tsx',
+    '.swift',
+    '.json',
+    '.gradle',
+    '.kt',
+    '.plist',
+    '.storyboard',
+    '.pbxproj',
+    '.xml',
+    '.rb',
+    '.xcprivacy',
+    '.properties',
+    '.md',
+]);
+const TEXT_TEMPLATE_BASENAMES = new Set([
+    '.watchmanconfig',
+    '.eslintrc.js',
+    '.xcode.env',
+    'Podfile',
+    'Gemfile',
+    'gradlew',
+    'gradlew.bat',
+]);
+function fail(message) {
+    throw new Error(`[nebula] ${message}`);
+}
+function readJson(filePath) {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+function readPackageVersion(packageDir) {
+    const packageJson = readJson(path.join(packageDir, 'package.json'));
+    return packageJson.version || '0.0.1';
+}
+function resolvePackageVersions() {
+    const packagesDir = path.resolve(__dirname, '../..');
+    return {
+        sdk: readPackageVersion(path.join(packagesDir, 'nebula-sdk')),
+        host: readPackageVersion(path.join(packagesDir, 'host')),
+        hostApis: readPackageVersion(path.join(packagesDir, 'host-apis')),
+        client: readPackageVersion(path.join(packagesDir, 'api')),
+    };
+}
+function toKebabCase(value) {
+    return value
+        .trim()
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/[^a-zA-Z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .toLowerCase();
+}
+function toPascalCase(value) {
+    return value
+        .split(/[^a-zA-Z0-9]+/)
+        .filter(Boolean)
+        .map(segment => segment[0].toUpperCase() + segment.slice(1))
+        .join('');
+}
+function toDisplayName(value) {
+    return value
+        .split(/[^a-zA-Z0-9]+/)
+        .filter(Boolean)
+        .map(segment => segment[0].toUpperCase() + segment.slice(1))
+        .join(' ');
+}
+function toBundleId(value) {
+    const normalized = value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '.')
+        .replace(/^\.+|\.+$/g, '')
+        .replace(/\.{2,}/g, '.');
+    const segments = normalized
+        .split('.')
+        .filter(Boolean)
+        .map(segment => segment.replace(/^[^a-z]+/, '').replace(/[^a-z0-9]/g, ''))
+        .filter(Boolean);
+    if (segments.length === 0) {
+        return 'com.nebula.app';
+    }
+    return `com.${segments.join('.')}`;
+}
+function ensureTargetDirectory(targetDir) {
+    if (!fs.existsSync(targetDir)) {
+        fs.mkdirSync(targetDir, { recursive: true });
+        return;
+    }
+    if (fs.readdirSync(targetDir).length > 0) {
+        fail(`Target directory is not empty: ${targetDir}`);
+    }
+}
+function getTemplateRoot(kind) {
+    const templateRoot = path.join(TEMPLATE_PACKAGE_ROOT, kind);
+    if (!fs.existsSync(templateRoot)) {
+        fail(`Missing ${kind} template at ${templateRoot}`);
+    }
+    return templateRoot;
+}
+function isTextTemplateFile(filePath) {
+    const basename = path.basename(filePath);
+    if (TEXT_TEMPLATE_BASENAMES.has(basename)) {
+        return true;
+    }
+    const extension = path.extname(filePath);
+    return TEXT_TEMPLATE_EXTENSIONS.has(extension);
+}
+function replaceTemplateTokens(value, replacements) {
+    let nextValue = value;
+    for (const [token, replacement] of Object.entries(replacements)) {
+        nextValue = nextValue.split(token).join(replacement);
+    }
+    return nextValue;
+}
+function applyTemplateReplacements(targetRoot, replacements) {
+    const visit = (currentPath) => {
+        const stats = fs.statSync(currentPath);
+        if (stats.isDirectory()) {
+            for (const entry of fs.readdirSync(currentPath)) {
+                visit(path.join(currentPath, entry));
+            }
+            return;
+        }
+        if (!isTextTemplateFile(currentPath)) {
+            return;
+        }
+        const original = fs.readFileSync(currentPath, 'utf8');
+        const replaced = replaceTemplateTokens(original, replacements);
+        if (original !== replaced) {
+            fs.writeFileSync(currentPath, replaced);
+        }
+    };
+    visit(targetRoot);
+}
+function buildReplacements(kind, options, versions) {
+    const slug = toKebabCase(options.name);
+    const displayName = options.displayName || toDisplayName(options.name);
+    const appId = options.appId || slug || 'nebula-miniapp';
+    const componentName = kind === 'runner'
+        ? toPascalCase(options.name) || 'NebulaDevRunner'
+        : kind === 'host'
+            ? toPascalCase(options.name) || 'NebulaHostApp'
+            : 'NebulaMiniapp';
+    const bundleId = options.bundleId || toBundleId(options.name);
+    return {
+        __PACKAGE_NAME__: slug,
+        __DISPLAY_NAME__: displayName,
+        __COMPONENT_NAME__: componentName,
+        __BUNDLE_ID__: bundleId,
+        __APP_ID__: appId,
+        __NEBULA_CLIENT_VERSION__: versions.client,
+        __NEBULA_HOST_VERSION__: versions.host,
+        __NEBULA_HOST_APIS_VERSION__: versions.hostApis,
+        __NEBULA_SDK_VERSION__: versions.sdk,
+    };
+}
+function copyTemplateProject(kind, targetDir, options) {
+    const templateRoot = getTemplateRoot(kind);
+    const versions = resolvePackageVersions();
+    const replacements = buildReplacements(kind, options, versions);
+    ensureTargetDirectory(targetDir);
+    fs.cpSync(templateRoot, targetDir, { recursive: true });
+    applyTemplateReplacements(targetDir, replacements);
+}
+function createProject(kind, options) {
+    const slug = toKebabCase(options.name);
+    if (!slug) {
+        fail('Project name cannot be empty.');
+    }
+    const targetDir = path.resolve(process.cwd(), options.directory || options.name);
+    copyTemplateProject(kind, targetDir, options);
+    return { targetDir };
+}

package/dist/miniapp.d.ts

@@ -0,0 +1,25 @@
+type PageStyle = {
+    backgroundColor?: string;
+    navigationBarBackgroundColor?: string;
+    navigationBarTextColor?: string;
+    navigationBarTitleText?: string;
+    navigationStyle?: 'default' | 'custom';
+    visualEffectInBackground?: 'blur' | 'none';
+};
+export type UserMiniAppConfig = {
+    appId: string;
+    entryPagePath?: string;
+    pages: string[] | Record<string, string>;
+    updateStrategy?: 'auto' | 'manual';
+    window?: PageStyle;
+};
+export type BuiltMiniAppArtifacts = {
+    manifestPath: string;
+    iosBundlePath: string;
+    androidBundlePath: string;
+    iosAssetsDir: string;
+    androidAssetsDir: string;
+};
+export declare function buildMiniAppArtifacts(projectRoot: string, workspaceRoot: string, appConfig: UserMiniAppConfig, extraArgs: string[]): Promise<BuiltMiniAppArtifacts>;
+export declare function runMiniApp(action: string, extraArgs: string[]): Promise<void>;
+export {};

package/dist/miniapp.js

@@ -0,0 +1,465 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildMiniAppArtifacts = buildMiniAppArtifacts;
+exports.runMiniApp = runMiniApp;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const module_1 = __importDefault(require("module"));
+const utils_1 = require("./utils");
+function registerTypeScriptRequire() {
+    const globalKey = '__nebulaTsRequireRegistered';
+    if (globalThis[globalKey]) {
+        return;
+    }
+    const workspaceRoot = (0, utils_1.findWorkspaceRoot)(process.cwd());
+    const moduleLoadKey = '__nebulaPageConfigModuleLoadPatched';
+    if (!globalThis[moduleLoadKey]) {
+        const moduleInternal = module_1.default;
+        const originalLoad = moduleInternal._load;
+        moduleInternal._load = function patchedNebulaModuleLoad(request, parent, isMain) {
+            if (request === '@nebula-rn/sdk') {
+                const sdkPageConfigEntry = path_1.default.join(workspaceRoot, 'packages', 'nebula-sdk', 'page-config.ts');
+                if (fs_1.default.existsSync(sdkPageConfigEntry)) {
+                    return Reflect.apply(originalLoad, this, [
+                        sdkPageConfigEntry,
+                        parent,
+                        isMain,
+                    ]);
+                }
+            }
+            return Reflect.apply(originalLoad, this, [request, parent, isMain]);
+        };
+        globalThis[moduleLoadKey] = true;
+    }
+    const compileExtension = (module, filename) => {
+        const ts = require('typescript');
+        const source = fs_1.default.readFileSync(filename, 'utf8');
+        const compiled = ts.transpileModule(source, {
+            compilerOptions: {
+                esModuleInterop: true,
+                jsx: ts.JsxEmit.React,
+                module: ts.ModuleKind.CommonJS,
+                target: ts.ScriptTarget.ES2020,
+            },
+            fileName: filename,
+        });
+        module._compile(compiled.outputText, filename);
+    };
+    require.extensions['.ts'] = compileExtension;
+    require.extensions['.tsx'] = compileExtension;
+    globalThis[globalKey] = true;
+}
+function normalizeRoute(route) {
+    if (!route || route === '/') {
+        return '/';
+    }
+    const normalized = route.replace(/^\/+/, '').replace(/\/+$/, '');
+    return `/${normalized}`;
+}
+function normalizeImportPath(fromDir, targetPath) {
+    const relativePath = path_1.default
+        .relative(fromDir, targetPath)
+        .split(path_1.default.sep)
+        .join('/')
+        .replace(/\.(tsx?|jsx?)$/, '');
+    return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
+}
+function toComponentName(pageId) {
+    return `NebulaPage_${pageId
+        .split(/[\/_-]/)
+        .filter(Boolean)
+        .map(segment => segment[0].toUpperCase() + segment.slice(1))
+        .join('')}`;
+}
+function resolveDevRunnerRoot(startDir) {
+    const candidates = [
+        path_1.default.join(startDir, 'packages', 'dev-runner'),
+        path_1.default.join(startDir, 'node_modules', '@nebula', 'dev-runner'),
+    ];
+    for (const candidate of candidates) {
+        if (fs_1.default.existsSync(path_1.default.join(candidate, 'package.json'))) {
+            return candidate;
+        }
+    }
+    let currentDir = startDir;
+    while (true) {
+        const candidate = path_1.default.join(currentDir, 'node_modules', '@nebula', 'dev-runner');
+        if (fs_1.default.existsSync(path_1.default.join(candidate, 'package.json'))) {
+            return candidate;
+        }
+        const parentDir = path_1.default.dirname(currentDir);
+        if (parentDir === currentDir) {
+            break;
+        }
+        currentDir = parentDir;
+    }
+    (0, utils_1.exitWithError)('Unable to locate @nebula-rn/dev-runner. Install it or use `nebula miniapp dev --no-runner`.');
+}
+function resolveRunnerPlatform(value) {
+    if (value === 'android' || value === 'ios') {
+        return value;
+    }
+    return process.platform === 'darwin' ? 'ios' : 'android';
+}
+function getMiniappServerBaseUrl(platform) {
+    return platform === 'android'
+        ? 'http://10.0.2.2:8082'
+        : 'http://localhost:8082';
+}
+function getRunnerLaunchUrl(platform, manifestPath, bundlePath) {
+    const baseUrl = getMiniappServerBaseUrl(platform);
+    const manifestUrl = `${baseUrl}${manifestPath}`;
+    const bundleUrl = `${baseUrl}${bundlePath}?platform=${platform}&dev=true&minify=false`;
+    return `devrunner://open?manifestUrl=${encodeURIComponent(manifestUrl)}&bundleUrl=${encodeURIComponent(bundleUrl)}&t=${Date.now()}`;
+}
+function launchRunnerControlUrl(platform, manifestPath, bundlePath) {
+    const runnerUrl = getRunnerLaunchUrl(platform, manifestPath, bundlePath);
+    if (platform === 'ios') {
+        (0, utils_1.spawnDetachedProcess)('xcrun', ['simctl', 'openurl', 'booted', runnerUrl], process.cwd());
+        return;
+    }
+    (0, utils_1.spawnDetachedProcess)('adb', [
+        'shell',
+        'am',
+        'start',
+        '-a',
+        'android.intent.action.VIEW',
+        '-d',
+        runnerUrl,
+    ], process.cwd());
+}
+function ensureDevRunner(workspaceRoot, platform, manifestPath, bundlePath) {
+    const devRunnerRoot = resolveDevRunnerRoot(workspaceRoot);
+    const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    (0, utils_1.spawnDetachedProcess)(npmCommand, ['run', 'start'], devRunnerRoot);
+    (0, utils_1.spawnDetachedProcess)(npmCommand, ['run', platform === 'ios' ? 'ios' : 'android'], devRunnerRoot);
+    const launchDelays = platform === 'ios' ? [6000, 12000] : [8000, 15000];
+    launchDelays.forEach(delay => {
+        setTimeout(() => {
+            launchRunnerControlUrl(platform, manifestPath, bundlePath);
+        }, delay);
+    });
+}
+function resolvePageModuleFile(projectRoot, pageId) {
+    const pageDir = path_1.default.join(projectRoot, 'src', 'pages', pageId);
+    const candidates = ['index.tsx', 'index.ts', 'index.jsx', 'index.js'];
+    for (const candidate of candidates) {
+        const filePath = path_1.default.join(pageDir, candidate);
+        if (fs_1.default.existsSync(filePath)) {
+            return filePath;
+        }
+    }
+    (0, utils_1.exitWithError)(`Missing page entry for "${pageId}" in ${pageDir}`);
+}
+function readPageConfig(projectRoot, pageId) {
+    registerTypeScriptRequire();
+    const pageConfigPath = path_1.default.join(projectRoot, 'src', 'pages', pageId, 'page.config.ts');
+    (0, utils_1.ensureFileExists)(pageConfigPath);
+    try {
+        const resolvedPath = require.resolve(pageConfigPath);
+        delete require.cache[resolvedPath];
+        const pageConfigModule = require(resolvedPath);
+        let pageConfig = null;
+        if (typeof pageConfigModule === 'object' &&
+            pageConfigModule !== null &&
+            ('default' in pageConfigModule || 'pageConfig' in pageConfigModule)) {
+            pageConfig =
+                pageConfigModule.default ?? pageConfigModule.pageConfig ?? null;
+        }
+        else if (typeof pageConfigModule === 'object' &&
+            pageConfigModule !== null) {
+            pageConfig = pageConfigModule;
+        }
+        if (!pageConfig || typeof pageConfig !== 'object') {
+            (0, utils_1.exitWithError)(`Invalid page config export in ${pageConfigPath}`);
+        }
+        return pageConfig;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        (0, utils_1.exitWithError)(`Failed to load ${pageConfigPath}: ${message}`);
+    }
+}
+function validateMiniAppConfig(appConfig) {
+    if (!appConfig || typeof appConfig !== 'object') {
+        (0, utils_1.exitWithError)('app.json must export a JSON object');
+    }
+    if (!appConfig.appId || typeof appConfig.appId !== 'string') {
+        (0, utils_1.exitWithError)('app.json must contain a string "appId"');
+    }
+    if (!appConfig.pages ||
+        (typeof appConfig.pages !== 'object' && !Array.isArray(appConfig.pages))) {
+        (0, utils_1.exitWithError)('app.json must contain a "pages" array or object');
+    }
+    if (appConfig.updateStrategy &&
+        appConfig.updateStrategy !== 'auto' &&
+        appConfig.updateStrategy !== 'manual') {
+        (0, utils_1.exitWithError)('app.json updateStrategy must be either "auto" or "manual"');
+    }
+}
+function buildRuntimeManifest(projectRoot, appConfig) {
+    validateMiniAppConfig(appConfig);
+    const version = (0, utils_1.getPackageVersion)(projectRoot);
+    const updateStrategy = appConfig.updateStrategy ?? 'manual';
+    if (!Array.isArray(appConfig.pages)) {
+        const routes = appConfig.pages;
+        const entryPagePath = normalizeRoute(appConfig.entryPagePath || '/');
+        const pages = {};
+        for (const [route, componentName] of Object.entries(routes)) {
+            pages[normalizeRoute(route)] = componentName;
+        }
+        return {
+            manifest: {
+                appId: appConfig.appId,
+                bundlePath: '/index.bundle',
+                entryPagePath,
+                pageConfigs: {},
+                pages,
+                updateStrategy,
+                version,
+                window: appConfig.window,
+            },
+            pageDefinitions: [],
+        };
+    }
+    const pageDefinitions = [];
+    const pageConfigs = {};
+    const pages = {};
+    for (const pageId of appConfig.pages) {
+        const pageConfig = readPageConfig(projectRoot, pageId);
+        const route = normalizeRoute(pageConfig.route || pageId);
+        const componentName = toComponentName(pageId);
+        const moduleFilePath = resolvePageModuleFile(projectRoot, pageId);
+        const style = { ...pageConfig, route: undefined };
+        pages[route] = componentName;
+        pageConfigs[route] = style;
+        pageDefinitions.push({
+            componentName,
+            importPath: moduleFilePath,
+        });
+    }
+    const entryPagePath = normalizeRoute(appConfig.entryPagePath || appConfig.pages[0] || '/');
+    if (!pages[entryPagePath]) {
+        (0, utils_1.exitWithError)(`entryPagePath "${entryPagePath}" does not match any configured page`);
+    }
+    pages['/'] = pages[entryPagePath];
+    pageConfigs['/'] = pageConfigs[entryPagePath];
+    return {
+        manifest: {
+            appId: appConfig.appId,
+            bundlePath: '/index.bundle',
+            entryPagePath,
+            pageConfigs,
+            pages,
+            updateStrategy,
+            version,
+            window: appConfig.window,
+        },
+        pageDefinitions,
+    };
+}
+function generateMiniAppFiles(projectRoot, workspaceRoot, appConfig) {
+    const { manifest, pageDefinitions } = buildRuntimeManifest(projectRoot, appConfig);
+    const generatedDir = path_1.default.join(projectRoot, '.nebula', 'generated');
+    const runtimeBundlePath = '/.nebula/generated/index.bundle';
+    const runtimeBundleEntryFile = '.nebula/generated/index.js';
+    const runtimeManifestUrlPath = '/.nebula/generated/app.json';
+    manifest.bundlePath = runtimeBundlePath;
+    manifest.bundleEntryFile = runtimeBundleEntryFile;
+    const entryFilePath = path_1.default.join(generatedDir, 'index.js');
+    const metroConfigPath = path_1.default.join(generatedDir, 'metro.config.cjs');
+    const runtimeManifestPath = path_1.default.join(generatedDir, 'app.json');
+    const buildManifestPath = path_1.default.join(projectRoot, 'build', 'app.json');
+    fs_1.default.mkdirSync(generatedDir, { recursive: true });
+    const loaderEntries = pageDefinitions.map(definition => {
+        const importPath = normalizeImportPath(generatedDir, definition.importPath);
+        return `  ${JSON.stringify(definition.componentName)}: () => {
+    const module = require(${JSON.stringify(importPath)});
+    return module?.default ?? module;
+  },`;
+    });
+    const entryContents = `import { AppRegistry } from 'react-native';
+import { createMiniAppPage, Miniapp, NebulaAPI } from '@nebula-rn/sdk';
+
+const manifest = ${JSON.stringify(manifest, null, 2)};
+const componentLoaders = {
+${loaderEntries.join('\n')}
+};
+
+Miniapp.bootstrap(manifest.appId);
+NebulaAPI.registerManifest(manifest.appId, manifest);
+
+Object.entries(manifest.pages).forEach(([routePath, componentName]) => {
+  const loadComponent = componentLoaders[componentName];
+  if (!loadComponent) {
+    console.warn(\`[Nebula] No component found for route "\${routePath}" and component "\${componentName}"\`);
+    return;
+  }
+  AppRegistry.registerComponent(componentName, () => {
+    const component = loadComponent();
+    return createMiniAppPage(component);
+  });
+});
+
+const defaultComponentName =
+  manifest.pages[manifest.entryPagePath] ||
+  manifest.pages['/'] ||
+  Object.values(manifest.pages)[0];
+const loadDefaultComponent = defaultComponentName
+  ? componentLoaders[defaultComponentName]
+  : null;
+
+if (loadDefaultComponent) {
+  AppRegistry.registerComponent('NebulaApp', () => {
+    const component = loadDefaultComponent();
+    return createMiniAppPage(component);
+  });
+}
+`;
+    const metroConfigContents = `const fs = require('fs');
+const path = require('path');
+const { getDefaultConfig, mergeConfig } = require('@react-native/metro-config');
+
+const projectRoot = ${JSON.stringify(projectRoot)};
+const workspaceRoot = ${JSON.stringify(workspaceRoot)};
+const generatedManifestPath = ${JSON.stringify(runtimeManifestPath)};
+const runtimeManifestUrlPath = ${JSON.stringify(runtimeManifestUrlPath)};
+
+/** @type {import('metro-config').MetroConfig} */
+const config = {
+  projectRoot,
+  watchFolders: [workspaceRoot],
+  server: {
+    enhanceMiddleware: middleware => {
+      return (req, res, next) => {
+        const requestUrl = new URL(req.url || '/', 'http://localhost');
+        if (
+          requestUrl.pathname === runtimeManifestUrlPath &&
+          fs.existsSync(generatedManifestPath)
+        ) {
+          res.setHeader('Content-Type', 'application/json');
+          res.end(fs.readFileSync(generatedManifestPath, 'utf8'));
+          return;
+        }
+        return middleware(req, res, next);
+      };
+    },
+  },
+  resolver: {
+    nodeModulesPaths: [
+      path.join(projectRoot, 'node_modules'),
+      path.join(workspaceRoot, 'node_modules'),
+    ],
+  },
+};
+
+module.exports = mergeConfig(getDefaultConfig(projectRoot), config);
+`;
+    (0, utils_1.writeFileIfChanged)(entryFilePath, entryContents);
+    (0, utils_1.writeFileIfChanged)(metroConfigPath, metroConfigContents);
+    (0, utils_1.writeFileIfChanged)(runtimeManifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
+    return {
+        buildManifestPath,
+        bundlePath: runtimeBundlePath,
+        bundleEntryFile: runtimeBundleEntryFile,
+        entryFilePath,
+        metroConfigPath,
+        runtimeManifestUrlPath,
+    };
+}
+async function runReactNative(projectRoot, args) {
+    const reactNativeBin = (0, utils_1.resolveBin)('react-native', projectRoot);
+    await (0, utils_1.spawnProcess)(projectRoot, reactNativeBin, args);
+}
+async function buildMiniAppArtifacts(projectRoot, workspaceRoot, appConfig, extraArgs) {
+    const generatedFiles = generateMiniAppFiles(projectRoot, workspaceRoot, appConfig);
+    const buildDir = path_1.default.join(projectRoot, 'build');
+    const iosBundlePath = path_1.default.join(buildDir, 'main.ios.jsbundle');
+    const androidBundlePath = path_1.default.join(buildDir, 'main.android.bundle');
+    fs_1.default.mkdirSync(buildDir, { recursive: true });
+    fs_1.default.copyFileSync(path_1.default.join(path_1.default.dirname(generatedFiles.entryFilePath), 'app.json'), generatedFiles.buildManifestPath);
+    const iosAssetsDir = path_1.default.join(buildDir, 'ios-assets');
+    const androidAssetsDir = path_1.default.join(buildDir, 'android-assets');
+    await Promise.all([
+        runReactNative(projectRoot, [
+            'bundle',
+            '--config',
+            generatedFiles.metroConfigPath,
+            '--platform',
+            'ios',
+            '--dev',
+            'false',
+            '--entry-file',
+            generatedFiles.entryFilePath,
+            '--bundle-output',
+            iosBundlePath,
+            '--assets-dest',
+            iosAssetsDir,
+            ...extraArgs,
+        ]),
+        runReactNative(projectRoot, [
+            'bundle',
+            '--config',
+            generatedFiles.metroConfigPath,
+            '--platform',
+            'android',
+            '--dev',
+            'false',
+            '--entry-file',
+            generatedFiles.entryFilePath,
+            '--bundle-output',
+            androidBundlePath,
+            '--assets-dest',
+            androidAssetsDir,
+            ...extraArgs,
+        ]),
+    ]);
+    return {
+        androidBundlePath,
+        iosBundlePath,
+        iosAssetsDir,
+        androidAssetsDir,
+        manifestPath: generatedFiles.buildManifestPath,
+    };
+}
+async function runMiniApp(action, extraArgs) {
+    const projectRoot = process.cwd();
+    const workspaceRoot = (0, utils_1.findWorkspaceRoot)(projectRoot);
+    const appJsonPath = path_1.default.join(projectRoot, 'app.json');
+    const packageJsonPath = path_1.default.join(projectRoot, 'package.json');
+    (0, utils_1.ensureFileExists)(appJsonPath);
+    (0, utils_1.ensureFileExists)(packageJsonPath);
+    const appConfig = JSON.parse(fs_1.default.readFileSync(appJsonPath, 'utf8'));
+    const generatedFiles = generateMiniAppFiles(projectRoot, workspaceRoot, appConfig);
+    if (action === 'dev') {
+        const flags = (0, utils_1.parseFlags)(extraArgs);
+        const runnerPlatform = resolveRunnerPlatform(flags.platform);
+        const shouldAutoLaunchRunner = flags['no-runner'] !== 'true';
+        const metroArgs = (0, utils_1.omitFlags)(extraArgs, ['platform', 'no-runner']);
+        console.log(`[nebula] Starting ${appConfig.appId} in development mode...`);
+        if (shouldAutoLaunchRunner) {
+            console.log(`[nebula] Opening ${appConfig.appId} on ${runnerPlatform}...`);
+            ensureDevRunner(workspaceRoot, runnerPlatform, generatedFiles.runtimeManifestUrlPath, generatedFiles.bundlePath);
+        }
+        else {
+            console.log('[nebula] Runner auto-launch is disabled. Only the miniapp dev server will be started.');
+        }
+        await runReactNative(projectRoot, [
+            'start',
+            '--config',
+            generatedFiles.metroConfigPath,
+            '--port',
+            '8082',
+            ...metroArgs,
+        ]);
+        return;
+    }
+    if (action === 'build') {
+        await buildMiniAppArtifacts(projectRoot, workspaceRoot, appConfig, extraArgs);
+        return;
+    }
+    (0, utils_1.exitWithError)(`Unsupported miniapp action "${action}". Use "dev" / "build" / "upload".`);
+}

package/dist/platform.d.ts

@@ -0,0 +1,4 @@
+export declare function loginPlatform(extraArgs: string[]): Promise<void>;
+export declare function logoutPlatform(): void;
+export declare function configureServer(extraArgs: string[]): void;
+export declare function uploadMiniApp(extraArgs: string[]): Promise<void>;

package/dist/platform.js

@@ -0,0 +1,198 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loginPlatform = loginPlatform;
+exports.logoutPlatform = logoutPlatform;
+exports.configureServer = configureServer;
+exports.uploadMiniApp = uploadMiniApp;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("./utils");
+const miniapp_1 = require("./miniapp");
+async function ensureAuthenticatedSession(serverUrl, accessToken) {
+    const response = await fetch(`${serverUrl.replace(/\/$/, '')}/auth/me`, {
+        headers: {
+            Authorization: `Bearer ${accessToken}`,
+        },
+        method: 'GET',
+    });
+    if (response.status === 401 || response.status === 403) {
+        const currentConfig = (0, utils_1.readNebulaConfig)();
+        (0, utils_1.writeNebulaConfig)({
+            ...currentConfig,
+            accessToken: undefined,
+            user: undefined,
+        });
+        (0, utils_1.exitWithError)('Saved CLI login is no longer valid. Please run `nebula auth login` again.');
+    }
+    if (!response.ok) {
+        const text = await response.text();
+        (0, utils_1.exitWithError)(text || `Failed to validate CLI login (status ${response.status})`);
+    }
+    return (await response.json());
+}
+async function loginPlatform(extraArgs) {
+    const flags = (0, utils_1.parseFlags)(extraArgs);
+    const config = (0, utils_1.readNebulaConfig)();
+    const serverUrl = (0, utils_1.normalizeServerUrl)(flags.server || config.serverUrl || 'http://localhost:3001/api');
+    const shouldOpen = flags.open !== 'false';
+    const session = await (0, utils_1.httpRequest)(`${serverUrl.replace(/\/$/, '')}/auth/cli/sessions`, {
+        method: 'POST',
+    });
+    console.log('[nebula] Open this URL in your browser to authorize the CLI:');
+    console.log(session.verificationUrl);
+    console.log(`[nebula] Session code: ${session.code}`);
+    if (shouldOpen) {
+        try {
+            (0, utils_1.tryOpenUrl)(session.verificationUrl);
+        }
+        catch {
+            // Ignore open failures and keep the manual URL flow.
+        }
+    }
+    const expiresAt = new Date(session.expiresAt).getTime();
+    while (Date.now() < expiresAt) {
+        const response = await (0, utils_1.httpRequest)(`${serverUrl.replace(/\/$/, '')}/auth/cli/sessions/${session.code}`, {
+            method: 'GET',
+        });
+        if (response.status === 'approved' &&
+            response.accessToken &&
+            response.user) {
+            (0, utils_1.writeNebulaConfig)({
+                accessToken: response.accessToken,
+                serverUrl,
+                user: response.user,
+            });
+            console.log(`[nebula] Logged in as ${response.user.displayName} <${response.user.email}>`);
+            return;
+        }
+        if (response.status === 'expired') {
+            (0, utils_1.exitWithError)('CLI login session expired. Please run `nebula auth login` again.');
+        }
+        await (0, utils_1.sleep)((session.intervalSeconds || 2) * 1000);
+    }
+    (0, utils_1.exitWithError)('CLI login session expired. Please run `nebula auth login` again.');
+}
+function logoutPlatform() {
+    (0, utils_1.writeNebulaConfig)({});
+    console.log('[nebula] Logged out');
+}
+function configureServer(extraArgs) {
+    const flags = (0, utils_1.parseFlags)(extraArgs);
+    const currentConfig = (0, utils_1.readNebulaConfig)();
+    const requestedUrl = flags.url || extraArgs.find(arg => !arg.startsWith('--')) || '';
+    if (flags.clear === 'true') {
+        (0, utils_1.writeNebulaConfig)({
+            accessToken: undefined,
+            serverUrl: undefined,
+            user: undefined,
+        });
+        console.log('[nebula] Cleared saved server configuration');
+        return;
+    }
+    if (!requestedUrl) {
+        if (currentConfig.serverUrl) {
+            console.log(`[nebula] Current server: ${currentConfig.serverUrl}`);
+        }
+        else {
+            console.log('[nebula] No server configured');
+        }
+        return;
+    }
+    const nextServerUrl = (0, utils_1.normalizeServerUrl)(requestedUrl);
+    const serverChanged = currentConfig.serverUrl !== nextServerUrl;
+    (0, utils_1.writeNebulaConfig)({
+        ...currentConfig,
+        accessToken: serverChanged ? undefined : currentConfig.accessToken,
+        serverUrl: nextServerUrl,
+        user: serverChanged ? undefined : currentConfig.user,
+    });
+    console.log(`[nebula] Saved server: ${nextServerUrl}`);
+    if (serverChanged && currentConfig.accessToken) {
+        console.log('[nebula] Cleared saved login because the server changed');
+    }
+}
+async function zipDirectory(dirPath, outputPath) {
+    const ZipArchive = require('archiver').ZipArchive;
+    return new Promise((resolve, reject) => {
+        const output = fs_1.default.createWriteStream(outputPath);
+        const archive = new ZipArchive({ zlib: { level: 9 } });
+        output.on('close', resolve);
+        archive.on('error', reject);
+        archive.pipe(output);
+        archive.directory(dirPath, false);
+        archive.finalize();
+    });
+}
+async function uploadMiniApp(extraArgs) {
+    const projectRoot = process.cwd();
+    const workspaceRoot = (0, utils_1.findWorkspaceRoot)(projectRoot);
+    const flags = (0, utils_1.parseFlags)(extraArgs);
+    const config = (0, utils_1.readNebulaConfig)();
+    const serverUrl = flags.server
+        ? (0, utils_1.normalizeServerUrl)(flags.server)
+        : config.serverUrl;
+    const accessToken = config.accessToken;
+    if (!serverUrl || !accessToken) {
+        (0, utils_1.exitWithError)('Please configure a server and login first: nebula config server <url> && nebula auth login');
+    }
+    const currentUser = await ensureAuthenticatedSession(serverUrl, accessToken);
+    console.log(`[nebula] Authenticated as ${currentUser.displayName} <${currentUser.email}>`);
+    const appJsonPath = path_1.default.join(projectRoot, 'app.json');
+    (0, utils_1.ensureFileExists)(appJsonPath);
+    const appConfig = (0, utils_1.readJson)(appJsonPath);
+    const buildArgs = (0, utils_1.omitFlags)(extraArgs, [
+        'server',
+        'bundle',
+        'bundle-ios',
+        'bundle-android',
+        'manifest',
+        'version',
+        'build-number',
+        'changelog',
+        'channel',
+        'release-type',
+    ]);
+    const builtArtifacts = await (0, miniapp_1.buildMiniAppArtifacts)(projectRoot, workspaceRoot, appConfig, buildArgs);
+    const manifestPath = builtArtifacts.manifestPath;
+    const iosBundlePath = builtArtifacts.iosBundlePath;
+    const androidBundlePath = builtArtifacts.androidBundlePath;
+    const iosAssetsDir = builtArtifacts.iosAssetsDir;
+    const androidAssetsDir = builtArtifacts.androidAssetsDir;
+    (0, utils_1.ensureFileExists)(iosBundlePath);
+    (0, utils_1.ensureFileExists)(androidBundlePath);
+    (0, utils_1.ensureFileExists)(manifestPath);
+    const buildDir = path_1.default.join(projectRoot, 'build');
+    const iosAssetsZipPath = path_1.default.join(buildDir, 'assets-ios.zip');
+    const androidAssetsZipPath = path_1.default.join(buildDir, 'assets-android.zip');
+    await zipDirectory(iosAssetsDir, iosAssetsZipPath);
+    await zipDirectory(androidAssetsDir, androidAssetsZipPath);
+    (0, utils_1.ensureFileExists)(iosAssetsZipPath);
+    (0, utils_1.ensureFileExists)(androidAssetsZipPath);
+    const version = flags.version || (0, utils_1.getPackageVersion)(projectRoot);
+    const changelog = flags.changelog || '';
+    const formData = new FormData();
+    formData.append('version', version);
+    formData.append('changelog', changelog);
+    formData.append('channel', 'stable');
+    formData.append('releaseType', 'RELEASE');
+    formData.append('bundleIos', new Blob([fs_1.default.readFileSync(iosBundlePath)]), path_1.default.basename(iosBundlePath));
+    formData.append('bundleAndroid', new Blob([fs_1.default.readFileSync(androidBundlePath)]), path_1.default.basename(androidBundlePath));
+    formData.append('manifest', new Blob([fs_1.default.readFileSync(manifestPath)]), path_1.default.basename(manifestPath));
+    formData.append('assetsIos', new Blob([fs_1.default.readFileSync(iosAssetsZipPath)]), 'assets-ios.zip');
+    formData.append('assetsAndroid', new Blob([fs_1.default.readFileSync(androidAssetsZipPath)]), 'assets-android.zip');
+    (0, utils_1.writeNebulaConfig)({
+        ...config,
+        serverUrl,
+    });
+    const response = await (0, utils_1.httpRequest)(`${serverUrl.replace(/\/$/, '')}/mini-apps/by-app-id/${appConfig.appId}/versions/upload`, {
+        body: formData,
+        headers: {
+            Authorization: `Bearer ${accessToken}`,
+        },
+        method: 'POST',
+    });
+    console.log(`[nebula] Uploaded ${appConfig.appId}@${response.version} status=${response.status}`);
+}

package/dist/utils.d.ts

@@ -0,0 +1,27 @@
+export type NebulaPlatformConfig = {
+    accessToken?: string;
+    serverUrl?: string;
+    user?: {
+        id: string;
+        email: string;
+        displayName: string;
+    };
+};
+export declare function exitWithError(message: string): never;
+export declare function ensureFileExists(filePath: string): void;
+export declare function readJson<T>(filePath: string): T;
+export declare function writeFileIfChanged(filePath: string, contents: string): void;
+export declare function resolveBin(binName: string, cwd: string): string;
+export declare function findWorkspaceRoot(startDir: string): string;
+export declare function parseFlags(args: string[]): Record<string, string>;
+export declare function omitFlags(args: string[], excludedKeys: string[]): string[];
+export declare function getPackageVersion(projectRoot: string): string;
+export declare function spawnProcess(projectRoot: string, command: string, args: string[]): Promise<void>;
+export declare function httpRequest<T>(input: string, init: RequestInit): Promise<T>;
+export declare function sleep(ms: number): Promise<void>;
+export declare function tryOpenUrl(url: string): void;
+export declare function spawnDetachedProcess(command: string, args: string[], cwd: string): void;
+export declare function getNebulaConfigPath(): string;
+export declare function readNebulaConfig(): NebulaPlatformConfig;
+export declare function writeNebulaConfig(config: NebulaPlatformConfig): void;
+export declare function normalizeServerUrl(rawValue: string): string;

package/dist/utils.js

@@ -0,0 +1,213 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exitWithError = exitWithError;
+exports.ensureFileExists = ensureFileExists;
+exports.readJson = readJson;
+exports.writeFileIfChanged = writeFileIfChanged;
+exports.resolveBin = resolveBin;
+exports.findWorkspaceRoot = findWorkspaceRoot;
+exports.parseFlags = parseFlags;
+exports.omitFlags = omitFlags;
+exports.getPackageVersion = getPackageVersion;
+exports.spawnProcess = spawnProcess;
+exports.httpRequest = httpRequest;
+exports.sleep = sleep;
+exports.tryOpenUrl = tryOpenUrl;
+exports.spawnDetachedProcess = spawnDetachedProcess;
+exports.getNebulaConfigPath = getNebulaConfigPath;
+exports.readNebulaConfig = readNebulaConfig;
+exports.writeNebulaConfig = writeNebulaConfig;
+exports.normalizeServerUrl = normalizeServerUrl;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+function exitWithError(message) {
+    console.error(`[nebula] ${message}`);
+    process.exit(1);
+}
+function ensureFileExists(filePath) {
+    if (!fs_1.default.existsSync(filePath)) {
+        exitWithError(`Missing required file: ${filePath}`);
+    }
+}
+function readJson(filePath) {
+    try {
+        return JSON.parse(fs_1.default.readFileSync(filePath, 'utf8'));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        exitWithError(`Failed to parse ${filePath}: ${message}`);
+    }
+}
+function writeFileIfChanged(filePath, contents) {
+    const previousContents = fs_1.default.existsSync(filePath)
+        ? fs_1.default.readFileSync(filePath, 'utf8')
+        : null;
+    if (previousContents !== contents) {
+        fs_1.default.writeFileSync(filePath, contents);
+    }
+}
+function resolveBin(binName, cwd) {
+    const extensions = process.platform === 'win32' ? ['.cmd', '.exe', ''] : [''];
+    let currentDir = cwd;
+    while (true) {
+        for (const extension of extensions) {
+            const candidate = path_1.default.join(currentDir, 'node_modules', '.bin', `${binName}${extension}`);
+            if (fs_1.default.existsSync(candidate)) {
+                return candidate;
+            }
+        }
+        const parentDir = path_1.default.dirname(currentDir);
+        if (parentDir === currentDir) {
+            break;
+        }
+        currentDir = parentDir;
+    }
+    exitWithError(`Unable to find "${binName}" from ${cwd}`);
+}
+function findWorkspaceRoot(startDir) {
+    let currentDir = startDir;
+    while (true) {
+        const packageJsonPath = path_1.default.join(currentDir, 'package.json');
+        if (fs_1.default.existsSync(packageJsonPath)) {
+            const packageJson = readJson(packageJsonPath);
+            if (packageJson.workspaces) {
+                return currentDir;
+            }
+        }
+        const parentDir = path_1.default.dirname(currentDir);
+        if (parentDir === currentDir) {
+            break;
+        }
+        currentDir = parentDir;
+    }
+    exitWithError(`Unable to locate workspace root from ${startDir}`);
+}
+function parseFlags(args) {
+    const flags = {};
+    for (let index = 0; index < args.length; index += 1) {
+        const current = args[index];
+        if (!current.startsWith('--')) {
+            continue;
+        }
+        const key = current.slice(2);
+        const next = args[index + 1];
+        if (!next || next.startsWith('--')) {
+            flags[key] = 'true';
+            continue;
+        }
+        flags[key] = next;
+        index += 1;
+    }
+    return flags;
+}
+function omitFlags(args, excludedKeys) {
+    const excluded = new Set(excludedKeys);
+    const result = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const current = args[index];
+        if (!current.startsWith('--')) {
+            result.push(current);
+            continue;
+        }
+        const key = current.slice(2);
+        if (!excluded.has(key)) {
+            result.push(current);
+            const next = args[index + 1];
+            if (next && !next.startsWith('--')) {
+                result.push(next);
+                index += 1;
+            }
+            continue;
+        }
+        const next = args[index + 1];
+        if (next && !next.startsWith('--')) {
+            index += 1;
+        }
+    }
+    return result;
+}
+function getPackageVersion(projectRoot) {
+    const packageJson = readJson(path_1.default.join(projectRoot, 'package.json'));
+    return packageJson.version || '0.0.1';
+}
+function spawnProcess(projectRoot, command, args) {
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(command, args, {
+            cwd: projectRoot,
+            stdio: 'inherit',
+        });
+        child.on('error', reject);
+        child.on('exit', (code, signal) => {
+            if (signal) {
+                reject(new Error(`Process terminated with signal ${signal}`));
+                return;
+            }
+            if (code && code !== 0) {
+                reject(new Error(`Process exited with code ${code}`));
+                return;
+            }
+            resolve();
+        });
+    });
+}
+async function httpRequest(input, init) {
+    const response = await fetch(input, init);
+    if (!response.ok) {
+        const text = await response.text();
+        exitWithError(text || `Request failed with status ${response.status}`);
+    }
+    return (await response.json());
+}
+function sleep(ms) {
+    return new Promise(resolve => {
+        setTimeout(resolve, ms);
+    });
+}
+function tryOpenUrl(url) {
+    const command = process.platform === 'darwin'
+        ? 'open'
+        : process.platform === 'win32'
+            ? 'cmd'
+            : 'xdg-open';
+    const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url];
+    const child = (0, child_process_1.spawn)(command, args, {
+        detached: true,
+        stdio: 'ignore',
+    });
+    child.unref();
+}
+function spawnDetachedProcess(command, args, cwd) {
+    const child = (0, child_process_1.spawn)(command, args, {
+        cwd,
+        detached: true,
+        stdio: 'ignore',
+    });
+    child.unref();
+}
+function getNebulaConfigPath() {
+    return path_1.default.join(os_1.default.homedir(), '.nebula', 'config.json');
+}
+function readNebulaConfig() {
+    const configPath = getNebulaConfigPath();
+    if (!fs_1.default.existsSync(configPath)) {
+        return {};
+    }
+    return readJson(configPath);
+}
+function writeNebulaConfig(config) {
+    const configPath = getNebulaConfigPath();
+    fs_1.default.mkdirSync(path_1.default.dirname(configPath), { recursive: true });
+    fs_1.default.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
+}
+function normalizeServerUrl(rawValue) {
+    const value = rawValue.trim();
+    if (!value) {
+        exitWithError('Server URL cannot be empty.');
+    }
+    return value.replace(/\/$/, '');
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@nebula-rn/cli",
+  "version": "0.0.1",
+  "description": "Nebula CLI - build, bundle and upload mini-apps",
+  "author": "Hector Zhuang",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Hector-Zhuang/nebula.git",
+    "directory": "packages/cli"
+  },
+  "bugs": {
+    "url": "https://github.com/Hector-Zhuang/nebula/issues"
+  },
+  "homepage": "https://github.com/Hector-Zhuang/nebula/tree/main/packages/cli#readme",
+  "keywords": ["nebula", "superapp", "miniapp", "cli"],
+  "main": "./dist/cli.js",
+  "types": "./dist/cli.d.ts",
+  "bin": {
+    "nebula": "./dist/cli.js"
+  },
+  "files": ["dist", "bin", "README.md"],
+  "publishConfig": { "access": "public" },
+  "scripts": {
+    "build": "tsc",
+    "prepack": "npm run build"
+  },
+  "dependencies": {
+    "archiver": "^8.0.0"
+  },
+  "devDependencies": {
+    "@types/archiver": "^8.0.0"
+  }
+}