@hcu-lab.me/mcp-device 1.0.9 → 1.0.12

package/dist/tools/improved-process-tools.js

@@ -17,6 +17,24 @@ const mcpRoot = path.resolve(__dirname, '..', '..');
 // Track virtual Node sessions (PIDs that are actually Node fallback sessions)
 const virtualNodeSessions = new Map();
 let virtualPidCounter = -1000; // Use negative PIDs for virtual sessions
+const processOperationTails = new Map();
+async function acquireProcessOperation(pid) {
+    const previous = processOperationTails.get(pid) ?? Promise.resolve();
+    let release;
+    const current = new Promise((resolve) => { release = resolve; });
+    const tail = previous.catch(() => { }).then(() => current);
+    processOperationTails.set(pid, tail);
+    await previous.catch(() => { });
+    return () => {
+        release();
+        if (processOperationTails.get(pid) === tail) {
+            tail.finally(() => {
+                if (processOperationTails.get(pid) === tail)
+                    processOperationTails.delete(pid);
+            });
+        }
+    };
+}
 /**
  * Execute Node.js code via temp file (fallback when Python unavailable)
  * Creates temp .mjs file in MCP directory for ES module import access
@@ -28,6 +46,7 @@ async function executeNodeCode(code, timeout_ms = 30000) {
         const result = await new Promise((resolve) => {
             const proc = spawn(process.execPath, [tempFile], {
                 cwd: mcpRoot,
+                env: { ...process.env, MCP_DEVICE_SESSION: 'process-tool' },
                 timeout: timeout_ms,
                 windowsHide: true // Prevent visible console windows on Windows
             });
@@ -152,13 +171,18 @@ export async function startProcess(args) {
             }
         }
     }
-    const result = await terminalManager.executeCommand(commandToRun, parsed.data.timeout_ms, shellUsed, parsed.data.verbose_timing || false, workingDirectory);
+    const result = await terminalManager.executeCommand(commandToRun, parsed.data.background ? 0 : (parsed.data.yield_ms ?? parsed.data.timeout_ms), shellUsed, parsed.data.verbose_timing || false, workingDirectory);
     if (result.pid === -1) {
         return {
             content: [{ type: "text", text: result.output }],
             isError: true,
         };
     }
+    // Initial output returned here is already delivered to the consuming caller.
+    // Note: Only mark consumed for active running processes; completed processes retain baseline replayability.
+    if (terminalManager.getSession(result.pid)) {
+        terminalManager.markOutputConsumed(result.pid, result.deliveredCursor);
+    }
     // Analyze the process state to detect if it's waiting for input
     const processState = analyzeProcessState(result.output, result.pid);
     let statusMessage = '';
@@ -181,6 +205,7 @@ export async function startProcess(args) {
                 type: "text",
                 text: `Process started with PID ${result.pid} (shell: ${shellUsed})\nInitial output:\n${result.output}${statusMessage}${timingMessage}`
             }],
+        _meta: { process: terminalManager.processIdentity(result.pid) },
     };
 }
 function formatTimingInfo(timing) {
@@ -225,48 +250,15 @@ export async function readProcessOutput(args) {
     verbose_timing = false } = parsed.data;
     // Timing telemetry
     const startTime = Date.now();
-    // For active sessions with no new output yet, optionally wait for output
+    // For active sessions with no unread bytes yet, wait on output/completion progress.
     const session = terminalManager.getSession(pid);
     if (session && offset === 0) {
-        // Wait for new output to arrive (only for "new output" reads, not absolute/tail)
-        const waitForOutput = () => {
-            return new Promise((resolve) => {
-                // Check if there's already new output
-                const currentLines = terminalManager.getOutputLineCount(pid) || 0;
-                if (currentLines > session.lastReadIndex) {
-                    resolve();
-                    return;
-                }
-                let resolved = false;
-                let interval = null;
-                let timeout = null;
-                const cleanup = () => {
-                    if (interval)
-                        clearInterval(interval);
-                    if (timeout)
-                        clearTimeout(timeout);
-                };
-                const resolveOnce = () => {
-                    if (resolved)
-                        return;
-                    resolved = true;
-                    cleanup();
-                    resolve();
-                };
-                // Poll for new output
-                interval = setInterval(() => {
-                    const newLineCount = terminalManager.getOutputLineCount(pid) || 0;
-                    if (newLineCount > session.lastReadIndex) {
-                        resolveOnce();
-                    }
-                }, 50);
-                // Timeout
-                timeout = setTimeout(() => {
-                    resolveOnce();
-                }, timeout_ms);
-            });
-        };
-        await waitForOutput();
+        const currentLine = session.outputLines[session.lastReadIndex];
+        const hasUnread = currentLine !== undefined && session.lastReadOffset < currentLine.length
+            || session.outputLines.length - 1 > session.lastReadIndex;
+        if (!hasUnread) {
+            await terminalManager.waitForOutputProgress(pid, session.outputVersion, timeout_ms);
+        }
     }
     // Read output with pagination
     const result = terminalManager.readOutputPaginated(pid, offset, length);
@@ -313,9 +305,8 @@ export async function readProcessOutput(args) {
         processStateMessage = `\n✅ Process completed with exit code ${result.exitCode}${runtimeStr}`;
     }
     else if (session) {
-        // Analyze state for running processes
-        const fullOutput = session.outputLines.join('\n');
-        const processState = analyzeProcessState(fullOutput, pid);
+        // Analyze only the newly returned/bounded output; never rescan retained history here.
+        const processState = analyzeProcessState(output, pid);
         if (processState.isWaitingForInput) {
             processStateMessage = `\n🔄 ${formatProcessStateMessage(processState, pid)}`;
         }
@@ -332,6 +323,8 @@ export async function readProcessOutput(args) {
                 type: "text",
                 text: `${statusMessage}\n\n${responseText}${processStateMessage}${timingMessage}`
             }],
+        _meta: { process: { ...terminalManager.processIdentity(pid), read_from: result.readFrom,
+                read_count: result.readCount, evicted_lines: result.evictedLines, is_complete: result.isComplete } },
     };
 }
 /**
@@ -350,9 +343,12 @@ export async function interactWithProcess(args) {
         };
     }
     const { pid, input, timeout_ms = 8000, wait_for_prompt = true, verbose_timing = false } = parsed.data;
-    // Get config for output line limit
+    // Get config for output line limit and cap a single blocking interaction below client ceilings.
     const config = await configManager.getConfig();
     const maxOutputLines = config.fileReadLineLimit ?? 1000;
+    const configuredWaitCap = Number(await configManager.getValue('maxProcessWaitMs'));
+    const waitCapMs = Number.isFinite(configuredWaitCap) && configuredWaitCap > 0 ? configuredWaitCap : 180000;
+    const effectiveTimeoutMs = Math.min(Math.max(0, timeout_ms), waitCapMs);
     // Check if this is a virtual Node session (node:local)
     if (virtualNodeSessions.has(pid)) {
         const session = virtualNodeSessions.get(pid);
@@ -371,6 +367,7 @@ export async function interactWithProcess(args) {
     let lastOutputTime;
     const outputEvents = [];
     let exitReason = 'timeout';
+    const releaseOperation = await acquireProcessOperation(pid);
     try {
         capture('server_interact_with_process', {
             pid: pid,
@@ -417,72 +414,55 @@ export async function interactWithProcess(args) {
         let earlyExit = false;
         // Quick prompt patterns for immediate detection
         const quickPromptPatterns = />>>\s*$|>\s*$|\$\s*$|#\s*$/;
-        const waitForResponse = () => {
-            return new Promise((resolve) => {
-                let resolved = false;
-                let attempts = 0;
-                const pollIntervalMs = 50; // Poll every 50ms for faster response
-                const maxAttempts = Math.ceil(timeout_ms / pollIntervalMs);
-                let interval = null;
-                let lastOutputLength = 0; // Track output length to detect new output
-                let resolveOnce = () => {
-                    if (resolved)
-                        return;
-                    resolved = true;
-                    if (interval)
-                        clearInterval(interval);
-                    resolve();
-                };
-                // Fast-polling check - check every 50ms for quick responses
-                interval = setInterval(() => {
-                    if (resolved)
-                        return;
-                    // Use snapshot-based reading to handle REPL prompt line appending
-                    const newOutput = outputSnapshot
-                        ? terminalManager.getOutputSinceSnapshot(pid, outputSnapshot)
-                        : terminalManager.getNewOutput(pid);
-                    if (newOutput && newOutput.length > lastOutputLength) {
-                        const now = Date.now();
-                        if (!firstOutputTime)
-                            firstOutputTime = now;
-                        lastOutputTime = now;
-                        if (verbose_timing) {
-                            outputEvents.push({
-                                timestamp: now,
-                                deltaMs: now - startTime,
-                                source: 'periodic_poll',
-                                length: newOutput.length - lastOutputLength,
-                                snippet: newOutput.slice(lastOutputLength, lastOutputLength + 50).replace(/\n/g, '\\n')
-                            });
-                        }
-                        output = newOutput; // Replace with full output since snapshot
-                        lastOutputLength = newOutput.length;
-                        // Analyze current state
-                        processState = analyzeProcessState(output, pid);
-                        // Exit early if we detect the process is waiting for input
-                        if (processState.isWaitingForInput) {
-                            earlyExit = true;
-                            exitReason = 'early_exit_periodic_check';
-                            if (verbose_timing && outputEvents.length > 0) {
-                                outputEvents[outputEvents.length - 1].matchedPattern = 'periodic_check';
-                            }
-                            resolveOnce();
-                            return;
-                        }
-                        // Also exit if process finished
-                        if (processState.isFinished) {
-                            exitReason = 'process_finished';
-                            resolveOnce();
-                            return;
+        const waitForResponse = async () => {
+            const deadline = Date.now() + effectiveTimeoutMs;
+            let lastOutputLength = 0;
+            while (Date.now() < deadline) {
+                const active = terminalManager.getSession(pid);
+                const version = active?.outputVersion ?? -1;
+                const newOutput = outputSnapshot
+                    ? terminalManager.getOutputSinceSnapshot(pid, outputSnapshot)
+                    : terminalManager.getNewOutput(pid);
+                if (newOutput && newOutput.length > lastOutputLength) {
+                    const now = Date.now();
+                    if (!firstOutputTime)
+                        firstOutputTime = now;
+                    lastOutputTime = now;
+                    if (verbose_timing) {
+                        outputEvents.push({
+                            timestamp: now,
+                            deltaMs: now - startTime,
+                            source: 'output_event',
+                            length: newOutput.length - lastOutputLength,
+                            snippet: newOutput.slice(lastOutputLength, lastOutputLength + 50).replace(/\n/g, '\\n')
+                        });
+                    }
+                    output = newOutput;
+                    lastOutputLength = newOutput.length;
+                    processState = analyzeProcessState(output, pid);
+                    if (processState.isWaitingForInput) {
+                        earlyExit = true;
+                        exitReason = 'early_exit_periodic_check';
+                        if (verbose_timing && outputEvents.length > 0) {
+                            outputEvents[outputEvents.length - 1].matchedPattern = 'output_event';
                         }
+                        return;
                     }
-                    attempts++;
-                    if (attempts >= maxAttempts) {
-                        exitReason = 'timeout';
-                        resolveOnce();
+                    if (processState.isFinished) {
+                        exitReason = 'process_finished';
+                        return;
                     }
-                }, pollIntervalMs);
-            });
+                }
+                const remaining = deadline - Date.now();
+                if (remaining <= 0)
+                    break;
+                if (!active) {
+                    exitReason = 'process_finished';
+                    return;
+                }
+                await terminalManager.waitForOutputProgress(pid, version, remaining);
+            }
+            exitReason = 'timeout';
         };
         await waitForResponse();
         // Clean and format output
@@ -569,6 +549,9 @@ export async function interactWithProcess(args) {
             isError: true,
         };
     }
+    finally {
+        releaseOperation();
+    }
 }
 /**
  * Force terminate a process

package/dist/tools/schemas.d.ts

@@ -23,6 +23,8 @@ export declare const ListProcessesArgsSchema: z.ZodObject<{}, "strip", z.ZodType
 export declare const StartProcessArgsSchema: z.ZodObject<{
     command: z.ZodString;
     timeout_ms: z.ZodNumber;
+    yield_ms: z.ZodOptional<z.ZodNumber>;
+    background: z.ZodOptional<z.ZodBoolean>;
     working_directory: z.ZodOptional<z.ZodString>;
     shell: z.ZodOptional<z.ZodString>;
     verbose_timing: z.ZodOptional<z.ZodBoolean>;
@@ -31,6 +33,8 @@ export declare const StartProcessArgsSchema: z.ZodObject<{
     command: string;
     timeout_ms: number;
     origin?: "ui" | "llm" | undefined;
+    yield_ms?: number | undefined;
+    background?: boolean | undefined;
     working_directory?: string | undefined;
     shell?: string | undefined;
     verbose_timing?: boolean | undefined;
@@ -38,6 +42,8 @@ export declare const StartProcessArgsSchema: z.ZodObject<{
     command: string;
     timeout_ms: number;
     origin?: "ui" | "llm" | undefined;
+    yield_ms?: number | undefined;
+    background?: boolean | undefined;
     working_directory?: string | undefined;
     shell?: string | undefined;
     verbose_timing?: boolean | undefined;
@@ -106,10 +112,19 @@ export declare const ReadFileArgsSchema: z.ZodObject<{
 }>;
 export declare const ReadMultipleFilesArgsSchema: z.ZodObject<{
     paths: z.ZodArray<z.ZodString, "many">;
+    offset: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    length: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    maxBytes: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
 }, "strip", z.ZodTypeAny, {
+    length: number;
+    offset: number;
     paths: string[];
+    maxBytes: number;
 }, {
     paths: string[];
+    length?: number | undefined;
+    offset?: number | undefined;
+    maxBytes?: number | undefined;
 }>;
 export declare const WriteFileArgsSchema: z.ZodObject<{
     path: z.ZodString;
@@ -287,19 +302,37 @@ export declare const EditBlockArgsSchema: z.ZodEffects<z.ZodObject<{
     old_string: z.ZodOptional<z.ZodString>;
     new_string: z.ZodOptional<z.ZodString>;
     expected_replacements: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    edits: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        old_string: z.ZodString;
+        new_string: z.ZodString;
+        expected_replacements: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        old_string: string;
+        new_string: string;
+        expected_replacements: number;
+    }, {
+        old_string: string;
+        new_string: string;
+        expected_replacements?: number | undefined;
+    }>, "many">>;
     range: z.ZodOptional<z.ZodString>;
     content: z.ZodOptional<z.ZodAny>;
     options: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
     origin: z.ZodOptional<z.ZodEnum<["ui", "llm"]>>;
 }, "strip", z.ZodTypeAny, {
-    file_path: string;
     expected_replacements: number;
+    file_path: string;
     origin?: "ui" | "llm" | undefined;
     options?: Record<string, any> | undefined;
     range?: string | undefined;
     content?: any;
     old_string?: string | undefined;
     new_string?: string | undefined;
+    edits?: {
+        old_string: string;
+        new_string: string;
+        expected_replacements: number;
+    }[] | undefined;
 }, {
     file_path: string;
     origin?: "ui" | "llm" | undefined;
@@ -309,15 +342,25 @@ export declare const EditBlockArgsSchema: z.ZodEffects<z.ZodObject<{
     old_string?: string | undefined;
     new_string?: string | undefined;
     expected_replacements?: number | undefined;
+    edits?: {
+        old_string: string;
+        new_string: string;
+        expected_replacements?: number | undefined;
+    }[] | undefined;
 }>, {
-    file_path: string;
     expected_replacements: number;
+    file_path: string;
     origin?: "ui" | "llm" | undefined;
     options?: Record<string, any> | undefined;
     range?: string | undefined;
     content?: any;
     old_string?: string | undefined;
     new_string?: string | undefined;
+    edits?: {
+        old_string: string;
+        new_string: string;
+        expected_replacements: number;
+    }[] | undefined;
 }, {
     file_path: string;
     origin?: "ui" | "llm" | undefined;
@@ -327,6 +370,11 @@ export declare const EditBlockArgsSchema: z.ZodEffects<z.ZodObject<{
     old_string?: string | undefined;
     new_string?: string | undefined;
     expected_replacements?: number | undefined;
+    edits?: {
+        old_string: string;
+        new_string: string;
+        expected_replacements?: number | undefined;
+    }[] | undefined;
 }>;
 export declare const InteractWithProcessArgsSchema: z.ZodObject<{
     pid: z.ZodNumber;
@@ -388,6 +436,50 @@ export declare const StartSearchArgsSchema: z.ZodObject<{
     earlyTermination?: boolean | undefined;
     literalSearch?: boolean | undefined;
 }>;
+export declare const SearchOnceArgsSchema: z.ZodObject<{
+    path: z.ZodString;
+    pattern: z.ZodString;
+    searchType: z.ZodDefault<z.ZodEnum<["files", "content"]>>;
+    filePattern: z.ZodOptional<z.ZodString>;
+    ignoreCase: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    maxResults: z.ZodOptional<z.ZodNumber>;
+    includeHidden: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    contextLines: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    timeout_ms: z.ZodOptional<z.ZodNumber>;
+    earlyTermination: z.ZodOptional<z.ZodBoolean>;
+    literalSearch: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    origin: z.ZodOptional<z.ZodEnum<["ui", "llm"]>>;
+} & {
+    maxBytes: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    maxBytes: number;
+    pattern: string;
+    searchType: "content" | "files";
+    ignoreCase: boolean;
+    includeHidden: boolean;
+    contextLines: number;
+    literalSearch: boolean;
+    origin?: "ui" | "llm" | undefined;
+    timeout_ms?: number | undefined;
+    filePattern?: string | undefined;
+    maxResults?: number | undefined;
+    earlyTermination?: boolean | undefined;
+}, {
+    path: string;
+    pattern: string;
+    origin?: "ui" | "llm" | undefined;
+    timeout_ms?: number | undefined;
+    maxBytes?: number | undefined;
+    searchType?: "content" | "files" | undefined;
+    filePattern?: string | undefined;
+    ignoreCase?: boolean | undefined;
+    maxResults?: number | undefined;
+    includeHidden?: boolean | undefined;
+    contextLines?: number | undefined;
+    earlyTermination?: boolean | undefined;
+    literalSearch?: boolean | undefined;
+}>;
 export declare const GetMoreSearchResultsArgsSchema: z.ZodObject<{
     sessionId: z.ZodString;
     offset: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;

package/dist/tools/schemas.js

@@ -23,6 +23,8 @@ export const ListProcessesArgsSchema = z.object({});
 export const StartProcessArgsSchema = z.object({
     command: z.string(),
     timeout_ms: z.number(),
+    yield_ms: z.number().positive().optional(),
+    background: z.boolean().optional(),
     working_directory: z.string().optional(),
     shell: z.string().optional(),
     verbose_timing: z.boolean().optional(),
@@ -60,6 +62,9 @@ export const ReadFileArgsSchema = z.object({
 });
 export const ReadMultipleFilesArgsSchema = z.object({
     paths: z.array(z.string()),
+    offset: z.number().optional().default(0),
+    length: z.number().optional().default(1000),
+    maxBytes: z.number().int().positive().optional().default(256 * 1024),
 });
 export const WriteFileArgsSchema = z.object({
     path: z.string(),
@@ -119,17 +124,21 @@ export const MoveFileArgsSchema = z.object({
 export const GetFileInfoArgsSchema = z.object({
     path: z.string(),
 });
-// Edit tools schema - SIMPLIFIED from three modes to two
-// Previously supported: text replacement, location-based edits (edits array), and range rewrites
-// Now supports only: text replacement and range rewrites
-// Removed 'edits' array parameter - location-based surgical edits were complex and unnecessary
-// Range rewrites are more powerful and cover all structured file editing needs
+// Edit tool schema. Legacy text replacement and structured range rewrites remain.
+// The additive edits[] mode is exact-only and batches multiple text replacements
+// into one validated read/write cycle.
+const ExactEditSchema = z.object({
+    old_string: z.string().min(1),
+    new_string: z.string(),
+    expected_replacements: z.number().int().positive().optional().default(1),
+});
 export const EditBlockArgsSchema = z.object({
     file_path: z.string(),
     // Text file string replacement
     old_string: z.string().optional(),
     new_string: z.string().optional(),
     expected_replacements: z.number().optional().default(1),
+    edits: z.array(ExactEditSchema).min(1).optional(),
     // Structured file range rewrite (Excel, etc.)
     range: z.string().optional(),
     content: z.any().optional(),
@@ -141,8 +150,9 @@ export const EditBlockArgsSchema = z.object({
     // Helper to check if value is actually provided (not undefined, not empty string)
     const hasValue = (v) => v !== undefined && v !== '';
     return (hasValue(data.old_string) && data.new_string !== undefined) ||
+        (data.edits !== undefined && data.edits.length > 0) ||
         (hasValue(data.range) && hasValue(data.content));
-}, { message: "Must provide either (old_string + new_string) or (range + content)" });
+}, { message: "Must provide either (old_string + new_string), edits, or (range + content)" });
 // Send input to process schema
 export const InteractWithProcessArgsSchema = z.object({
     pid: z.number(),
@@ -170,6 +180,9 @@ export const StartSearchArgsSchema = z.object({
     // excluded from tool-call telemetry (see isUiOriginCall in server.ts).
     origin: z.enum(['ui', 'llm']).optional(),
 });
+export const SearchOnceArgsSchema = StartSearchArgsSchema.extend({
+    maxBytes: z.number().int().positive().optional().default(256 * 1024),
+});
 export const GetMoreSearchResultsArgsSchema = z.object({
     sessionId: z.string(),
     offset: z.number().optional().default(0), // Same as file reading
@@ -213,6 +226,7 @@ export const toolArgSchemas = {
     list_directory: ListDirectoryArgsSchema,
     move_file: MoveFileArgsSchema,
     start_search: StartSearchArgsSchema,
+    search_once: SearchOnceArgsSchema,
     get_more_search_results: GetMoreSearchResultsArgsSchema,
     stop_search: StopSearchArgsSchema,
     list_searches: ListSearchesArgsSchema,

package/dist/types.d.ts

@@ -12,10 +12,14 @@ export interface ProcessInfo {
     memory: string;
 }
 export interface TerminalSession {
+    executionId: string;
     pid: number;
     process: ChildProcess;
     outputLines: string[];
     lastReadIndex: number;
+    lastReadOffset: number;
+    outputVersion: number;
+    outputWaiters: Set<() => void>;
     isBlocked: boolean;
     startTime: Date;
     bufferedChars: number;
@@ -26,6 +30,10 @@ export interface CommandExecutionResult {
     pid: number;
     output: string;
     isBlocked: boolean;
+    deliveredCursor?: {
+        lineIndex: number;
+        lineOffset: number;
+    };
     timingInfo?: TimingInfo;
 }
 export interface TimingInfo {

package/dist/utils/output-budget.d.ts

@@ -0,0 +1,6 @@
+export interface BudgetedText {
+    text: string;
+    bytes: number;
+    truncated: boolean;
+}
+export declare function takeUtf8Budget(text: string, maxBytes: number): BudgetedText;

package/dist/utils/output-budget.js

@@ -0,0 +1,15 @@
+import { StringDecoder } from 'node:string_decoder';
+export function takeUtf8Budget(text, maxBytes) {
+    const totalBytes = Buffer.byteLength(text, 'utf8');
+    if (totalBytes <= maxBytes) {
+        return { text, bytes: totalBytes, truncated: false };
+    }
+    const decoder = new StringDecoder('utf8');
+    const chunk = Buffer.from(text, 'utf8').subarray(0, Math.max(0, maxBytes));
+    const bounded = decoder.write(chunk);
+    return {
+        text: bounded,
+        bytes: Buffer.byteLength(bounded, 'utf8'),
+        truncated: true,
+    };
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "1.0.9";
+export declare const VERSION = "1.0.12";

package/dist/version.js

@@ -1 +1 @@
-export const VERSION = '1.0.9';
+export const VERSION = '1.0.12';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hcu-lab.me/mcp-device",
-  "version": "1.0.9",
+  "version": "1.0.12",
   "description": "MCP Device runtime.",
   "license": "MIT",
   "author": "Hirohimeow",
@@ -12,14 +12,22 @@
   "bugs": "https://github.com/Hiroshimeow/agent-mcp-device/issues",
   "type": "module",
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=22.13.0"
   },
   "bin": {
     "mcp-device": "dist/mcp-device.js",
     "md": "dist/mcp-device.js"
   },
   "files": [
-    "dist"
+    "dist",
+    "!dist/plugins/palace",
+    "config/revoked-approvals.json",
+    "skills/mcp-device-context",
+    "SECURITY.md",
+    "PRIVACY.md",
+    "control-plane/scripts",
+    "control-plane/config",
+    "control-plane/contracts"
   ],
   "scripts": {
     "device:install": "cd src/device && npm install",
@@ -38,6 +46,8 @@
     "start": "node dist/mcp-device.js",
     "start:debug": "node --inspect-brk=9229 dist/mcp-device.js",
     "prepack": "node scripts/verify-production-trust.cjs",
+    "build:palace": "npm run build && node scripts/v12/build-palace-package.mjs --stable",
+    "pack:palace": "npm run build:palace && npm pack .tmp/v12-palace-standalone/package --pack-destination .tmp/v12-palace-standalone",
     "prepare": "npm run build",
     "clean": "shx rm -rf dist",
     "test": "npm run build && node test/run-all-tests.js",
@@ -51,7 +61,10 @@
     "logs:clear": "npm run build && node scripts/clear-fuzzy-logs.js",
     "logs:export": "npm run build && node scripts/export-fuzzy-logs.js",
     "count-tokens": "npm run build && node scripts/count-tokens.js",
-    "count-tokens:json": "npm run build && node scripts/count-tokens.js --json"
+    "count-tokens:json": "npm run build && node scripts/count-tokens.js --json",
+    "test:v12": "node scripts/v12/run-platform-tests.mjs",
+    "test:v12:server": "node scripts/v12/run-platform-tests.mjs --server",
+    "test:parity": "node scripts/v12/run-device-parity.mjs"
   },
   "keywords": [
     "mcp",
@@ -104,9 +117,19 @@
     "tiptap-markdown": "^0.9.0",
     "unified": "^11.0.5",
     "unpdf": "^1.4.0",
-    "ws": "^8.18.3",
+    "ws": "^8.21.3",
     "zod": "^3.24.1",
-    "zod-to-json-schema": "^3.23.5"
+    "zod-to-json-schema": "^3.23.5",
+    "@modelcontextprotocol/client": "2.0.0",
+    "@modelcontextprotocol/core": "2.0.0",
+    "@modelcontextprotocol/express": "2.0.0",
+    "@modelcontextprotocol/node": "2.0.0",
+    "@modelcontextprotocol/server": "2.0.0",
+    "cors": "^2.8.6",
+    "express": "5.1.0",
+    "express-rate-limit": "^8.7.0",
+    "smol-toml": "^1.4.2",
+    "yaml": "^2.9.1"
   },
   "optionalDependencies": {
     "caffeinate": "^1.0.1"