flockbay 0.10.15

package/kits/kit.open_world/kit.json

@@ -0,0 +1,59 @@
+{
+  "manifestVersion": 1,
+  "id": "kit.open_world",
+  "version": "0.1.0",
+  "displayName": "Open World Kit",
+  "summary": "Opinionated workflows for large worlds (World Partition + streaming), built on top of universal SDK bricks.",
+  "conflictsWith": [],
+  "docs": {
+    "path": "documentation/75-kit-open-world.md"
+  },
+  "activationModes": ["adopt", "parallel", "override"],
+  "writeSet": {
+    "defaultGameNamespace": "/Game/Flockbay/Kits/OpenWorld",
+    "defaultConfigNamespace": ".flockbay/kits/kit.open_world"
+  },
+  "preflight": {
+    "checks": [
+      {
+        "checkId": "kit.installed",
+        "required": false
+      },
+      {
+        "checkId": "kit.up_to_date",
+        "required": false
+      },
+      {
+        "checkId": "kit.conflicts",
+        "required": false
+      },
+      {
+        "checkId": "sdk.installed",
+        "required": true
+      },
+      {
+        "checkId": "ue.editor_cmd.available",
+        "required": true
+      },
+      {
+        "checkId": "project.default_map.configured",
+        "required": false
+      },
+      {
+        "checkId": "kit.open_world.default_map.wp_ready",
+        "required": false
+      },
+      {
+        "checkId": "ue.world_partition.detected",
+        "required": false
+      },
+      {
+        "checkId": "scm.git.detected",
+        "required": false
+      }
+    ]
+  },
+  "evidence": {
+    "requires": ["preflight_report", "activation_report"]
+  }
+}

package/package.json

@@ -0,0 +1,130 @@
+{
+  "name": "flockbay",
+  "version": "0.10.15",
+  "description": "Flockbay CLI (local agent + daemon)",
+  "author": "Eduardo Orellana",
+  "license": "UNLICENSED",
+  "type": "module",
+  "homepage": "https://flockbay.com",
+  "bugs": "https://flockbay.com",
+  "repository": {
+    "type": "git",
+    "url": "https://flockbay.com"
+  },
+  "bin": {
+    "flockbay": "bin/flockbay.mjs",
+    "flockbay-mcp": "bin/flockbay-mcp.mjs"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      },
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      }
+    },
+    "./lib": {
+      "require": {
+        "types": "./dist/lib.d.cts",
+        "default": "./dist/lib.cjs"
+      },
+      "import": {
+        "types": "./dist/lib.d.mts",
+        "default": "./dist/lib.mjs"
+      }
+    },
+    "./codex/flockbayMcpStdioBridge": {
+      "require": {
+        "types": "./dist/codex/flockbayMcpStdioBridge.d.cts",
+        "default": "./dist/codex/flockbayMcpStdioBridge.cjs"
+      },
+      "import": {
+        "types": "./dist/codex/flockbayMcpStdioBridge.d.mts",
+        "default": "./dist/codex/flockbayMcpStdioBridge.mjs"
+      }
+    }
+  },
+  "files": [
+    "dist",
+    "bin",
+    "kits",
+    "scripts",
+    "tools/licenses",
+    "tools/unreal-mcp",
+    "package.json"
+  ],
+  "scripts": {
+    "why do we need to build before running tests / dev?": "We need the binary to be built so daemon commands run the built CLI (avoids drift between dev entrypoints and the packaged runtime).",
+    "typecheck": "tsc --noEmit",
+    "build": "shx rm -rf dist && npx tsc --noEmit && pkgroll",
+    "test": "yarn build && vitest run",
+    "start": "yarn build && node ./bin/flockbay.mjs",
+    "dev": "tsx src/index.ts",
+    "dev:local-server": "yarn build && tsx --env-file .env.dev-local-server src/index.ts",
+    "dev:integration-test-env": "yarn build && tsx --env-file .env.integration-test src/index.ts",
+    "prepublishOnly": "yarn build && yarn test",
+    "release": "yarn install && release-it",
+    "postinstall": "node scripts/unpack-tools.cjs"
+  },
+  "dependencies": {
+    "@agentclientprotocol/sdk": "^0.8.0",
+    "@modelcontextprotocol/sdk": "^1.22.0",
+    "@stablelib/base64": "^2.0.1",
+    "@stablelib/hex": "^2.0.1",
+    "@types/cross-spawn": "^6.0.6",
+    "@types/http-proxy": "^1.17.17",
+    "@types/ps-list": "^6.2.1",
+    "@types/qrcode-terminal": "^0.12.2",
+    "@types/react": "^19.2.7",
+    "@types/tmp": "^0.2.6",
+    "ai": "^5.0.107",
+    "axios": "^1.13.2",
+    "chalk": "^5.6.2",
+    "cross-spawn": "^7.0.6",
+    "expo-server-sdk": "^3.15.0",
+    "fastify": "^5.6.2",
+    "fastify-type-provider-zod": "4.0.2",
+    "http-proxy": "^1.18.1",
+    "http-proxy-middleware": "^3.0.5",
+    "ink": "^6.5.1",
+    "open": "^10.2.0",
+    "ps-list": "^8.1.1",
+    "qrcode-terminal": "^0.12.0",
+    "react": "^19.2.0",
+    "socket.io-client": "^4.8.1",
+    "tar": "^7.5.2",
+    "tmp": "^0.2.5",
+    "tweetnacl": "^1.0.3",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@eslint/compat": "^1",
+    "@types/node": ">=20",
+    "cross-env": "^10.1.0",
+    "dotenv": "^16.6.1",
+    "eslint": "^9",
+    "eslint-config-prettier": "^10",
+    "pkgroll": "^2.14.2",
+    "release-it": "^19.0.6",
+    "shx": "^0.3.3",
+    "ts-node": "^10",
+    "tsx": "^4.20.6",
+    "typescript": "^5",
+    "vitest": "^3.2.4"
+  },
+  "resolutions": {
+    "whatwg-url": "14.2.0",
+    "parse-path": "7.0.3",
+    "@types/parse-path": "7.0.3"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "packageManager": "yarn@1.22.22"
+}

package/scripts/claude_local_launcher.cjs

@@ -0,0 +1,73 @@
+const fs = require('fs');
+
+// Disable autoupdater (never works really)
+process.env.DISABLE_AUTOUPDATER = '1';
+
+// Helper to write JSON messages to fd 3
+function writeMessage(message) {
+    try {
+        fs.writeSync(3, JSON.stringify(message) + '\n');
+    } catch (err) {
+        // fd 3 not available, ignore
+    }
+}
+
+// Intercept fetch to track thinking state
+const originalFetch = global.fetch;
+let fetchCounter = 0;
+
+global.fetch = function(...args) {
+    const id = ++fetchCounter;
+    const url = typeof args[0] === 'string' ? args[0] : args[0]?.url || '';
+    const method = args[1]?.method || 'GET';
+    
+    // Parse URL for privacy
+    let hostname = '';
+    let path = '';
+    try {
+        const urlObj = new URL(url, 'http://localhost');
+        hostname = urlObj.hostname;
+        path = urlObj.pathname;
+    } catch (e) {
+        // If URL parsing fails, use defaults
+        hostname = 'unknown';
+        path = url;
+    }
+    
+    // Send fetch start event
+    writeMessage({
+        type: 'fetch-start',
+        id,
+        hostname,
+        path,
+        method,
+        timestamp: Date.now()
+    });
+
+    // Execute the original fetch immediately
+    const fetchPromise = originalFetch(...args);
+    
+    // Attach handlers to send fetch end event
+    const sendEnd = () => {
+        writeMessage({
+            type: 'fetch-end',
+            id,
+            timestamp: Date.now()
+        });
+    };
+    
+    // Send end event on both success and failure
+    fetchPromise.then(sendEnd, sendEnd);
+    
+    // Return the original promise unchanged
+    return fetchPromise;
+};
+
+// Preserve fetch properties
+Object.defineProperty(global.fetch, 'name', { value: 'fetch' });
+Object.defineProperty(global.fetch, 'length', { value: originalFetch.length });
+
+// Import global Claude Code CLI
+const { getClaudeCliPath, runClaudeCli } = require('./claude_version_utils.cjs');
+
+runClaudeCli(getClaudeCliPath());

package/scripts/claude_remote_launcher.cjs

@@ -0,0 +1,16 @@
+// Intercept setTimeout for the Claude Code SDK
+const originalSetTimeout = global.setTimeout;
+
+global.setTimeout = function(callback, delay, ...args) {
+    // Just wrap and call the original setTimeout
+    return originalSetTimeout(callback, delay, ...args);
+};
+
+// Preserve setTimeout properties
+Object.defineProperty(global.setTimeout, 'name', { value: 'setTimeout' });
+Object.defineProperty(global.setTimeout, 'length', { value: originalSetTimeout.length });
+
+// Import global Claude Code CLI
+const { getClaudeCliPath, runClaudeCli } = require('./claude_version_utils.cjs');
+
+runClaudeCli(getClaudeCliPath());

package/scripts/claude_version_utils.cjs

@@ -0,0 +1,391 @@
+/**
+ * Shared utilities for finding and resolving Claude Code CLI path
+ * Used by both local and remote launchers
+ *
+ * Supports multiple installation methods:
+ * 1. npm global: npm install -g @anthropic-ai/claude-code
+ * 2. Homebrew: brew install claude-code
+ * 3. Native installer:
+ *    - macOS/Linux: curl -fsSL https://claude.ai/install.sh | bash
+ *    - PowerShell:  irm https://claude.ai/install.ps1 | iex
+ *    - Windows CMD: curl -fsSL https://claude.ai/install.cmd | cmd
+ */
+
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+/**
+ * Safely resolve symlink or return path if it exists
+ * @param {string} filePath - Path to resolve
+ * @returns {string|null} Resolved path or null if not found
+ */
+function resolvePathSafe(filePath) {
+    if (!fs.existsSync(filePath)) return null;
+    try {
+        return fs.realpathSync(filePath);
+    } catch (e) {
+        // Symlink resolution failed, return original path
+        return filePath;
+    }
+}
+
+/**
+ * Find path to npm globally installed Claude Code CLI
+ * @returns {string|null} Path to cli.js or null if not found
+ */
+function findNpmGlobalCliPath() {
+    try {
+        const globalRoot = execSync('npm root -g', { encoding: 'utf8' }).trim();
+        const globalCliPath = path.join(globalRoot, '@anthropic-ai', 'claude-code', 'cli.js');
+        if (fs.existsSync(globalCliPath)) {
+            return globalCliPath;
+        }
+    } catch (e) {
+        // npm root -g failed
+    }
+    return null;
+}
+
+/**
+ * Find path to Homebrew installed Claude Code CLI
+ * @returns {string|null} Path to cli.js or binary, or null if not found
+ */
+function findHomebrewCliPath() {
+    if (process.platform !== 'darwin' && process.platform !== 'linux') {
+        return null;
+    }
+    
+    // Try to get Homebrew prefix via command first
+    let brewPrefix = null;
+    try {
+        brewPrefix = execSync('brew --prefix 2>/dev/null', { encoding: 'utf8' }).trim();
+    } catch (e) {
+        // brew command not in PATH, try standard locations
+    }
+    
+    // Standard Homebrew locations to check
+    const possiblePrefixes = [];
+    if (brewPrefix) {
+        possiblePrefixes.push(brewPrefix);
+    }
+    
+    // Add standard locations based on platform
+    if (process.platform === 'darwin') {
+        // macOS: Intel (/usr/local) or Apple Silicon (/opt/homebrew)
+        possiblePrefixes.push('/opt/homebrew', '/usr/local');
+    } else if (process.platform === 'linux') {
+        // Linux: system-wide or user installation
+        const homeDir = os.homedir();
+        possiblePrefixes.push('/home/linuxbrew/.linuxbrew', path.join(homeDir, '.linuxbrew'));
+    }
+    
+    // Check each possible prefix
+    for (const prefix of possiblePrefixes) {
+        if (!fs.existsSync(prefix)) {
+            continue;
+        }
+        
+        // Homebrew installs claude-code as a Cask (binary) in Caskroom
+        const caskroomPath = path.join(prefix, 'Caskroom', 'claude-code');
+        if (fs.existsSync(caskroomPath)) {
+            const found = findLatestVersionBinary(caskroomPath, 'claude');
+            if (found) return found;
+        }
+        
+        // Also check Cellar (for formula installations, though claude-code is usually a Cask)
+        const cellarPath = path.join(prefix, 'Cellar', 'claude-code');
+        if (fs.existsSync(cellarPath)) {
+            // Cellar has different structure - check for cli.js in libexec
+            const entries = fs.readdirSync(cellarPath);
+            if (entries.length > 0) {
+                const sorted = entries.sort((a, b) => compareVersions(b, a));
+                const latestVersion = sorted[0];
+                const cliPath = path.join(cellarPath, latestVersion, 'libexec', 'lib', 'node_modules', '@anthropic-ai', 'claude-code', 'cli.js');
+                if (fs.existsSync(cliPath)) {
+                    return cliPath;
+                }
+            }
+        }
+        
+        // Check bin directory for symlink (most reliable)
+        const binPath = path.join(prefix, 'bin', 'claude');
+        const resolvedBinPath = resolvePathSafe(binPath);
+        if (resolvedBinPath) return resolvedBinPath;
+    }
+    
+    return null;
+}
+
+/**
+ * Find path to native installer Claude Code CLI
+ * 
+ * Installation locations:
+ * - macOS/Linux: ~/.local/bin/claude (symlink) -> ~/.local/share/claude/versions/<version>
+ * - Windows: %LOCALAPPDATA%\Claude\ or %USERPROFILE%\.claude\
+ * - Legacy: ~/.claude/local/
+ * 
+ * @returns {string|null} Path to cli.js or binary, or null if not found
+ */
+function findNativeInstallerCliPath() {
+    const homeDir = os.homedir();
+    
+    // Windows-specific locations
+    if (process.platform === 'win32') {
+        const localAppData = process.env.LOCALAPPDATA || path.join(homeDir, 'AppData', 'Local');
+        
+        // Check %LOCALAPPDATA%\Claude\
+        const windowsClaudePath = path.join(localAppData, 'Claude');
+        if (fs.existsSync(windowsClaudePath)) {
+            // Check for versions directory
+            const versionsDir = path.join(windowsClaudePath, 'versions');
+            if (fs.existsSync(versionsDir)) {
+                const found = findLatestVersionBinary(versionsDir);
+                if (found) return found;
+            }
+            
+            // Check for claude.exe directly
+            const exePath = path.join(windowsClaudePath, 'claude.exe');
+            if (fs.existsSync(exePath)) {
+                return exePath;
+            }
+            
+            // Check for cli.js
+            const cliPath = path.join(windowsClaudePath, 'cli.js');
+            if (fs.existsSync(cliPath)) {
+                return cliPath;
+            }
+        }
+        
+        // Check %USERPROFILE%\.claude\ (alternative Windows location)
+        const dotClaudePath = path.join(homeDir, '.claude');
+        if (fs.existsSync(dotClaudePath)) {
+            const versionsDir = path.join(dotClaudePath, 'versions');
+            if (fs.existsSync(versionsDir)) {
+                const found = findLatestVersionBinary(versionsDir);
+                if (found) return found;
+            }
+            
+            const exePath = path.join(dotClaudePath, 'claude.exe');
+            if (fs.existsSync(exePath)) {
+                return exePath;
+            }
+        }
+    }
+    
+    // Check ~/.local/bin/claude symlink (most common location on macOS/Linux)
+    const localBinPath = path.join(homeDir, '.local', 'bin', 'claude');
+    const resolvedLocalBinPath = resolvePathSafe(localBinPath);
+    if (resolvedLocalBinPath) return resolvedLocalBinPath;
+    
+    // Check ~/.local/share/claude/versions/ (native installer location)
+    const versionsDir = path.join(homeDir, '.local', 'share', 'claude', 'versions');
+    if (fs.existsSync(versionsDir)) {
+        const found = findLatestVersionBinary(versionsDir);
+        if (found) return found;
+    }
+    
+    // Check ~/.claude/local/ (older installation method)
+    const nativeBasePath = path.join(homeDir, '.claude', 'local');
+    if (fs.existsSync(nativeBasePath)) {
+        // Look for the cli.js in the node_modules structure
+        const cliPath = path.join(nativeBasePath, 'node_modules', '@anthropic-ai', 'claude-code', 'cli.js');
+        if (fs.existsSync(cliPath)) {
+            return cliPath;
+        }
+        
+        // Alternative: direct cli.js in the installation
+        const directCliPath = path.join(nativeBasePath, 'cli.js');
+        if (fs.existsSync(directCliPath)) {
+            return directCliPath;
+        }
+    }
+    
+    return null;
+}
+
+/**
+ * Helper to find the latest version binary in a versions directory
+ * @param {string} versionsDir - Path to versions directory
+ * @param {string} [binaryName] - Optional binary name to look for inside version directory
+ * @returns {string|null} Path to binary or null
+ */
+function findLatestVersionBinary(versionsDir, binaryName = null) {
+    try {
+        const entries = fs.readdirSync(versionsDir);
+        if (entries.length === 0) return null;
+        
+        // Sort using semver comparison (descending)
+        const sorted = entries.sort((a, b) => compareVersions(b, a));
+        const latestVersion = sorted[0];
+        const versionPath = path.join(versionsDir, latestVersion);
+        
+        // Check if it's a file (binary) or directory
+        const stat = fs.statSync(versionPath);
+        if (stat.isFile()) {
+            return versionPath;
+        } else if (stat.isDirectory()) {
+            // If specific binary name provided, check for it
+            if (binaryName) {
+                const binaryPath = path.join(versionPath, binaryName);
+                if (fs.existsSync(binaryPath)) {
+                    return binaryPath;
+                }
+            }
+            // Check for executable or cli.js inside directory
+            const exePath = path.join(versionPath, process.platform === 'win32' ? 'claude.exe' : 'claude');
+            if (fs.existsSync(exePath)) {
+                return exePath;
+            }
+            const cliPath = path.join(versionPath, 'cli.js');
+            if (fs.existsSync(cliPath)) {
+                return cliPath;
+            }
+        }
+    } catch (e) {
+        // Directory read failed
+    }
+    return null;
+}
+
+/**
+ * Find path to globally installed Claude Code CLI
+ * Checks multiple installation methods in order of preference:
+ * 1. npm global (highest priority)
+ * 2. Homebrew
+ * 3. Native installer
+ * @returns {{path: string, source: string}|null} Path and source, or null if not found
+ */
+function findGlobalClaudeCliPath() {
+    // Check npm global first (highest priority)
+    const npmPath = findNpmGlobalCliPath();
+    if (npmPath) return { path: npmPath, source: 'npm' };
+
+    // Check Homebrew installation
+    const homebrewPath = findHomebrewCliPath();
+    if (homebrewPath) return { path: homebrewPath, source: 'Homebrew' };
+
+    // Check native installer
+    const nativePath = findNativeInstallerCliPath();
+    if (nativePath) return { path: nativePath, source: 'native installer' };
+
+    return null;
+}
+
+/**
+ * Get version from Claude Code package.json
+ * @param {string} cliPath - Path to cli.js
+ * @returns {string|null} Version string or null
+ */
+function getVersion(cliPath) {
+    try {
+        const pkgPath = path.join(path.dirname(cliPath), 'package.json');
+        if (fs.existsSync(pkgPath)) {
+            const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+            return pkg.version;
+        }
+    } catch (e) {}
+    return null;
+}
+
+/**
+ * Compare semver versions
+ * @param {string} a - First version
+ * @param {string} b - Second version
+ * @returns {number} 1 if a > b, -1 if a < b, 0 if equal
+ */
+function compareVersions(a, b) {
+    if (!a || !b) return 0;
+    const partsA = a.split('.').map(Number);
+    const partsB = b.split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        if (partsA[i] > partsB[i]) return 1;
+        if (partsA[i] < partsB[i]) return -1;
+    }
+    return 0;
+}
+
+/**
+ * Get the CLI path to use (global installation)
+ * @returns {string} Path to cli.js
+ * @throws {Error} If no global installation found
+ */
+function getClaudeCliPath() {
+    // Allow forcing a specific Claude Code install.
+    // Useful when multiple installs exist and the auto-resolver picks the "wrong" one,
+    // or when a daemon has a different PATH/HOME than your interactive shell.
+    const forcedPath = process.env.FLOCKBAY_CLAUDE_PATH || process.env.FLOCKBAY_CLAUDE_CLI_PATH;
+    if (forcedPath) {
+        const p = String(forcedPath).trim();
+        if (p && fs.existsSync(p)) {
+            console.error(`\x1b[90mUsing Claude Code from FLOCKBAY_CLAUDE_PATH: ${p}\x1b[0m`);
+            return p;
+        }
+        console.error(`\x1b[33mWarning:\x1b[0m FLOCKBAY_CLAUDE_PATH is set but does not exist: ${p}`);
+        console.error('\x1b[90mFalling back to auto-detection.\x1b[0m');
+    }
+
+    const result = findGlobalClaudeCliPath();
+    if (!result) {
+        console.error('\n\x1b[1m\x1b[33mClaude Code is not installed\x1b[0m\n');
+        console.error('Please install Claude Code using one of these methods:\n');
+        console.error('\x1b[1mOption 1 - npm (recommended, highest priority):\x1b[0m');
+        console.error('  \x1b[36mnpm install -g @anthropic-ai/claude-code\x1b[0m\n');
+        console.error('\x1b[1mOption 2 - Homebrew (macOS/Linux):\x1b[0m');
+        console.error('  \x1b[36mbrew install claude-code\x1b[0m\n');
+        console.error('\x1b[1mOption 3 - Native installer:\x1b[0m');
+        console.error('  \x1b[90mmacOS/Linux:\x1b[0m  \x1b[36mcurl -fsSL https://claude.ai/install.sh | bash\x1b[0m');
+        console.error('  \x1b[90mPowerShell:\x1b[0m   \x1b[36mirm https://claude.ai/install.ps1 | iex\x1b[0m');
+        console.error('  \x1b[90mWindows CMD:\x1b[0m  \x1b[36mcurl -fsSL https://claude.ai/install.cmd -o install.cmd && install.cmd && del install.cmd\x1b[0m\n');
+        console.error('\x1b[90mNote: If multiple installations exist, npm takes priority.\x1b[0m\n');
+        process.exit(1);
+    }
+
+    const version = getVersion(result.path);
+    const versionStr = version ? ` v${version}` : '';
+    console.error(`\x1b[90mUsing Claude Code${versionStr} from ${result.source}\x1b[0m`);
+
+    return result.path;
+}
+
+/**
+ * Run Claude CLI, handling both JavaScript and binary files
+ * @param {string} cliPath - Path to CLI (from getClaudeCliPath)
+ */
+function runClaudeCli(cliPath) {
+    const { pathToFileURL } = require('url');
+    const { spawn } = require('child_process');
+    
+    // Check if it's a JavaScript file (.js or .cjs) or a binary file
+    const isJsFile = cliPath.endsWith('.js') || cliPath.endsWith('.cjs');
+
+    if (isJsFile) {
+        // JavaScript file - use import to keep interceptors working
+        const importUrl = pathToFileURL(cliPath).href;
+        import(importUrl);
+    } else {
+        // Binary file (e.g., Homebrew installation) - spawn directly
+        // Note: Interceptors won't work with binary files, but that's acceptable
+        // as binary files are self-contained and don't need interception
+        const args = process.argv.slice(2);
+        const child = spawn(cliPath, args, {
+            stdio: 'inherit',
+            env: process.env
+        });
+        child.on('exit', (code) => {
+            process.exit(code || 0);
+        });
+    }
+}
+
+module.exports = {
+    findGlobalClaudeCliPath,
+    findNpmGlobalCliPath,
+    findHomebrewCliPath,
+    findNativeInstallerCliPath,
+    getVersion,
+    compareVersions,
+    getClaudeCliPath,
+    runClaudeCli
+};