crca 1.4.0__py3-none-any.whl

tools/bolt.diy/app/vite-env.d.ts

@@ -0,0 +1,2 @@
+declare const __COMMIT_HASH: string;
+declare const __APP_VERSION: string;

tools/bolt.diy/assets/entitlements.mac.plist

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <!-- Allows Just-In-Time compilation required by V8 JavaScript engine in Electron -->
+    <key>com.apple.security.cs.allow-jit</key>
+    <true/>
+
+    <!-- This is needed for the V8 JavaScript engine to function properly -->
+    <key>com.apple.security.cs.allow-unsigned-executable-memory</key>
+    <true/>
+    
+    <!-- Allows network connections -->
+    <key>com.apple.security.network.client</key>
+    <true/>
+
+    <!-- Uncomment to allow read and write access to files explicitly selected by the user through system dialogs -->
+    <!-- <key>com.apple.security.files.user-selected.read-write</key>
+    <true/> -->
+
+    <!-- Uncomment to allow read and write access to the user's Downloads directory -->
+    <!-- <key>com.apple.security.files.downloads.read-write</key>
+    <true/> -->
+  </dict>
+</plist>

tools/bolt.diy/bindings.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+/**
+ * Windows-compatible bindings generator for Wrangler.
+ * Reads .env.local and generates --binding flags for environment variables.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Extracts environment variable names from the TypeScript interface.
+ * @returns {string[]} Array of environment variable names
+ */
+function extractEnvVars() {
+  try {
+    const workerConfigPath = path.join(__dirname, 'worker-configuration.d.ts');
+    const content = fs.readFileSync(workerConfigPath, 'utf-8');
+    const matches = content.match(/[A-Z_]+:/g) || [];
+    return matches.map((match) => match.replace(':', ''));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Generates Wrangler bindings from .env.local or environment variables.
+ * @returns {string} Space-separated --binding flags
+ */
+function generateBindings() {
+  let bindings = [];
+  const envLocalPath = path.join(__dirname, '.env.local');
+
+  // First try to read from .env.local if it exists
+  if (fs.existsSync(envLocalPath)) {
+    const content = fs.readFileSync(envLocalPath, 'utf-8');
+    const lines = content.split(/\r?\n/);
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      // Skip comments and empty lines
+      if (!trimmed || trimmed.startsWith('#')) {
+        continue;
+      }
+
+      const equalIndex = trimmed.indexOf('=');
+      if (equalIndex === -1) {
+        continue;
+      }
+
+      const name = trimmed.substring(0, equalIndex).trim();
+      let value = trimmed.substring(equalIndex + 1).trim();
+
+      // Remove surrounding quotes if present
+      if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+        value = value.slice(1, -1);
+      }
+
+      if (name && value) {
+        bindings.push(`--binding ${name}=${value}`);
+      }
+    }
+  } else {
+    // If .env.local doesn't exist, use environment variables defined in .d.ts
+    const envVars = extractEnvVars();
+    for (const varName of envVars) {
+      const value = process.env[varName];
+      if (value) {
+        bindings.push(`--binding ${varName}=${value}`);
+      }
+    }
+  }
+
+  return bindings.join(' ');
+}
+
+// Output bindings
+console.log(generateBindings());
+

tools/bolt.diy/bindings.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+
+bindings=""
+
+# Function to extract variable names from the TypeScript interface
+extract_env_vars() {
+  grep -o '[A-Z_]\+:' worker-configuration.d.ts | sed 's/://'
+}
+
+# First try to read from .env.local if it exists
+if [ -f ".env.local" ]; then
+  while IFS= read -r line || [ -n "$line" ]; do
+    if [[ ! "$line" =~ ^# ]] && [[ -n "$line" ]]; then
+      name=$(echo "$line" | cut -d '=' -f 1)
+      value=$(echo "$line" | cut -d '=' -f 2-)
+      value=$(echo $value | sed 's/^"\(.*\)"$/\1/')
+      bindings+="--binding ${name}=${value} "
+    fi
+  done < .env.local
+else
+  # If .env.local doesn't exist, use environment variables defined in .d.ts
+  env_vars=($(extract_env_vars))
+  # Generate bindings for each environment variable if it exists
+  for var in "${env_vars[@]}"; do
+    if [ -n "${!var}" ]; then
+      bindings+="--binding ${var}=${!var} "
+    fi
+  done
+fi
+
+bindings=$(echo $bindings | sed 's/[[:space:]]*$//')
+
+echo $bindings

tools/bolt.diy/docker-compose.yaml

@@ -0,0 +1,145 @@
+services:
+  app-prod:
+    image: bolt-ai:production
+    build:
+      context: .
+      dockerfile: Dockerfile
+      target: bolt-ai-production
+    ports:
+      - '5173:5173'
+    env_file: 
+      - '.env'
+      - '.env.local'
+    environment:
+      - NODE_ENV=production
+      - COMPOSE_PROFILES=production
+      # No strictly needed but serving as hints for Coolify
+      - PORT=5173
+      - GROQ_API_KEY=${GROQ_API_KEY:-}
+      - HuggingFace_API_KEY=${HuggingFace_API_KEY:-}
+      - OPENAI_API_KEY=${OPENAI_API_KEY:-}
+      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY:-}
+      - OPEN_ROUTER_API_KEY=${OPEN_ROUTER_API_KEY:-}
+      - GOOGLE_GENERATIVE_AI_API_KEY=${GOOGLE_GENERATIVE_AI_API_KEY:-}
+      - OLLAMA_API_BASE_URL=${OLLAMA_API_BASE_URL:-}
+      - XAI_API_KEY=${XAI_API_KEY:-}
+      - TOGETHER_API_KEY=${TOGETHER_API_KEY:-}
+      - TOGETHER_API_BASE_URL=${TOGETHER_API_BASE_URL:-}
+      - AWS_BEDROCK_CONFIG=${AWS_BEDROCK_CONFIG:-}
+      - VITE_LOG_LEVEL=${VITE_LOG_LEVEL:-debug}
+      - DEFAULT_NUM_CTX=${DEFAULT_NUM_CTX:-32768}
+      - RUNNING_IN_DOCKER=true
+    extra_hosts:
+      - 'host.docker.internal:host-gateway'
+    command: pnpm run dockerstart
+    profiles:
+      - production
+
+  app-dev:
+    image: bolt-ai:development
+    build:
+      context: .
+      dockerfile: Dockerfile
+      target: development
+    env_file: 
+      - '.env'
+      - '.env.local'
+    environment:
+      - NODE_ENV=development
+      - VITE_HMR_PROTOCOL=ws
+      - VITE_HMR_HOST=localhost
+      - VITE_HMR_PORT=5173
+      - CHOKIDAR_USEPOLLING=true
+      - WATCHPACK_POLLING=true
+      - PORT=5173
+      - GROQ_API_KEY=${GROQ_API_KEY:-}
+      - HuggingFace_API_KEY=${HuggingFace_API_KEY:-}
+      - OPENAI_API_KEY=${OPENAI_API_KEY:-}
+      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY:-}
+      - OPEN_ROUTER_API_KEY=${OPEN_ROUTER_API_KEY:-}
+      - XAI_API_KEY=${XAI_API_KEY:-}
+      - GOOGLE_GENERATIVE_AI_API_KEY=${GOOGLE_GENERATIVE_AI_API_KEY:-}
+      - OLLAMA_API_BASE_URL=${OLLAMA_API_BASE_URL:-}
+      - TOGETHER_API_KEY=${TOGETHER_API_KEY:-}
+      - TOGETHER_API_BASE_URL=${TOGETHER_API_BASE_URL:-}
+      - AWS_BEDROCK_CONFIG=${AWS_BEDROCK_CONFIG:-}
+      - VITE_LOG_LEVEL=${VITE_LOG_LEVEL:-debug}
+      - DEFAULT_NUM_CTX=${DEFAULT_NUM_CTX:-32768}
+      - RUNNING_IN_DOCKER=true
+    extra_hosts:
+      - 'host.docker.internal:host-gateway'
+    volumes:
+      - type: bind
+        source: .
+        target: /app
+        consistency: cached
+      - /app/node_modules
+    ports:
+      - '5173:5173'
+    command: pnpm run dev --host 0.0.0.0
+    profiles: ['development', 'default']
+
+  app-prebuild:
+    image: ghcr.io/stackblitz-labs/bolt.diy:latest
+    ports:
+      - '5173:5173'
+    environment:
+      - NODE_ENV=production
+      - COMPOSE_PROFILES=production
+      # No strictly needed but serving as hints for Coolify
+      - PORT=5173
+      - OLLAMA_API_BASE_URL=http://127.0.0.1:11434
+      - DEFAULT_NUM_CTX=${DEFAULT_NUM_CTX:-32768}
+      - RUNNING_IN_DOCKER=true
+    extra_hosts:
+      - 'host.docker.internal:host-gateway'
+    command: pnpm run dockerstart
+    profiles:
+      - prebuilt
+
+  execution-governor:
+    build:
+      context: ./services/execution-governor
+      dockerfile: Dockerfile
+    ports:
+      - '3000:3000'
+    environment:
+      - NODE_ENV=production
+      - PORT=3000
+      - MAX_CONCURRENT_EXECUTIONS=${MAX_CONCURRENT_EXECUTIONS:-5}
+      - MAX_MANDATES_PER_MINUTE=${MAX_MANDATES_PER_MINUTE:-20}
+      - GLOBAL_BUDGET_LIMIT=${GLOBAL_BUDGET_LIMIT:-1000.0}
+      - CPU_LIMIT=${CPU_LIMIT:-2.0}
+      - MEMORY_LIMIT=${MEMORY_LIMIT:-4096}
+      - WORKER_TIMEOUT=${WORKER_TIMEOUT:-3600000}
+      - RETRY_ATTEMPTS=${RETRY_ATTEMPTS:-3}
+      - WORKER_HEALTH_CHECK_INTERVAL=${WORKER_HEALTH_CHECK_INTERVAL:-30000}
+      - QUEUE_CHECK_INTERVAL=${QUEUE_CHECK_INTERVAL:-1000}
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:3000/governor/state"]
+      interval: 30s
+      timeout: 10s
+      retries: 3
+    profiles:
+      - production
+      - development
+
+  headless-executor:
+    build:
+      context: ./services/headless-executor
+      dockerfile: Dockerfile
+    environment:
+      - GOVERNOR_URL=http://execution-governor:3000
+      - BOLT_DIY_URL=http://app-prod:5173
+      - WORKER_ID=headless-executor-${HOSTNAME:-unknown}
+      - MAX_CONCURRENT=${MAX_CONCURRENT:-1}
+      - POLL_INTERVAL=${POLL_INTERVAL:-5000}
+      - HEADLESS=true
+      - EXECUTION_TIMEOUT=${EXECUTION_TIMEOUT:-3600000}
+    depends_on:
+      - execution-governor
+      - app-prod
+    deploy:
+      replicas: ${HEADLESS_EXECUTOR_REPLICAS:-3}
+    profiles:
+      - production

tools/bolt.diy/electron/main/index.ts

@@ -0,0 +1,201 @@
+/// <reference types="vite/client" />
+import { createRequestHandler } from '@remix-run/node';
+import electron, { app, BrowserWindow, ipcMain, protocol, session } from 'electron';
+import log from 'electron-log';
+import path from 'node:path';
+import * as pkg from '../../package.json';
+import { setupAutoUpdater } from './utils/auto-update';
+import { isDev, DEFAULT_PORT } from './utils/constants';
+import { initViteServer, viteServer } from './utils/vite-server';
+import { setupMenu } from './ui/menu';
+import { createWindow } from './ui/window';
+import { initCookies, storeCookies } from './utils/cookie';
+import { loadServerBuild, serveAsset } from './utils/serve';
+import { reloadOnChange } from './utils/reload';
+
+Object.assign(console, log.functions);
+
+console.debug('main: import.meta.env:', import.meta.env);
+console.log('main: isDev:', isDev);
+console.log('NODE_ENV:', global.process.env.NODE_ENV);
+console.log('isPackaged:', app.isPackaged);
+
+// Log unhandled errors
+process.on('uncaughtException', async (error) => {
+  console.log('Uncaught Exception:', error);
+});
+
+process.on('unhandledRejection', async (error) => {
+  console.log('Unhandled Rejection:', error);
+});
+
+(() => {
+  const root = global.process.env.APP_PATH_ROOT ?? import.meta.env.VITE_APP_PATH_ROOT;
+
+  if (root === undefined) {
+    console.log('no given APP_PATH_ROOT or VITE_APP_PATH_ROOT. default path is used.');
+    return;
+  }
+
+  if (!path.isAbsolute(root)) {
+    console.log('APP_PATH_ROOT must be absolute path.');
+    global.process.exit(1);
+  }
+
+  console.log(`APP_PATH_ROOT: ${root}`);
+
+  const subdirName = pkg.name;
+
+  for (const [key, val] of [
+    ['appData', ''],
+    ['userData', subdirName],
+    ['sessionData', subdirName],
+  ] as const) {
+    app.setPath(key, path.join(root, val));
+  }
+
+  app.setAppLogsPath(path.join(root, subdirName, 'Logs'));
+})();
+
+console.log('appPath:', app.getAppPath());
+
+const keys: Parameters<typeof app.getPath>[number][] = ['home', 'appData', 'userData', 'sessionData', 'logs', 'temp'];
+keys.forEach((key) => console.log(`${key}:`, app.getPath(key)));
+console.log('start whenReady');
+
+declare global {
+  // eslint-disable-next-line no-var, @typescript-eslint/naming-convention
+  var __electron__: typeof electron;
+}
+
+(async () => {
+  await app.whenReady();
+  console.log('App is ready');
+
+  // Load any existing cookies from ElectronStore, set as cookie
+  await initCookies();
+
+  const serverBuild = await loadServerBuild();
+
+  protocol.handle('http', async (req) => {
+    console.log('Handling request for:', req.url);
+
+    if (isDev) {
+      console.log('Dev mode: forwarding to vite server');
+      return await fetch(req);
+    }
+
+    req.headers.append('Referer', req.referrer);
+
+    try {
+      const url = new URL(req.url);
+
+      // Forward requests to specific local server ports
+      if (url.port !== `${DEFAULT_PORT}`) {
+        console.log('Forwarding request to local server:', req.url);
+        return await fetch(req);
+      }
+
+      // Always try to serve asset first
+      const assetPath = path.join(app.getAppPath(), 'build', 'client');
+      const res = await serveAsset(req, assetPath);
+
+      if (res) {
+        console.log('Served asset:', req.url);
+        return res;
+      }
+
+      // Forward all cookies to remix server
+      const cookies = await session.defaultSession.cookies.get({});
+
+      if (cookies.length > 0) {
+        req.headers.set('Cookie', cookies.map((c) => `${c.name}=${c.value}`).join('; '));
+
+        // Store all cookies
+        await storeCookies(cookies);
+      }
+
+      // Create request handler with the server build
+      const handler = createRequestHandler(serverBuild, 'production');
+      console.log('Handling request with server build:', req.url);
+
+      const result = await handler(req, {
+        /*
+         * Remix app access cloudflare.env
+         * Need to pass an empty object to prevent undefined
+         */
+        // @ts-ignore:next-line
+        cloudflare: {},
+      });
+
+      return result;
+    } catch (err) {
+      console.log('Error handling request:', {
+        url: req.url,
+        error:
+          err instanceof Error
+            ? {
+                message: err.message,
+                stack: err.stack,
+                cause: err.cause,
+              }
+            : err,
+      });
+
+      const error = err instanceof Error ? err : new Error(String(err));
+
+      return new Response(`Error handling request to ${req.url}: ${error.stack ?? error.message}`, {
+        status: 500,
+        headers: { 'content-type': 'text/plain' },
+      });
+    }
+  });
+
+  const rendererURL = await (isDev
+    ? (async () => {
+        await initViteServer();
+
+        if (!viteServer) {
+          throw new Error('Vite server is not initialized');
+        }
+
+        const listen = await viteServer.listen();
+        global.__electron__ = electron;
+        viteServer.printUrls();
+
+        return `http://localhost:${listen.config.server.port}`;
+      })()
+    : `http://localhost:${DEFAULT_PORT}`);
+
+  console.log('Using renderer URL:', rendererURL);
+
+  const win = await createWindow(rendererURL);
+
+  app.on('activate', async () => {
+    if (BrowserWindow.getAllWindows().length === 0) {
+      await createWindow(rendererURL);
+    }
+  });
+
+  console.log('end whenReady');
+
+  return win;
+})()
+  .then((win) => {
+    // IPC samples : send and recieve.
+    let count = 0;
+    setInterval(() => win.webContents.send('ping', `hello from main! ${count++}`), 60 * 1000);
+    ipcMain.handle('ipcTest', (event, ...args) => console.log('ipc: renderer -> main', { event, ...args }));
+
+    return win;
+  })
+  .then((win) => setupMenu(win));
+
+app.on('window-all-closed', () => {
+  if (process.platform !== 'darwin') {
+    app.quit();
+  }
+});
+
+reloadOnChange();
+setupAutoUpdater();

tools/bolt.diy/electron/main/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "include": ["."],
+  "compilerOptions": {
+    "lib": ["ESNext"],
+    "jsx": "preserve",
+    "target": "ESNext",
+    "noEmit": true,
+    "skipLibCheck": true,
+    "useDefineForClassFields": true,
+
+    /* modules */
+    "moduleResolution": "Bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "module": "ESNext",
+    "isolatedModules": true,
+    "emitDeclarationOnly": true,
+    "declaration": true,
+    "declarationDir": "./dist",
+
+    /* type checking */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitReturns": true,
+    "verbatimModuleSyntax": true,
+    "forceConsistentCasingInFileNames": true
+  }
+}

tools/bolt.diy/electron/main/ui/menu.ts

@@ -0,0 +1,29 @@
+import { BrowserWindow, Menu } from 'electron';
+
+export function setupMenu(win: BrowserWindow): void {
+  const app = Menu.getApplicationMenu();
+  Menu.setApplicationMenu(
+    Menu.buildFromTemplate([
+      ...(app ? app.items : []),
+      {
+        label: 'Go',
+        submenu: [
+          {
+            label: 'Back',
+            accelerator: 'CmdOrCtrl+[',
+            click: () => {
+              win?.webContents.navigationHistory.goBack();
+            },
+          },
+          {
+            label: 'Forward',
+            accelerator: 'CmdOrCtrl+]',
+            click: () => {
+              win?.webContents.navigationHistory.goForward();
+            },
+          },
+        ],
+      },
+    ]),
+  );
+}

tools/bolt.diy/electron/main/ui/window.ts

@@ -0,0 +1,54 @@
+import { app, BrowserWindow } from 'electron';
+import path from 'node:path';
+import { isDev } from '../utils/constants';
+import { store } from '../utils/store';
+
+export function createWindow(rendererURL: string) {
+  console.log('Creating window with URL:', rendererURL);
+
+  const bounds = store.get('bounds');
+  console.log('restored bounds:', bounds);
+
+  // preload path
+  const preloadPath = path.join(isDev ? process.cwd() : app.getAppPath(), 'build', 'electron', 'preload', 'index.cjs');
+
+  const win = new BrowserWindow({
+    ...{
+      width: 1200,
+      height: 800,
+      ...bounds,
+    },
+    vibrancy: 'under-window',
+    visualEffectState: 'active',
+    webPreferences: {
+      preload: preloadPath,
+    },
+  });
+
+  console.log('Window created, loading URL...');
+  win.loadURL(rendererURL).catch((err) => {
+    console.log('Failed to load URL:', err);
+  });
+
+  win.webContents.on('did-fail-load', (_, errorCode, errorDescription) => {
+    console.log('Failed to load:', errorCode, errorDescription);
+  });
+
+  win.webContents.on('did-finish-load', () => {
+    console.log('Window finished loading');
+  });
+
+  // Open devtools in development
+  if (isDev) {
+    win.webContents.openDevTools();
+  }
+
+  const boundsListener = () => {
+    const bounds = win.getBounds();
+    store.set('bounds', bounds);
+  };
+  win.on('moved', boundsListener);
+  win.on('resized', boundsListener);
+
+  return win;
+}