flowstride 1.0.20-rc.2 → 1.0.20

package/dist/cli/manual_server/workspace_server.js

@@ -37,6 +37,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.startManualWorkspaceServer = startManualWorkspaceServer;
+const projectPaths_1 = require("../../utils/projectPaths");
+const security_1 = require("../../manual/security");
 const http = __importStar(require("http"));
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
@@ -49,12 +51,12 @@ async function startManualWorkspaceServer() {
         console.error(chalk_1.default.red(`\n❌ Error: UI build bundle not found at ${uiDistPath}. Please build the UI first.`));
         process.exit(1);
     }
-    const manualFlowsDir = path.join(process.cwd(), "manual_flows");
-    const templatesDir = path.join(manualFlowsDir, "templates");
-    const runsDir = path.join(manualFlowsDir, "runs");
-    const mediaDir = path.join(manualFlowsDir, "media");
-    const defectMediaDir = path.join(manualFlowsDir, "defect_media");
-    const workspaceStateFile = path.join(manualFlowsDir, ".workspace_state.json");
+    const manualFlowsDir = (0, projectPaths_1.projectPath)(process.cwd(), path.join(process.cwd(), "manual_flows"));
+    const templatesDir = (0, projectPaths_1.projectPath)(process.cwd(), path.join(manualFlowsDir, "templates"));
+    const runsDir = (0, projectPaths_1.projectPath)(process.cwd(), path.join(manualFlowsDir, "runs"));
+    const mediaDir = (0, projectPaths_1.projectPath)(process.cwd(), path.join(manualFlowsDir, "media"));
+    const defectMediaDir = (0, projectPaths_1.projectPath)(process.cwd(), path.join(manualFlowsDir, "defect_media"));
+    const workspaceStateFile = (0, projectPaths_1.projectPath)(process.cwd(), path.join(manualFlowsDir, ".workspace_state.json"));
     if (!fs.existsSync(templatesDir))
         fs.mkdirSync(templatesDir, { recursive: true });
     if (!fs.existsSync(runsDir))
@@ -92,7 +94,7 @@ async function startManualWorkspaceServer() {
                 return res.end(JSON.stringify({ error: "Invalid or missing file extension." }));
             }
             const safeFilename = `media_${Date.now()}_${Math.random().toString(36).substring(2, 9)}${ext.toLowerCase()}`;
-            const filePath = path.join(mediaDir, safeFilename);
+            const filePath = (0, projectPaths_1.projectPath)(process.cwd(), path.join(mediaDir, safeFilename));
             const MAX_SIZE = 104857600;
             let uploadedSize = 0;
             let isAborted = false;
@@ -141,7 +143,7 @@ async function startManualWorkspaceServer() {
                 }
                 const rawFilename = targetPath.replace("/media/", "");
                 const safeFilename = path.basename(rawFilename);
-                const filePath = path.join(mediaDir, safeFilename);
+                const filePath = (0, projectPaths_1.projectPath)(process.cwd(), path.join(mediaDir, safeFilename));
                 if (!fs.existsSync(filePath)) {
                     res.writeHead(404, { "Content-Type": "application/json" });
                     return res.end(JSON.stringify({ error: "Media file not found in vault" }));
@@ -166,7 +168,7 @@ async function startManualWorkspaceServer() {
         if (req.method === "GET" && pathname.startsWith("/media/")) {
             const filename = pathname.replace("/media/", "");
             const safeFilename = path.basename(filename);
-            const filePath = path.join(mediaDir, safeFilename);
+            const filePath = (0, projectPaths_1.projectPath)(process.cwd(), path.join(mediaDir, safeFilename));
             if (!fs.existsSync(filePath)) {
                 res.writeHead(404);
                 return res.end("Media not found");
@@ -213,7 +215,7 @@ async function startManualWorkspaceServer() {
                 return res.end(JSON.stringify({ error: "Invalid or missing file extension." }));
             }
             const safeFilename = `defect_${Date.now()}_${Math.random().toString(36).substring(2, 9)}${ext.toLowerCase()}`;
-            const filePath = path.join(defectMediaDir, safeFilename);
+            const filePath = (0, projectPaths_1.projectPath)(process.cwd(), path.join(defectMediaDir, safeFilename));
             const MAX_SIZE = 41943040; // Capped at 40MB
             let uploadedSize = 0;
             let isAborted = false;
@@ -263,7 +265,7 @@ async function startManualWorkspaceServer() {
                 }
                 const rawFilename = targetPath.replace("/defect_media/", "");
                 const safeFilename = path.basename(rawFilename);
-                const filePath = path.join(defectMediaDir, safeFilename);
+                const filePath = (0, projectPaths_1.projectPath)(process.cwd(), path.join(defectMediaDir, safeFilename));
                 if (fs.existsSync(filePath)) {
                     fs.unlinkSync(filePath);
                     console.log(chalk_1.default.yellow(`\n[Local Cache Cleared]: Asset securely removed from manual_flows/defect_media/${safeFilename}`));
@@ -286,7 +288,7 @@ async function startManualWorkspaceServer() {
         if (req.method === "GET" && pathname.startsWith("/defect_media/")) {
             const filename = pathname.replace("/defect_media/", "");
             const safeFilename = path.basename(filename);
-            const filePath = path.join(defectMediaDir, safeFilename);
+            const filePath = (0, projectPaths_1.projectPath)(process.cwd(), path.join(defectMediaDir, safeFilename));
             if (!fs.existsSync(filePath)) {
                 res.writeHead(404);
                 return res.end("Defect media not found");
@@ -326,13 +328,17 @@ async function startManualWorkspaceServer() {
         // CORE SYSTEM ROUTES
         // ============================================================================
         if (req.method === "POST" && pathname === "/api/save-design") {
-            let body = "";
-            req.on("data", (chunk) => {
-                body += chunk.toString();
-            });
-            req.on("end", () => {
+            let payload;
+            try {
+                payload = await (0, security_1.readManualPayload)(req);
+            }
+            catch (error) {
+                res.writeHead(error instanceof security_1.ManualInputError ? error.status : 400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: error instanceof security_1.ManualInputError ? error.message : 'Invalid manual payload' }));
+                return;
+            }
+            const savePayload = async () => {
                 try {
-                    const payload = JSON.parse(body);
                     const rawFilename = payload.filename || `New Flow.json`;
                     const canvasData = payload.canvasData;
                     if (!canvasData) {
@@ -343,7 +349,7 @@ async function startManualWorkspaceServer() {
                     if (!safeFilename.endsWith(".json")) {
                         safeFilename += ".json";
                     }
-                    const filePath = path.join(templatesDir, safeFilename);
+                    const filePath = (0, projectPaths_1.projectPath)(process.cwd(), path.join(templatesDir, safeFilename));
                     fs.writeFileSync(filePath, JSON.stringify(canvasData, null, 2), "utf-8");
                     console.log(chalk_1.default.green(`\n[Saved]: Template securely vaulted to manual_flows/templates/${safeFilename}`));
                     res.writeHead(200, { "Content-Type": "application/json" });
@@ -360,7 +366,8 @@ async function startManualWorkspaceServer() {
                         error: "Internal server error while saving template.",
                     }));
                 }
-            });
+            };
+            await savePayload();
             return;
         }
         if (req.method === "GET" && pathname === "/api/templates") {
@@ -398,7 +405,7 @@ async function startManualWorkspaceServer() {
                         error: "Forbidden: Only JSON configuration files can be loaded",
                     }));
                 }
-                const filePath = path.join(templatesDir, safeFilename);
+                const filePath = (0, projectPaths_1.projectPath)(process.cwd(), path.join(templatesDir, safeFilename));
                 if (!fs.existsSync(filePath)) {
                     res.writeHead(404, { "Content-Type": "application/json" });
                     return res.end(JSON.stringify({ error: "Template file not found" }));
@@ -430,7 +437,7 @@ async function startManualWorkspaceServer() {
                         error: "Forbidden: Only JSON configuration files can be deleted",
                     }));
                 }
-                const filePath = path.join(templatesDir, safeFilename);
+                const filePath = (0, projectPaths_1.projectPath)(process.cwd(), path.join(templatesDir, safeFilename));
                 if (!fs.existsSync(filePath)) {
                     res.writeHead(404, { "Content-Type": "application/json" });
                     return res.end(JSON.stringify({ error: "Template file not found" }));
@@ -453,13 +460,17 @@ async function startManualWorkspaceServer() {
             return;
         }
         if (req.method === "POST" && pathname === "/api/save-run") {
-            let body = "";
-            req.on("data", (chunk) => {
-                body += chunk.toString();
-            });
-            req.on("end", async () => {
+            let payload;
+            try {
+                payload = await (0, security_1.readManualPayload)(req);
+            }
+            catch (error) {
+                res.writeHead(error instanceof security_1.ManualInputError ? error.status : 400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: error instanceof security_1.ManualInputError ? error.message : 'Invalid manual payload' }));
+                return;
+            }
+            const savePayload = async () => {
                 try {
-                    const payload = JSON.parse(body);
                     const rawFilename = payload.filename || `Execution_Run_${Date.now()}.json`;
                     const canvasData = payload.canvasData;
                     if (!canvasData) {
@@ -469,7 +480,7 @@ async function startManualWorkspaceServer() {
                     const now = new Date();
                     const dayFolder = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
                     const timeFolder = `${String(now.getHours()).padStart(2, "0")}-${String(now.getMinutes()).padStart(2, "0")}-${String(now.getSeconds()).padStart(2, "0")}`;
-                    const runTargetDir = path.join(runsDir, dayFolder, timeFolder);
+                    const runTargetDir = (0, projectPaths_1.projectPath)(process.cwd(), path.join(runsDir, dayFolder, timeFolder));
                     if (!fs.existsSync(runTargetDir)) {
                         fs.mkdirSync(runTargetDir, { recursive: true });
                     }
@@ -477,7 +488,7 @@ async function startManualWorkspaceServer() {
                     if (!safeFilename.endsWith(".json")) {
                         safeFilename += ".json";
                     }
-                    const filePath = path.join(runTargetDir, safeFilename);
+                    const filePath = (0, projectPaths_1.projectPath)(process.cwd(), path.join(runTargetDir, safeFilename));
                     fs.writeFileSync(filePath, JSON.stringify(canvasData, null, 2), "utf-8");
                     const relativePath = path
                         .join(dayFolder, timeFolder, safeFilename)
@@ -498,7 +509,8 @@ async function startManualWorkspaceServer() {
                         error: "Internal server error while saving run.",
                     }));
                 }
-            });
+            };
+            await savePayload();
             return;
         }
         if (req.method === "GET" && pathname === "/api/runs") {
@@ -589,7 +601,7 @@ async function startManualWorkspaceServer() {
                     res.writeHead(403, { "Content-Type": "application/json" });
                     return res.end(JSON.stringify({ error: "Forbidden: Invalid file path" }));
                 }
-                const filePath = path.join(runsDir, targetFilename);
+                const filePath = (0, projectPaths_1.projectPath)(process.cwd(), path.join(runsDir, targetFilename));
                 const resolvedPath = path.resolve(filePath);
                 const resolvedRunsDir = path.resolve(runsDir);
                 if (!resolvedPath.startsWith(resolvedRunsDir) ||

package/dist/cli/utils/cloudSession.d.ts

@@ -0,0 +1,7 @@
+/** Resolve .env before authentication, using the same precedence as execution. */
+export declare function loadCloudEnvironment(root: string, profile?: string): string;
+export declare function cloudSessionDescription(apiBase: string): string;
+export declare function tokenExpiryDescription(data: {
+    tokenExpiresAt?: string;
+    tokenScope?: string;
+}): string;

package/dist/cli/utils/cloudSession.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadCloudEnvironment = loadCloudEnvironment;
+exports.cloudSessionDescription = cloudSessionDescription;
+exports.tokenExpiryDescription = tokenExpiryDescription;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
+const dotenv_1 = __importDefault(require("dotenv"));
+const cloud_1 = require("../../utils/cloud");
+/** Resolve .env before authentication, using the same precedence as execution. */
+function loadCloudEnvironment(root, profile) {
+    if (profile && !/^[a-zA-Z0-9_-]+$/.test(profile))
+        throw new Error('Invalid environment profile name.');
+    const files = profile ? [`.env.${profile}`, '.env'] : ['.env'];
+    for (const file of files) {
+        const filename = node_path_1.default.join(root, file);
+        if (node_fs_1.default.existsSync(filename))
+            dotenv_1.default.config({ path: filename, quiet: true });
+    }
+    return (0, cloud_1.cloudApiBase)(process.env);
+}
+function cloudSessionDescription(apiBase) {
+    const source = process.env.FLOWSTRIDE_TOKEN ? 'FLOWSTRIDE_TOKEN (environment)'
+        : node_fs_1.default.existsSync(node_path_1.default.join(process.cwd(), '.flowstride', 'credentials.json')) ? 'project credentials'
+            : node_fs_1.default.existsSync(node_path_1.default.join(node_os_1.default.homedir(), '.flowstride', 'credentials.json')) ? 'global credentials' : 'no saved credentials';
+    return `[Cloud]: ${apiBase}; credential source: ${source}`;
+}
+function tokenExpiryDescription(data) {
+    const expiry = data.tokenExpiresAt ? new Date(data.tokenExpiresAt) : null;
+    const label = expiry && Number.isFinite(expiry.getTime()) ? expiry.toISOString() : 'unavailable from this Cloud server';
+    const scope = ['execution', 'admin', 'readonly'].includes(data.tokenScope || '') ? `; scope: ${data.tokenScope}` : '';
+    return `[Cloud]: Token expiry (UTC): ${label}${scope}. Logging in with the same key does not renew it.`;
+}

package/dist/cli/utils/proInstaller.d.ts

@@ -0,0 +1,5 @@
+export declare function validateProArchive(buffer: Buffer): Promise<string>;
+export declare function installProEngine(apiBase: string, token: string, root?: string): Promise<{
+    version: string;
+    sha256: string;
+}>;

package/dist/cli/utils/proInstaller.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateProArchive = validateProArchive;
+exports.installProEngine = installProEngine;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_zlib_1 = require("node:zlib");
+const node_child_process_1 = require("node:child_process");
+const tar_1 = require("tar");
+const projectPaths_1 = require("../../utils/projectPaths");
+const MAX_ARCHIVE = 32 * 1024 * 1024;
+async function validateProArchive(buffer) {
+    if (!buffer.length || buffer.length > MAX_ARCHIVE)
+        throw new Error('Invalid Enterprise archive size');
+    const unpacked = (0, node_zlib_1.gunzipSync)(buffer, { maxOutputLength: 128 * 1024 * 1024 });
+    const files = new Set();
+    let metadata = '';
+    const invalid = [];
+    await new Promise((resolve, reject) => {
+        const parser = new tar_1.Parser({ onReadEntry(entry) {
+                const name = entry.path.replace(/\/$/, '');
+                if (!/^package(?:\/|$)/.test(name) || /\\/.test(name) || name.split('/').some(part => part === '..' || part === '.' || part === 'node_modules' || part === '.npmrc' || part === '.env' || part.startsWith('.env.')) || !['File', 'Directory'].includes(entry.type))
+                    invalid.push(name);
+                if (files.has(name))
+                    invalid.push(name);
+                files.add(name);
+                if (entry.path === 'package/package.json')
+                    entry.on('data', chunk => { metadata += chunk.toString('utf8'); if (metadata.length > 65536)
+                        invalid.push('oversized package metadata'); });
+                entry.resume();
+            }, strict: true });
+        parser.on('error', reject);
+        parser.on('end', resolve);
+        parser.end(unpacked);
+    });
+    if (invalid.length)
+        throw new Error('Enterprise archive contains unsafe paths or entries');
+    const pkg = JSON.parse(metadata);
+    if (pkg.name !== '@flowstride/pro' || typeof pkg.version !== 'string' || pkg.bin?.flowstride !== 'dist/cli/index.js')
+        throw new Error('Enterprise package identity is invalid');
+    for (const file of ['dist/cli/index.js', 'dist/runner/flow_worker.js', 'dist/runner/flow_orchestrator.js'])
+        if (!files.has(`package/${file}`))
+            throw new Error(`Enterprise archive is incomplete: ${file}`);
+    return pkg.version;
+}
+async function installProEngine(apiBase, token, root = process.cwd()) {
+    const response = await fetch(`${apiBase}/api/workspace/download-pro`, { headers: { Authorization: `Bearer ${token}` }, signal: AbortSignal.timeout(60000) });
+    if (!response.ok)
+        throw new Error(`Enterprise download failed (HTTP ${response.status})`);
+    const lengthHeader = response.headers.get('content-length');
+    const length = lengthHeader === null ? undefined : Number(lengthHeader);
+    if (length !== undefined && (!Number.isSafeInteger(length) || length <= 0 || length > MAX_ARCHIVE))
+        throw new Error('Invalid Enterprise download size');
+    if (!response.body)
+        throw new Error('Empty Enterprise download');
+    const reader = response.body.getReader();
+    const chunks = [];
+    let size = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            size += value.length;
+            if (size > MAX_ARCHIVE)
+                throw new Error('Enterprise download exceeds 32 MiB');
+            chunks.push(value);
+        }
+    }
+    catch (error) {
+        await reader.cancel().catch(() => { });
+        throw error;
+    }
+    finally {
+        reader.releaseLock();
+    }
+    if (length !== undefined && size !== length)
+        throw new Error('Enterprise download is truncated');
+    const archive = Buffer.concat(chunks);
+    const expected = process.env.FLOWSTRIDE_PRO_SHA256 || response.headers.get('x-flowstride-sha256');
+    const actual = node_crypto_1.default.createHash('sha256').update(archive).digest('hex');
+    if (expected && (!/^[a-f\d]{64}$/i.test(expected) || actual !== expected.toLowerCase()))
+        throw new Error('Enterprise archive checksum mismatch');
+    if (!expected)
+        console.warn('[Installer]: This Cloud server did not provide an archive checksum. HTTPS and package validation are being used; update Cloud to enable checksum verification.');
+    const version = await validateProArchive(archive);
+    const engine = (0, projectPaths_1.projectPath)(root, 'node_modules/@flowstride/pro');
+    const bins = ['flowstride', 'flowstride.cmd', 'flowstride.ps1'].map(name => node_path_1.default.resolve(root, 'node_modules/.bin', name));
+    (0, projectPaths_1.projectPath)(root, 'node_modules/.bin'); // Reject directory symlinks escaping the project; binary symlinks are preserved below.
+    const scratch = node_fs_1.default.mkdtempSync(node_path_1.default.join(node_os_1.default.tmpdir(), 'flowstride-pro-install-'));
+    const tarball = node_path_1.default.join(scratch, 'engine.tgz');
+    const backup = node_path_1.default.join(scratch, 'previous-pro');
+    const binState = bins.map(file => { try {
+        const st = node_fs_1.default.lstatSync(file);
+        return { file, link: st.isSymbolicLink() ? node_fs_1.default.readlinkSync(file) : undefined, data: st.isSymbolicLink() ? undefined : node_fs_1.default.readFileSync(file), mode: st.mode };
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+        return { file };
+    } });
+    let hadEngine = false;
+    let mutationStarted = false;
+    try {
+        node_fs_1.default.writeFileSync(tarball, archive, { mode: 0o600 });
+        if (node_fs_1.default.existsSync(engine)) {
+            node_fs_1.default.cpSync(engine, backup, { recursive: true, dereference: false });
+            hadEngine = true;
+        }
+        mutationStarted = true;
+        (0, node_child_process_1.execFileSync)(process.platform === 'win32' ? 'npm.cmd' : 'npm', ['install', tarball, '--no-save', '--ignore-scripts', '--package-lock=false', '--no-audit', '--no-fund'], { cwd: root, stdio: 'pipe', timeout: 120000, maxBuffer: 1024 * 1024 });
+        if (JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(engine, 'package.json'), 'utf8')).version !== version || !node_fs_1.default.existsSync(node_path_1.default.join(engine, 'dist/runner/flow_worker.js')))
+            throw new Error('Enterprise installation verification failed');
+        return { version, sha256: actual };
+    }
+    catch {
+        if (!mutationStarted)
+            throw new Error('Enterprise backup failed; the existing installation was left untouched.');
+        node_fs_1.default.rmSync(engine, { recursive: true, force: true });
+        if (hadEngine) {
+            node_fs_1.default.mkdirSync(node_path_1.default.dirname(engine), { recursive: true });
+            node_fs_1.default.cpSync(backup, engine, { recursive: true, dereference: false });
+        }
+        for (const state of binState) {
+            node_fs_1.default.rmSync(state.file, { force: true });
+            if (state.link !== undefined)
+                node_fs_1.default.symlinkSync(state.link, state.file);
+            else if (state.data !== undefined)
+                node_fs_1.default.writeFileSync(state.file, state.data, { mode: state.mode });
+        }
+        throw new Error('Enterprise installation failed. The previous engine and CLI launchers were restored; the OSS fallback remains available.');
+    }
+    finally {
+        node_fs_1.default.rmSync(scratch, { recursive: true, force: true });
+    }
+}

package/dist/game/sdk.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GameSDK = void 0;
+const projectPaths_1 = require("../utils/projectPaths");
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const strict_1 = __importDefault(require("node:assert/strict"));
@@ -127,7 +128,7 @@ class GameSDK {
             throw new Error('Checkpoint name must use letters, digits, underscores or hyphens.');
         const directory = this.config.artifactsDir || node_path_1.default.resolve('flowstride-artifacts');
         node_fs_1.default.mkdirSync(directory, { recursive: true });
-        const prefix = this.config.testFile ? this.config.testFile.replace(/[^a-zA-Z0-9_.-]/g, '_') + '-' : '';
+        const prefix = (0, projectPaths_1.artifactPrefix)(this.config.testFile);
         const file = node_path_1.default.join(directory, prefix + name + '.png');
         if (typeof options === 'object' && options.canvas)
             await this.page().locator(options.canvas).screenshot({ path: file });
@@ -167,7 +168,7 @@ class GameSDK {
     async expectVisual(options) {
         let before;
         if (options.baseline)
-            before = node_fs_1.default.readFileSync(node_path_1.default.resolve(options.baseline));
+            before = node_fs_1.default.readFileSync((0, projectPaths_1.projectPath)(this.config.projectRoot || process.cwd(), options.baseline));
         else
             before = this.snapshots.get(options.name);
         if (!before)

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { registerGame } from './game/bridge';
+export { registerThreeGame } from './game/three-bridge';
+export { GameSDK } from './game/sdk';
+export type { NativeRunResult } from './ci/runtime';
+export type { FlowstrideConfig } from './types';

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GameSDK = exports.registerThreeGame = exports.registerGame = void 0;
+var bridge_1 = require("./game/bridge");
+Object.defineProperty(exports, "registerGame", { enumerable: true, get: function () { return bridge_1.registerGame; } });
+var three_bridge_1 = require("./game/three-bridge");
+Object.defineProperty(exports, "registerThreeGame", { enumerable: true, get: function () { return three_bridge_1.registerThreeGame; } });
+var sdk_1 = require("./game/sdk");
+Object.defineProperty(exports, "GameSDK", { enumerable: true, get: function () { return sdk_1.GameSDK; } });

package/dist/manual/security.d.ts

@@ -0,0 +1,183 @@
+import { z } from "zod";
+export declare function sanitizeManualHtml(value: unknown): string;
+export declare const manualRunSchema: z.ZodObject<{
+    name: z.ZodString;
+    status: z.ZodEnum<{
+        PASS: "PASS";
+        FAIL: "FAIL";
+        INCOMPLETE: "INCOMPLETE";
+        "NO STEPS": "NO STEPS";
+    }>;
+    metrics: z.ZodObject<{
+        total: z.ZodNumber;
+        passed: z.ZodNumber;
+        failed: z.ZodNumber;
+        pending: z.ZodNumber;
+    }, z.core.$strip>;
+    canvasData: z.ZodObject<{
+        nodes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodNumber;
+            title: z.ZodOptional<z.ZodString>;
+            visual_step: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+            steps: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+            expected_result: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+            references: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+            defect_report: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+            defect_media: z.ZodOptional<z.ZodString>;
+            assigned_to: z.ZodOptional<z.ZodString>;
+            priority: z.ZodOptional<z.ZodString>;
+            x: z.ZodOptional<z.ZodNumber>;
+            y: z.ZodOptional<z.ZodNumber>;
+            width: z.ZodOptional<z.ZodNumber>;
+            height: z.ZodOptional<z.ZodNumber>;
+            is_active: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$loose>>>;
+        groups: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodNumber;
+            title: z.ZodOptional<z.ZodString>;
+            x: z.ZodOptional<z.ZodNumber>;
+            y: z.ZodOptional<z.ZodNumber>;
+            width: z.ZodOptional<z.ZodNumber>;
+            height: z.ZodOptional<z.ZodNumber>;
+            is_active: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$loose>>>;
+        texts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodNumber;
+            content: z.ZodOptional<z.ZodString>;
+            x: z.ZodOptional<z.ZodNumber>;
+            y: z.ZodOptional<z.ZodNumber>;
+            width: z.ZodOptional<z.ZodNumber>;
+            height: z.ZodOptional<z.ZodNumber>;
+            is_active: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$loose>>>;
+        connections: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodNumber;
+        }, z.core.$loose>>>;
+        executionReport: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            status: z.ZodEnum<{
+                fail: "fail";
+                passed: "passed";
+                failed: "failed";
+                skipped: "skipped";
+                success: "success";
+                Pending: "Pending";
+                Current: "Current";
+                Passed: "Passed";
+                Failed: "Failed";
+                Blocked: "Blocked";
+                Skipped: "Skipped";
+                Pass: "Pass";
+                Fail: "Fail";
+                Success: "Success";
+                pass: "pass";
+                pending: "pending";
+                blocked: "blocked";
+            }>;
+            group_title: z.ZodOptional<z.ZodString>;
+            id: z.ZodNumber;
+            title: z.ZodOptional<z.ZodString>;
+            visual_step: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+            steps: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+            expected_result: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+            references: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+            defect_report: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+            defect_media: z.ZodOptional<z.ZodString>;
+            assigned_to: z.ZodOptional<z.ZodString>;
+            priority: z.ZodOptional<z.ZodString>;
+            x: z.ZodOptional<z.ZodNumber>;
+            y: z.ZodOptional<z.ZodNumber>;
+            width: z.ZodOptional<z.ZodNumber>;
+            height: z.ZodOptional<z.ZodNumber>;
+            is_active: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$loose>>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$loose>;
+}, z.core.$strip>;
+export declare function sanitizeStoredCanvas(value: unknown): Record<string, unknown>;
+export declare const manualCanvasSchema: z.ZodObject<{
+    nodes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        title: z.ZodOptional<z.ZodString>;
+        visual_step: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        steps: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        expected_result: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        references: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        defect_report: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        defect_media: z.ZodOptional<z.ZodString>;
+        assigned_to: z.ZodOptional<z.ZodString>;
+        priority: z.ZodOptional<z.ZodString>;
+        x: z.ZodOptional<z.ZodNumber>;
+        y: z.ZodOptional<z.ZodNumber>;
+        width: z.ZodOptional<z.ZodNumber>;
+        height: z.ZodOptional<z.ZodNumber>;
+        is_active: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>>;
+    groups: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        title: z.ZodOptional<z.ZodString>;
+        x: z.ZodOptional<z.ZodNumber>;
+        y: z.ZodOptional<z.ZodNumber>;
+        width: z.ZodOptional<z.ZodNumber>;
+        height: z.ZodOptional<z.ZodNumber>;
+        is_active: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>>;
+    texts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+        content: z.ZodOptional<z.ZodString>;
+        x: z.ZodOptional<z.ZodNumber>;
+        y: z.ZodOptional<z.ZodNumber>;
+        width: z.ZodOptional<z.ZodNumber>;
+        height: z.ZodOptional<z.ZodNumber>;
+        is_active: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>>;
+    connections: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodNumber;
+    }, z.core.$loose>>>;
+    executionReport: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        status: z.ZodEnum<{
+            fail: "fail";
+            passed: "passed";
+            failed: "failed";
+            skipped: "skipped";
+            success: "success";
+            Pending: "Pending";
+            Current: "Current";
+            Passed: "Passed";
+            Failed: "Failed";
+            Blocked: "Blocked";
+            Skipped: "Skipped";
+            Pass: "Pass";
+            Fail: "Fail";
+            Success: "Success";
+            pass: "pass";
+            pending: "pending";
+            blocked: "blocked";
+        }>;
+        group_title: z.ZodOptional<z.ZodString>;
+        id: z.ZodNumber;
+        title: z.ZodOptional<z.ZodString>;
+        visual_step: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        steps: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        expected_result: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        references: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        defect_report: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+        defect_media: z.ZodOptional<z.ZodString>;
+        assigned_to: z.ZodOptional<z.ZodString>;
+        priority: z.ZodOptional<z.ZodString>;
+        x: z.ZodOptional<z.ZodNumber>;
+        y: z.ZodOptional<z.ZodNumber>;
+        width: z.ZodOptional<z.ZodNumber>;
+        height: z.ZodOptional<z.ZodNumber>;
+        is_active: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$loose>;
+export declare class ManualInputError extends Error {
+    status: number;
+    constructor(status: number, message: string);
+}
+export declare function readManualPayload(req: import("http").IncomingMessage): Promise<any>;