@eide/foir-cli 0.1.16 → 0.1.18

package/dist/scaffold/scaffold.js

@@ -0,0 +1,462 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { detectPackageManager } from './package-manager.js';
+export async function scaffold(projectName, extensionType, apiUrl) {
+    const projectDir = path.resolve(process.cwd(), projectName);
+    if (fs.existsSync(projectDir)) {
+        throw new Error(`Directory "${projectName}" already exists. Choose a different name or remove the existing directory.`);
+    }
+    // Create directory structure
+    const files = getFiles(projectName, extensionType, apiUrl);
+    for (const [filePath, content] of Object.entries(files)) {
+        const fullPath = path.join(projectDir, filePath);
+        const dir = path.dirname(fullPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(fullPath, content, 'utf-8');
+    }
+    // Detect package manager and print instructions
+    const pm = detectPackageManager();
+    console.log('  Files created:');
+    console.log();
+    for (const filePath of Object.keys(files)) {
+        console.log(`    ${filePath}`);
+    }
+    console.log();
+    console.log('  Done! Next steps:');
+    console.log();
+    console.log(`    cd ${projectName}`);
+    console.log(`    ${pm.installCommand}`);
+    console.log(`    cp ui/.env.example ui/.env.local`);
+    console.log(`    cp api/.env.example api/.env.local`);
+    console.log(`    ${pm.name === 'npm' ? 'npm run' : pm.name} dev`);
+    console.log();
+}
+function getFiles(projectName, extensionType, apiUrl) {
+    return {
+        // Root
+        'package.json': getRootPackageJson(projectName),
+        'extension.manifest.json': getManifest(projectName, extensionType),
+        // UI (Vite SPA)
+        'ui/package.json': getUiPackageJson(projectName),
+        'ui/tsconfig.json': getUiTsconfig(),
+        'ui/vite.config.ts': getUiViteConfig(),
+        'ui/index.html': getUiIndexHtml(projectName),
+        'ui/.env.example': getUiEnvExample(apiUrl),
+        'ui/.gitignore': getUiGitignore(),
+        'ui/src/main.tsx': getUiMain(),
+        'ui/src/App.tsx': getUiApp(extensionType),
+        'ui/src/index.css': getUiCss(),
+        'ui/src/vite-env.d.ts': '/// <reference types="vite/client" />\n',
+        // API (Hono)
+        'api/package.json': getApiPackageJson(projectName),
+        'api/tsconfig.json': getApiTsconfig(),
+        'api/.env.example': getApiEnvExample(apiUrl),
+        'api/.gitignore': 'node_modules\ndist\n.env\n.env.local\n',
+        'api/src/index.ts': getApiIndex(),
+        'api/src/routes/webhooks.ts': getApiWebhooks(),
+        'api/src/routes/health.ts': getApiHealth(),
+        'api/src/lib/platform.ts': getApiPlatform(),
+    };
+}
+// ---------------------------------------------------------------------------
+// Root
+// ---------------------------------------------------------------------------
+function getRootPackageJson(name) {
+    const pkg = {
+        name,
+        version: '0.1.0',
+        private: true,
+        scripts: {
+            dev: 'concurrently "pnpm --filter ./ui dev" "pnpm --filter ./api dev"',
+            build: 'pnpm --filter ./ui build && pnpm --filter ./api build',
+        },
+        devDependencies: {
+            concurrently: '^9.0.0',
+        },
+    };
+    return JSON.stringify(pkg, null, 2) + '\n';
+}
+function getManifest(name, extensionType) {
+    const manifest = {
+        name: name.replace(/-/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase()),
+        version: '0.1.0',
+        type: extensionType,
+        description: `${extensionType} extension`,
+        entityTypes: [],
+    };
+    return JSON.stringify(manifest, null, 2) + '\n';
+}
+// ---------------------------------------------------------------------------
+// UI (Vite SPA)
+// ---------------------------------------------------------------------------
+function getUiPackageJson(name) {
+    const pkg = {
+        name: `${name}-ui`,
+        version: '0.1.0',
+        private: true,
+        type: 'module',
+        scripts: {
+            dev: 'vite',
+            build: 'tsc && vite build',
+            preview: 'vite preview',
+        },
+        dependencies: {
+            '@eide/extension-sdk': '^0.1.0',
+            react: '^19.0.0',
+            'react-dom': '^19.0.0',
+        },
+        devDependencies: {
+            '@tailwindcss/vite': '^4.0.6',
+            '@types/react': '^19.0.0',
+            '@types/react-dom': '^19.0.0',
+            '@vitejs/plugin-react': '^4.3.4',
+            tailwindcss: '^4.0.0',
+            typescript: '^5.0.0',
+            vite: '^6.0.7',
+        },
+    };
+    return JSON.stringify(pkg, null, 2) + '\n';
+}
+function getUiTsconfig() {
+    const config = {
+        compilerOptions: {
+            target: 'ES2020',
+            lib: ['ES2020', 'DOM', 'DOM.Iterable'],
+            module: 'ESNext',
+            skipLibCheck: true,
+            moduleResolution: 'bundler',
+            allowImportingTsExtensions: true,
+            resolveJsonModule: true,
+            isolatedModules: true,
+            noEmit: true,
+            jsx: 'react-jsx',
+            strict: true,
+            baseUrl: '.',
+            paths: { '@/*': ['./src/*'] },
+        },
+        include: ['src'],
+    };
+    return JSON.stringify(config, null, 2) + '\n';
+}
+function getUiViteConfig() {
+    return `import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+import tailwindcss from '@tailwindcss/vite';
+import path from 'path';
+
+export default defineConfig({
+  plugins: [react(), tailwindcss()],
+  resolve: {
+    alias: {
+      '@': path.resolve(__dirname, './src'),
+    },
+  },
+  server: {
+    port: 3001,
+    host: '127.0.0.1',
+    cors: true,
+    headers: {
+      'X-Frame-Options': 'ALLOWALL',
+      'Content-Security-Policy': 'frame-ancestors *',
+    },
+  },
+  build: {
+    outDir: 'dist',
+    sourcemap: true,
+  },
+});
+`;
+}
+function getUiIndexHtml(name) {
+    const title = name
+        .replace(/-/g, ' ')
+        .replace(/\b\w/g, (c) => c.toUpperCase());
+    return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${title}</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
+`;
+}
+function getUiEnvExample(apiUrl) {
+    return `VITE_PARENT_ORIGIN=http://localhost:3000
+VITE_API_URL=${apiUrl}
+`;
+}
+function getUiGitignore() {
+    return `node_modules
+dist
+.env
+.env.local
+`;
+}
+function getUiMain() {
+    return `import { StrictMode } from 'react';
+import { createRoot } from 'react-dom/client';
+import { ExtensionProvider, useExtension } from '@eide/extension-sdk';
+import { useEffect } from 'react';
+import { App } from './App';
+import './index.css';
+
+function ThemeSync({ children }: { children: React.ReactNode }) {
+  const { theme } = useExtension();
+
+  useEffect(() => {
+    const root = document.documentElement;
+    root.classList.remove('light', 'dark');
+    root.classList.add(theme);
+  }, [theme]);
+
+  return <>{children}</>;
+}
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <ExtensionProvider>
+      <ThemeSync>
+        <App />
+      </ThemeSync>
+    </ExtensionProvider>
+  </StrictMode>
+);
+`;
+}
+function getUiApp(extensionType) {
+    switch (extensionType) {
+        case 'custom-editor':
+            return getCustomEditorApp();
+        case 'widget':
+            return getWidgetApp();
+        case 'workflow':
+            return getWorkflowApp();
+    }
+}
+function getCustomEditorApp() {
+    return `import { useExtension, useAutoResize } from '@eide/extension-sdk';
+
+export function App() {
+  const { isReady, init, updateField, setDirty } = useExtension();
+  const containerRef = useAutoResize({ minHeight: 600 });
+
+  if (!isReady) return null;
+
+  return (
+    <div ref={containerRef} className="p-6 space-y-4">
+      <h1 className="text-lg font-semibold">
+        Editing: {init?.entityModelKey}
+      </h1>
+      <p className="text-sm text-gray-500">
+        Record: {init?.recordId}
+      </p>
+      {/* Add your editor form fields here */}
+    </div>
+  );
+}
+`;
+}
+function getWidgetApp() {
+    return `import { useExtension, useAutoResize } from '@eide/extension-sdk';
+
+export function App() {
+  const { isReady, init, client } = useExtension();
+  const containerRef = useAutoResize({ minHeight: 300 });
+
+  if (!isReady) return null;
+
+  return (
+    <div ref={containerRef} className="p-6 space-y-4">
+      <h2 className="text-lg font-semibold">Dashboard Widget</h2>
+      <p className="text-sm text-gray-500">
+        Connected to: {init?.entityModelKey}
+      </p>
+      {/* Add your widget content here */}
+    </div>
+  );
+}
+`;
+}
+function getWorkflowApp() {
+    return `import { useExtension, useAutoResize } from '@eide/extension-sdk';
+
+export function App() {
+  const { isReady, init, client, requestSave } = useExtension();
+  const containerRef = useAutoResize({ minHeight: 400 });
+
+  if (!isReady) return null;
+
+  return (
+    <div ref={containerRef} className="p-6 space-y-4">
+      <h1 className="text-lg font-semibold">Workflow Extension</h1>
+      <p className="text-sm text-gray-500">
+        Processing: {init?.entityModelKey} / {init?.recordId}
+      </p>
+      {/* Add your workflow steps here */}
+    </div>
+  );
+}
+`;
+}
+function getUiCss() {
+    return `@import 'tailwindcss';
+
+:root {
+  --background: #ffffff;
+  --foreground: #171717;
+}
+
+.dark {
+  --background: #0a0a0a;
+  --foreground: #ededed;
+}
+
+body {
+  background: var(--background);
+  color: var(--foreground);
+  font-family: system-ui, sans-serif;
+}
+`;
+}
+// ---------------------------------------------------------------------------
+// API (Hono)
+// ---------------------------------------------------------------------------
+function getApiPackageJson(name) {
+    const pkg = {
+        name: `${name}-api`,
+        version: '0.1.0',
+        private: true,
+        type: 'module',
+        scripts: {
+            dev: 'tsx watch src/index.ts',
+            build: 'tsx src/index.ts',
+            start: 'node dist/index.js',
+        },
+        dependencies: {
+            '@eide/extension-sdk': '^0.1.0',
+            hono: '^4.0.0',
+            '@hono/node-server': '^1.0.0',
+        },
+        devDependencies: {
+            tsx: '^4.0.0',
+            typescript: '^5.0.0',
+        },
+    };
+    return JSON.stringify(pkg, null, 2) + '\n';
+}
+function getApiTsconfig() {
+    const config = {
+        compilerOptions: {
+            target: 'ES2020',
+            module: 'ESNext',
+            moduleResolution: 'bundler',
+            outDir: './dist',
+            rootDir: './src',
+            strict: true,
+            esModuleInterop: true,
+            skipLibCheck: true,
+            resolveJsonModule: true,
+            isolatedModules: true,
+        },
+        include: ['src'],
+        exclude: ['dist', 'node_modules'],
+    };
+    return JSON.stringify(config, null, 2) + '\n';
+}
+function getApiEnvExample(apiUrl) {
+    const baseUrl = apiUrl.replace(/\/graphql$/, '');
+    return `# Platform API
+PLATFORM_BASE_URL=${baseUrl}
+PLATFORM_API_KEY=sk_your_api_key_here
+
+# Extension
+EXTENSION_KEY=${'{your-extension-key}'}
+WEBHOOK_SECRET=your_webhook_secret_here
+
+# Server
+PORT=3002
+`;
+}
+function getApiIndex() {
+    return `import { Hono } from 'hono';
+import { serve } from '@hono/node-server';
+import { webhooks } from './routes/webhooks';
+import { health } from './routes/health';
+
+const app = new Hono();
+
+// Routes
+app.route('/webhooks', webhooks);
+app.route('/', health);
+
+const port = parseInt(process.env.PORT || '3002', 10);
+
+console.log(\`Extension API running on http://localhost:\${port}\`);
+
+serve({ fetch: app.fetch, port });
+`;
+}
+function getApiWebhooks() {
+    return `import { Hono } from 'hono';
+import { verifyWebhookSignature } from '@eide/extension-sdk/server';
+
+const WEBHOOK_SECRET = process.env.WEBHOOK_SECRET || '';
+
+export const webhooks = new Hono();
+
+/**
+ * Receive entity lifecycle events from the platform.
+ */
+webhooks.post('/entity-changed', async (c) => {
+  const body = await c.req.text();
+  const signature = c.req.header('x-eide-signature') ?? '';
+
+  const valid = await verifyWebhookSignature(body, signature, WEBHOOK_SECRET);
+  if (!valid) {
+    return c.json({ error: 'Invalid signature' }, 401);
+  }
+
+  const payload = JSON.parse(body);
+  console.log('[Webhook] Entity changed:', payload.event, payload.entityId);
+
+  // TODO: Handle the event (sync, transform, notify, etc.)
+
+  return c.json({ received: true });
+});
+`;
+}
+function getApiHealth() {
+    return `import { Hono } from 'hono';
+
+export const health = new Hono();
+
+health.get('/health', (c) => {
+  return c.json({ status: 'ok', timestamp: new Date().toISOString() });
+});
+`;
+}
+function getApiPlatform() {
+    return `import { createExtensionClient } from '@eide/extension-sdk/server';
+
+/**
+ * Pre-configured platform client for this extension.
+ *
+ * Uses env vars for configuration:
+ * - PLATFORM_BASE_URL: Platform API base URL
+ * - PLATFORM_API_KEY: Project-scoped API key (sk_*)
+ * - EXTENSION_KEY: This extension's extension key
+ */
+export const platform = createExtensionClient({
+  baseUrl: process.env.PLATFORM_BASE_URL || 'http://localhost:4000',
+  apiKey: process.env.PLATFORM_API_KEY || '',
+  extensionKey: process.env.EXTENSION_KEY || '',
+});
+`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eide/foir-cli",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "Universal platform CLI for EIDE — scriptable, composable resource management",
   "type": "module",
   "publishConfig": {