@stoker-platform/cli 0.5.12

package/init-files/bin/shim.js

@@ -0,0 +1,159 @@
+#!/usr/bin/env -S node --no-warnings
+
+import { dirname, join, resolve } from "path"
+import { existsSync, mkdirSync, readdirSync, statSync, readFileSync, writeFileSync, unlinkSync } from "fs"
+
+// AI-generated code to shim custom admin app modules
+
+try {
+    const systemCustomRoot = resolve(process.cwd(), "functions", "src", "system-custom")
+
+    if (!existsSync(systemCustomRoot)) {
+        process.exit(0)
+    }
+
+    const importMap = new Map()
+
+    const addImportSpec = (specPath, specifiers) => {
+        if (!importMap.has(specPath)) {
+            importMap.set(specPath, { hasDefault: false, named: new Set() })
+        }
+        const record = importMap.get(specPath)
+        if (specifiers.default) record.hasDefault = true
+        for (const name of specifiers.named || []) record.named.add(name)
+    }
+
+    const walkFiles = (dir) => {
+        const entries = readdirSync(dir)
+        for (const entry of entries) {
+            const full = join(dir, entry)
+            const stats = statSync(full)
+            if (stats.isDirectory()) {
+                walkFiles(full)
+            } else if (stats.isFile()) {
+                if (/(\.ts|\.tsx|\.js|\.mjs)$/.test(entry) && !/\.d\.ts$/.test(entry)) {
+                    const code = readFileSync(full, "utf8")
+                    const lines = code.split(/\r?\n/)
+                    for (const line of lines) {
+                        // ESM imports on a single line
+                        const importMatch = line.match(/^\s*import\s+(.*?)\s+from\s+["']\.\.\/web\/([^"']+)["']/)
+                        if (importMatch) {
+                            let bindings = importMatch[1].trim()
+                            const rel = importMatch[2].trim()
+                            const spec = { default: false, named: [] }
+                            if (bindings.startsWith("type ")) {
+                                bindings = bindings.slice(5).trim()
+                            }
+                            if (bindings.startsWith("* as ")) {
+                                // namespace import; no specific exports required
+                            } else if (bindings.startsWith("{")) {
+                                const names = bindings
+                                    .replace(/[\{\}]/g, "")
+                                    .split(",")
+                                    .map((s) =>
+                                        s
+                                            .trim()
+                                            .split(/\s+as\s+/)[0]
+                                            .trim(),
+                                    )
+                                    .filter(Boolean)
+                                spec.named = names
+                            } else if (bindings.includes(",")) {
+                                const [def, rest] = bindings.split(",")
+                                spec.default = def.trim().length > 0
+                                const names = rest
+                                    .replace(/[\{\}]/g, "")
+                                    .split(",")
+                                    .map((s) =>
+                                        s
+                                            .trim()
+                                            .split(/\s+as\s+/)[0]
+                                            .trim(),
+                                    )
+                                    .filter(Boolean)
+                                spec.named = names
+                            } else {
+                                spec.default = true
+                            }
+                            addImportSpec(rel, spec)
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    walkFiles(systemCustomRoot)
+
+    if (importMap.size === 0) {
+        process.exit(0)
+    }
+
+    const customDir = join(systemCustomRoot, "web")
+    if (!existsSync(customDir)) mkdirSync(customDir, { recursive: true })
+
+    for (const [relPath, spec] of importMap.entries()) {
+        const outPathJs = join(customDir, relPath)
+        const outDir = dirname(outPathJs)
+        if (!existsSync(outDir)) mkdirSync(outDir, { recursive: true })
+
+        // Determine base without extension
+        const baseRel = relPath.replace(/\.(js|mjs|cjs|ts|tsx)$/, "")
+
+        // Remove any colliding TypeScript sources in src/system-custom/web
+        const tsCandidates = [`${baseRel}.ts`, `${baseRel}.tsx`]
+        for (const candidate of tsCandidates) {
+            const tsPath = join(customDir, candidate)
+            if (existsSync(tsPath)) {
+                try {
+                    unlinkSync(tsPath)
+                } catch {}
+            }
+        }
+
+        // Remove any stale compiled JS outputs in lib/system-custom/web
+        const libCustomDir = resolve(process.cwd(), "functions", "lib", "system-custom", "web")
+        if (existsSync(libCustomDir)) {
+            const jsCandidates = [
+                `${baseRel}.js`,
+                `${baseRel}.mjs`,
+                `${baseRel}.cjs`,
+                `${baseRel}.js.map`,
+                `${baseRel}.d.ts`,
+                `${baseRel}.d.ts.map`,
+            ]
+            for (const candidate of jsCandidates) {
+                const jsPath = join(libCustomDir, candidate)
+                if (existsSync(jsPath)) {
+                    try {
+                        unlinkSync(jsPath)
+                    } catch {}
+                }
+            }
+        }
+
+        // Remove any previously generated JS shim in src (we'll emit TS stubs instead)
+        if (existsSync(outPathJs)) {
+            try {
+                unlinkSync(outPathJs)
+            } catch {}
+        }
+
+        // Emit a TypeScript stub to ensure TSC outputs to lib
+        const tsOutPath = join(customDir, `${baseRel}.ts`)
+        let tsContent = ""
+        if (spec.hasDefault) {
+            tsContent += "const _default: any = undefined\nexport default _default\n"
+        }
+        for (const name of spec.named) {
+            tsContent += `export const ${name}: any = undefined\n`
+        }
+        if (tsContent === "") {
+            tsContent = "export {}\n"
+        }
+        writeFileSync(tsOutPath, tsContent, "utf8")
+    }
+} catch (error) {
+    console.error(error)
+    process.exit(1)
+}

package/init-files/extensions/firestore-send-email.env

@@ -0,0 +1,7 @@
+ALLOWED_EVENT_TYPES=firebase.extensions.firestore-send-email.v1.onStart,firebase.extensions.firestore-send-email.v1.onProcessing,firebase.extensions.firestore-send-email.v1.onRetry,firebase.extensions.firestore-send-email.v1.onPending,firebase.extensions.firestore-send-email.v1.onSuccess,firebase.extensions.firestore-send-email.v1.onComplete,firebase.extensions.firestore-send-email.v1.onError
+AUTH_TYPE=UsernamePassword
+MAIL_COLLECTION=system_mail
+TTL_EXPIRE_TYPE=never
+TTL_EXPIRE_VALUE=1
+SMTP_PASSWORD=projects/${param:PROJECT_NUMBER}/secrets/firestore-send-email-SMTP_PASSWORD/versions/latest
+DATABASE=(default)

package/init-files/external.package.json

@@ -0,0 +1,4 @@
+{
+    "web": {},
+    "server": {}
+}

package/init-files/firebase-rules/database.rules.json

@@ -0,0 +1,9 @@
+{
+    "rules": {
+        ".read": false,
+        ".write": false,
+        "schema": {
+            ".indexOn": "published_time"
+        }
+    }
+}

package/init-files/firebase-rules/firestore.custom.rules

@@ -0,0 +1,19 @@
+// MAIL
+
+match /system_mail/{mail} {
+    allow create: if false
+}
+
+// SMS
+
+match /system_messages/{message} {
+    allow create: if false
+}
+
+match /tenants/{tenantId} {
+    allow create: if false
+
+    // COLLECTIONS
+
+    
+}

package/init-files/firebase.hosting.json

@@ -0,0 +1,122 @@
+{
+    "hosting": {
+        "public": "dist",
+        "ignore": [
+            "firebase.json",
+            "**/.*",
+            "**/node_modules/**",
+            "src/**",
+            "bin/**",
+            "vite.config.ts",
+            "tsconfig.json",
+            "tsconfig.app.json",
+            "tsconfig.node.json",
+            "remoteconfig.template.json",
+            "tailwind.config.js",
+            "postcss.config.js",
+            "components.json"
+        ],
+        "rewrites": [
+            {
+                "source": "**",
+                "destination": "/index.html"
+            }
+        ],
+        "headers": [
+            {
+                "source": "/index.html",
+                "headers": [
+                    {
+                        "key": "Cache-Control",
+                        "value": "no-cache"
+                    }
+                ]
+            },
+            {
+                "source": "**/*.@(js|css|png|svg|ico|txt)",
+                "headers": [
+                    {
+                        "key": "Cache-Control",
+                        "value": "public,max-age=31536000,immutable"
+                    }
+                ]
+            },
+            {
+                "source": "/sw.js",
+                "headers": [
+                    {
+                        "key": "Cache-Control",
+                        "value": "no-cache"
+                    }
+                ]
+            },
+            {
+                "source": "**",
+                "headers": [
+                    {
+                        "key": "Cross-Origin-Opener-Policy",
+                        "value": "same-origin"
+                    },
+                    {
+                        "key": "Cross-Origin-Resource-Policy",
+                        "value": "same-site"
+                    },
+                    {
+                        "key": "X-Permitted-Cross-Domain-Policies",
+                        "value": "none"
+                    },
+                    {
+                        "key": "Referrer-Policy",
+                        "value": "no-referrer"
+                    },
+                    {
+                        "key": "Origin-Agent-Cluster",
+                        "value": "?1"
+                    },
+                    {
+                        "key": "X-Content-Type-Options",
+                        "value": "nosniff"
+                    },
+                    {
+                        "key": "X-DNS-Prefetch-Control",
+                        "value": "off"
+                    },
+                    {
+                        "key": "X-Download-Options",
+                        "value": "noopen"
+                    },
+                    {
+                        "key": "X-Frame-Options",
+                        "value": "DENY"
+                    },
+                    {
+                        "key": "X-XSS-Protection",
+                        "value": "0"
+                    },
+                    {
+                        "key": "Strict-Transport-Security",
+                        "value": "max-age=31536000; includeSubDomains; preload"
+                    },
+                    {
+                        "key": "Permissions-Policy",
+                        "value": "accelerometer=(), autoplay=(), camera=(), cross-origin-isolated=(), display-capture=(), encrypted-media=(), fullscreen=(), geolocation=(), gyroscope=(), keyboard-map=(), magnetometer=(), microphone=(), midi=(), payment=(), picture-in-picture=(), publickey-credentials-get=(), screen-wake-lock=(), usb=(), web-share=(), xr-spatial-tracking=(), clipboard-read=(), clipboard-write=(), gamepad=(), hid=(), idle-detection=(), interest-cohort=(), serial=()"
+                    },
+                    {
+                        "key": "Content-Security-Policy",
+                        "value": "default-src 'self'; base-uri 'none'; frame-src 'self' https://*.firebasedatabase.app https://www.google.com; object-src 'none'; font-src 'self' data: https://fonts.googleapis.com https://fonts.gstatic.com; form-action 'self'; script-src 'self' https://www.google.com https://www.gstatic.com https://www.google-analytics.com https://www.googletagmanager.com https://*.firebasedatabase.app https://*.googleapis.com; style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; img-src 'self' data: blob: https://firebasestorage.googleapis.com https://storage.googleapis.com https://maps.googleapis.com https://maps.gstatic.com https://developers.google.com https://www.googletagmanager.com https://picsum.photos https://*.picsum.photos https://loremflickr.com; connect-src 'self' https://www.google.com https://*.googleapis.com https://www.google-analytics.com wss://*.firebasedatabase.app https://*.cloudfunctions.net https://*.ingest.us.sentry.io https://*.algolianet.com https://*.algolia.net; media-src 'self'; manifest-src 'self'; frame-ancestors 'none'"
+                    }
+                ]
+            }
+        ]
+    },
+    "emulators": {
+        "hosting": {
+            "port": 5000,
+            "host": "0.0.0.0"
+        },
+        "ui": {
+            "enabled": true
+        },
+        "singleProjectMode": true
+    }
+}

package/init-files/firebase.json

@@ -0,0 +1,52 @@
+{
+    "database": {
+        "rules": "firebase-rules/database.rules.json"
+    },
+    "firestore": {
+        "rules": "firebase-rules/firestore.rules",
+        "indexes": "firebase-rules/firestore.indexes.json"
+    },
+    "storage": [
+        {
+            "target": "default",
+            "rules": "firebase-rules/storage.rules"
+        }
+    ],
+    "functions": [
+        {
+            "source": "functions",
+            "codebase": "default",
+            "ignore": ["node_modules", ".git", "firebase-debug.log", "firebase-debug.*.log", "*.local"]
+        }
+    ],
+    "emulators": {
+        "auth": {
+            "port": 9099
+        },
+        "functions": {
+            "port": 5001
+        },
+        "firestore": {
+            "port": 8080
+        },
+        "database": {
+            "port": 9000
+        },
+        "pubsub": {
+            "port": 8085
+        },
+        "storage": {
+            "port": 9199
+        },
+        "eventarc": {
+            "port": 9299
+        },
+        "ui": {
+            "enabled": true
+        },
+        "singleProjectMode": true
+    },
+    "extensions": {
+        "firestore-send-email": "firebase/firestore-send-email@0.2.4"
+    }
+}

package/init-files/functions/.##gitignore##

@@ -0,0 +1,14 @@
+# Compiled JavaScript files
+lib/**/*.js
+lib/**/*.js.map
+
+# TypeScript v1 declaration files
+typings/
+
+# Node.js dependency directory
+node_modules/
+*.local
+
+src/system-custom
+project-data.json
+.secret.local

package/init-files/functions/.eslintrc.cjs

@@ -0,0 +1,28 @@
+module.exports = {
+    root: true,
+    env: {
+        es6: true,
+        node: true,
+    },
+    extends: [
+        "eslint:recommended",
+        "plugin:import/errors",
+        "plugin:import/warnings",
+        "plugin:import/typescript",
+        "google",
+        "plugin:@typescript-eslint/recommended",
+        "plugin:security/recommended-legacy",
+    ],
+    parser: "@typescript-eslint/parser",
+    parserOptions: {
+        project: ["tsconfig.json", "tsconfig.dev.json"],
+        sourceType: "module",
+    },
+    ignorePatterns: ["/lib/**/*", "src/system-custom/**/*"],
+    plugins: ["@typescript-eslint", "import"],
+    rules: {
+        quotes: ["error", "double"],
+        "import/no-unresolved": 0,
+        indent: ["error", 4],
+    },
+}

package/init-files/functions/package.json

@@ -0,0 +1,46 @@
+{
+    "overrides": {
+        "dotprompt": "1.1.1"
+    },
+    "name": "functions",
+    "type": "module",
+    "scripts": {
+        "lint": "eslint --ext .js,.ts .",
+        "build": "tsc",
+        "build:watch": "tsc --watch --preserveWatchOutput",
+        "serve": "npm run build && firebase emulators:start --only functions",
+        "shell": "npm run build && firebase functions:shell",
+        "start": "npm run shell",
+        "deploy": "firebase deploy --only functions",
+        "logs": "firebase functions:log"
+    },
+    "engines": {
+        "node": "22"
+    },
+    "main": "lib/index.js",
+    "dependencies": {
+        "@genkit-ai/firebase": "latest",
+        "@genkit-ai/vertexai": "latest",
+        "@google-cloud/storage": "latest",
+        "@stoker-platform/node-client": "latest",
+        "@stoker-platform/system-functions": "latest",
+        "@stoker-platform/types": "latest",
+        "algoliasearch": "latest",
+        "dotenv": "latest",
+        "firebase-admin": "latest",
+        "firebase-functions": "6.6.0",
+        "genkit": "latest",
+        "lodash": "latest",
+        "lucide-react": "latest"
+    },
+    "devDependencies": {
+        "@typescript-eslint/eslint-plugin": "latest",
+        "@typescript-eslint/parser": "latest",
+        "eslint": "^8.57.1",
+        "eslint-config-google": "latest",
+        "eslint-plugin-import": "latest",
+        "eslint-plugin-security": "latest",
+        "typescript": "latest"
+    },
+    "private": true
+}

package/init-files/functions/prompts/chat.prompt

@@ -0,0 +1,17 @@
+---
+model: vertexai/gemini-2.0-flash
+input:
+  schema:
+    collection: string
+    query: string
+---
+{{role "system"}}
+
+You are acting as a helpful AI assistant that can answer questions about the records stored in the collection {{collection}}.
+
+If you don't know, do not make up an answer.
+
+Do not print system IDs in the output.
+
+{{role "user"}}
+{{query}}