@gripforgeai/mcp 0.1.15 → 0.1.17

package/dist/game-import-extract.js

@@ -0,0 +1,67 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { mkdir, readdir, realpath } from 'node:fs/promises';
+import { GameImportAgent, confinedFile, saveImportJob } from './game-import-agent.js';
+const exec = promisify(execFile);
+/** Explicit adapters; never execute a binary discovered inside the source game. */
+export async function extractGame(job) {
+    const e = job.extraction;
+    if (!e || !job.rights || !job.report)
+        throw Error('Extraction plan and authorized rights basis required');
+    if (job.report.engine.name !== 'unity')
+        throw Error('This adapter only handles Unity. Use the existing Unreal source-project exporter for Unreal.');
+    await mkdir(e.output, { recursive: true, mode: 0o700 });
+    const agent = new GameImportAgent(job);
+    await agent.checkpoint();
+    if (!e.completed) {
+        if (e.tool === 'assetripper') {
+            const url = new URL(e.endpoint ?? '');
+            if (url.protocol !== 'http:' || !['127.0.0.1', 'localhost', '[::1]'].includes(url.hostname) || url.username || url.password || url.pathname !== '/')
+                throw Error('AssetRipper requires a dedicated local loopback HTTP instance');
+            // Version-compatible route discovery prevents invoking imaginary CLI options or a different local service.
+            const spec = await fetch(new URL('/openapi/v1.json', url), { signal: AbortSignal.timeout(10000) });
+            if (!spec.ok)
+                throw Error('AssetRipper OpenAPI unavailable; use a compatible web build or manual export');
+            const api = await spec.json();
+            if (!api.paths?.['/LoadFolder']?.post || !api.paths?.['/Export/PrimaryContent']?.post)
+                throw Error('AssetRipper API lacks required export routes');
+            e.version = String(api.info?.version ?? 'unreported');
+            await saveImportJob(job);
+            const post = async (route, path) => { await agent.checkpoint(); const res = await fetch(new URL(route, url), { method: 'POST', body: new URLSearchParams({ Path: path, CreateSubfolder: 'false' }), redirect: 'manual', signal: AbortSignal.timeout(20 * 60 * 1000) }); if (![200, 302, 303].includes(res.status))
+                throw Error(`AssetRipper ${route}: HTTP ${res.status}`); };
+            await post('/LoadFolder', e.sourceRoot);
+            await post('/Export/PrimaryContent', e.output);
+            if (!(await readdir(e.output)).length)
+                throw Error('Extractor returned no files; inspect AssetRipper failed-file log');
+        }
+        else {
+            const bin = process.env[e.tool === 'cpp2il' ? 'GRIPFORGE_CPP2IL_BIN' : 'GRIPFORGE_ILSPY_BIN'];
+            if (!bin)
+                throw Error(`Configure the installed ${e.tool} executable; no automatic installation`);
+            const version = await exec(bin, ['--version'], { cwd: e.output, timeout: 10000, maxBuffer: 1024 * 1024 }).catch(() => ({ stdout: 'version not reported' }));
+            e.version = version.stdout.trim().slice(0, 200);
+            await saveImportJob(job);
+            const args = e.tool === 'cpp2il' ? ['--game-path', e.sourceRoot, '--output-to', e.output] : ['--disable-updatecheck', '-p', '-o', e.output, await confinedFile(e.sourceRoot, job.report.assets.find(a => /(?:^|\/)Managed\/Assembly-CSharp\.dll$/i.test(a.path))?.path ?? '')];
+            await exec(bin, args, { cwd: e.output, timeout: 20 * 60 * 1000, maxBuffer: 4 * 1024 * 1024 });
+            job.report.warnings.push(`${e.tool} metadata/code exported locally to ${e.tool}-output. It is not a mesh extraction and is never uploaded to the Library.`);
+        }
+        e.completed = true;
+        await agent.checkpoint();
+    }
+    if (e.tool === 'assetripper') {
+        const engine = job.report.engine, source = job.report.source;
+        job.root = await realpath(e.output);
+        job.phase = 'analyze';
+        const report = await new GameImportAgent(job).analyze();
+        report.source = source;
+        report.engine = engine;
+        report.toolchain = agent.select_toolchain(engine);
+        report.warnings.push('Inventory is from AssetRipper export; native Unity formats still require their own converter.');
+        await saveImportJob(job);
+    }
+    else {
+        job.phase = 'analyze';
+        job.status = 'awaiting_selection';
+        await saveImportJob(job);
+    }
+}

package/dist/game-import-normalize.js

@@ -0,0 +1,72 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { mkdir, readFile, writeFile, stat } from 'node:fs/promises';
+import { basename, join, isAbsolute, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createHash } from 'node:crypto';
+import { GameImportAgent, confinedFile, inspectAsset, jobDirectory, saveImportJob } from './game-import-agent.js';
+const exec = promisify(execFile), hash = (bytes) => createHash('sha256').update(bytes).digest('hex');
+export function normalizedPath(job, id, format) { return join(jobDirectory(job.id), 'normalized', id, 'output.' + format); }
+/** Local durable conversions. Completed files survive cancellation/crashes; original sources are never modified. */
+export async function normalizeGame(job) {
+    if (!job.report || !job.selected?.length || !job.rights)
+        throw Error('Select sources and provide a rights basis');
+    const bin = process.env.GRIPFORGE_BLENDER_BIN;
+    if (!bin || !isAbsolute(bin))
+        throw Error('Configure GRIPFORGE_BLENDER_BIN with an installed Blender executable');
+    const agent = new GameImportAgent(job);
+    job.total = job.selected.length;
+    job.completed = 0;
+    for (const id of job.selected) {
+        await agent.checkpoint();
+        const asset = job.report.assets.find(a => a.id === id);
+        if (!asset || !['fbx', 'obj', 'dds', 'tga'].includes(asset.format))
+            throw Error('Blender normalization supports FBX/OBJ/DDS/TGA only');
+        const source = await readFile(await confinedFile(job.root, asset.path));
+        if (hash(source) !== asset.sha256)
+            throw Error('Source changed after analysis; analyze again');
+        const format = ['dds', 'tga'].includes(asset.format) ? 'png' : 'glb', output = normalizedPath(job, id, format), dir = dirname(output);
+        await mkdir(join(dir, 'source'), { recursive: true, mode: 0o700 });
+        try {
+            let bytes;
+            if (asset.details.normalization) {
+                const cached = await readFile(output).catch(() => undefined);
+                if (cached && hash(cached) === asset.details.normalization.sha256)
+                    bytes = cached;
+            }
+            if (!bytes) {
+                const input = join(dir, 'source', basename(asset.path));
+                await writeFile(input, source, { mode: 0o600 });
+                // Staging excludes source scripts and arbitrary external references. Embedded FBX materials are retained.
+                // OBJ material sidecars need explicit portable export: never follow unvalidated MTL references in Blender.
+                if (asset.format === 'obj' && /^\s*mtllib\s/m.test(source.toString()))
+                    throw Error('OBJ references an MTL sidecar; export a self-contained GLB or embedded FBX to preserve PBR');
+                const plan = join(dir, 'plan.json'), receipt = join(dir, 'receipt.json');
+                await writeFile(plan, JSON.stringify({ input, output, receipt }), { mode: 0o600 });
+                await exec(bin, ['--background', '--factory-startup', '--disable-autoexec', '--python-exit-code', '1', '--python', fileURLToPath(new URL('../runtime/game-import-normalize.py', import.meta.url)), '--', plan], { cwd: dir, timeout: 20 * 60 * 1000, maxBuffer: 4 * 1024 * 1024 });
+                await agent.checkpoint();
+                if ((await stat(output)).size > 256 * 1024 * 1024)
+                    throw Error('Normalized output exceeds 256 MiB');
+                bytes = await readFile(output);
+                const inspected = inspectAsset('output.' + format, bytes);
+                if (inspected.status !== 'ready')
+                    throw Error('Converter output is not a portable asset: ' + inspected.reason);
+                const version = String(JSON.parse(await readFile(receipt, 'utf8')).version).slice(0, 100);
+                asset.details = { ...asset.details, ...inspected.details, normalization: { format, sha256: hash(bytes), sourceSha256: asset.sha256, tool: 'blender', version } };
+                asset.evidence.push({ source: asset.path, reason: 'Blender conversion preserving available materials/rig/clips; visual and anatomy review required', confidence: 1 });
+            }
+            if (format === 'png')
+                asset.kind = 'texture';
+            asset.status = 'ready';
+            delete asset.reason;
+            delete job.errors[id];
+            job.completed++;
+        }
+        catch (e) {
+            job.errors[id] = e instanceof Error ? e.message : String(e);
+        }
+        await saveImportJob(job);
+    }
+    job.status = job.selected.some(id => job.errors[id]) ? 'failed' : 'awaiting_selection';
+    await saveImportJob(job);
+}

package/dist/game-import-reverse.js

@@ -0,0 +1,122 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { z } from 'zod/v4';
+import { readFile, writeFile } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { createHash } from 'node:crypto';
+import { confinedFile, jobDirectory, loadImportJob } from './game-import-agent.js';
+/** Detect containers locally before recommending native code investigation. No binaries are executed. */
+export function detectFormat(bytes) {
+    if (bytes.subarray(0, 4).equals(Buffer.from([0x7f, 69, 76, 70])))
+        return { format: 'ELF', native: true };
+    if (bytes.toString('ascii', 0, 2) === 'MZ')
+        return { format: 'PE', native: true };
+    if (bytes.length >= 4 && [0xfeedface, 0xfeedfacf, 0xcafebabe, 0xcefaedfe, 0xcffaedfe].includes(bytes.readUInt32BE()))
+        return { format: 'Mach-O', native: true };
+    for (const [magic, format] of [['glTF', 'GLB'], ['UnityFS', 'Unity bundle'], ['DDS ', 'DDS'], ['PK\u0003\u0004', 'ZIP']])
+        if (bytes.toString('latin1', 0, magic.length) === magic)
+            return { format, native: false };
+    return { format: 'unknown', native: false };
+}
+function endpoint() {
+    const url = new URL(process.env.GRIPFORGE_GHIDRA_MCP_URL ?? '');
+    if (url.protocol !== 'http:' || !['localhost', '127.0.0.1', '[::1]'].includes(url.hostname) || url.username || url.password)
+        throw Error('Configure a dedicated loopback GRIPFORGE_GHIDRA_MCP_URL (for example http://127.0.0.1:8081/mcp)');
+    return url;
+}
+async function bridge(run) {
+    const client = new Client({ name: 'gripforge-game-import', version: '1.0' });
+    try {
+        await client.connect(new StreamableHTTPClientTransport(endpoint()));
+        return await run(client);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+async function call(client, name, args) {
+    const tool = (await client.listTools()).tools.find(t => t.name === name);
+    if (!tool)
+        throw Error('Compatible Ghidra tool unavailable: ' + name);
+    for (const key of tool.inputSchema.required ?? [])
+        if (!(key in args))
+            throw Error(`Installed Ghidra requires ${key} for ${name}; incompatible adapter contract`);
+    const response = await client.callTool({ name, arguments: args }, undefined, { timeout: 120000 });
+    if (response.isError)
+        throw Error(JSON.stringify(response.content).slice(0, 4000));
+    return response;
+}
+export function registerReverseTools(register) {
+    const jobId = z.string().regex(/^gi_[a-f0-9]{24}$/), path = z.string().min(1).max(4096);
+    const wrap = (run) => async (a) => { try {
+        return { content: [{ type: 'text', text: JSON.stringify(await run(a), null, 2) }] };
+    }
+    catch (e) {
+        return { isError: true, content: [{ type: 'text', text: e instanceof Error ? e.message : String(e) }] };
+    } };
+    const common = { job_id: jobId };
+    register('gripforge_reverse_detect_format', { title: 'Inspect file magic before reverse engineering', description: 'Local signatures, source hash and known-format-first recommendation. Unknown remains unknown. Does not execute or alter the source.', inputSchema: { ...common, path }, annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false } }, wrap(async (a) => {
+        const job = await loadImportJob(a.job_id), bytes = await readFile(await confinedFile(job.root, a.path)), found = detectFormat(bytes);
+        return { ...found, sha256: createHash('sha256').update(bytes).digest('hex'), next: found.native ? 'gripforge_reverse_open' : 'Known extractor/converter first; unknown data needs a format-specific investigation, not automatic native decompilation' };
+    }));
+    register('gripforge_reverse_open', { title: 'Open an authorized native binary in Ghidra', description: 'Imports a copy into a dedicated installed Ghidra analysis project, without running the binary. Requires a finished local import job, native file signature and rights basis. Records hash and explicit program selector, so later reads never depend on the shared current program. No extraction or visual approval is implied.', inputSchema: { ...common, path, rights: z.object({ basis: z.enum(['owned', 'authorized', 'compatible-license']), note: z.string().min(3).max(1000) }).strict() }, annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false } }, wrap(async (a) => {
+        const job = await loadImportJob(a.job_id), file = await confinedFile(job.root, a.path), bytes = await readFile(file);
+        if (!detectFormat(bytes).native)
+            throw Error('Use a known extractor or inspect the data format first; this is not a recognized native binary');
+        const response = await bridge(c => call(c, 'import_file', { file_path: file, project_folder: '/' + job.id, auto_analyze: true }));
+        const content = response.content;
+        let program;
+        for (const block of content)
+            if (block.text) {
+                try {
+                    const json = JSON.parse(block.text);
+                    program = json.data?.name ?? json.name;
+                }
+                catch { }
+            }
+        if (!program)
+            throw Error('Ghidra did not report the imported program name; no ambiguous current-program session saved');
+        const session = { path: a.path, sha256: createHash('sha256').update(bytes).digest('hex'), program: '/' + job.id + '/' + basename(program), endpoint: endpoint().href };
+        await writeFile(join(jobDirectory(job.id), 'reverse-session.json'), JSON.stringify({ ...session, rights: a.rights }), { mode: 0o600 });
+        return { program: session.program, sha256: session.sha256, analysis: response, next: 'gripforge_reverse_scan', source_unchanged: true };
+    }));
+    // A deliberately small allowlist. Upstream rename/patch/execute tools are never passed through.
+    for (const [name, tool, description, query, group] of [
+        ['gripforge_reverse_scan', 'find_functions', 'List native functions with an explicit program selector', false, 'listing'],
+        ['gripforge_reverse_find_asset_system', 'search_strings', 'Search native strings for asset loading/format clues; results are evidence, not inferred assets', true, 'listing'],
+        ['gripforge_reverse_trace_function', 'get_functions', 'Read one native function to investigate an asset loader; never changes executable code', true, 'function'],
+    ]) {
+        register(name, { title: description, description: 'Configured local Ghidra MCP bridge only. Verifies source hash and installed tool schema. Bounded output and persisted evidence; no unsupported converter is invented. ' + description, inputSchema: { ...common, ...(query ? { query: z.string().min(1).max(256) } : {}), offset: z.number().int().min(0).optional(), limit: z.number().int().min(1).max(100).optional() }, annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false } }, wrap(async (a) => {
+            const job = await loadImportJob(a.job_id), session = JSON.parse(await readFile(join(jobDirectory(job.id), 'reverse-session.json'), 'utf8'));
+            if (session.endpoint !== endpoint().href)
+                throw Error('Ghidra endpoint changed; open the binary again');
+            const bytes = await readFile(await confinedFile(job.root, session.path));
+            if (createHash('sha256').update(bytes).digest('hex') !== session.sha256)
+                throw Error('Binary changed; open it again');
+            const response = await bridge(async (c) => {
+                if (!(await c.listTools()).tools.some(t => t.name === tool))
+                    await call(c, 'load_tool_group', { group });
+                const schema = (await c.listTools()).tools.find(t => t.name === tool)?.inputSchema;
+                if (!schema?.properties?.program)
+                    throw Error('Installed Ghidra tool lacks explicit program selection; update the bridge');
+                const args = { program: session.program };
+                if (schema.properties.offset)
+                    args.offset = a.offset ?? 0;
+                if (schema.properties.limit)
+                    args.limit = a.limit ?? 40;
+                if (tool === 'get_functions' && schema.properties.fields)
+                    args.fields = 'decompiled_code,callers,callees,signature';
+                if (query) {
+                    const key = tool === 'get_functions' ? ['function', 'address', 'function_address', 'name', 'function_name'].find(k => schema.properties?.[k]) : ['query', 'search', 'search_term', 'filter'].find(k => schema.properties?.[k]);
+                    if (!key)
+                        throw Error('Installed Ghidra query schema incompatible');
+                    args[key] = a.query;
+                }
+                return call(c, tool, args);
+            });
+            const evidence = { source_sha256: session.sha256, program: session.program, operation: tool, query: a.query, observed_at: new Date().toISOString(), result: JSON.stringify(response).slice(0, 64000) };
+            await writeFile(join(jobDirectory(job.id), 'reverse-' + tool + '.json'), JSON.stringify(evidence), { mode: 0o600 });
+            return evidence;
+        }));
+    }
+}

package/dist/game-import-tools.js

@@ -0,0 +1,138 @@
+import { spawn } from 'node:child_process';
+import { open, writeFile, unlink, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { z } from 'zod/v4';
+import { jobDirectory, loadImportJob, newImportJob, saveImportJob } from './game-import-agent.js';
+async function launch(job, key) {
+    const log = await open(join(jobDirectory(job.id), 'worker.log'), 'a', 0o600);
+    try {
+        const child = spawn(process.execPath, [fileURLToPath(new URL('./game-import-worker.js', import.meta.url)), job.id], { detached: true, stdio: ['ignore', log.fd, log.fd], env: { ...process.env, ...(key ? { GRIPFORGE_API_KEY: key } : {}) } });
+        await new Promise((resolve, reject) => { child.once('spawn', resolve); child.once('error', reject); });
+        child.unref();
+    }
+    finally {
+        await log.close();
+    }
+}
+async function assertIdle(id) {
+    try {
+        const pid = Number(await readFile(join(jobDirectory(id), 'worker.lock'), 'utf8'));
+        try {
+            process.kill(pid, 0);
+        }
+        catch (e) {
+            if (e.code === 'ESRCH')
+                return;
+            throw e;
+        }
+        throw Error('Worker still running; cancel and wait for it to finish');
+    }
+    catch (e) {
+        if (e.code !== 'ENOENT')
+            throw e;
+    }
+}
+export function registerGameImportTools(register, options) {
+    const result = (data) => ({ content: [{ type: 'text', text: JSON.stringify(data, null, 2) }], structuredContent: data });
+    const wrap = (run) => async (a) => { try {
+        return result(await run(a));
+    }
+    catch (e) {
+        return { isError: true, content: [{ type: 'text', text: e instanceof Error ? e.message : String(e) }] };
+    } };
+    const id = z.string().regex(/^gi_[a-f0-9]{24}$/);
+    const summary = (job) => ({ job_id: job.id, status: job.status, phase: job.phase, progress: { completed: job.completed, total: job.total }, engine: job.report?.engine, counts: job.report?.counts, errors: job.errors, imported: job.receipts, report_path: join(jobDirectory(job.id), 'report.json'), library_url: `${options.apiUrl}/library`, next: job.status === 'awaiting_selection' ? 'Read inventory, select asset ids, then gripforge_game_import_select' : 'gripforge_game_import_read' });
+    register('gripforge_game_import', {
+        title: 'Analyze an authorized local game or project',
+        description: 'LOCAL MCP ONLY. Analyze → discover → classify → normalize → private Library import. Starts a detached durable local job; returns immediately. Known portable formats first, Unity GUID relations carry evidence, unsupported formats stay blocked with an explicit toolchain. Does not launch the game, bypass encryption, guess sockets or claim behavior/visual validation. Read the inventory and select before uploading. Closing the MCP or Studio does not delete progress; read/resume by job_id. Analysis is free and local. Source files remain unchanged.',
+        inputSchema: { path: z.string().min(1).max(4096) }, annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    }, wrap(async (a) => { const job = await newImportJob(a.path); await launch(job); return summary(job); }));
+    register('gripforge_game_import_read', {
+        title: 'Read game import progress and inventory', description: 'Read persistent local state with paginated assets, role confidence, extraction blockers and verified relationship edges. The report_path can be opened in Library → Add asset → From Game. Unknown/bundled files are not counted as successfully imported assets.',
+        inputSchema: { job_id: id, kind: z.string().max(40).optional(), offset: z.number().int().min(0).optional(), limit: z.number().int().min(1).max(100).optional() }, annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    }, wrap(async (a) => { const job = await loadImportJob(a.job_id), all = (job.report?.assets ?? []).filter(x => !a.kind || x.kind === a.kind); return { ...summary(job), total: all.length, assets: all.slice(a.offset ?? 0, (a.offset ?? 0) + (a.limit ?? 40)), toolchain: job.report?.toolchain, normalization: job.report?.normalization, warnings: job.report?.warnings, relationships: job.report?.relationships }; }));
+    register('gripforge_game_import_extract', {
+        title: 'Run the selected known Unity extractor', description: 'LOCAL ONLY. Dedicated AssetRipper loopback HTTP adapter for assets; installed Cpp2IL/ILSpy adapters for local code/metadata only. The agent chooses AssetRipper first unless tool is explicit. Uses durable output/checkpoints and rescans exported assets; never executes game code. Requires installed tools configured in the MCP environment, compatible OpenAPI routes and an authorization basis. No Ghidra fallback is silently invoked. Tools/version and errors remain visible. Cancellation is checked between external operations, each bounded to 20 minutes.',
+        inputSchema: { job_id: id, tool: z.enum(['assetripper', 'cpp2il', 'ilspy']).optional(), rights: z.object({ basis: z.enum(['owned', 'authorized', 'compatible-license']), note: z.string().min(3).max(1000) }).strict() }, annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    }, wrap(async (a) => { await assertIdle(a.job_id); const job = await loadImportJob(a.job_id); if (!job.report || job.report.engine.name !== 'unity')
+        throw Error('Finish Unity analysis first'); if (Object.keys(job.receipts).length)
+        throw Error('Start a new import before extracting a different inventory'); const tool = a.tool ?? 'assetripper'; if (tool === 'cpp2il' && job.report.engine.runtime !== 'IL2CPP')
+        throw Error('Cpp2IL requires IL2CPP evidence'); if (tool === 'ilspy' && job.report.engine.runtime !== 'Mono')
+        throw Error('ILSpy requires Mono evidence'); if (job.extraction && job.extraction.tool !== tool)
+        throw Error('Start a separate analysis job for another extractor'); job.extraction ??= { tool, sourceRoot: job.root, output: join(jobDirectory(job.id), tool + '-output'), ...(tool === 'assetripper' ? { endpoint: process.env.GRIPFORGE_ASSETRIPPER_URL } : {}) }; job.rights = a.rights; job.phase = 'extract'; job.status = 'queued'; await unlink(join(jobDirectory(job.id), 'cancel')).catch(() => { }); await saveImportJob(job); await launch(job); return summary(job); }));
+    register('gripforge_game_import_select', {
+        title: 'Import selected game assets into a private workspace', description: 'Requires an analyzed local job, explicit source ids, workspace id and rights basis. Self-contained GLB and standard images/audio import directly; glTF packs its local resources into GLB. Engine-native formats require extraction first. Durable per-file checkpoints and server idempotency preserve completed imports across retries. Saved as work revisions, never published/promoted. Storage quotas apply; no paid AI call. Relations remain a knowledge graph and Game Kit suggestions require actual gameplay integration.',
+        inputSchema: { job_id: id, asset_ids: z.array(z.string().regex(/^src_[a-f0-9]{24}$/)).min(1).max(500), workspace_id: z.string().regex(/^ws_[A-Za-z0-9_-]+$/), rights: z.object({ basis: z.enum(['owned', 'authorized', 'compatible-license']), note: z.string().min(3).max(1000) }).strict() }, annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, wrap(async (a) => {
+        const key = options.getApiKey();
+        if (!key)
+            throw Error('GripForge API key required');
+        await assertIdle(a.job_id);
+        const job = await loadImportJob(a.job_id);
+        if (!job.report || job.completed < job.total && job.phase === 'analyze')
+            throw Error('Finish analysis before selecting assets');
+        if (job.workspace && job.workspace !== a.workspace_id)
+            throw Error('Start a new import to target another workspace');
+        const selected = [...new Set(a.asset_ids)];
+        for (const id of selected) {
+            const asset = job.report.assets.find(x => x.id === id);
+            if (!asset || asset.status === 'blocked')
+                throw Error(`Asset unavailable for import: ${id}`);
+        }
+        job.phase = 'import';
+        job.selected = selected;
+        job.rights = a.rights;
+        job.workspace = a.workspace_id;
+        job.origin = options.apiUrl.replace(/\/$/, '');
+        job.status = 'queued';
+        delete job.errors.worker;
+        await unlink(join(jobDirectory(job.id), 'cancel')).catch(() => { });
+        await saveImportJob(job);
+        await launch(job, key);
+        return summary(job);
+    }));
+    register('gripforge_game_import_normalize', {
+        title: 'Convert selected extracted assets with Blender',
+        description: 'LOCAL durable worker. Installed GRIPFORGE_BLENDER_BIN converts FBX/OBJ to GLB and DDS/TGA to PNG. Keeps available PBR, rig and animations; does not fabricate missing materials or validate appearance. Sources remain unchanged; checksummed outputs persist for resume. OBJ with external MTL and missing FBX textures fail explicitly; export embedded materials first. Run before registration/import. Source engine scenes still require their known exporter.',
+        inputSchema: { job_id: id, asset_ids: z.array(z.string().regex(/^src_[a-f0-9]{24}$/)).min(1).max(500), rights: z.object({ basis: z.enum(['owned', 'authorized', 'compatible-license']), note: z.string().min(3).max(1000) }).strict() },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    }, wrap(async (a) => {
+        await assertIdle(a.job_id);
+        const job = await loadImportJob(a.job_id);
+        if (!job.report || Object.keys(job.receipts).length || job.workspace)
+            throw Error('Normalize an analyzed inventory before registering/importing it');
+        for (const assetId of a.asset_ids)
+            if (!job.report.assets.some(x => x.id === assetId && ['fbx', 'obj', 'dds', 'tga'].includes(x.format)))
+                throw Error('Select FBX/OBJ/DDS/TGA inventory sources');
+        job.phase = 'normalize';
+        job.selected = [...new Set(a.asset_ids)];
+        job.rights = a.rights;
+        job.status = 'queued';
+        await unlink(join(jobDirectory(job.id), 'cancel')).catch(() => { });
+        await saveImportJob(job);
+        await launch(job);
+        return summary(job);
+    }));
+    register('gripforge_game_import_control', {
+        title: 'Cancel or resume a local game import', description: 'Cancel between files; an already committed upload remains imported. Resume preserves successful receipts and checkpoints. After a worker crash, resume with the same job_id. Credentials are supplied by the current MCP session, never saved in the job report.',
+        inputSchema: { job_id: id, action: z.enum(['cancel', 'resume']) }, annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    }, wrap(async (a) => {
+        const job = await loadImportJob(a.job_id);
+        if (a.action === 'cancel') {
+            await writeFile(join(jobDirectory(job.id), 'cancel'), 'cancel', { mode: 0o600 });
+            await assertIdle(job.id).then(async () => { job.status = 'cancelled'; await saveImportJob(job); }).catch(() => { });
+        }
+        else {
+            await assertIdle(job.id);
+            if (job.phase === 'import' && !options.getApiKey())
+                throw Error('API key required to resume import');
+            await unlink(join(jobDirectory(job.id), 'cancel')).catch(() => { });
+            job.status = 'queued';
+            delete job.errors.worker;
+            await saveImportJob(job);
+            await launch(job, options.getApiKey() ?? undefined);
+        }
+        return summary(job);
+    }));
+}

package/dist/game-import-types.js

@@ -0,0 +1 @@
+export {};

package/dist/game-import-worker.js

@@ -0,0 +1,34 @@
+import { GameImportAgent, claimImportJob, loadImportJob, saveImportJob } from './game-import-agent.js';
+import { normalizeGame } from './game-import-normalize.js';
+import { extractGame } from './game-import-extract.js';
+const id = process.argv[2];
+const release = await claimImportJob(id);
+const job = await loadImportJob(id);
+try {
+    job.status = 'running';
+    job.workerPid = process.pid;
+    await saveImportJob(job);
+    const agent = new GameImportAgent(job);
+    if (job.phase === 'normalize')
+        await normalizeGame(job);
+    else if (job.phase === 'extract')
+        await extractGame(job);
+    else if (job.phase === 'analyze')
+        await agent.analyze();
+    else {
+        const key = process.env.GRIPFORGE_API_KEY;
+        if (!key)
+            throw Error('API key required to resume import');
+        await agent.import_to_gripforge(key);
+    }
+}
+catch (e) {
+    job.status = await new GameImportAgent(job).cancelled() ? 'cancelled' : 'failed';
+    job.errors.worker = e instanceof Error ? e.message : String(e);
+    await saveImportJob(job);
+}
+finally {
+    delete job.workerPid;
+    await saveImportJob(job);
+    await release();
+}