@embeddables/cli 0.8.0 → 0.8.1

package/dist/commands/init.js

@@ -0,0 +1,384 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import pc from 'picocolors';
+import { writeProjectConfig, readProjectConfig } from '../config/index.js';
+import { isLoggedIn } from '../auth/index.js';
+import { promptForProject } from '../prompts/index.js';
+import * as stdout from '../stdout.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/** Recursively copy a directory, creating target dirs as needed. */
+function copyDirSync(src, dest) {
+    fs.mkdirSync(dest, { recursive: true });
+    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyDirSync(srcPath, destPath);
+        }
+        else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+/**
+ * Generate type declaration stubs in .types/ (project root) so the editor
+ * can resolve imports in generated TSX files without npm install.
+ */
+function writeTypeStubs(cwd) {
+    const typesDir = path.join(cwd, '.types');
+    fs.mkdirSync(typesDir, { recursive: true });
+    // Copy compiled types-builder.d.ts → .types/types.d.ts
+    // (named types-builder in this codebase because it's copied from another repo,
+    // but exposed as simply "types" in consumer projects)
+    // When running from compiled JS: __dirname is dist/commands/, so ../types-builder.d.ts works.
+    // When running via tsx in dev: __dirname is src/commands/, so we fall back to dist/.
+    const candidates = [
+        path.join(__dirname, '..', 'types-builder.d.ts'),
+        path.join(__dirname, '..', '..', 'dist', 'types-builder.d.ts'),
+    ];
+    const typesBuilderDts = candidates.find((p) => fs.existsSync(p));
+    if (typesBuilderDts) {
+        fs.copyFileSync(typesBuilderDts, path.join(typesDir, 'types.d.ts'));
+    }
+    else {
+        stdout.warn('Could not find types-builder.d.ts — run `npm run build` first');
+    }
+    // React JSX runtime types (needed for "jsx": "react-jsx" in tsconfig)
+    fs.writeFileSync(path.join(typesDir, 'react-jsx-runtime.d.ts'), `export namespace JSX {
+  type Element = any
+  interface IntrinsicElements {
+    [elemName: string]: any
+  }
+}
+export function jsx(type: any, props: any, key?: string): JSX.Element
+export function jsxs(type: any, props: any, key?: string): JSX.Element
+export const Fragment: unique symbol
+`, 'utf8');
+    // Component primitives — import real prop types from types-builder,
+    // omitting JSON-structural properties that aren't valid React props
+    const componentsWithOwnType = [
+        'BookMeeting',
+        'Chart',
+        'Container',
+        'CustomButton',
+        'CustomHTML',
+        'FileUpload',
+        'InputBox',
+        'Lottie',
+        'MediaEmbed',
+        'MediaImage',
+        'OptionSelector',
+        'PaypalCheckout',
+        'ProgressBar',
+        'Rive',
+        'StripeCheckout',
+        'StripeCheckout2',
+    ];
+    const baseOnlyComponents = ['PlainText', 'RichText', 'RichTextMarkdown'];
+    const importAliases = componentsWithOwnType.map((name) => `${name} as ${name}JSON`).join(', ');
+    const importLine = `import type { Base, OptionSelectorButton, ${importAliases} } from './types'`;
+    // Properties from the JSON format that are structural/derived in React
+    const omitLine = `type JSONOnly = 'type' | 'parent_id' | 'parent_key' | '_location' | 'components' | '__hide_initially' | '__is_child_already_inserted' | 'clearable' | 'central_play_button'`;
+    // In React, child components are passed via JSX nesting (children), not via a components array
+    // languages is a React-only prop (JSON uses flat lang--{code}--{attr} properties instead)
+    // props is a React-only prop for non-schema properties preserved during round-trip
+    const languagesType = `type Languages = { languages?: Record<string, Record<string, any>> }`;
+    const componentPropsType = `type ComponentProps = { props?: Record<string, any> }`;
+    const propsTypeLine = `type Props<T> = Omit<T, JSONOnly> & { children?: any } & Languages & ComponentProps`;
+    // Extended button type for OptionSelector buttons with multi-language support
+    const buttonTypeLine = `export type OptionSelectorButtonWithLanguages = OptionSelectorButton & Languages`;
+    const typedExports = componentsWithOwnType
+        .map((name) => `export function ${name}(props: Props<${name}JSON>): any`)
+        .join('\n');
+    const baseExports = baseOnlyComponents
+        .map((name) => `export function ${name}(props: Props<Base>): any`)
+        .join('\n');
+    fs.writeFileSync(path.join(typesDir, 'components.d.ts'), importLine +
+        '\n\n' +
+        omitLine +
+        '\n' +
+        languagesType +
+        '\n' +
+        componentPropsType +
+        '\n' +
+        propsTypeLine +
+        '\n\n' +
+        buttonTypeLine +
+        '\n\n' +
+        typedExports +
+        '\n' +
+        baseExports +
+        '\n', 'utf8');
+}
+export async function runInit(opts) {
+    const cwd = process.cwd();
+    const gitignorePath = path.join(cwd, '.gitignore');
+    const embeddablesDir = path.join(cwd, 'embeddables');
+    stdout.header(`${stdout.symbols.wave} Embeddables Project Setup`);
+    const existingConfig = readProjectConfig();
+    // Step 1: Get Embeddables project
+    let projectId = opts.projectId;
+    let selectedProjectTitle;
+    let selectedOrgId;
+    let selectedOrgTitle;
+    if (!projectId && !opts.yes) {
+        if (existingConfig?.project_id) {
+            stdout.dim(`  Using existing project ID: ${existingConfig.project_id}`);
+            projectId = existingConfig.project_id;
+            selectedProjectTitle = existingConfig.project_name || undefined;
+            selectedOrgId = existingConfig.org_id || undefined;
+            selectedOrgTitle = existingConfig.org_title || undefined;
+        }
+        else if (isLoggedIn()) {
+            // Fetch and show project list
+            const fetchSpinner = stdout.spinner('Fetching projects…');
+            try {
+                const selectedProject = await promptForProject({
+                    allowSkip: true,
+                    message: 'Select your Embeddables project:',
+                });
+                fetchSpinner.stop();
+                if (selectedProject) {
+                    projectId = selectedProject.id;
+                    selectedProjectTitle = selectedProject.title || undefined;
+                    selectedOrgId = selectedProject.org_id || undefined;
+                    selectedOrgTitle = selectedProject.org_title || undefined;
+                }
+            }
+            catch {
+                fetchSpinner.stop();
+            }
+        }
+        else {
+            // Not logged in - offer manual entry or skip
+            stdout.dim('  (Login with "embeddables login" to select from your projects)');
+            const { prompt: promptWithCancel } = await import('../helpers/prompt.js');
+            const response = await promptWithCancel({
+                type: 'text',
+                name: 'projectId',
+                message: 'Embeddables project ID (optional):',
+                hint: 'e.g., proj_abc123 - leave empty to skip',
+            });
+            projectId = response.projectId || undefined;
+        }
+    }
+    // Write embeddables.json config
+    if (projectId) {
+        writeProjectConfig({
+            org_id: selectedOrgId,
+            org_title: selectedOrgTitle,
+            project_id: projectId,
+            project_name: selectedProjectTitle,
+        });
+        stdout.success('Created embeddables.json');
+    }
+    // Create or update .gitignore
+    const gitignoreEntries = ['**/.generated/', 'node_modules/', '.DS_Store'];
+    const embeddablesBlock = `# Embeddables\n${gitignoreEntries.join('\n')}\n`;
+    let existingGitignore = '';
+    if (fs.existsSync(gitignorePath)) {
+        existingGitignore = fs.readFileSync(gitignorePath, 'utf8');
+    }
+    const embeddablesSectionRegex = /# Embeddables\n(?:[^\n]*\n)*?(?=\n#|\n\n|$)/;
+    if (embeddablesSectionRegex.test(existingGitignore)) {
+        const updated = existingGitignore.replace(embeddablesSectionRegex, embeddablesBlock);
+        if (updated !== existingGitignore) {
+            fs.writeFileSync(gitignorePath, updated, 'utf8');
+            stdout.success('Updated .gitignore');
+        }
+        else {
+            stdout.dim('  ✓ .gitignore already configured');
+        }
+    }
+    else {
+        const separator = existingGitignore && !existingGitignore.endsWith('\n') ? '\n' : '';
+        const content = existingGitignore
+            ? `${existingGitignore}${separator}\n${embeddablesBlock}`
+            : embeddablesBlock;
+        fs.writeFileSync(gitignorePath, content, 'utf8');
+        stdout.success(existingGitignore ? 'Updated .gitignore' : 'Created .gitignore');
+    }
+    // Create embeddables directory
+    if (!fs.existsSync(embeddablesDir)) {
+        fs.mkdirSync(embeddablesDir, { recursive: true });
+        stdout.success('Created embeddables/ directory');
+    }
+    else {
+        stdout.dim('  ✓ embeddables/ directory exists');
+    }
+    // Remove old .claudefiles folder (replaced by .cursor/ and .claude/)
+    const claudefilesDir = path.join(cwd, '.claudefiles');
+    if (fs.existsSync(claudefilesDir)) {
+        fs.rmSync(claudefilesDir, { recursive: true });
+        stdout.success('Removed old .claudefiles/');
+    }
+    // Inject .cursor/ and .claude/ from source .prompts/embeddables-cli.md (or copy if pre-built dirs exist)
+    const packageRoot = path.resolve(__dirname, '..', '..');
+    const promptsSource = path.join(packageRoot, '.prompts', 'embeddables-cli.md');
+    const sourceCursorDir = path.join(packageRoot, '.cursor');
+    const sourceClaudeDir = path.join(packageRoot, '.claude');
+    if (fs.existsSync(promptsSource)) {
+        const content = fs.readFileSync(promptsSource, 'utf8');
+        const cursorFrontmatter = `---
+globs:
+alwaysApply: true
+---
+
+`;
+        const claudeIntro = `# Embeddables project (Claude Code)
+
+This is an Embeddables project managed by the Embeddables CLI. The CLI transforms Embeddable JSON into a local file structure for development, then compiles it back to JSON for saving.
+
+For full context when editing embeddables (pages, components, styles, actions, computed fields), see:
+
+- **.claude/embeddables-cli.md** — Embeddables CLI structure, types, file layout, and conventions.
+
+All TypeScript types are in \`.types/\` (generated by \`embeddables init\`). Use \`embeddables dev\` to run the dev server and \`embeddables pull\` / \`embeddables save\` to sync with the project.
+`;
+        const codexIntro = `# Embeddables project (Codex)
+
+This is an Embeddables project managed by the Embeddables CLI. The CLI transforms Embeddable JSON into a local file structure for development, then compiles it back to JSON for saving.
+
+All TypeScript types are in \`.types/\` (generated by \`embeddables init\`). Use \`embeddables dev\` to run the dev server and \`embeddables pull\` / \`embeddables save\` to sync with the project.
+
+`;
+        const cursorRulesDir = path.join(cwd, '.cursor', 'rules');
+        const claudeDir = path.join(cwd, '.claude');
+        fs.mkdirSync(cursorRulesDir, { recursive: true });
+        fs.mkdirSync(claudeDir, { recursive: true });
+        fs.writeFileSync(path.join(cursorRulesDir, 'embeddables-cli.md'), cursorFrontmatter + content, 'utf8');
+        fs.writeFileSync(path.join(claudeDir, 'CLAUDE.md'), claudeIntro, 'utf8');
+        fs.writeFileSync(path.join(claudeDir, 'embeddables-cli.md'), content, 'utf8');
+        fs.writeFileSync(path.join(cwd, 'AGENTS.md'), codexIntro + content, 'utf8');
+        stdout.success('Injected .cursor/ rules');
+        stdout.success('Injected .claude/');
+        stdout.success('Injected AGENTS.md (Codex)');
+    }
+    else if (fs.existsSync(sourceCursorDir) || fs.existsSync(sourceClaudeDir)) {
+        if (fs.existsSync(sourceCursorDir)) {
+            copyDirSync(sourceCursorDir, path.join(cwd, '.cursor'));
+            stdout.success('Injected .cursor/ rules');
+        }
+        if (fs.existsSync(sourceClaudeDir)) {
+            copyDirSync(sourceClaudeDir, path.join(cwd, '.claude'));
+            stdout.success('Injected .claude/');
+        }
+    }
+    // Create tsconfig.json for editor support (JSX, type checking)
+    const tsconfigPath = path.join(cwd, 'tsconfig.json');
+    if (!fs.existsSync(tsconfigPath)) {
+        const tsconfig = {
+            compilerOptions: {
+                target: 'esnext',
+                module: 'esnext',
+                moduleResolution: 'bundler',
+                jsx: 'react-jsx',
+                noEmit: true,
+                strict: false,
+                skipLibCheck: true,
+                esModuleInterop: true,
+                baseUrl: '.',
+                paths: {
+                    'react/jsx-runtime': ['./.types/react-jsx-runtime.d.ts'],
+                    '@embeddables/cli/components': ['./.types/components.d.ts'],
+                    '@embeddables/cli/types': ['./.types/types.d.ts'],
+                },
+            },
+            include: ['embeddables'],
+        };
+        fs.writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2) + '\n', 'utf8');
+        stdout.success('Created tsconfig.json');
+    }
+    else {
+        stdout.dim('  ✓ tsconfig.json already exists');
+    }
+    // Migrate .types from old location (embeddables/.types/) to project root (.types/)
+    const oldTypesDir = path.join(embeddablesDir, '.types');
+    if (fs.existsSync(oldTypesDir)) {
+        fs.rmSync(oldTypesDir, { recursive: true });
+        stdout.success('Removed old embeddables/.types/');
+    }
+    // Ensure tsconfig has baseUrl and paths for type resolution
+    if (fs.existsSync(tsconfigPath)) {
+        let tsconfigContent = fs.readFileSync(tsconfigPath, 'utf8');
+        let updated = false;
+        // Migrate old embeddables/.types/ location → .types/
+        if (tsconfigContent.includes('./embeddables/.types/')) {
+            tsconfigContent = tsconfigContent.replaceAll('./embeddables/.types/', './.types/');
+            updated = true;
+        }
+        // Migrate old .types/types-builder → .types/types
+        if (tsconfigContent.includes('./.types/types-builder')) {
+            tsconfigContent = tsconfigContent.replace(/\.\/\.types\/types-builder(\.d\.ts)?"/g, './.types/types.d.ts"');
+            updated = true;
+        }
+        // Migrate paths without .d.ts extension → with .d.ts
+        const extensionless = [
+            ['./.types/react-jsx-runtime"', './.types/react-jsx-runtime.d.ts"'],
+            ['./.types/components"', './.types/components.d.ts"'],
+            ['./.types/types"', './.types/types.d.ts"'],
+        ];
+        for (const [old, replacement] of extensionless) {
+            if (tsconfigContent.includes(old) && !tsconfigContent.includes(replacement)) {
+                tsconfigContent = tsconfigContent.replaceAll(old, replacement);
+                updated = true;
+            }
+        }
+        // Add baseUrl and paths if missing entirely
+        try {
+            const tsconfig = JSON.parse(tsconfigContent);
+            const co = tsconfig.compilerOptions ?? {};
+            let coUpdated = false;
+            if (!co.baseUrl) {
+                co.baseUrl = '.';
+                coUpdated = true;
+            }
+            const requiredPaths = {
+                'react/jsx-runtime': ['./.types/react-jsx-runtime.d.ts'],
+                '@embeddables/cli/components': ['./.types/components.d.ts'],
+                '@embeddables/cli/types': ['./.types/types.d.ts'],
+            };
+            if (!co.paths)
+                co.paths = {};
+            for (const [key, value] of Object.entries(requiredPaths)) {
+                if (!co.paths[key]) {
+                    co.paths[key] = value;
+                    coUpdated = true;
+                }
+            }
+            if (coUpdated) {
+                tsconfig.compilerOptions = co;
+                tsconfigContent = JSON.stringify(tsconfig, null, 2) + '\n';
+                updated = true;
+            }
+        }
+        catch {
+            // If tsconfig isn't valid JSON (e.g. has comments), fall through to string-based updates above
+        }
+        if (updated) {
+            fs.writeFileSync(tsconfigPath, tsconfigContent, 'utf8');
+            stdout.success('Updated tsconfig.json');
+        }
+    }
+    // Remove old .types/types-builder.d.ts (now named .types/types.d.ts)
+    const legacyTypesBuilderDts = path.join(cwd, '.types', 'types-builder.d.ts');
+    if (fs.existsSync(legacyTypesBuilderDts)) {
+        fs.rmSync(legacyTypesBuilderDts);
+    }
+    // Generate type declaration stubs for editor support (no npm install needed)
+    writeTypeStubs(cwd);
+    stdout.success('Generated type declarations');
+    // Next steps in a compact box
+    stdout.gap();
+    const nextStepsLines = [
+        `${pc.cyan('1.')} Login:         ${pc.white('embeddables login')}`,
+        projectId
+            ? `${pc.cyan('2.')} Pull:          ${pc.white('embeddables pull')}`
+            : `${pc.cyan('2.')} Pull:          ${pc.white('embeddables pull --id <embeddable-id>')}`,
+        `${pc.cyan('3.')} Start dev:     ${pc.white('embeddables dev')}`,
+    ];
+    stdout.box(nextStepsLines.join('\n'), { title: 'Next steps', borderColor: 'cyan' });
+    stdout.gap();
+}

package/dist/commands/inspect.d.ts

@@ -0,0 +1,9 @@
+export type RunInspectOptions = {
+    id: string;
+    version?: string;
+    branch?: string;
+    fix?: boolean;
+    engine?: string;
+};
+export declare function runInspect(opts: RunInspectOptions): Promise<void>;
+//# sourceMappingURL=inspect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inspect.d.ts","sourceRoot":"","sources":["../../src/commands/inspect.ts"],"names":[],"mappings":"AA8HA,MAAM,MAAM,iBAAiB,GAAG;IAC9B,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,GAAG,CAAC,EAAE,OAAO,CAAA;IACb,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,wBAAsB,UAAU,CAAC,IAAI,EAAE,iBAAiB,iBAwNvD"}