flockbay 0.10.15

package/scripts/ripgrep_launcher.cjs

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+
+/**
+ * Ripgrep runner - executed as a subprocess to run the native module
+ * This file is intentionally written in CommonJS to avoid ESM complexities
+ */
+
+const path = require('path');
+
+// Load the native module from unpacked directory
+const modulePath = path.join(__dirname, '..', 'tools', 'unpacked', 'ripgrep.node');
+const ripgrepNative = require(modulePath);
+
+// Get arguments from command line (skip node and script name)
+const args = process.argv.slice(2);
+
+// Parse the JSON-encoded arguments
+let parsedArgs;
+try {
+    parsedArgs = JSON.parse(args[0]);
+} catch (error) {
+    console.error('Failed to parse arguments:', error.message);
+    process.exit(1);
+}
+
+// Run ripgrep
+try {
+    const exitCode = ripgrepNative.ripgrepMain(parsedArgs);
+    process.exit(exitCode);
+} catch (error) {
+    console.error('Ripgrep error:', error.message);
+    process.exit(1);
+}

package/scripts/session_hook_forwarder.cjs

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+/**
+ * Session Hook Forwarder
+ * 
+ * This script is executed by Claude's SessionStart hook.
+ * It reads JSON data from stdin and forwards it to Flockbay's hook server.
+ * 
+ * Usage: echo '{"session_id":"..."}' | node session_hook_forwarder.cjs <port>
+ */
+
+const http = require('http');
+
+const port = parseInt(process.argv[2], 10);
+
+if (!port || isNaN(port)) {
+    process.exit(1);
+}
+
+const chunks = [];
+
+process.stdin.on('data', (chunk) => {
+    chunks.push(chunk);
+});
+
+process.stdin.on('end', () => {
+    const body = Buffer.concat(chunks);
+    
+    const req = http.request({
+        host: '127.0.0.1',
+        port: port,
+        method: 'POST',
+        path: '/hook/session-start',
+        headers: {
+            'Content-Type': 'application/json',
+            'Content-Length': body.length
+        }
+    }, (res) => {
+        res.resume(); // Drain response
+    });
+    
+    req.on('error', (error) => {
+        // Don't throw (this runs inside Claude hooks), but don't mask failures either.
+        console.error('[session_hook_forwarder] Failed to forward session-start hook:', error?.message || error);
+    });
+    
+    req.end(body);
+});
+
+process.stdin.resume();

package/scripts/test-codex-abort-history.mjs

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+import { randomUUID } from 'node:crypto';
+import { setTimeout as delay } from 'node:timers/promises';
+
+// Minimal, optional integration check (uses local `codex` CLI via MCP).
+// Goal: verify that an abort does NOT force a new Codex session / lose context.
+//
+// Usage:
+//   node flockbay-cli/scripts/test-codex-abort-history.mjs
+//   ABORT_DELAY_MS=50 node flockbay-cli/scripts/test-codex-abort-history.mjs
+//
+// Exits:
+//   0 on pass
+//   1 on fail
+
+const ABORT_DELAY_MS = Number(process.env.ABORT_DELAY_MS || 50);
+
+function extractText(res) {
+  const items = Array.isArray(res?.content) ? res.content : [];
+  return items
+    .map((x) => (x && x.type === 'text' ? x.text : ''))
+    .filter(Boolean)
+    .join('\n');
+}
+
+async function main() {
+  const { CodexMcpClient } = await import('../dist/codex/codexMcpClient.cjs');
+
+  const client = new CodexMcpClient();
+  await client.connect();
+
+  const seed = `Remember these three items for this chat, and respond with ONLY the word: ack\n- green apple\n- red horse\n- purple giraffe\n\nRun id: ${randomUUID()}`;
+  await client.startSession({
+    prompt: seed,
+    sandbox: 'workspace-write',
+    'approval-policy': 'untrusted',
+    config: {},
+  });
+
+  // Fire a request and abort it quickly (tries to exercise the abort path).
+  const abortController = new AbortController();
+  const inflight = client.continueSession(
+    `Write 2000 words about the three items (this is intentionally long).`,
+    { signal: abortController.signal },
+  );
+
+  await delay(ABORT_DELAY_MS);
+  abortController.abort();
+
+  try {
+    await inflight;
+  } catch {
+    // Expected: abort cancels the in-flight request.
+  }
+
+  const recall = await client.startSession({
+    prompt: `List the three items you were asked to remember. Reply in 3 bullet points only.`,
+    config: {},
+  });
+
+  const text = extractText(recall).toLowerCase();
+  const ok = text.includes('green') && text.includes('red') && text.includes('purple');
+  if (!ok) {
+    console.error('FAIL: missing expected recall terms');
+    console.error(text);
+    process.exit(1);
+  }
+
+  console.log('PASS');
+  process.exit(0);
+}
+
+main().catch((err) => {
+  console.error('FAIL:', err?.stack || err?.message || String(err));
+  process.exit(1);
+});
+

package/scripts/unpack-tools.cjs

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+
+/**
+ * Unpacks platform-specific binaries from compressed archives
+ * This script extracts the necessary tools for the current platform
+ */
+
+const fs = require('fs');
+const path = require('path');
+const zlib = require('zlib');
+const tar = require('tar');
+const os = require('os');
+const https = require('https');
+
+/**
+ * Get the platform-specific directory name
+ */
+function getPlatformDir() {
+    const platform = os.platform();
+    const arch = os.arch();
+    
+    if (platform === 'darwin') {
+        if (arch === 'arm64') return 'arm64-darwin';
+        if (arch === 'x64') return 'x64-darwin';
+    } else if (platform === 'linux') {
+        if (arch === 'arm64') return 'arm64-linux';
+        if (arch === 'x64') return 'x64-linux';
+    } else if (platform === 'win32') {
+        if (arch === 'x64') return 'x64-win32';
+    }
+    
+    throw new Error(`Unsupported platform: ${arch}-${platform}`);
+}
+
+/**
+ * Get the root tools directory
+ */
+function getToolsDir() {
+    // Handle both direct execution and require() calls
+    const scriptDir = __dirname;
+    return path.resolve(scriptDir, '..', 'tools');
+}
+
+function getToolsBaseUrl() {
+    // Allow override for development/testing or alternative mirrors.
+    // Default points at our public Cloudflare Worker path that serves R2 objects.
+    return (process.env.FLOCKBAY_TOOLS_BASE_URL || 'https://api.flockbay.com/bootstrap/tools').replace(/\/+$/, '');
+}
+
+function downloadFile(url, destPath, redirectCount = 0) {
+    return new Promise((resolve, reject) => {
+        if (redirectCount > 5) {
+            reject(new Error(`Too many redirects while downloading: ${url}`));
+            return;
+        }
+
+        const req = https.get(url, (res) => {
+            const statusCode = res.statusCode || 0;
+
+            if (statusCode >= 300 && statusCode < 400 && res.headers.location) {
+                const nextUrl = new URL(res.headers.location, url).toString();
+                res.resume();
+                downloadFile(nextUrl, destPath, redirectCount + 1).then(resolve).catch(reject);
+                return;
+            }
+
+            if (statusCode !== 200) {
+                res.resume();
+                reject(new Error(`Download failed (${statusCode}) for ${url}`));
+                return;
+            }
+
+            const tmpPath = `${destPath}.tmp`;
+            const out = fs.createWriteStream(tmpPath);
+            res.pipe(out);
+            out.on('finish', () => {
+                out.close(() => {
+                    fs.renameSync(tmpPath, destPath);
+                    resolve();
+                });
+            });
+            out.on('error', (err) => {
+                try { fs.unlinkSync(tmpPath); } catch {}
+                reject(err);
+            });
+        });
+
+        req.on('error', reject);
+    });
+}
+
+/**
+ * Check if tools are already unpacked for current platform
+ */
+function areToolsUnpacked(toolsDir) {
+    const unpackedPath = path.join(toolsDir, 'unpacked');
+    
+    if (!fs.existsSync(unpackedPath)) {
+        return false;
+    }
+    
+    // Check for expected binaries
+    const isWin = os.platform() === 'win32';
+    const difftBinary = isWin ? 'difft.exe' : 'difft';
+    const rgBinary = isWin ? 'rg.exe' : 'rg';
+    
+    const expectedFiles = [
+        path.join(unpackedPath, difftBinary),
+        path.join(unpackedPath, rgBinary),
+        path.join(unpackedPath, 'ripgrep.node')
+    ];
+    
+    return expectedFiles.every(file => fs.existsSync(file));
+}
+
+/**
+ * Unpack a tar.gz archive to a destination directory
+ */
+async function unpackArchive(archivePath, destDir) {
+    return new Promise((resolve, reject) => {
+        // Ensure destination directory exists
+        if (!fs.existsSync(destDir)) {
+            fs.mkdirSync(destDir, { recursive: true });
+        }
+        
+        // Create read stream and extract
+        fs.createReadStream(archivePath)
+            .pipe(zlib.createGunzip())
+            .pipe(tar.extract({
+                cwd: destDir,
+                preserveMode: true,
+                preserveOwner: false
+            }))
+            .on('finish', () => {
+                // Set executable permissions for Unix systems
+                if (os.platform() !== 'win32') {
+                    const files = fs.readdirSync(destDir);
+                    files.forEach(file => {
+                        const filePath = path.join(destDir, file);
+                        const stats = fs.statSync(filePath);
+                        if (stats.isFile() && !file.endsWith('.node')) {
+                            // Make binary files executable
+                            fs.chmodSync(filePath, 0o755);
+                        }
+                    });
+                }
+                resolve();
+            })
+            .on('error', reject);
+    });
+}
+
+/**
+ * Main unpacking function
+ */
+async function unpackTools() {
+    try {
+        const platformDir = getPlatformDir();
+        const toolsDir = getToolsDir();
+        const archivesDir = path.join(toolsDir, 'archives');
+        const unpackedPath = path.join(toolsDir, 'unpacked');
+        const baseUrl = getToolsBaseUrl();
+        
+        // Check if already unpacked
+        if (areToolsUnpacked(toolsDir)) {
+            console.log(`Tools already unpacked for ${platformDir}`);
+            return { success: true, alreadyUnpacked: true };
+        }
+        
+        console.log(`Unpacking tools for ${platformDir}...`);
+        
+        // Create unpacked directory
+        if (!fs.existsSync(unpackedPath)) {
+            fs.mkdirSync(unpackedPath, { recursive: true });
+        }
+
+        // Ensure archives directory exists (archives are downloaded on-demand in npm installs)
+        if (!fs.existsSync(archivesDir)) {
+            fs.mkdirSync(archivesDir, { recursive: true });
+        }
+        
+        // Unpack difftastic
+        const difftasticArchive = path.join(archivesDir, `difftastic-${platformDir}.tar.gz`);
+        if (!fs.existsSync(difftasticArchive)) {
+            const url = `${baseUrl}/difftastic-${platformDir}.tar.gz`;
+            console.log(`Downloading difftastic archive: ${url}`);
+            await downloadFile(url, difftasticArchive);
+        }
+        await unpackArchive(difftasticArchive, unpackedPath);
+        
+        // Unpack ripgrep
+        const ripgrepArchive = path.join(archivesDir, `ripgrep-${platformDir}.tar.gz`);
+        if (!fs.existsSync(ripgrepArchive)) {
+            const url = `${baseUrl}/ripgrep-${platformDir}.tar.gz`;
+            console.log(`Downloading ripgrep archive: ${url}`);
+            await downloadFile(url, ripgrepArchive);
+        }
+        await unpackArchive(ripgrepArchive, unpackedPath);
+        
+        console.log(`Tools unpacked successfully to ${unpackedPath}`);
+        return { success: true, alreadyUnpacked: false };
+        
+    } catch (error) {
+        console.error('Failed to unpack tools:', error.message);
+        throw error;
+    }
+}
+
+// Export for use as module
+module.exports = { unpackTools, getPlatformDir, getToolsDir };
+
+// Run if executed directly
+if (require.main === module) {
+    unpackTools()
+        .then(result => {
+            process.exit(0);
+        })
+        .catch(error => {
+            console.error('Error:', error);
+            process.exit(1);
+        });
+}

package/tools/licenses/difftastic-LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-2025 Wilfred Hughes
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/tools/licenses/ripgrep-LICENSE

@@ -0,0 +1,3 @@
+This project is dual-licensed under the Unlicense and MIT licenses.
+
+You may use this code under the terms of either license.

package/tools/unreal-mcp/UPSTREAM_VERSION.md

@@ -0,0 +1,8 @@
+# Upstream Snapshot
+
+Repository: `https://github.com/chongdashu/unreal-mcp`
+
+Pinned commit: `4e5f00da50733190481311e254d16d137a84ef33`
+
+Snapshot location: `tools/unreal-mcp/upstream/`
+

package/tools/unreal-mcp/upstream/Docs/README.md

@@ -0,0 +1,8 @@
+# Unreal Engine MCP Documentation
+
+Welcome to the documentation for the Unreal Engine Model Context Protocol (MCP) integration. This documentation will help you understand, set up, and use the MCP system with Unreal Engine.
+
+## Contents
+
+- [Tools](Tools/README.md) - All the tools that are available.
+

package/tools/unreal-mcp/upstream/Docs/Tools/README.md

@@ -0,0 +1,7 @@
+# Unreal MCP Tools
+
+This document is an index to all the tools supported.
+
+- [Actor Tools](actor_tools.md)
+- [Editor Tools](editor_tools.md)
+- [Blueprint Tools](blueprint_tools.md)

package/tools/unreal-mcp/upstream/Docs/Tools/actor_tools.md

@@ -0,0 +1,184 @@
+# Unreal MCP Editor Tools
+
+This document provides detailed information about the actor tools available in the Unreal MCP integration.
+
+## Overview
+
+Actor tools allow you to manipulate actors in the Unreal Engine scene.
+
+## Actor Tools
+
+### get_actors_in_level
+
+Get a list of all actors in the current level.
+
+**Parameters:**
+- None
+
+**Returns:**
+- List of all actors with their properties
+
+**Example:**
+```json
+{
+  "command": "get_actors_in_level",
+  "params": {}
+}
+```
+
+### find_actors_by_name
+
+Find actors in the current level by name pattern.
+
+**Parameters:**
+- `pattern` (string) - The name or partial name pattern to search for
+
+**Returns:**
+- List of matching actor names
+
+**Example:**
+```json
+{
+  "command": "find_actors_by_name",
+  "params": {
+    "pattern": "Cube"
+  }
+}
+```
+
+### create_actor
+
+Create a new actor in the current level.
+
+**Parameters:**
+- `name` (string) - The name for the new actor (must be unique)
+- `type` (string) - The type of actor to create (must be uppercase)
+- `location` (array, optional) - [X, Y, Z] coordinates for the actor's position, defaults to [0, 0, 0]
+- `rotation` (array, optional) - [Pitch, Yaw, Roll] values for the actor's rotation, defaults to [0, 0, 0]
+- `scale` (array, optional) - [X, Y, Z] values for the actor's scale, defaults to [1, 1, 1]
+
+**Returns:**
+- Information about the created actor
+
+**Example:**
+```json
+{
+  "command": "create_actor",
+  "params": {
+    "name": "MyCube",
+    "type": "CUBE",
+    "location": [0, 0, 100],
+    "rotation": [0, 45, 0],
+    "scale": [2, 2, 2]
+  }
+}
+```
+
+### delete_actor
+
+Delete an actor by name.
+
+**Parameters:**
+- `name` (string) - The name of the actor to delete
+
+**Returns:**
+- Result of the delete operation
+
+**Example:**
+```json
+{
+  "command": "delete_actor",
+  "params": {
+    "name": "MyCube"
+  }
+}
+```
+
+### set_actor_transform
+
+Set the transform (location, rotation, scale) of an actor.
+
+**Parameters:**
+- `name` (string) - The name of the actor to modify
+- `location` (array, optional) - [X, Y, Z] coordinates for the actor's position
+- `rotation` (array, optional) - [Pitch, Yaw, Roll] values for the actor's rotation
+- `scale` (array, optional) - [X, Y, Z] values for the actor's scale
+
+**Returns:**
+- Result of the transform operation
+
+**Example:**
+```json
+{
+  "command": "set_actor_transform",
+  "params": {
+    "name": "MyCube",
+    "location": [100, 200, 300],
+    "rotation": [0, 90, 0]
+  }
+}
+```
+
+### get_actor_properties
+
+Get all properties of an actor.
+
+**Parameters:**
+- `name` (string) - The name of the actor
+
+**Returns:**
+- Object containing all actor properties
+
+**Example:**
+```json
+{
+  "command": "get_actor_properties",
+  "params": {
+    "name": "MyCube"
+  }
+}
+```
+
+## Error Handling
+
+All command responses include a "success" field indicating whether the operation succeeded, and an optional "message" field with details in case of failure.
+
+```json
+{
+  "success": false,
+  "message": "Actor 'MyCube' not found in the current level"
+}
+```
+
+## Implementation Notes
+
+- All numeric parameters for transforms (location, rotation, scale) must be provided as lists of 3 float values
+- Actor types should be provided in uppercase
+- The server maintains logging of all operations with detailed information and error messages
+- All commands are executed through a connection to the Unreal Engine editor
+
+## Type Reference
+
+### Actor Types
+
+Supported actor types for the `create_actor` command:
+
+- `CUBE` - Static mesh cube
+- `SPHERE` - Static mesh sphere
+- `CYLINDER` - Static mesh cylinder
+- `PLANE` - Static mesh plane
+- `POINT_LIGHT` - Point light source
+- `SPOT_LIGHT` - Spot light source
+- `DIRECTIONAL_LIGHT` - Directional light source
+- `CAMERA` - Camera actor
+- `EMPTY` - Empty actor (container)
+
+## Future Extensions
+
+The following tool categories are planned for future releases:
+
+- **Level Tools**: Managing Unreal Engine levels
+- **Material Tools**: Creating and editing materials
+- **Blueprint Tools**: Manipulating Blueprints
+- **Asset Tools**: Managing project assets
+- **Editor Tools**: Controlling the Unreal Editor