@bardioc/app-sdk 1.0.2 → 1.0.3

package/dist/dev-auth-vite.js

@@ -0,0 +1,221 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { forwardDevAuthProxyRequest, readJsonBody, sendJson, } from './dev-auth-proxy-core.js';
+import { readDotEnvFile } from './dot-env.js';
+function resolveSessionStorageKey(options) {
+    return options.sessionStorageKey ?? `bardioc.dev.auth.${options.appName}`;
+}
+function readRuntimeEnv(server) {
+    const envDir = server.config.envDir ?? server.config.root;
+    const mode = server.config.mode?.trim();
+    const envFileNames = [
+        '.env',
+        '.env.local',
+        mode ? `.env.${mode}` : null,
+        mode ? `.env.${mode}.local` : null,
+    ];
+    const env = {};
+    for (const fileName of envFileNames) {
+        if (!fileName) {
+            continue;
+        }
+        const filePath = resolve(envDir, fileName);
+        if (!existsSync(filePath)) {
+            continue;
+        }
+        Object.assign(env, readDotEnvFile(filePath));
+    }
+    for (const [key, value] of Object.entries(process.env)) {
+        if (typeof value === 'string') {
+            env[key] = value;
+        }
+    }
+    return env;
+}
+function readDevAuthEnv(server, options) {
+    const env = readRuntimeEnv(server);
+    const hostUrl = env.DEV_AUTH_HOST_URL?.trim().replace(/\/$/, '');
+    const devSessionKey = env.DEV_SESSION_KEY?.trim();
+    const exchangeAppId = env.VITE_APP_ID?.trim();
+    if (!hostUrl || !devSessionKey || !exchangeAppId) {
+        return null;
+    }
+    return {
+        exchangeAppId,
+        hostUrl,
+        devSessionKey,
+        sessionStorageKey: resolveSessionStorageKey(options),
+    };
+}
+function getRequestPathname(req) {
+    const originalUrl = req.__bardiocOriginalUrl;
+    return new URL(originalUrl ?? req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`)
+        .pathname;
+}
+function getBasePath(req, routePath) {
+    const pathname = getRequestPathname(req);
+    if (pathname.endsWith(routePath)) {
+        const basePath = pathname.slice(0, -routePath.length);
+        return basePath || '/';
+    }
+    return '/';
+}
+function buildAppPath(basePath, path) {
+    const normalizedBase = basePath === '/' ? '' : basePath.replace(/\/$/, '');
+    const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+    return `${normalizedBase}${normalizedPath}`;
+}
+function sendHtml(res, status, html) {
+    res.statusCode = status;
+    res.setHeader('Content-Type', 'text/html; charset=utf-8');
+    res.setHeader('Cache-Control', 'no-store');
+    res.end(html);
+}
+function renderLoginHtml(session, basePath, sessionStorageKey) {
+    const payload = JSON.stringify(JSON.stringify(session))
+        .replace(/</g, '\\u003c')
+        .replace(/>/g, '\\u003e')
+        .replace(/&/g, '\\u0026');
+    const redirectPath = buildAppPath(basePath, '/');
+    return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Signing in...</title>
+  </head>
+  <body>
+    <script>
+      window.localStorage.removeItem('${sessionStorageKey.replace('bardioc.dev.auth.', '')}.dev.auth');
+      window.localStorage.setItem('${sessionStorageKey}', ${payload});
+      window.location.replace(${JSON.stringify(redirectPath)});
+    </script>
+  </body>
+</html>`;
+}
+function createLoginHandler(env) {
+    return async (req, res) => {
+        const basePath = getBasePath(req, '/login');
+        sendHtml(res, 200, renderLoginHtml({
+            sessionKey: env.devSessionKey,
+            hostUrl: env.hostUrl,
+            scopeId: null,
+        }, basePath, env.sessionStorageKey));
+    };
+}
+function createProxyHandler(options) {
+    return async (req, res) => {
+        const payload = await readJsonBody(req);
+        if (!payload?.path) {
+            sendJson(res, 400, { error: 'invalid_payload' });
+            return;
+        }
+        try {
+            const transportResponse = await forwardDevAuthProxyRequest(payload, {
+                appId: options.appId,
+                hostUrl: options.env.hostUrl,
+                devSessionKey: options.env.devSessionKey,
+            });
+            const responseText = await transportResponse.text();
+            res.statusCode = transportResponse.status;
+            const contentType = transportResponse.headers.get('content-type');
+            if (contentType) {
+                res.setHeader('Content-Type', contentType);
+            }
+            res.setHeader('Cache-Control', 'no-store');
+            res.end(responseText);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message === 'missing_dev_session') {
+                sendJson(res, 400, { error: 'missing_dev_session' });
+                return;
+            }
+            sendJson(res, 502, { error: 'host_transport_failed' });
+        }
+    };
+}
+function createDevAuthRouter(options) {
+    const handleLogin = createLoginHandler(options.env);
+    const handleProxy = createProxyHandler(options);
+    const handlers = {
+        'GET /login': handleLogin,
+        'POST /proxy': handleProxy,
+    };
+    return async (req, res) => {
+        const url = new URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`);
+        const key = `${req.method ?? 'GET'} ${url.pathname}`;
+        const handler = handlers[key];
+        if (!handler) {
+            sendJson(res, 404, { error: 'not_found' });
+            return;
+        }
+        await handler(req, res);
+    };
+}
+export function bardiocDevAuth(options) {
+    let runtimeConfig = null;
+    return {
+        name: 'bardioc-dev-auth',
+        apply: 'serve',
+        enforce: 'pre',
+        configureServer(server) {
+            runtimeConfig = readDevAuthEnv(server, options);
+            if (!runtimeConfig) {
+                server.config.logger.warn(`[bardioc-dev-auth] DEV_AUTH_HOST_URL + DEV_SESSION_KEY, plus VITE_APP_ID, are required in env files — dev auth disabled for appName="${options.appName}".`);
+                return;
+            }
+            const env = {
+                hostUrl: runtimeConfig.hostUrl,
+                devSessionKey: runtimeConfig.devSessionKey,
+                sessionStorageKey: runtimeConfig.sessionStorageKey,
+            };
+            const router = createDevAuthRouter({ appId: runtimeConfig.exchangeAppId, env });
+            server.config.logger.info(`[bardioc-dev-auth] enabled for appName="${options.appName}" appId="${runtimeConfig.exchangeAppId}" → ${runtimeConfig.hostUrl}/api/transport`);
+            const basePath = server.config.base.endsWith('/')
+                ? server.config.base.slice(0, -1)
+                : server.config.base;
+            server.middlewares.use(async (req, res, next) => {
+                const originalUrl = req.url ?? '';
+                const devAuthReq = req;
+                const parsed = new URL(originalUrl, 'http://localhost');
+                const pathname = parsed.pathname;
+                const routePath = pathname.startsWith(basePath)
+                    ? pathname.slice(basePath.length) || '/'
+                    : pathname;
+                const shouldHandle = routePath === '/login' || routePath === '/proxy';
+                if (shouldHandle) {
+                    try {
+                        devAuthReq.__bardiocOriginalUrl = originalUrl;
+                        req.url = `${routePath}${parsed.search}`;
+                        await router(req, res);
+                    }
+                    catch (error) {
+                        next(error);
+                    }
+                    finally {
+                        req.url = originalUrl;
+                        delete devAuthReq.__bardiocOriginalUrl;
+                    }
+                }
+                else {
+                    next();
+                }
+            });
+        },
+        transformIndexHtml() {
+            if (!runtimeConfig) {
+                return;
+            }
+            return [
+                {
+                    tag: 'script',
+                    injectTo: 'head',
+                    children: `window.__BARDIOC_DEV_AUTH__ = ${JSON.stringify({
+                        hostUrl: runtimeConfig.hostUrl,
+                        sessionKey: runtimeConfig.devSessionKey,
+                    })};`,
+                },
+            ];
+        },
+    };
+}

package/dist/dev-idb.d.ts

@@ -2,9 +2,9 @@ import type { AppMethods, IdbEntry, Params } from './contract.js';
 type In<K extends keyof AppMethods> = Params<AppMethods[K]>;
 /** The host's app storage, kept in this browser's IndexedDB while running standalone. */
 export declare function devIdb(): {
-    get: ({ store, key }: In<"idb.get">) => Promise<IdbEntry<unknown> | null>;
-    put: ({ store, key, value }: In<"idb.put">) => Promise<void>;
-    delete: ({ store, key }: In<"idb.delete">) => Promise<void>;
-    query: ({ store, prefix, limit }: In<"idb.query">) => Promise<IdbEntry<unknown>[]>;
+    get: ({ store, key }: In<'idb.get'>) => Promise<IdbEntry<unknown> | null>;
+    put: ({ store, key, value }: In<'idb.put'>) => Promise<void>;
+    delete: ({ store, key }: In<'idb.delete'>) => Promise<void>;
+    query: ({ store, prefix, limit }: In<'idb.query'>) => Promise<IdbEntry<unknown>[]>;
 };
 export {};

package/dist/dev-session-cli.d.ts

@@ -0,0 +1,34 @@
+import { spawn } from 'node:child_process';
+interface CliConfig {
+    hostUrl?: string;
+    cliAccessToken?: string;
+    cliAccessTokenExpiresAt?: number;
+}
+interface RuntimeEnv {
+    VITE_ENABLE_DEV_AUTH?: string;
+    VITE_APP_ID?: string;
+    DEV_AUTH_HOST_URL?: string;
+}
+interface DevSessionResponse {
+    sessionKey: string;
+    hostUrl: string;
+    appId: string;
+}
+interface CliMainRuntime {
+    argv?: string[];
+    cwd?: () => string;
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    spawnCommand?: typeof spawn;
+    stdout?: Pick<NodeJS.WriteStream, 'write'>;
+    stderr?: Pick<NodeJS.WriteStream, 'write'>;
+    exit?: (code: number) => void;
+    readCliConfig?: () => CliConfig | null;
+}
+export declare function readLayeredEnv(cwd: string, runtimeEnv?: NodeJS.ProcessEnv): RuntimeEnv;
+export declare function readCliConfigFromFile(configPath: string): CliConfig | null;
+export declare function normalizeHostUrl(hostUrl: string): string;
+export declare function assertCliConfig(config: CliConfig | null, hostUrl: string): asserts config is CliConfig;
+export declare function fetchDevSession(hostUrl: string, cliAccessToken: string, appId: string): Promise<DevSessionResponse>;
+export declare function main(runtime?: CliMainRuntime): Promise<void>;
+export {};

package/dist/dev-session-cli.js

@@ -0,0 +1,125 @@
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { readDotEnvFile } from './dot-env.js';
+export function readLayeredEnv(cwd, runtimeEnv = process.env) {
+    const env = {};
+    for (const fileName of ['.env', '.env.local']) {
+        const filePath = resolve(cwd, fileName);
+        if (!existsSync(filePath)) {
+            continue;
+        }
+        Object.assign(env, readDotEnvFile(filePath));
+    }
+    for (const [key, value] of Object.entries(runtimeEnv)) {
+        if (typeof value === 'string') {
+            env[key] = value;
+        }
+    }
+    return env;
+}
+export function readCliConfigFromFile(configPath) {
+    if (!existsSync(configPath)) {
+        return null;
+    }
+    const parsed = JSON.parse(readFileSync(configPath, 'utf8'));
+    return parsed;
+}
+function readCliConfig() {
+    return readCliConfigFromFile(resolve(homedir(), '.bardioc', 'config.json'));
+}
+export function normalizeHostUrl(hostUrl) {
+    return hostUrl.trim().replace(/\/$/, '');
+}
+export function assertCliConfig(config, hostUrl) {
+    if (!config?.hostUrl || !config.cliAccessToken) {
+        throw new Error('Missing CLI login. Run `bardioc login` first.');
+    }
+    if (normalizeHostUrl(config.hostUrl) !== normalizeHostUrl(hostUrl)) {
+        throw new Error(`CLI login host ${normalizeHostUrl(config.hostUrl)} does not match DEV_AUTH_HOST_URL ${normalizeHostUrl(hostUrl)}.`);
+    }
+    if (typeof config.cliAccessTokenExpiresAt === 'number' &&
+        config.cliAccessTokenExpiresAt > 0 &&
+        config.cliAccessTokenExpiresAt * 1000 <= Date.now()) {
+        throw new Error('Stored CLI login is expired. Run `bardioc login` again.');
+    }
+}
+export async function fetchDevSession(hostUrl, cliAccessToken, appId) {
+    const response = await fetch(`${normalizeHostUrl(hostUrl)}/api/auth/dev-session`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${cliAccessToken}`,
+        },
+        body: JSON.stringify({ appId }),
+        cache: 'no-store',
+    });
+    if (!response.ok) {
+        const data = (await response.json().catch(() => ({})));
+        throw new Error(data.error ?? `Dev session failed (${response.status})`);
+    }
+    return (await response.json());
+}
+export async function main(runtime = {}) {
+    const argv = runtime.argv ?? process.argv;
+    const currentEnv = runtime.env ?? process.env;
+    const currentCwd = runtime.cwd ?? (() => process.cwd());
+    const spawnCommand = runtime.spawnCommand ?? spawn;
+    const stdout = runtime.stdout ?? process.stdout;
+    const stderr = runtime.stderr ?? process.stderr;
+    const exit = runtime.exit ?? process.exit;
+    const separatorIndex = argv.indexOf('--');
+    const commandArgs = separatorIndex >= 0 ? argv.slice(separatorIndex + 1) : [];
+    if (commandArgs.length === 0) {
+        throw new Error('Missing command after `--`. Example: bardioc-dev-session -- vite');
+    }
+    const cwd = currentCwd();
+    const env = readLayeredEnv(cwd, currentEnv);
+    const devAuthEnabled = env.VITE_ENABLE_DEV_AUTH === 'true';
+    const childEnv = { ...currentEnv };
+    const [command, ...commandRestArgs] = commandArgs;
+    if (!command) {
+        throw new Error('Missing command after `--`. Example: bardioc-dev-session -- vite');
+    }
+    if (devAuthEnabled) {
+        const appId = env.VITE_APP_ID?.trim();
+        const hostUrl = env.DEV_AUTH_HOST_URL?.trim();
+        if (!appId) {
+            throw new Error('Missing VITE_APP_ID for standalone dev auth.');
+        }
+        if (!hostUrl) {
+            throw new Error('Missing DEV_AUTH_HOST_URL for standalone dev auth.');
+        }
+        const cliConfig = (runtime.readCliConfig ?? readCliConfig)();
+        assertCliConfig(cliConfig, hostUrl);
+        const devSession = await fetchDevSession(hostUrl, cliConfig.cliAccessToken, appId);
+        childEnv.DEV_AUTH_HOST_URL = normalizeHostUrl(devSession.hostUrl);
+        childEnv.DEV_SESSION_KEY = devSession.sessionKey;
+        stdout.write(`[bardioc-dev-session] Refreshed dev session for appId="${devSession.appId}" via ${childEnv.DEV_AUTH_HOST_URL}\n`);
+    }
+    const child = spawnCommand(command, commandRestArgs, {
+        stdio: 'inherit',
+        env: childEnv,
+        shell: (runtime.platform ?? process.platform) === 'win32',
+    });
+    child.on('exit', (code) => {
+        exit(code ?? 0);
+    });
+    child.on('error', (error) => {
+        stderr.write(`${error.message}\n`);
+        exit(1);
+    });
+}
+const isDirectRun = process.argv[1]
+    ? realpathSync.native(resolve(process.argv[1])) ===
+        realpathSync.native(fileURLToPath(import.meta.url))
+    : false;
+if (isDirectRun) {
+    void main().catch(error => {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`[bardioc-dev-session] ${message}\n`);
+        process.exit(1);
+    });
+}

package/dist/host-bridge.d.ts

@@ -0,0 +1,3 @@
+import type { HostBridge, HostBridgeConfig } from './types.js';
+/** Create a bridge between an app and its host OS, over `postMessage` unless `config.channel` says otherwise. */
+export declare function createHostBridge(config: HostBridgeConfig): HostBridge;