@jshookmcp/jshook 0.2.1 → 0.2.3

package/dist/src/server/domains/workflow/manifest.js

@@ -25,16 +25,42 @@ const manifest = {
     depKey: DEP_KEY,
     profiles: ['workflow', 'full'],
     ensure,
+    workflowRule: {
+        patterns: [/(workflow|extension|run)/i, /(工作流|扩展|运行)/i],
+        priority: 95,
+        tools: ['run_extension_workflow', 'list_extension_workflows'],
+        hint: 'Extension workflow: list available workflows -> run the best matching workflow',
+    },
     registrations: [
-        { tool: t('web_api_capture_session'), domain: DOMAIN, bind: b((h, a) => h.handleWebApiCaptureSession(a)) },
-        { tool: t('register_account_flow'), domain: DOMAIN, bind: b((h, a) => h.handleRegisterAccountFlow(a)) },
-        { tool: t('page_script_register'), domain: DOMAIN, bind: b((h, a) => h.handlePageScriptRegister(a)) },
+        {
+            tool: t('web_api_capture_session'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleWebApiCaptureSession(a)),
+        },
+        {
+            tool: t('register_account_flow'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleRegisterAccountFlow(a)),
+        },
+        {
+            tool: t('page_script_register'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handlePageScriptRegister(a)),
+        },
         { tool: t('page_script_run'), domain: DOMAIN, bind: b((h, a) => h.handlePageScriptRun(a)) },
         { tool: t('api_probe_batch'), domain: DOMAIN, bind: b((h, a) => h.handleApiProbeBatch(a)) },
         { tool: t('js_bundle_search'), domain: DOMAIN, bind: b((h, a) => h.handleJsBundleSearch(a)) },
         { tool: t('batch_register'), domain: DOMAIN, bind: b((h, a) => h.handleBatchRegister(a)) },
-        { tool: t('list_extension_workflows'), domain: DOMAIN, bind: b((h) => h.handleListExtensionWorkflows()) },
-        { tool: t('run_extension_workflow'), domain: DOMAIN, bind: b((h, a) => h.handleRunExtensionWorkflow(a)) },
+        {
+            tool: t('list_extension_workflows'),
+            domain: DOMAIN,
+            bind: b((h) => h.handleListExtensionWorkflows()),
+        },
+        {
+            tool: t('run_extension_workflow'),
+            domain: DOMAIN,
+            bind: b((h, a) => h.handleRunExtensionWorkflow(a)),
+        },
     ],
 };
 export default manifest;

package/dist/src/server/extensions/ExtensionManager.integrity.js

@@ -37,8 +37,8 @@ export function parseDigestAllowlist(raw) {
 export async function verifyPluginIntegrity(plugin, currentVersion) {
     const errors = [];
     const warnings = [];
-    if (!isCompatibleVersion(plugin.getCompatibleCore, currentVersion)) {
-        errors.push(`Plugin ${plugin.id} incompatible with core ${currentVersion}; requires ${plugin.getCompatibleCore}`);
+    if (!isCompatibleVersion(plugin.compatibleCoreRange, currentVersion)) {
+        errors.push(`Plugin ${plugin.id} incompatible with core ${currentVersion}; requires ${plugin.compatibleCoreRange}`);
     }
     return {
         ok: errors.length === 0,

package/dist/src/server/extensions/ExtensionManager.js

@@ -1,20 +1,46 @@
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
 import { allTools } from '../ToolCatalog.js';
 import { logger } from '../../utils/logger.js';
-import { DEFAULT_PLUGIN_ROOTS, DEFAULT_WORKFLOW_ROOTS, parseRoots, resolveRoots } from './ExtensionManager.roots.js';
-import { sha256Hex, normalizeHex, isPluginStrictLoad, parseDigestAllowlist, verifyPluginIntegrity } from './ExtensionManager.integrity.js';
+import { DEFAULT_PLUGIN_ROOTS, DEFAULT_WORKFLOW_ROOTS, parseRoots, resolveRoots, } from './ExtensionManager.roots.js';
+import { sha256Hex, normalizeHex, isPluginStrictLoad, parseDigestAllowlist, verifyPluginIntegrity, } from './ExtensionManager.integrity.js';
 import { isExtensionBuilder, isWorkflowContract } from './ExtensionManager.guards.js';
 import { discoverPluginFiles, discoverWorkflowFiles } from './ExtensionManager.discovery.js';
-import { extractConfigValue, createFreshImportUrl, clearLoadedExtensionTools, buildListResult } from './ExtensionManager.lifecycle.js';
+import { extractConfigValue, createFreshImportUrl, clearLoadedExtensionTools, buildListResult, } from './ExtensionManager.lifecycle.js';
 export function listExtensions(ctx) {
     const pluginRoots = resolveRoots(parseRoots(process.env.MCP_PLUGIN_ROOTS, DEFAULT_PLUGIN_ROOTS));
     const workflowRoots = resolveRoots(parseRoots(process.env.MCP_WORKFLOW_ROOTS, DEFAULT_WORKFLOW_ROOTS));
     return buildListResult(ctx, pluginRoots, workflowRoots);
 }
+function parseSimpleYaml(filePath) {
+    try {
+        const text = readFileSync(filePath, 'utf-8');
+        const result = {};
+        for (const line of text.split(/\r?\n/)) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#'))
+                continue;
+            const colonIdx = trimmed.indexOf(':');
+            if (colonIdx < 1)
+                continue;
+            const key = trimmed.slice(0, colonIdx).trim();
+            const value = trimmed.slice(colonIdx + 1).trim();
+            if (key)
+                result[key] = value;
+        }
+        return result;
+    }
+    catch {
+        return {};
+    }
+}
 let reloadMutex = Promise.resolve();
 export async function reloadExtensions(ctx) {
     const prev = reloadMutex;
     let resolve;
-    reloadMutex = new Promise((r) => { resolve = r; });
+    reloadMutex = new Promise((r) => {
+        resolve = r;
+    });
     await prev;
     try {
         return await reloadExtensionsInner(ctx);
@@ -113,6 +139,9 @@ async function reloadExtensionsInner(ctx) {
             errors.push(`Failed to import plugin file ${pluginFile}: ${String(error)}`);
             continue;
         }
+        const metaYamlPath = join(dirname(pluginFile), 'meta.yaml');
+        const meta = parseSimpleYaml(metaYamlPath);
+        plugin.mergeMetadata(meta);
         if (ctx.extensionPluginsById.has(plugin.id)) {
             warnings.push(`Skip plugin "${plugin.id}" from ${pluginFile}: duplicate plugin id`);
             continue;
@@ -132,7 +161,7 @@ async function reloadExtensionsInner(ctx) {
         const runtimeData = new Map();
         const metrics = new Set();
         let pluginState = 'loaded';
-        const allowInvokeAll = plugin.allowTools.includes('*');
+        const allowInvokeAll = plugin.allowedTools.includes('*');
         const lifecycleContext = {
             pluginId: plugin.id,
             pluginRoot: pluginFile,
@@ -147,7 +176,7 @@ async function reloadExtensionsInner(ctx) {
                 if (typeof name !== 'string' || name.length === 0) {
                     throw new Error('invokeTool requires a non-empty tool name');
                 }
-                if (!allowInvokeAll && !plugin.allowTools.includes(name)) {
+                if (!allowInvokeAll && !plugin.allowedTools.includes(name)) {
                     throw new Error(`Plugin "${plugin.id}" is not allowed to invoke "${name}". ` +
                         'Declare it in allowTool calls.');
                 }
@@ -217,8 +246,10 @@ async function reloadExtensionsInner(ctx) {
         const loadedTools = plugin.tools.map((t) => t.name);
         const record = {
             id: plugin.id,
-            name: plugin.getName,
+            name: plugin.pluginName,
             source: pluginFile,
+            author: plugin.pluginAuthor || undefined,
+            sourceRepo: plugin.pluginSourceRepo || undefined,
             domains: [],
             workflows: [],
             tools: loadedTools,

package/dist/src/server/extensions/ExtensionManager.roots.js

@@ -1,11 +1,21 @@
 import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { existsSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
-const IS_TS_RUNTIME = import.meta.url.endsWith('.ts');
+function findProjectRoot(startDir) {
+    let dir = startDir;
+    while (true) {
+        if (existsSync(join(dir, 'package.json')))
+            return dir;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return resolve(startDir, '..', '..', '..', '..');
+}
 const EXTENSION_MANAGER_DIR = dirname(fileURLToPath(import.meta.url));
-const EXTENSION_INSTALL_ROOT = resolve(EXTENSION_MANAGER_DIR, '..', '..', '..');
-export const DEFAULT_PLUGIN_ROOTS = IS_TS_RUNTIME
-    ? [join(EXTENSION_INSTALL_ROOT, 'plugins'), join(EXTENSION_INSTALL_ROOT, 'dist', 'plugins')]
-    : [join(EXTENSION_INSTALL_ROOT, 'dist', 'plugins'), join(EXTENSION_INSTALL_ROOT, 'plugins')];
+const EXTENSION_INSTALL_ROOT = findProjectRoot(EXTENSION_MANAGER_DIR);
+export const DEFAULT_PLUGIN_ROOTS = [join(EXTENSION_INSTALL_ROOT, 'plugins')];
 export const DEFAULT_WORKFLOW_ROOTS = [join(EXTENSION_INSTALL_ROOT, 'workflows')];
 export function parseRoots(raw, fallback) {
     const value = raw?.trim();

package/dist/src/server/extensions/plugin-config.d.ts

@@ -1,3 +1,4 @@
 import type { PluginLifecycleContext } from '../plugins/PluginContract.js';
 export declare function getPluginBooleanConfig(ctx: PluginLifecycleContext, pluginId: string, key: string, fallback: boolean): boolean;
-export declare function getPluginBoostTier(pluginId: string): string;
+export type BoostTier = 'search' | 'workflow' | 'full';
+export declare function getPluginBoostTier(pluginId: string): BoostTier;

package/dist/src/server/extensions/plugin-config.js

@@ -1,13 +1,14 @@
 function normalizeSegment(value) {
-    return value.trim().replace(/[^a-zA-Z0-9]+/g, '_').replace(/^_+|_+$/g, '').toUpperCase();
+    return value
+        .trim()
+        .replace(/[^a-zA-Z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '')
+        .toUpperCase();
 }
 function envCandidates(pluginId, key) {
     const pluginSegment = normalizeSegment(pluginId);
     const keySegment = normalizeSegment(key);
-    return [
-        `PLUGIN_${pluginSegment}_${keySegment}`,
-        `PLUGINS_${pluginSegment}_${keySegment}`,
-    ];
+    return [`PLUGIN_${pluginSegment}_${keySegment}`, `PLUGINS_${pluginSegment}_${keySegment}`];
 }
 function parseBoolean(raw) {
     if (raw == null)
@@ -27,7 +28,11 @@ export function getPluginBooleanConfig(ctx, pluginId, key, fallback) {
     }
     return ctx.getConfig(`plugins.${pluginId}.${key}`, fallback);
 }
-const VALID_BOOST_TIERS = new Set(['search', 'workflow', 'full']);
+const VALID_BOOST_TIERS = new Set([
+    'search',
+    'workflow',
+    'full',
+]);
 export function getPluginBoostTier(pluginId) {
     for (const candidate of envCandidates(pluginId, 'BOOST_DOMAIN')) {
         const raw = process.env[candidate]?.trim().toLowerCase();

package/dist/src/server/extensions/types.d.ts

@@ -15,6 +15,8 @@ export interface ExtensionPluginRecord {
     id: string;
     name: string;
     source: string;
+    author?: string;
+    sourceRepo?: string;
     domains: string[];
     workflows: string[];
     tools: string[];

package/dist/src/server/http/HttpMiddleware.js

@@ -1,9 +1,5 @@
 import { timingSafeEqual as cryptoTimingSafeEqual } from 'node:crypto';
-const LOCALHOST_ORIGINS = new Set([
-    'http://127.0.0.1',
-    'http://localhost',
-    'http://[::1]',
-]);
+const LOCALHOST_ORIGINS = new Set(['http://127.0.0.1', 'http://localhost', 'http://[::1]']);
 export function checkOrigin(req, res) {
     const origin = req.headers.origin;
     if (!origin)
@@ -40,7 +36,7 @@ export function checkAuth(req, res) {
         return true;
     }
     const header = req.headers.authorization;
-    if (!header || !header.startsWith('Bearer ')) {
+    if (!header?.startsWith('Bearer ')) {
         res.writeHead(401, { 'Content-Type': 'text/plain' });
         res.end('Unauthorized – missing or malformed Authorization header');
         return false;
@@ -120,7 +116,7 @@ function rateLimitCleanup(now) {
     lastCleanup = now;
     const cutoff = now - RATE_LIMIT_WINDOW_MS;
     for (const [ip, entry] of rateLimitStore) {
-        entry.timestamps = entry.timestamps.filter(t => t > cutoff);
+        entry.timestamps = entry.timestamps.filter((t) => t > cutoff);
         if (entry.timestamps.length === 0) {
             rateLimitStore.delete(ip);
         }
@@ -143,9 +139,7 @@ function getClientIP(req) {
     if (trustProxy) {
         const forwarded = req.headers['x-forwarded-for'];
         if (forwarded) {
-            const first = Array.isArray(forwarded)
-                ? forwarded[0]
-                : forwarded.split(',')[0];
+            const first = Array.isArray(forwarded) ? forwarded[0] : forwarded.split(',')[0];
             return first.trim();
         }
     }
@@ -166,7 +160,7 @@ export function checkRateLimit(req, res, authenticated = false) {
         rateLimitStore.set(ip, entry);
     }
     const cutoff = now - RATE_LIMIT_WINDOW_MS;
-    entry.timestamps = entry.timestamps.filter(t => t > cutoff);
+    entry.timestamps = entry.timestamps.filter((t) => t > cutoff);
     if (entry.timestamps.length >= maxRequests) {
         const retryAfterSec = Math.ceil(RATE_LIMIT_WINDOW_MS / 1000);
         res.writeHead(429, {

package/dist/src/server/macros/MacroConfigLoader.d.ts

@@ -0,0 +1,22 @@
+import type { MacroDefinition } from './types.js';
+interface MacroJsonSchema {
+    id: string;
+    displayName: string;
+    description?: string;
+    tags?: string[];
+    timeoutMs?: number;
+    steps: Array<{
+        id: string;
+        toolName: string;
+        input?: Record<string, unknown>;
+        inputFrom?: Record<string, string>;
+        timeoutMs?: number;
+        optional?: boolean;
+    }>;
+}
+export declare class MacroConfigLoader {
+    static loadFromDirectory(dir: string): Promise<MacroDefinition[]>;
+    static validate(raw: unknown): raw is MacroJsonSchema;
+    private static toDefinition;
+}
+export {};

package/dist/src/server/macros/MacroConfigLoader.js

@@ -0,0 +1,71 @@
+import { readdir, readFile } from 'node:fs/promises';
+import { resolve, extname } from 'node:path';
+import { logger } from '../../utils/logger.js';
+export class MacroConfigLoader {
+    static async loadFromDirectory(dir) {
+        let files;
+        try {
+            files = await readdir(dir);
+        }
+        catch {
+            return [];
+        }
+        const jsonFiles = files.filter((f) => extname(f) === '.json');
+        const macros = [];
+        for (const file of jsonFiles) {
+            const path = resolve(dir, file);
+            try {
+                const raw = JSON.parse(await readFile(path, 'utf-8'));
+                if (MacroConfigLoader.validate(raw)) {
+                    macros.push(MacroConfigLoader.toDefinition(raw));
+                    logger.info(`[macros] Loaded user macro "${raw.id}" from ${file}`);
+                }
+                else {
+                    logger.warn(`[macros] Skipping ${file}: invalid macro schema`);
+                }
+            }
+            catch (err) {
+                logger.warn(`[macros] Skipping ${file}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        return macros;
+    }
+    static validate(raw) {
+        if (!raw || typeof raw !== 'object')
+            return false;
+        const obj = raw;
+        if (typeof obj.id !== 'string' || !obj.id)
+            return false;
+        if (typeof obj.displayName !== 'string' || !obj.displayName)
+            return false;
+        if (!Array.isArray(obj.steps) || obj.steps.length === 0)
+            return false;
+        for (const step of obj.steps) {
+            if (!step || typeof step !== 'object')
+                return false;
+            const s = step;
+            if (typeof s.id !== 'string' || !s.id)
+                return false;
+            if (typeof s.toolName !== 'string' || !s.toolName)
+                return false;
+        }
+        return true;
+    }
+    static toDefinition(json) {
+        return {
+            id: json.id,
+            displayName: json.displayName,
+            description: json.description ?? '',
+            tags: json.tags ?? [],
+            timeoutMs: json.timeoutMs,
+            steps: json.steps.map((s) => ({
+                id: s.id,
+                toolName: s.toolName,
+                input: s.input,
+                inputFrom: s.inputFrom,
+                timeoutMs: s.timeoutMs,
+                optional: s.optional,
+            })),
+        };
+    }
+}

package/dist/src/server/macros/MacroRunner.d.ts

@@ -0,0 +1,12 @@
+import { type WorkflowContract } from '../workflows/WorkflowContract.js';
+import type { MCPServerContext } from '../MCPServer.context.js';
+import type { MacroDefinition, MacroResult } from '../macros/types.js';
+export declare class MacroRunner {
+    private readonly ctx;
+    constructor(ctx: MCPServerContext);
+    buildWorkflowFromDefinition(def: MacroDefinition): WorkflowContract;
+    execute(def: MacroDefinition, inputOverrides?: Record<string, Record<string, unknown>>): Promise<MacroResult>;
+    formatProgressReport(result: MacroResult): string;
+    private _buildProgress;
+    private _buildPartialProgress;
+}

package/dist/src/server/macros/MacroRunner.js

@@ -0,0 +1,118 @@
+import { createWorkflow, SequenceNodeBuilder, ToolNodeBuilder, } from '../workflows/WorkflowContract.js';
+import { executeExtensionWorkflow } from '../workflows/WorkflowEngine.js';
+export class MacroRunner {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    buildWorkflowFromDefinition(def) {
+        return createWorkflow(def.id, def.displayName)
+            .description(def.description)
+            .tags(def.tags)
+            .timeoutMs(def.timeoutMs ?? 120_000)
+            .buildGraph(() => {
+            const seq = new SequenceNodeBuilder(`${def.id}-root`);
+            for (const step of def.steps) {
+                seq.step(new ToolNodeBuilder(step.id, step.toolName)
+                    .input(step.input ?? {})
+                    .timeout(step.timeoutMs ?? 0));
+            }
+            return seq;
+        })
+            .onStart((ctx) => {
+            ctx.emitSpan('macro.start', {
+                macroId: def.id,
+                totalSteps: def.steps.length,
+            });
+        })
+            .onError((_ctx, err) => {
+            _ctx.emitSpan('macro.error', {
+                macroId: def.id,
+                error: err.message,
+            });
+        })
+            .build();
+    }
+    async execute(def, inputOverrides) {
+        const workflow = this.buildWorkflowFromDefinition(def);
+        const startMs = Date.now();
+        try {
+            const result = await executeExtensionWorkflow(this.ctx, workflow, {
+                nodeInputOverrides: inputOverrides,
+            });
+            const progress = this._buildProgress(def, result.spans, result.stepResults);
+            return {
+                macroId: def.id,
+                displayName: def.displayName,
+                ok: true,
+                durationMs: result.durationMs,
+                stepsCompleted: def.steps.length,
+                totalSteps: def.steps.length,
+                stepResults: result.stepResults,
+                progress,
+            };
+        }
+        catch (err) {
+            const durationMs = Date.now() - startMs;
+            const error = err instanceof Error ? err.message : String(err);
+            const progress = this._buildPartialProgress(def, error);
+            return {
+                macroId: def.id,
+                displayName: def.displayName,
+                ok: false,
+                durationMs,
+                stepsCompleted: progress.filter((p) => p.status === 'complete').length,
+                totalSteps: def.steps.length,
+                stepResults: {},
+                progress,
+                error,
+            };
+        }
+    }
+    formatProgressReport(result) {
+        const lines = [];
+        lines.push(`**Macro:** ${result.displayName} (\`${result.macroId}\`)`);
+        lines.push('');
+        for (const p of result.progress) {
+            const durStr = p.durationMs !== undefined ? ` (${p.durationMs}ms)` : '';
+            const errStr = p.error ? `: ${p.error}` : '';
+            const icon = p.status === 'complete' ? '✓' : p.status === 'failed' ? '✗' : '○';
+            lines.push(`[stage ${p.step}/${p.totalSteps}] ${icon} ${p.stepName} — ${p.status}${durStr}${errStr}`);
+        }
+        lines.push('');
+        if (result.ok) {
+            lines.push(`✓ Macro complete (${result.stepsCompleted}/${result.totalSteps} steps, ${result.durationMs}ms)`);
+        }
+        else {
+            lines.push(`✗ Macro failed at step ${result.stepsCompleted + 1}/${result.totalSteps}: ${result.error ?? 'unknown error'}`);
+        }
+        return lines.join('\n');
+    }
+    _buildProgress(def, spans, stepResults) {
+        return def.steps.map((step, i) => {
+            const startSpan = spans.find((s) => s.name === 'workflow.node.start' && s.attrs?.nodeId === step.id);
+            const finishSpan = spans.find((s) => s.name === 'workflow.node.finish' && s.attrs?.nodeId === step.id);
+            let durationMs;
+            if (startSpan && finishSpan) {
+                durationMs = new Date(finishSpan.at).getTime() - new Date(startSpan.at).getTime();
+            }
+            const hasResult = step.id in stepResults;
+            return {
+                step: i + 1,
+                totalSteps: def.steps.length,
+                stepName: step.id,
+                status: hasResult ? 'complete' : 'skipped',
+                durationMs,
+            };
+        });
+    }
+    _buildPartialProgress(def, error) {
+        return def.steps.map((step, i) => ({
+            step: i + 1,
+            totalSteps: def.steps.length,
+            stepName: step.id,
+            status: 'failed',
+            error: i === 0 ? error : undefined,
+        }));
+    }
+}

package/dist/src/server/macros/builtins/deobfuscate-ast-flow.d.ts

@@ -0,0 +1,2 @@
+import type { MacroDefinition } from '../../macros/types.js';
+export declare const deobfuscateAstFlow: MacroDefinition;

package/dist/src/server/macros/builtins/deobfuscate-ast-flow.js

@@ -0,0 +1,25 @@
+export const deobfuscateAstFlow = {
+    id: 'deobfuscate_ast_flow',
+    displayName: 'Deobfuscate AST Flow',
+    description: 'Chain: deobfuscate → advanced deobfuscation → extract function tree',
+    tags: ['analysis', 'deobfuscation', 'ast'],
+    timeoutMs: 60_000,
+    steps: [
+        {
+            id: 'deobfuscate',
+            toolName: 'deobfuscate',
+            input: {},
+        },
+        {
+            id: 'advanced_deobfuscate',
+            toolName: 'advanced_deobfuscate',
+            inputFrom: { code: 'deobfuscate.code' },
+            optional: true,
+        },
+        {
+            id: 'extract_functions',
+            toolName: 'extract_function_tree',
+            inputFrom: { code: 'deobfuscate.code' },
+        },
+    ],
+};

package/dist/src/server/macros/builtins/index.d.ts

@@ -0,0 +1,5 @@
+import { deobfuscateAstFlow } from './deobfuscate-ast-flow.js';
+import { unpackerFlow } from './unpacker-flow.js';
+import type { MacroDefinition } from '../types.js';
+export declare const BUILTIN_MACROS: MacroDefinition[];
+export { deobfuscateAstFlow, unpackerFlow };

package/dist/src/server/macros/builtins/index.js

@@ -0,0 +1,7 @@
+import { deobfuscateAstFlow } from './deobfuscate-ast-flow.js';
+import { unpackerFlow } from './unpacker-flow.js';
+export const BUILTIN_MACROS = [
+    deobfuscateAstFlow,
+    unpackerFlow,
+];
+export { deobfuscateAstFlow, unpackerFlow };

package/dist/src/server/macros/builtins/unpacker-flow.d.ts

@@ -0,0 +1,2 @@
+import type { MacroDefinition } from '../../macros/types.js';
+export declare const unpackerFlow: MacroDefinition;

package/dist/src/server/macros/builtins/unpacker-flow.js

@@ -0,0 +1,25 @@
+export const unpackerFlow = {
+    id: 'unpacker_flow',
+    displayName: 'Unpacker Flow',
+    description: 'Detect packer type → extract inner code → deobfuscate → beautify output',
+    tags: ['analysis', 'unpacking', 'deobfuscation'],
+    timeoutMs: 90_000,
+    steps: [
+        {
+            id: 'detect_and_unpack',
+            toolName: 'deobfuscate',
+            input: { unpack: true },
+        },
+        {
+            id: 'deep_deobfuscate',
+            toolName: 'advanced_deobfuscate',
+            inputFrom: { code: 'detect_and_unpack.code' },
+            optional: true,
+        },
+        {
+            id: 'beautify',
+            toolName: 'ast_transform_beautify',
+            inputFrom: { code: 'detect_and_unpack.code' },
+        },
+    ],
+};

package/dist/src/server/macros/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types.js';
+export { MacroRunner } from './MacroRunner.js';
+export { MacroConfigLoader } from './MacroConfigLoader.js';

package/dist/src/server/macros/index.js

@@ -0,0 +1,3 @@
+export * from './types.js';
+export { MacroRunner } from './MacroRunner.js';
+export { MacroConfigLoader } from './MacroConfigLoader.js';

package/dist/src/server/macros/types.d.ts

@@ -0,0 +1,36 @@
+export interface MacroStepProgress {
+    step: number;
+    totalSteps: number;
+    stepName: string;
+    status: 'running' | 'complete' | 'failed' | 'skipped';
+    durationMs?: number;
+    error?: string;
+}
+export interface MacroResult {
+    macroId: string;
+    displayName: string;
+    ok: boolean;
+    durationMs: number;
+    stepsCompleted: number;
+    totalSteps: number;
+    stepResults: Record<string, unknown>;
+    progress: MacroStepProgress[];
+    error?: string;
+    partialOutput?: unknown;
+}
+export interface MacroDefinition {
+    id: string;
+    displayName: string;
+    description: string;
+    tags: string[];
+    timeoutMs?: number;
+    steps: MacroStepDefinition[];
+}
+export interface MacroStepDefinition {
+    id: string;
+    toolName: string;
+    input?: Record<string, unknown>;
+    inputFrom?: Record<string, string>;
+    timeoutMs?: number;
+    optional?: boolean;
+}

package/dist/src/server/observability/InstrumentationContract.js

@@ -25,8 +25,10 @@ export class NoopInstrumentation {
         return {
             name,
             startTime,
-            end() { },
-            addEvent() { },
+            end() {
+            },
+            addEvent() {
+            },
         };
     }
     emitMetric(_name, _value, _type, _attrs) {

package/dist/src/server/plugin-api.d.ts

@@ -1,5 +1,5 @@
-export type { DomainManifest, ToolHandlerDeps } from './registry/contracts.js';
 export type { ExtensionBuilder, PluginLifecycleContext } from './plugins/PluginContract.js';
 export type { ToolArgs } from './types.js';
 export { getPluginBooleanConfig, getPluginBoostTier } from './extensions/plugin-config.js';
 export { loadPluginEnv } from './extensions/plugin-env.js';
+export { createExtension, jsonResponse, errorResponse } from './plugins/PluginContract.js';

package/dist/src/server/plugin-api.js

@@ -1,2 +1,3 @@
 export { getPluginBooleanConfig, getPluginBoostTier } from './extensions/plugin-config.js';
 export { loadPluginEnv } from './extensions/plugin-env.js';
+export { createExtension, jsonResponse, errorResponse } from './plugins/PluginContract.js';

package/dist/src/server/plugins/PluginContract.d.ts

@@ -1 +1 @@
-export { type ToolProfileId, type ToolArgs, type ToolResponse, type PluginState, type PluginLifecycleContext, type ExtensionToolHandler, type ExtensionToolDefinition, ExtensionBuilder, createExtension, } from '../../../packages/extension-sdk/src/plugin.js';
+export { type ToolProfileId, type ToolArgs, type ToolResponse, type PluginState, type PluginLifecycleContext, type ExtensionToolHandler, type ExtensionToolDefinition, ExtensionBuilder, createExtension, jsonResponse, errorResponse, } from '../../../packages/extension-sdk/src/plugin.js';