@embeddables/cli 0.8.0 → 0.8.2

package/dist/commands/builder-open.js

@@ -0,0 +1,74 @@
+import { exec } from 'node:child_process';
+import pc from 'picocolors';
+import { isLoggedIn } from '../auth/index.js';
+import { getProjectId, writeProjectConfig } from '../config/index.js';
+import { promptForProject, promptForLocalEmbeddable } from '../prompts/index.js';
+import { createLogger, exit } from '../logger.js';
+import { getSentryContextFromEmbeddableConfig, getSentryContextFromProjectConfig, setSentryContext, } from '../sentry-context.js';
+import * as stdout from '../stdout.js';
+import { inferEmbeddableFromCwd } from '../helpers/utils.js';
+function openUrl(url) {
+    const platform = process.platform;
+    const cmd = platform === 'darwin' ? 'open' : platform === 'win32' ? 'start' : 'xdg-open';
+    exec(`${cmd} ${JSON.stringify(url)}`, (err) => {
+        if (err) {
+            stdout.warn('Could not open browser automatically. Please open the URL manually.');
+        }
+    });
+}
+export async function runBuilderOpen(opts) {
+    const logger = createLogger('runBuilderOpen');
+    const inferred = inferEmbeddableFromCwd();
+    let embeddableId = opts.id ?? inferred?.embeddableId;
+    if (inferred && !opts.id && embeddableId) {
+        process.chdir(inferred.projectRoot);
+    }
+    setSentryContext(getSentryContextFromProjectConfig());
+    let projectId = getProjectId();
+    if (!projectId) {
+        if (!isLoggedIn()) {
+            stdout.warn('No project configured and not logged in.');
+            stdout.dim('Run "embeddables login" first, or add a project_id to embeddables.json.');
+            logger.error('no project id and not logged in');
+            await exit(1);
+            return;
+        }
+        stdout.step('No project configured. Fetching projects…');
+        const selectedProject = await promptForProject();
+        if (!selectedProject) {
+            logger.error('project selection failed');
+            await exit(1);
+            return;
+        }
+        projectId = selectedProject.id;
+        writeProjectConfig({
+            org_id: selectedProject.org_id || undefined,
+            org_title: selectedProject.org_title || undefined,
+            project_id: projectId,
+            project_name: selectedProject.title || undefined,
+        });
+        stdout.success('Saved project to embeddables.json');
+        stdout.gap();
+    }
+    if (!embeddableId) {
+        const selected = await promptForLocalEmbeddable({
+            message: 'Select an embeddable to open in the Builder:',
+        });
+        if (!selected) {
+            logger.error('no embeddable selected');
+            await exit(1);
+            return;
+        }
+        embeddableId = selected;
+        stdout.gap();
+    }
+    if (embeddableId) {
+        setSentryContext({
+            embeddable: { id: embeddableId },
+            ...getSentryContextFromEmbeddableConfig(embeddableId),
+        });
+    }
+    const url = `https://app.embeddables.com/project/${projectId}/embeddables/${embeddableId}/edit`;
+    stdout.success(`Opening Builder: ${pc.underline(url)}`);
+    openUrl(url);
+}

package/dist/commands/dev.d.ts

@@ -0,0 +1,12 @@
+export declare function runDev(opts: {
+    id?: string;
+    pages?: string;
+    out?: string;
+    fix?: boolean;
+    local?: boolean;
+    engine: string;
+    port: string;
+    overrideRoute: string;
+    pageKeyFrom: 'filename' | 'export';
+}): Promise<void>;
+//# sourceMappingURL=dev.d.ts.map

package/dist/commands/dev.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../src/commands/dev.ts"],"names":[],"mappings":"AAoHA,wBAAsB,MAAM,CAAC,IAAI,EAAE;IACjC,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,GAAG,CAAC,EAAE,OAAO,CAAA;IACb,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,aAAa,EAAE,MAAM,CAAA;IACrB,WAAW,EAAE,UAAU,GAAG,QAAQ,CAAA;CACnC,iBAwJA"}

package/dist/commands/dev.js

@@ -0,0 +1,226 @@
+import fs from 'node:fs';
+import net from 'node:net';
+import path from 'node:path';
+import chokidar from 'chokidar';
+import pc from 'picocolors';
+import { compileAllPages } from '../compiler/index.js';
+import { startProxyServer } from '../proxy/server.js';
+import { formatError } from '../compiler/errors.js';
+import { captureException, createLogger, exit } from '../logger.js';
+import { getSentryContextFromEmbeddableConfig, getSentryContextFromProjectConfig, setSentryContext, } from '../sentry-context.js';
+import * as stdout from '../stdout.js';
+import { inferEmbeddableFromCwd } from '../helpers/utils.js';
+/**
+ * Check whether a port is available by attempting to listen on it.
+ */
+function isPortAvailable(port) {
+    return new Promise((resolve) => {
+        const server = net.createServer();
+        server.once('error', () => resolve(false));
+        server.once('listening', () => {
+            server.close(() => resolve(true));
+        });
+        server.listen(port);
+    });
+}
+/**
+ * Starting from `startPort`, find the first available port.
+ * Tries up to `maxAttempts` consecutive ports.
+ */
+async function getAvailablePort(startPort, maxAttempts = 20) {
+    for (let i = 0; i < maxAttempts; i++) {
+        const port = startPort + i;
+        if (await isPortAvailable(port)) {
+            return port;
+        }
+    }
+    throw new Error(`Could not find an available port (tried ${startPort}–${startPort + maxAttempts - 1})`);
+}
+async function discoverEmbeddables() {
+    const embeddablesDir = 'embeddables';
+    if (!fs.existsSync(embeddablesDir)) {
+        return [];
+    }
+    const entries = fs.readdirSync(embeddablesDir, { withFileTypes: true });
+    const embeddables = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const id = entry.name;
+        const metadataPath = path.join(embeddablesDir, id, 'metadata.json');
+        let title = null;
+        if (fs.existsSync(metadataPath)) {
+            try {
+                const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf-8'));
+                title = metadata.title || null;
+            }
+            catch {
+                // Ignore JSON parse errors
+            }
+        }
+        embeddables.push({ id, title });
+    }
+    // Sort by title (with title) first, then by id
+    return embeddables.sort((a, b) => {
+        if (a.title && !b.title)
+            return -1;
+        if (!a.title && b.title)
+            return 1;
+        const aLabel = a.title || a.id;
+        const bLabel = b.title || b.id;
+        return aLabel.localeCompare(bLabel, undefined, { sensitivity: 'base' });
+    });
+}
+async function promptForEmbeddable() {
+    const embeddables = await discoverEmbeddables();
+    if (embeddables.length === 0) {
+        stdout.error('No embeddables found in the embeddables/ directory.');
+        stdout.dim('Run `embeddables pull --id <id>` to pull an embeddable first.');
+        return null;
+    }
+    const choices = embeddables.map((e) => ({
+        title: e.title ? `${e.title} (${e.id})` : e.id,
+        value: e.id,
+    }));
+    const { prompt: promptWithCancel } = await import('../helpers/prompt.js');
+    const response = await promptWithCancel({
+        type: 'select',
+        name: 'id',
+        message: 'Select an embeddable to run:',
+        choices,
+    });
+    return response.id || null;
+}
+export async function runDev(opts) {
+    const logger = createLogger('runDev');
+    const inferred = inferEmbeddableFromCwd();
+    let embeddableId = opts.id ?? inferred?.embeddableId;
+    if (inferred && !opts.id && embeddableId) {
+        process.chdir(inferred.projectRoot);
+    }
+    setSentryContext(getSentryContextFromProjectConfig());
+    if (!embeddableId) {
+        const selected = await promptForEmbeddable();
+        if (!selected) {
+            logger.error('no embeddable selected');
+            await exit(1);
+            return;
+        }
+        embeddableId = selected;
+    }
+    if (embeddableId) {
+        setSentryContext({
+            embeddable: { id: embeddableId },
+            ...getSentryContextFromEmbeddableConfig(embeddableId),
+        });
+    }
+    logger.info('dev started', { engine: opts.engine, port: opts.port });
+    const pagesGlob = opts.pages || `embeddables/${embeddableId}/pages/**/*.page.tsx`;
+    const outPath = opts.out || path.join('embeddables', embeddableId, '.generated', 'embeddable.json');
+    const stylesDir = path.join('embeddables', embeddableId, 'styles');
+    const stylesGlob = `embeddables/${embeddableId}/styles/**/*.css`;
+    const configPath = path.join('embeddables', embeddableId, 'config.json');
+    const globalComponentsGlob = `embeddables/${embeddableId}/global-components/**/*.location.tsx`;
+    const computedFieldsGlob = `embeddables/${embeddableId}/computed-fields/**/*.js`;
+    const actionsGlob = `embeddables/${embeddableId}/actions/**/*.js`;
+    const fixLint = opts.fix ? true : 'prompt';
+    // Initial build with spinner
+    try {
+        await stdout.withSpinner('Building…', async () => {
+            await compileAllPages({
+                pagesGlob,
+                outPath,
+                pageKeyFrom: opts.pageKeyFrom,
+                stylesDir,
+                embeddableId: embeddableId,
+                configPath,
+                fixLint,
+            });
+        }, {
+            successText: 'Initial build complete',
+        });
+    }
+    catch (e) {
+        captureException(e);
+        stdout.error(formatError(e));
+        logger.error('initial build failed');
+        await exit(1);
+    }
+    // Start proxy — find an available port if the requested one is taken
+    const requestedPort = Number(opts.port);
+    let port;
+    try {
+        port = await getAvailablePort(requestedPort);
+    }
+    catch (e) {
+        captureException(e);
+        stdout.error(e.message);
+        logger.error('no available port', { requestedPort });
+        await exit(1);
+        return;
+    }
+    if (port !== requestedPort) {
+        stdout.warn(`Port ${requestedPort} is in use, using ${port} instead.`);
+    }
+    // Mute proxy startup logs (workbench, routes, etc.) — the Dev Server box has all the info
+    stdout.mute();
+    const proxy = await startProxyServer({
+        port,
+        engineOrigin: opts.engine,
+        overrideRoute: opts.overrideRoute,
+        generatedJsonPath: outPath,
+        embeddableId,
+        watchWorkbench: true,
+    });
+    stdout.unmute();
+    logger.info('dev server running', { port });
+    // Watch all source files: pages, styles, config, global components, computed fields, and actions
+    const watcher = chokidar.watch([pagesGlob, stylesGlob, configPath, globalComponentsGlob, computedFieldsGlob, actionsGlob], {
+        ignoreInitial: true,
+    });
+    const rebuild = async () => {
+        const elapsed = stdout.timer();
+        const s = stdout.spinner('Rebuilding…');
+        try {
+            await compileAllPages({
+                pagesGlob,
+                outPath,
+                pageKeyFrom: opts.pageKeyFrom,
+                stylesDir,
+                embeddableId: embeddableId,
+                configPath,
+                fixLint,
+            });
+            proxy.broadcastReload();
+            s.succeed(`Rebuilt in ${elapsed()}`);
+        }
+        catch (e) {
+            // Keep dev server running; compiler errors show in console.
+            // (Proxy will still serve the last good JSON.)
+            captureException(e);
+            s.fail('Rebuild failed');
+            stdout.error(formatError(e));
+        }
+    };
+    let t;
+    watcher.on('all', () => {
+        clearTimeout(t);
+        t = setTimeout(rebuild, 80);
+    });
+    // Embeddable context
+    stdout.infoBox(`ID: ${embeddableId}  ·  Engine: ${opts.engine}`);
+    // Dev server ready box
+    const previewUrl = `http://localhost:${port}?id=${embeddableId}&version=latest`;
+    const modeLabel = opts.local
+        ? `${pc.blue('Local')} (${opts.engine})`
+        : `${pc.yellow('Remote')} (${opts.engine})`;
+    const boxContent = [
+        `${pc.gray('Mode:')}      ${modeLabel}`,
+        `${pc.gray('Preview:')}   ${pc.underline(pc.cyan(previewUrl))}`,
+        '',
+        `${pc.gray(`Watching embeddables/${embeddableId}/ for changes…`)}`,
+    ].join('\n');
+    stdout.gap();
+    stdout.box(boxContent, { title: 'Dev Server', borderColor: 'green' });
+    stdout.gap();
+}

package/dist/commands/experiments-connect.d.ts

@@ -0,0 +1,6 @@
+export declare function runExperimentsConnect(opts: {
+    id?: string;
+    experimentId?: string;
+    experimentKey?: string;
+}): Promise<void>;
+//# sourceMappingURL=experiments-connect.d.ts.map

package/dist/commands/experiments-connect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"experiments-connect.d.ts","sourceRoot":"","sources":["../../src/commands/experiments-connect.ts"],"names":[],"mappings":"AAmBA,wBAAsB,qBAAqB,CAAC,IAAI,EAAE;IAChD,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB,iBAeA"}

package/dist/commands/experiments-connect.js

@@ -0,0 +1,140 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { isLoggedIn } from '../auth/index.js';
+import { getProjectId, writeProjectConfig } from '../config/index.js';
+import { promptForProject, promptForLocalEmbeddable, promptForExperiment, } from '../prompts/index.js';
+import { createLogger, exit } from '../logger.js';
+import { getSentryContextFromEmbeddableConfig, getSentryContextFromProjectConfig, setSentryContext, } from '../sentry-context.js';
+import * as stdout from '../stdout.js';
+import { inferEmbeddableFromCwd } from '../helpers/utils.js';
+export async function runExperimentsConnect(opts) {
+    const logger = createLogger('runExperimentsConnect');
+    try {
+        await runExperimentsConnectInner(opts);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            stdout.error(`Connect failed: ${error.message}`);
+        }
+        else {
+            stdout.error('Connect failed with an unexpected error.');
+        }
+        logger.error('experiments connect failed', {
+            message: error instanceof Error ? error.message : 'unexpected error',
+        });
+        await exit(1);
+    }
+}
+async function runExperimentsConnectInner(opts) {
+    const logger = createLogger('runExperimentsConnect');
+    // 1. Check login (needed for fetching experiments from Supabase)
+    if (!isLoggedIn()) {
+        stdout.warn('Not logged in.');
+        stdout.dim('Run "embeddables login" first.');
+        logger.error('not logged in');
+        await exit(1);
+    }
+    // 2. Get project ID (needed for experiment list)
+    let projectId = getProjectId();
+    if (!projectId) {
+        stdout.step('No project configured. Fetching projects…');
+        const selectedProject = await promptForProject();
+        if (!selectedProject) {
+            await exit(1);
+            return;
+        }
+        projectId = selectedProject.id;
+        writeProjectConfig({
+            org_id: selectedProject.org_id || undefined,
+            org_title: selectedProject.org_title || undefined,
+            project_id: projectId,
+            project_name: selectedProject.title || undefined,
+        });
+        stdout.success('Saved project to embeddables.json');
+        stdout.gap();
+    }
+    // 4. Get embeddable ID (from option, cwd inference, or interactive prompt)
+    const inferred = inferEmbeddableFromCwd();
+    let embeddableId = opts.id ?? inferred?.embeddableId;
+    if (inferred && !opts.id && embeddableId) {
+        process.chdir(inferred.projectRoot);
+    }
+    setSentryContext(getSentryContextFromProjectConfig());
+    if (!embeddableId) {
+        const selected = await promptForLocalEmbeddable({
+            message: 'Select an embeddable to connect the experiment to:',
+        });
+        if (!selected) {
+            await exit(1);
+            return;
+        }
+        embeddableId = selected;
+        stdout.gap();
+    }
+    if (embeddableId) {
+        setSentryContext({
+            embeddable: { id: embeddableId },
+            ...getSentryContextFromEmbeddableConfig(embeddableId),
+        });
+    }
+    // 5. Get experiment_id and experiment_key (from opts or interactive prompt)
+    let experimentId = opts.experimentId;
+    let experimentKey = opts.experimentKey;
+    if (experimentId && !experimentKey) {
+        stdout.error('When using --experiment-id, --experiment-key is also required.');
+        logger.error('missing experiment-key flag');
+        await exit(1);
+    }
+    if (experimentKey && !experimentId) {
+        stdout.error('When using --experiment-key, --experiment-id is also required.');
+        logger.error('missing experiment-id flag');
+        await exit(1);
+    }
+    if (!experimentId || !experimentKey) {
+        const selected = await stdout.withSpinner('Fetching experiments…', async () => {
+            return promptForExperiment(projectId, {
+                message: 'Select an experiment to connect:',
+                excludeConnectedTo: embeddableId,
+            });
+        }, { successText: 'Experiments loaded' });
+        if (!selected) {
+            await exit(1);
+            return;
+        }
+        experimentId = selected.experiment_id;
+        experimentKey = selected.experiment_key;
+        stdout.gap();
+    }
+    // 6. Read config.json
+    const configPath = path.join('embeddables', embeddableId, 'config.json');
+    if (!fs.existsSync(configPath)) {
+        stdout.error(`No config.json found at ${configPath}`);
+        stdout.dim('Run "embeddables pull" or "embeddables init" first.');
+        logger.error('config not found', { configPath });
+        await exit(1);
+    }
+    let config;
+    try {
+        const content = fs.readFileSync(configPath, 'utf8');
+        config = JSON.parse(content);
+    }
+    catch {
+        stdout.error('Failed to parse config.json.');
+        logger.error('failed to parse config');
+        await exit(1);
+        return;
+    }
+    // 7. Append to connected_experiments
+    const connectedExperiments = Array.isArray(config.connected_experiments) ? [...config.connected_experiments] : [];
+    const alreadyConnected = connectedExperiments.some((e) => e.experiment_id === experimentId && e.experiment_key === experimentKey);
+    if (alreadyConnected) {
+        stdout.warn(`Experiment "${experimentKey}" is already connected to this embeddable.`);
+        return;
+    }
+    connectedExperiments.push({ experiment_id: experimentId, experiment_key: experimentKey });
+    config.connected_experiments = connectedExperiments;
+    // 8. Write the modified config back
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf8');
+    stdout.success(`Connected experiment "${experimentKey}" to embeddable`);
+    stdout.dim('Run "embeddables save" to persist to the cloud.');
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,5 @@
+export declare function runInit(opts: {
+    projectId?: string;
+    yes?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=init.d.ts.map

package/dist/commands/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"AAoIA,wBAAsB,OAAO,CAAC,IAAI,EAAE;IAAE,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,OAAO,CAAA;CAAE,iBAkSxE"}