windows-exe-decompiler-mcp-server 0.1.0

package/dist/tools/task-sweep.d.ts

@@ -0,0 +1,22 @@
+/**
+ * task.sweep MCP tool
+ * Reap stale running tasks and clear old finished records.
+ */
+import { z } from 'zod';
+import type { ToolDefinition, ToolHandler } from '../types.js';
+import type { JobQueue } from '../job-queue.js';
+import type { DatabaseManager } from '../database.js';
+export declare const taskSweepInputSchema: z.ZodObject<{
+    stale_running_ms: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    clear_finished_older_ms: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    clear_finished_older_ms: number;
+    stale_running_ms?: number | null | undefined;
+}, {
+    stale_running_ms?: number | null | undefined;
+    clear_finished_older_ms?: number | undefined;
+}>;
+export type TaskSweepInput = z.infer<typeof taskSweepInputSchema>;
+export declare const taskSweepToolDefinition: ToolDefinition;
+export declare function createTaskSweepHandler(jobQueue: JobQueue, database?: DatabaseManager): ToolHandler;
+//# sourceMappingURL=task-sweep.d.ts.map

package/dist/tools/task-sweep.js

@@ -0,0 +1,77 @@
+/**
+ * task.sweep MCP tool
+ * Reap stale running tasks and clear old finished records.
+ */
+import { z } from 'zod';
+const TOOL_NAME = 'task.sweep';
+export const taskSweepInputSchema = z.object({
+    stale_running_ms: z
+        .number()
+        .int()
+        .min(1000)
+        .nullable()
+        .optional()
+        .describe('Optional stale-running threshold in milliseconds. Omit or null to disable automatic reaping.'),
+    clear_finished_older_ms: z
+        .number()
+        .int()
+        .min(60 * 1000)
+        .optional()
+        .default(24 * 60 * 60 * 1000)
+        .describe('Clear completed/failed/cancelled jobs older than this threshold (default: 24 hours)'),
+});
+export const taskSweepToolDefinition = {
+    name: TOOL_NAME,
+    description: 'Sweep stale running tasks and clear old finished task records.',
+    inputSchema: taskSweepInputSchema,
+};
+export function createTaskSweepHandler(jobQueue, database) {
+    return async (args) => {
+        try {
+            const input = taskSweepInputSchema.parse(args);
+            const reaper = jobQueue;
+            const reaped = typeof input.stale_running_ms === 'number' && typeof reaper.reapStaleRunningJobs === 'function'
+                ? reaper.reapStaleRunningJobs(input.stale_running_ms)
+                : [];
+            const reapedAnalyses = database
+                ? typeof input.stale_running_ms === 'number'
+                    ? database.reapStaleAnalyses(input.stale_running_ms)
+                    : []
+                : [];
+            const cleared = jobQueue.clearOldJobs(input.clear_finished_older_ms);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            ok: true,
+                            data: {
+                                reaped_running_jobs: reaped,
+                                reaped_count: reaped.length,
+                                reaped_persisted_analyses: reapedAnalyses.map((item) => item.id),
+                                reaped_persisted_analysis_count: reapedAnalyses.length,
+                                cleared_finished_count: cleared,
+                            },
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            ok: false,
+                            errors: [message],
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    };
+}
+//# sourceMappingURL=task-sweep.js.map

package/dist/tools/tool-help.d.ts

@@ -0,0 +1,340 @@
+import { z } from 'zod';
+import type { ToolArgs, ToolDefinition, WorkerResult } from '../types.js';
+export declare const toolHelpInputSchema: z.ZodObject<{
+    tool_name: z.ZodOptional<z.ZodString>;
+    include_output_schema: z.ZodDefault<z.ZodBoolean>;
+    include_fields: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    include_output_schema: boolean;
+    include_fields: boolean;
+    tool_name?: string | undefined;
+}, {
+    tool_name?: string | undefined;
+    include_output_schema?: boolean | undefined;
+    include_fields?: boolean | undefined;
+}>;
+export declare const toolHelpOutputSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    data: z.ZodObject<{
+        count: z.ZodNumber;
+        tools: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodString;
+            usage_notes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            input: z.ZodOptional<z.ZodObject<{
+                field_count: z.ZodNumber;
+                fields: z.ZodArray<z.ZodObject<{
+                    path: z.ZodString;
+                    type: z.ZodString;
+                    required: z.ZodBoolean;
+                    nullable: z.ZodBoolean;
+                    description: z.ZodNullable<z.ZodString>;
+                    help_hint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    default_value: z.ZodOptional<z.ZodAny>;
+                    enum_values: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                }, "strip", z.ZodTypeAny, {
+                    path: string;
+                    type: string;
+                    description: string | null;
+                    required: boolean;
+                    nullable: boolean;
+                    help_hint?: string | null | undefined;
+                    default_value?: any;
+                    enum_values?: string[] | undefined;
+                }, {
+                    path: string;
+                    type: string;
+                    description: string | null;
+                    required: boolean;
+                    nullable: boolean;
+                    help_hint?: string | null | undefined;
+                    default_value?: any;
+                    enum_values?: string[] | undefined;
+                }>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                field_count: number;
+                fields: {
+                    path: string;
+                    type: string;
+                    description: string | null;
+                    required: boolean;
+                    nullable: boolean;
+                    help_hint?: string | null | undefined;
+                    default_value?: any;
+                    enum_values?: string[] | undefined;
+                }[];
+            }, {
+                field_count: number;
+                fields: {
+                    path: string;
+                    type: string;
+                    description: string | null;
+                    required: boolean;
+                    nullable: boolean;
+                    help_hint?: string | null | undefined;
+                    default_value?: any;
+                    enum_values?: string[] | undefined;
+                }[];
+            }>>;
+            output: z.ZodOptional<z.ZodObject<{
+                field_count: z.ZodNumber;
+                fields: z.ZodArray<z.ZodObject<{
+                    path: z.ZodString;
+                    type: z.ZodString;
+                    required: z.ZodBoolean;
+                    nullable: z.ZodBoolean;
+                    description: z.ZodNullable<z.ZodString>;
+                    help_hint: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    default_value: z.ZodOptional<z.ZodAny>;
+                    enum_values: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                }, "strip", z.ZodTypeAny, {
+                    path: string;
+                    type: string;
+                    description: string | null;
+                    required: boolean;
+                    nullable: boolean;
+                    help_hint?: string | null | undefined;
+                    default_value?: any;
+                    enum_values?: string[] | undefined;
+                }, {
+                    path: string;
+                    type: string;
+                    description: string | null;
+                    required: boolean;
+                    nullable: boolean;
+                    help_hint?: string | null | undefined;
+                    default_value?: any;
+                    enum_values?: string[] | undefined;
+                }>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                field_count: number;
+                fields: {
+                    path: string;
+                    type: string;
+                    description: string | null;
+                    required: boolean;
+                    nullable: boolean;
+                    help_hint?: string | null | undefined;
+                    default_value?: any;
+                    enum_values?: string[] | undefined;
+                }[];
+            }, {
+                field_count: number;
+                fields: {
+                    path: string;
+                    type: string;
+                    description: string | null;
+                    required: boolean;
+                    nullable: boolean;
+                    help_hint?: string | null | undefined;
+                    default_value?: any;
+                    enum_values?: string[] | undefined;
+                }[];
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            description: string;
+            output?: {
+                field_count: number;
+                fields: {
+                    path: string;
+                    type: string;
+                    description: string | null;
+                    required: boolean;
+                    nullable: boolean;
+                    help_hint?: string | null | undefined;
+                    default_value?: any;
+                    enum_values?: string[] | undefined;
+                }[];
+            } | undefined;
+            input?: {
+                field_count: number;
+                fields: {
+                    path: string;
+                    type: string;
+                    description: string | null;
+                    required: boolean;
+                    nullable: boolean;
+                    help_hint?: string | null | undefined;
+                    default_value?: any;
+                    enum_values?: string[] | undefined;
+                }[];
+            } | undefined;
+            usage_notes?: string[] | undefined;
+        }, {
+            name: string;
+            description: string;
+            output?: {
+                field_count: number;
+                fields: {
+                    path: string;
+                    type: string;
+                    description: string | null;
+                    required: boolean;
+                    nullable: boolean;
+                    help_hint?: string | null | undefined;
+                    default_value?: any;
+                    enum_values?: string[] | undefined;
+                }[];
+            } | undefined;
+            input?: {
+                field_count: number;
+                fields: {
+                    path: string;
+                    type: string;
+                    description: string | null;
+                    required: boolean;
+                    nullable: boolean;
+                    help_hint?: string | null | undefined;
+                    default_value?: any;
+                    enum_values?: string[] | undefined;
+                }[];
+            } | undefined;
+            usage_notes?: string[] | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        count: number;
+        tools: {
+            name: string;
+            description: string;
+            output?: {
+                field_count: number;
+                fields: {
+                    path: string;
+                    type: string;
+                    description: string | null;
+                    required: boolean;
+                    nullable: boolean;
+                    help_hint?: string | null | undefined;
+                    default_value?: any;
+                    enum_values?: string[] | undefined;
+                }[];
+            } | undefined;
+            input?: {
+                field_count: number;
+                fields: {
+                    path: string;
+                    type: string;
+                    description: string | null;
+                    required: boolean;
+                    nullable: boolean;
+                    help_hint?: string | null | undefined;
+                    default_value?: any;
+                    enum_values?: string[] | undefined;
+                }[];
+            } | undefined;
+            usage_notes?: string[] | undefined;
+        }[];
+    }, {
+        count: number;
+        tools: {
+            name: string;
+            description: string;
+            output?: {
+                field_count: number;
+                fields: {
+                    path: string;
+                    type: string;
+                    description: string | null;
+                    required: boolean;
+                    nullable: boolean;
+                    help_hint?: string | null | undefined;
+                    default_value?: any;
+                    enum_values?: string[] | undefined;
+                }[];
+            } | undefined;
+            input?: {
+                field_count: number;
+                fields: {
+                    path: string;
+                    type: string;
+                    description: string | null;
+                    required: boolean;
+                    nullable: boolean;
+                    help_hint?: string | null | undefined;
+                    default_value?: any;
+                    enum_values?: string[] | undefined;
+                }[];
+            } | undefined;
+            usage_notes?: string[] | undefined;
+        }[];
+    }>;
+    errors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    data: {
+        count: number;
+        tools: {
+            name: string;
+            description: string;
+            output?: {
+                field_count: number;
+                fields: {
+                    path: string;
+                    type: string;
+                    description: string | null;
+                    required: boolean;
+                    nullable: boolean;
+                    help_hint?: string | null | undefined;
+                    default_value?: any;
+                    enum_values?: string[] | undefined;
+                }[];
+            } | undefined;
+            input?: {
+                field_count: number;
+                fields: {
+                    path: string;
+                    type: string;
+                    description: string | null;
+                    required: boolean;
+                    nullable: boolean;
+                    help_hint?: string | null | undefined;
+                    default_value?: any;
+                    enum_values?: string[] | undefined;
+                }[];
+            } | undefined;
+            usage_notes?: string[] | undefined;
+        }[];
+    };
+    ok: boolean;
+    errors?: string[] | undefined;
+}, {
+    data: {
+        count: number;
+        tools: {
+            name: string;
+            description: string;
+            output?: {
+                field_count: number;
+                fields: {
+                    path: string;
+                    type: string;
+                    description: string | null;
+                    required: boolean;
+                    nullable: boolean;
+                    help_hint?: string | null | undefined;
+                    default_value?: any;
+                    enum_values?: string[] | undefined;
+                }[];
+            } | undefined;
+            input?: {
+                field_count: number;
+                fields: {
+                    path: string;
+                    type: string;
+                    description: string | null;
+                    required: boolean;
+                    nullable: boolean;
+                    help_hint?: string | null | undefined;
+                    default_value?: any;
+                    enum_values?: string[] | undefined;
+                }[];
+            } | undefined;
+            usage_notes?: string[] | undefined;
+        }[];
+    };
+    ok: boolean;
+    errors?: string[] | undefined;
+}>;
+export declare const toolHelpToolDefinition: ToolDefinition;
+export declare function createToolHelpHandler(getDefinitions: () => ToolDefinition[]): (args: ToolArgs) => Promise<WorkerResult>;
+//# sourceMappingURL=tool-help.d.ts.map

package/dist/tools/tool-help.js

@@ -0,0 +1,261 @@
+import { z } from 'zod';
+const TOOL_NAME = 'tool.help';
+const ToolFieldSchema = z.object({
+    path: z.string(),
+    type: z.string(),
+    required: z.boolean(),
+    nullable: z.boolean(),
+    description: z.string().nullable(),
+    help_hint: z.string().nullable().optional(),
+    default_value: z.any().optional(),
+    enum_values: z.array(z.string()).optional(),
+});
+const ToolSchemaSummarySchema = z.object({
+    field_count: z.number().int().nonnegative(),
+    fields: z.array(ToolFieldSchema),
+});
+export const toolHelpInputSchema = z.object({
+    tool_name: z.string().optional().describe('Optional exact tool name for a detailed schema/help lookup'),
+    include_output_schema: z
+        .boolean()
+        .default(true)
+        .describe('Include output schema field help when the tool defines one'),
+    include_fields: z
+        .boolean()
+        .default(true)
+        .describe('When false, only return name/description counts without flattened field help'),
+});
+export const toolHelpOutputSchema = z.object({
+    ok: z.boolean(),
+    data: z.object({
+        count: z.number().int().nonnegative(),
+        tools: z.array(z.object({
+            name: z.string(),
+            description: z.string(),
+            usage_notes: z.array(z.string()).optional(),
+            input: ToolSchemaSummarySchema.optional(),
+            output: ToolSchemaSummarySchema.optional(),
+        })),
+    }),
+    errors: z.array(z.string()).optional(),
+});
+export const toolHelpToolDefinition = {
+    name: TOOL_NAME,
+    description: 'Query normalized schema/help for registered MCP tools, including enum values, defaults, and field descriptions.',
+    inputSchema: toolHelpInputSchema,
+    outputSchema: toolHelpOutputSchema,
+};
+function unwrapSchema(schema) {
+    let current = schema;
+    let required = true;
+    let nullable = false;
+    let defaultValue;
+    while (true) {
+        if (current instanceof z.ZodOptional) {
+            required = false;
+            current = current._def.innerType;
+            continue;
+        }
+        if (current instanceof z.ZodDefault) {
+            required = false;
+            try {
+                defaultValue = current._def.defaultValue();
+            }
+            catch {
+                defaultValue = undefined;
+            }
+            current = current._def.innerType;
+            continue;
+        }
+        if (current instanceof z.ZodNullable) {
+            nullable = true;
+            current = current._def.innerType;
+            continue;
+        }
+        if (current instanceof z.ZodCatch) {
+            current = current._def.innerType;
+            continue;
+        }
+        if (current instanceof z.ZodEffects) {
+            current = current._def.schema;
+            continue;
+        }
+        if (current instanceof z.ZodBranded) {
+            current = current._def.type;
+            continue;
+        }
+        if (current instanceof z.ZodReadonly) {
+            current = current._def.innerType;
+            continue;
+        }
+        break;
+    }
+    return {
+        schema: current,
+        required,
+        nullable,
+        defaultValue,
+    };
+}
+function describeSchemaType(schema) {
+    if (schema instanceof z.ZodString)
+        return 'string';
+    if (schema instanceof z.ZodNumber)
+        return 'number';
+    if (schema instanceof z.ZodBoolean)
+        return 'boolean';
+    if (schema instanceof z.ZodEnum)
+        return 'enum';
+    if (schema instanceof z.ZodLiteral)
+        return 'literal';
+    if (schema instanceof z.ZodObject)
+        return 'object';
+    if (schema instanceof z.ZodArray) {
+        const itemInfo = unwrapSchema(schema._def.type);
+        return `array<${describeSchemaType(itemInfo.schema)}>`;
+    }
+    if (schema instanceof z.ZodUnion)
+        return 'union';
+    if (schema instanceof z.ZodTuple)
+        return 'tuple';
+    return 'unknown';
+}
+function collectSchemaFields(schema, prefix = '', toolName) {
+    const info = unwrapSchema(schema);
+    const current = info.schema;
+    if (current instanceof z.ZodObject) {
+        const shape = current.shape;
+        return Object.entries(shape).flatMap(([key, value]) => collectSchemaFields(value, prefix ? `${prefix}.${key}` : key, toolName));
+    }
+    const field = {
+        path: prefix || '$',
+        type: describeSchemaType(current),
+        required: info.required,
+        nullable: info.nullable,
+        description: schema.description || current.description || null,
+        help_hint: buildFieldHelpHint(prefix || '$', toolName),
+    };
+    if (info.defaultValue !== undefined) {
+        field.default_value = info.defaultValue;
+    }
+    if (current instanceof z.ZodEnum) {
+        field.enum_values = [...current._def.values];
+    }
+    else if (current instanceof z.ZodLiteral) {
+        field.enum_values = [String(current._def.value)];
+    }
+    return [field];
+}
+function buildFieldHelpHint(path, toolName) {
+    if (toolName === 'sample.ingest') {
+        if (path === 'path') {
+            return 'Preferred for local files. Pass an absolute path when the MCP client can read the same filesystem as the MCP server.';
+        }
+        if (path === 'bytes_b64') {
+            return 'Fallback only. Use this when the MCP client cannot read the local file path directly, such as remote or browser-hosted clients.';
+        }
+        if (path === 'filename') {
+            return 'Optional display/original filename. Useful when ingesting from bytes_b64 because there is no source path-derived filename.';
+        }
+    }
+    if (path === 'evidence_scope') {
+        return 'Controls runtime evidence selection only. Use session for one runtime import/replay lineage, latest for the newest artifact window, all to aggregate historical runtime evidence.';
+    }
+    if (path === 'evidence_session_tag') {
+        return 'Required when evidence_scope=session. You can also pass it with all/latest to narrow runtime evidence to one named session.';
+    }
+    if (path === 'semantic_scope') {
+        return 'Controls semantic naming/explanation artifact selection only. Use session to consume one naming or explanation review pass, latest for the newest semantic artifact window, all to aggregate historical semantic artifacts.';
+    }
+    if (path === 'semantic_session_tag') {
+        return 'Required when semantic_scope=session. Usually set this to the naming or explanation review session_tag you want reconstruct/export/report to consume.';
+    }
+    if (path === 'session_tag') {
+        return 'Session tag groups newly created artifacts so later MCP calls can select this exact review/export/import session.';
+    }
+    if (path === 'path_prefix') {
+        return 'Use this to narrow artifact tools to one export directory such as reports/reconstruct/<session>.';
+    }
+    return null;
+}
+function buildUsageNotes(definition) {
+    const notes = [];
+    const inputFields = buildSchemaSummary(definition.inputSchema, definition.name).fields.map((item) => item.path);
+    const hasEvidenceScope = inputFields.includes('evidence_scope');
+    const hasSemanticScope = inputFields.includes('semantic_scope');
+    const hasSessionTag = inputFields.includes('session_tag');
+    if (hasEvidenceScope && hasSemanticScope) {
+        notes.push('This tool separates runtime evidence scope from semantic artifact scope. Set both when you need fully reproducible session-only results.');
+    }
+    else if (hasEvidenceScope) {
+        notes.push('This tool consumes runtime evidence artifacts. Prefer evidence_scope=session plus evidence_session_tag for one replay/import session.');
+    }
+    if (hasSemanticScope) {
+        notes.push('This tool consumes naming/explanation artifacts. Prefer semantic_scope=session plus semantic_session_tag to avoid mixing historical LLM outputs.');
+    }
+    if (hasSessionTag) {
+        notes.push('session_tag labels newly created artifacts. Reuse that tag in later semantic_scope=session or artifacts.diff calls.');
+    }
+    if (definition.name === 'artifacts.list') {
+        notes.push('Use session_tag, path_prefix, or latest_only to narrow artifact views before reading or diffing files.');
+    }
+    if (definition.name === 'artifacts.diff') {
+        notes.push('Diff two session_tag values after export, naming review, explanation review, or runtime import to see what changed between analysis rounds.');
+    }
+    if (definition.name === 'tool.help') {
+        notes.push('Query this tool first when an MCP client needs exact enum values, defaults, or scope/session usage guidance before calling another tool.');
+    }
+    if (definition.name === 'sample.ingest') {
+        notes.push('Prefer path for local files. Use bytes_b64 only when the MCP client cannot access the same local filesystem as the MCP server.');
+        notes.push('When both path and bytes_b64 are provided, path wins. Passing an absolute file path is the most reliable option for local VS Code/Copilot clients.');
+    }
+    return notes;
+}
+function buildSchemaSummary(schema, toolName) {
+    const fields = collectSchemaFields(schema, '', toolName);
+    return {
+        field_count: fields.length,
+        fields,
+    };
+}
+export function createToolHelpHandler(getDefinitions) {
+    return async (args) => {
+        try {
+            const input = toolHelpInputSchema.parse(args);
+            const definitions = getDefinitions();
+            const filtered = input.tool_name
+                ? definitions.filter((item) => item.name === input.tool_name)
+                : definitions;
+            if (input.tool_name && filtered.length === 0) {
+                return {
+                    ok: false,
+                    errors: [`Tool not found: ${input.tool_name}`],
+                };
+            }
+            return {
+                ok: true,
+                data: {
+                    count: filtered.length,
+                    tools: filtered.map((definition) => ({
+                        name: definition.name,
+                        description: definition.description,
+                        usage_notes: buildUsageNotes(definition),
+                        input: input.include_fields
+                            ? buildSchemaSummary(definition.inputSchema, definition.name)
+                            : undefined,
+                        output: input.include_fields && input.include_output_schema && definition.outputSchema
+                            ? buildSchemaSummary(definition.outputSchema, definition.name)
+                            : undefined,
+                    })),
+                },
+            };
+        }
+        catch (error) {
+            return {
+                ok: false,
+                errors: [error instanceof Error ? error.message : String(error)],
+            };
+        }
+    };
+}
+//# sourceMappingURL=tool-help.js.map