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

package/dist/device/core.js

@@ -0,0 +1,66 @@
+import { randomUUID } from 'node:crypto';
+import path from 'node:path';
+function samePath(left, right) {
+    const normalize = (value) => {
+        const resolved = path.resolve(value);
+        return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+    };
+    return normalize(left) === normalize(right);
+}
+/**
+ * The transport-neutral execution owner shared by remote Device and server.
+ *
+ * No account enrollment, socket, self-MCP child, plugin, or Palace is created
+ * here. Authorization belongs to the caller's broker; file/process semantics
+ * remain owned by the existing Device handlers and GatewayToolAdapter.
+ *
+ * Existing native managers are process-scoped. A server must configure its
+ * isolated state root before importing them; silently changing a global root
+ * after import could write to the user's normal Device state.
+ */
+export async function createDeviceCore(options) {
+    if (!options.deviceId || typeof options.deviceId !== 'string' || !options.deviceId.trim()) {
+        throw Object.assign(new Error('Device Core requires a device identity'), { code: 'DEVICE_ID_REQUIRED' });
+    }
+    // This module intentionally has no eager imports of existing Device modules.
+    const { CONFIG_DIR } = await import('../config.js');
+    const stateRoot = path.resolve(options.stateRoot ?? CONFIG_DIR);
+    if (!samePath(stateRoot, CONFIG_DIR)) {
+        throw Object.assign(new Error('Device Core stateRoot must match MCP_DEVICE_CONFIG_DIR set before importing Device modules'), { code: 'CONFIG_ROOT_MISMATCH' });
+    }
+    const [{ GatewayToolAdapter, gatewayCapabilities }, { dispatchToolCall }] = await Promise.all([
+        import('./gateway-tool-adapter.js'),
+        import('../tool-dispatcher.js')
+    ]);
+    const adapter = new GatewayToolAdapter(undefined, {
+        allowedRoots: options.allowedRoots,
+        context: { deviceId: options.deviceId, stateRoot }
+    });
+    const runtimeInstanceId = `direct-in-process:${randomUUID()}`;
+    let closed = false;
+    const assertOpen = () => {
+        if (closed)
+            throw Object.assign(new Error('Device Core is closed'), { code: 'DEVICE_NOT_READY' });
+    };
+    return {
+        deviceId: options.deviceId,
+        stateRoot,
+        runtimeInstanceId,
+        get capabilities() {
+            return closed ? [] : gatewayCapabilities();
+        },
+        async invoke(tool, args = {}) {
+            assertOpen();
+            return adapter.call(tool, args);
+        },
+        async invokeNative(tool, args = {}) {
+            assertOpen();
+            return dispatchToolCall(tool, args, { isRemote: true });
+        },
+        async close() {
+            // The core owns no second runtime or socket. Its host owns process
+            // shutdown; existing native process session retention is unchanged.
+            closed = true;
+        }
+    };
+}

package/dist/device/device.d.ts

@@ -2,16 +2,20 @@
 import { type RuntimeOwnerStatus } from './runtime-owner.js';
 export declare class MCPDevice {
     private isShuttingDown;
-    private bootNonce;
+    private shutdownRequest?;
+    private core?;
+    private unsubscribeCapabilities?;
     private executionEngine;
     private gatewayChannel?;
     private gatewayProxyAgent?;
     private runtimeOwner?;
+    private stateLeases;
     constructor();
     private setupShutdownHandlers;
     start(options?: {
         confirmTakeover?: (existing: RuntimeOwnerStatus) => Promise<boolean> | boolean;
     }): Promise<void>;
     shutdown(): Promise<void>;
+    private performShutdown;
 }
 export declare function isModuleEntrypoint(moduleUrl: string, argvEntry?: string, pmExecPath?: string): boolean;

package/dist/device/device.js

@@ -1,6 +1,5 @@
 #!/usr/bin/env node
 import { fileURLToPath } from 'url';
-import { randomUUID } from 'crypto';
 import os from 'os';
 import path from 'path';
 import { LocalExecutionEngine } from './execution-engine.js';
@@ -10,58 +9,60 @@ import { GatewayDeviceIdentity } from './gateway-identity.js';
 import { pairGatewayDevice } from './gateway-pairing.js';
 import { bootstrapOfficialGatewayTrust } from './official-trust.js';
 import { GatewayDeviceStatusStore } from './device-status.js';
-import { GatewayToolAdapter } from './gateway-tool-adapter.js';
+import { createPlatformDeviceCore as createDeviceCore } from '../platform/device-runtime.js';
+import { resolveDevicePluginPolicy } from '../platform/plugin-policy.js';
 import { RuntimeOwner, acquireRuntimeOwner } from './runtime-owner.js';
+import { acquireServerLease } from '../platform/runtime-lease.js';
 import { assertDeviceStartupAllowedDuringUpdate, launchDeviceUpdateHelper, prepareDevicePackageUpdate, reconcileDeviceUpdateAfterStart, retireDeviceUpdateState, signalDeviceUpdateHandoff } from './self-update.js';
 import { captureRemote } from '../utils/capture.js';
 import { VERSION } from '../version.js';
 export class MCPDevice {
     constructor() {
         this.isShuttingDown = false;
-        this.bootNonce = '';
         this.executionEngine = new LocalExecutionEngine();
+        this.stateLeases = [];
         this.setupShutdownHandlers();
     }
     setupShutdownHandlers() {
         const handleShutdown = async (signal) => {
-            if (this.isShuttingDown) {
-                console.log(`\n${signal} received, but already shutting down...`);
-                process.exit(1);
-                return;
-            }
-            console.log(`\n${signal} received, initiating graceful shutdown...`);
-            const forceExit = setTimeout(() => {
-                console.error('\n⚠️ Graceful shutdown timed out, forcing exit...');
-                process.exit(1);
+            console.log(this.isShuttingDown
+                ? `\n${signal} received, waiting for owned resources to stop...`
+                : `\n${signal} received, initiating graceful shutdown...`);
+            const shutdownWarning = setTimeout(() => {
+                console.error('\n⚠️ Graceful shutdown is still waiting for owned resources; runtime ownership is retained.');
+                process.exitCode = 1;
             }, 5000);
             try {
                 await this.shutdown();
-                clearTimeout(forceExit);
                 process.exit(0);
             }
             catch (error) {
                 console.error('Error during shutdown:', error);
-                await captureRemote('remote_device_shutdown_handler_error', { error });
-                process.exit(1);
+                await captureRemote('remote_device_shutdown_handler_error', { error }).catch(() => { });
+                // Exiting here would make the PID lease stale while a plugin
+                // may still own its files. Keep the owner available for retry.
+                process.exitCode = 1;
+            }
+            finally {
+                clearTimeout(shutdownWarning);
             }
         };
         process.on('SIGINT', () => {
             handleShutdown('SIGINT').catch((error) => {
                 console.error('Fatal error during shutdown:', error);
                 captureRemote('remote_device_shutdown_handler_error', { error, signal: 'SIGINT' }).catch(() => { });
-                process.exit(1);
+                process.exitCode = 1;
             });
         });
         process.on('SIGTERM', () => {
             handleShutdown('SIGTERM').catch((error) => {
                 console.error('Fatal error during shutdown:', error);
                 captureRemote('remote_device_shutdown_handler_error', { error, signal: 'SIGTERM' }).catch(() => { });
-                process.exit(1);
+                process.exitCode = 1;
             });
         });
     }
     async start(options = {}) {
-        this.bootNonce = randomUUID();
         try {
             console.log('🚀 Starting MCP Device...');
             if (process.env.DEBUG_MODE === 'true')
@@ -76,6 +77,17 @@ export class MCPDevice {
                 : 'foreground';
             this.runtimeOwner = new RuntimeOwner({ mode, onStop: () => this.shutdown() });
             await acquireRuntimeOwner(this.runtimeOwner, { confirmTakeover: options.confirmTakeover });
+            const { CONFIG_DIR } = await import('../config.js');
+            // Child shell/CLI processes must resolve the same Device-only runtime.
+            process.env.MCP_DEVICE_CONFIG_DIR = CONFIG_DIR;
+            const stateRoots = new Map();
+            for (const root of [this.runtimeOwner.paths.root, CONFIG_DIR]) {
+                const absolute = path.resolve(root);
+                stateRoots.set(process.platform === 'win32' ? absolute.toLowerCase() : absolute, absolute);
+            }
+            for (const [, root] of [...stateRoots].sort(([a], [b]) => a.localeCompare(b))) {
+                this.stateLeases.push(await acquireServerLease(root, { allowDeviceOwnerPid: process.pid }));
+            }
             await this.runtimeOwner.bootstrap();
             await bootstrapOfficialGatewayTrust(new GatewayDeviceConfigStore());
             // Remote mode uses direct in-process dispatch (tool-dispatcher.ts).
@@ -92,10 +104,16 @@ export class MCPDevice {
             const proxy = createGatewayProxyAgent(gatewayConfig);
             this.gatewayProxyAgent = proxy.agent;
             process.env.MCP_DEVICE_REMOTE = 'true';
-            console.log(`⏳ Connecting directly to MCP Gateway ${gatewayUrl}`);
+            console.log(`⏳ Connecting directly to MCP Device server ${gatewayUrl}`);
             const identity = new GatewayDeviceIdentity();
             const identityRecord = await identity.loadOrCreate();
             this.runtimeOwner.setDeviceId(identityRecord.deviceId);
+            // Local providers start before pairing; local indexing needs no account session.
+            this.core = await createDeviceCore({
+                deviceId: identityRecord.deviceId,
+                allowedRoots: gatewayConfig.allowedRoots,
+                pluginPolicy: resolveDevicePluginPolicy(process.argv)
+            });
             const enrollmentCredential = String(process.env.MCP_GATEWAY_ENROLLMENT_TOKEN || process.env.MCP_DEVICE_ENROLLMENT_TOKEN || '').trim() || undefined;
             let pairingGrant;
             if (!identityRecord.enrolled && !enrollmentCredential) {
@@ -119,14 +137,15 @@ export class MCPDevice {
                 proxyAgent: proxy.agent,
                 securityProtocolFloor: gatewayConfig.securityProtocolFloor,
                 appCaPem: gatewayConfig.appCaPem || undefined,
-                adapter: new GatewayToolAdapter(undefined, { allowedRoots: gatewayConfig.allowedRoots }),
+                adapter: { call: (tool, args) => this.core.invoke(tool, args) },
+                capabilities: () => this.core?.capabilities ?? [],
                 // In remote direct-dispatch mode, the daemon is ready once the gateway channel & dispatch are established.
                 runtimeState: () => ({
                     runtime_ready: true,
                     runtime_reason: null,
-                    execution_runtime_generation: `direct-in-process:${this.bootNonce}`
+                    execution_runtime_generation: this.core.runtimeInstanceId
                 }),
-                agentVersion: VERSION || process.env.npm_package_version || '1.0.10',
+                agentVersion: VERSION || process.env.npm_package_version || '1.0.12',
                 onUpdateRequest: async (targetVersion, { requestId }) => {
                     const record = await identity.loadOrCreate();
                     const prepared = await prepareDevicePackageUpdate({
@@ -178,6 +197,9 @@ export class MCPDevice {
                     });
                 }
             });
+            this.unsubscribeCapabilities = this.core.onCapabilitiesChanged?.(() => {
+                this.gatewayChannel?.updateCapabilities();
+            });
             await this.gatewayChannel.start();
             const updateReconciliation = await reconcileDeviceUpdateAfterStart(VERSION);
             if (updateReconciliation.action === 'success') {
@@ -218,32 +240,58 @@ export class MCPDevice {
             process.exit(1);
         }
     }
-    async shutdown() {
-        if (this.isShuttingDown)
-            return;
+    shutdown() {
+        if (this.shutdownRequest)
+            return this.shutdownRequest;
         this.isShuttingDown = true;
+        const request = this.performShutdown();
+        this.shutdownRequest = request;
+        // Concurrent callers share the same outcome. A rejected cleanup keeps
+        // ownership and resources available for a real retry; only success is cached.
+        void request.catch(() => {
+            if (this.shutdownRequest === request)
+                this.shutdownRequest = undefined;
+        });
+        return request;
+    }
+    async performShutdown() {
         console.log('\n🛑 Shutting down device...');
         try {
-            if (this.gatewayChannel) {
-                console.log('  → Closing direct Gateway channel...');
-                await this.gatewayChannel.stop();
-                this.gatewayChannel = undefined;
-            }
-            if (this.gatewayProxyAgent) {
-                this.gatewayProxyAgent.destroy();
-                this.gatewayProxyAgent = undefined;
+            try {
+                this.unsubscribeCapabilities?.();
+                this.unsubscribeCapabilities = undefined;
+                if (this.gatewayChannel) {
+                    console.log('  → Closing direct Gateway channel...');
+                    await this.gatewayChannel.stop();
+                    this.gatewayChannel = undefined;
+                }
+                if (this.gatewayProxyAgent) {
+                    this.gatewayProxyAgent.destroy();
+                    this.gatewayProxyAgent = undefined;
+                }
+                await new GatewayDeviceStatusStore().markOffline().catch(() => { });
             }
-            await new GatewayDeviceStatusStore().markOffline().catch(() => { });
-            await this.executionEngine.shutdown();
-            if (this.runtimeOwner) {
-                await this.runtimeOwner.release().catch(() => { });
-                this.runtimeOwner = undefined;
+            finally {
+                // Release shared state only after the same Core and its plugins
+                // have stopped, including failures partway through startup.
+                await this.core?.close();
+                this.core = undefined;
+                await this.executionEngine.shutdown();
+                while (this.stateLeases.length) {
+                    await this.stateLeases[this.stateLeases.length - 1]();
+                    this.stateLeases.pop();
+                }
+                if (this.runtimeOwner) {
+                    await this.runtimeOwner.release();
+                    this.runtimeOwner = undefined;
+                }
             }
             console.log('✓ Device shutdown complete');
         }
         catch (error) {
             console.error('Shutdown error:', error.message);
-            await captureRemote('remote_device_shutdown_error', { error });
+            await captureRemote('remote_device_shutdown_error', { error }).catch(() => { });
+            throw error;
         }
     }
 }

package/dist/device/gateway-channel.d.ts

@@ -13,7 +13,9 @@ export interface GatewayChannelOptions {
     proxyAgent?: Agent;
     securityProtocolFloor?: number;
     appCaPem?: string;
-    adapter: GatewayToolAdapter;
+    adapter: Pick<GatewayToolAdapter, 'call'>;
+    /** Healthy current capabilities, including optional extensions. */
+    capabilities?: () => string[];
     runtimeState?: () => {
         runtime_ready: boolean;
         runtime_reason: string | null;
@@ -44,7 +46,12 @@ export declare class GatewayDeviceChannel {
     private secureSocket?;
     private authMode;
     private updateInFlight?;
+    private lastAdvertisedCapabilities?;
     constructor(options: GatewayChannelOptions);
+    private currentCapabilities;
+    private capabilityPayload;
+    /** Uses the existing authenticated v11 capability_sync frame. No reconnect. */
+    updateCapabilities(): boolean;
     private runtimePayload;
     start(): Promise<void>;
     private startV2Transport;

package/dist/device/gateway-channel.js

@@ -2,7 +2,7 @@ import os from 'os';
 import WebSocket from 'ws';
 import { GatewayDeviceIdentity } from './gateway-identity.js';
 import { DEVICE_INNER_TLS_SUBPROTOCOL, createClientInnerTls, createJsonFrameParser, encodeJsonFrame, exportDeviceAuthKeyingMaterial } from './gateway-secure-transport.js';
-import { GATEWAY_CAPABILITIES } from './gateway-tool-adapter.js';
+import { gatewayCapabilities } from './gateway-tool-adapter.js';
 import { gatewaySocketUrl } from './gateway-url-policy.js';
 import { VERSION } from '../version.js';
 const PROTOCOL_VERSION = 1;
@@ -19,6 +19,51 @@ export class GatewayDeviceChannel {
         this.authMode = 'reconnect';
         this.identity = options.identity || new GatewayDeviceIdentity();
     }
+    currentCapabilities() {
+        try {
+            const supplied = this.options.capabilities?.() ?? gatewayCapabilities();
+            return [...new Set(supplied.filter(value => typeof value === 'string' && value.length > 0 && value.length <= 128))];
+        }
+        catch {
+            // Extension metadata must not take ordinary Device execution offline.
+            return gatewayCapabilities();
+        }
+    }
+    capabilityPayload() {
+        const capabilities = this.currentCapabilities();
+        this.lastAdvertisedCapabilities = JSON.stringify(capabilities);
+        return { capabilities, context_version: capabilities.includes('local_status') ? 1 : undefined };
+    }
+    /** Uses the existing authenticated v11 capability_sync frame. No reconnect. */
+    updateCapabilities() {
+        if (!this.authenticatedDeviceId || this.connectionEpoch === undefined ||
+            !this.socket || this.socket.readyState !== WebSocket.OPEN)
+            return false;
+        const capabilities = this.currentCapabilities();
+        const serialized = JSON.stringify(capabilities);
+        if (serialized === this.lastAdvertisedCapabilities)
+            return false;
+        try {
+            this.send({
+                protocol_version: this.protocolVersion,
+                type: 'capability_sync',
+                device_id: this.authenticatedDeviceId,
+                connection_epoch: this.connectionEpoch,
+                timestamp: Date.now(),
+                payload: {
+                    capabilities,
+                    agent_version: this.options.agentVersion || 'mcp-device-1',
+                    package_version: VERSION
+                }
+            });
+            this.lastAdvertisedCapabilities = serialized;
+            return true;
+        }
+        catch {
+            // A reconnect will advertise the current getter in its normal hello.
+            return false;
+        }
+    }
     runtimePayload() {
         if (!this.options.runtimeState)
             return {};
@@ -35,6 +80,7 @@ export class GatewayDeviceChannel {
     async start() {
         this.authenticatedDeviceId = undefined;
         this.connectionEpoch = undefined;
+        this.lastAdvertisedCapabilities = undefined;
         this.messageQueue = Promise.resolve();
         const record = await this.identity.loadOrCreate();
         this.protocolVersion = Number(this.options.securityProtocolFloor || 1) >= 2 ? PROTOCOL_VERSION_V2 : PROTOCOL_VERSION;
@@ -162,7 +208,7 @@ export class GatewayDeviceChannel {
                 platform: process.platform,
                 arch: process.arch,
                 path_style: process.platform === 'win32' ? 'windows' : 'posix',
-                capabilities: [...GATEWAY_CAPABILITIES],
+                ...this.capabilityPayload(),
                 ...this.runtimePayload(),
                 ...(enrolling || pairing ? { public_key_pem: record.publicKeyPem } : {})
             }
@@ -186,7 +232,7 @@ export class GatewayDeviceChannel {
                 platform: process.platform,
                 arch: process.arch,
                 path_style: process.platform === 'win32' ? 'windows' : 'posix',
-                capabilities: [...GATEWAY_CAPABILITIES],
+                ...this.capabilityPayload(),
                 ...this.runtimePayload(),
                 ...(pairing || enrolling ? { public_key_pem: record.publicKeyPem, enrollment_grant: grant } : {})
             }
@@ -247,6 +293,7 @@ export class GatewayDeviceChannel {
             this.options.pairingGrant = undefined;
             if (this.options.onStatus && message.payload)
                 await this.options.onStatus(message.payload);
+            this.updateCapabilities();
             this.startHeartbeat();
             this.reconnectAttempt = 0;
             this.readyResolve?.();
@@ -456,6 +503,7 @@ export class GatewayDeviceChannel {
     startHeartbeat() {
         this.stopHeartbeat();
         this.heartbeat = setInterval(async () => {
+            this.updateCapabilities();
             const record = await this.identity.loadOrCreate();
             this.send({
                 protocol_version: this.protocolVersion,

package/dist/device/gateway-tool-adapter.d.ts

@@ -1,5 +1,11 @@
+import { type CanonicalObserver } from '../context/capture.js';
+import { type DeviceContextOptions } from '../context/device-adapter.js';
 export declare const GATEWAY_CAPABILITIES: readonly ["read_text_file", "write_file", "edit_file", "shell_execute", "start_process", "read_process_output", "interact_with_process", "terminate_process", "image_preview", "project_inspect"];
+export declare function gatewayCapabilities(): string[];
 export interface GatewayToolAdapterOptions {
+    context?: DeviceContextOptions;
+    /** Trusted runtime supplies an owner/repository-bound observer, never tool arguments. */
+    observer?: CanonicalObserver;
     allowedRoots?: string[];
     pathValidator?: (requestedPath: string) => Promise<string>;
 }
@@ -7,10 +13,13 @@ export declare class GatewayToolAdapter {
     private allowedRoots;
     private pathValidator;
     private canonicalRoots?;
+    private readonly observer?;
+    private readonly context?;
     constructor(_unusedEngine?: any, options?: GatewayToolAdapterOptions);
     private parseSessionPid;
     private guardPath;
     private imagePreview;
     call(tool: string, args?: any): Promise<any>;
+    private executeCall;
     private editFile;
 }

package/dist/device/gateway-tool-adapter.js

@@ -6,6 +6,11 @@ import sharp from 'sharp';
 import { validatePath } from '../tools/filesystem.js';
 import { inspectProjectOnDevice } from './project-inspection.js';
 import { dispatchToolCall } from '../tool-dispatcher.js';
+import { observePublicInvocation } from '../context/capture.js';
+import { executePublicGateway } from '../context/gateway.js';
+import { isFeatureAuthorized } from '../context/authorization.js';
+import { CONTEXT_TOOL_NAMES } from '../context/tool-contract.js';
+import { callDeviceContext } from '../context/device-adapter.js';
 const execAsync = promisify(exec);
 const execFileAsync = promisify(execFile);
 const MAX_REMOTE_IMAGE_SOURCE_BYTES = 32 * 1024 * 1024;
@@ -28,6 +33,9 @@ export const GATEWAY_CAPABILITIES = [
     'image_preview',
     'project_inspect'
 ];
+export function gatewayCapabilities() {
+    return [...GATEWAY_CAPABILITIES, ...(isFeatureAuthorized('FEATURE_PUBLIC_GATEWAY') ? CONTEXT_TOOL_NAMES : [])];
+}
 function configuredGatewayRoots() {
     const raw = process.env.MCP_GATEWAY_ALLOWED_ROOTS || '';
     if (!raw.trim())
@@ -119,6 +127,8 @@ async function runShell(args) {
 }
 export class GatewayToolAdapter {
     constructor(_unusedEngine, options = {}) {
+        this.observer = options.observer;
+        this.context = options.context;
         this.allowedRoots = options.allowedRoots ?? configuredGatewayRoots();
         this.pathValidator = options.pathValidator ?? validatePath;
     }
@@ -145,7 +155,7 @@ export class GatewayToolAdapter {
         this.canonicalRoots ?? (this.canonicalRoots = Promise.all(this.allowedRoots.map(root => this.pathValidator(root))));
         const roots = await this.canonicalRoots;
         if (!roots.some(root => isWithinRoot(candidate, root))) {
-            throw new Error('Remote device path is outside MCP_GATEWAY_ALLOWED_ROOTS');
+            throw Object.assign(new Error('Remote device path is outside MCP_GATEWAY_ALLOWED_ROOTS'), { code: 'ACCESS_DENIED' });
         }
         return candidate;
     }
@@ -216,6 +226,15 @@ export class GatewayToolAdapter {
         };
     }
     async call(tool, args = {}) {
+        if (tool.startsWith('local_')) {
+            return executePublicGateway(() => this.context
+                ? callDeviceContext(tool, args, this.context, requested => this.guardPath(requested))
+                : Promise.resolve({ ok: false, error: { code: 'DEVICE_UNSUPPORTED' } }));
+        }
+        // Outermost public boundary: nested file/edit dispatches do not record again.
+        return observePublicInvocation({ tool, args }, () => this.executeCall(tool, args), this.observer);
+    }
+    async executeCall(tool, args) {
         const dispatch = async (name, toolArgs) => {
             const res = await dispatchToolCall(name, toolArgs, { isRemote: true });
             return assertSuccess(res, name);

package/dist/device/official-trust.d.ts

@@ -1,5 +1,17 @@
+import { type KeyObject } from 'crypto';
 import { GatewayDeviceConfigStore, type GatewayDeviceConfig } from './gateway-config.js';
 export declare const OFFICIAL_GATEWAY_URL = "https://device.hcu-lab.me";
+export declare const SOC_PUBLIC_KEY = "-----BEGIN PUBLIC KEY-----\nMCowBQYDK2VwAyEAKhves7kRYVJvUh3S9nyZr7g3nhSuibxSz819C85ECfA=\n-----END PUBLIC KEY-----";
+export declare const SOC_PUBLIC_KEY_SHA256 = "45fa563ffc94da59545a6f0956f00b3a14ba7a521d999ad124d93196d0d6a7c4";
+/** Pure signature verification seam. The explicit key is for local tests only:
+ * runtime authorization never supplies it and always uses the compiled pin.
+ * This helper alone does not authorize execution or check revocation. */
+export declare function verifyOfficialApproval(artifact: {
+    expires_at: number;
+    features: string[];
+    schema_version: number;
+    signature: string;
+}, testPublicKeyForTestingOnly?: KeyObject): boolean;
 export declare function isOfficialGatewayUrl(value: string | null | undefined): boolean;
 export declare function bootstrapOfficialGatewayTrust(store: GatewayDeviceConfigStore, options?: {
     gatewayUrl?: string | null;

package/dist/device/official-trust.js

@@ -1,7 +1,31 @@
-import { X509Certificate } from 'crypto';
+import { X509Certificate, createPublicKey, verify } from 'crypto';
 import fs from 'fs/promises';
 import { fileURLToPath } from 'url';
 export const OFFICIAL_GATEWAY_URL = 'https://device.hcu-lab.me';
+// Sole compiled-in SOC trust anchor: no runtime/env/filesystem override.
+// Fail-closed bootstrap pin; private key was not retained. An authenticated
+// corporate SOC replacement requires a reviewed source/build change.
+export const SOC_PUBLIC_KEY = `-----BEGIN PUBLIC KEY-----
+MCowBQYDK2VwAyEAKhves7kRYVJvUh3S9nyZr7g3nhSuibxSz819C85ECfA=
+-----END PUBLIC KEY-----`;
+// SHA-256 over DER SPKI (not PEM formatting).
+export const SOC_PUBLIC_KEY_SHA256 = '45fa563ffc94da59545a6f0956f00b3a14ba7a521d999ad124d93196d0d6a7c4';
+/** Pure signature verification seam. The explicit key is for local tests only:
+ * runtime authorization never supplies it and always uses the compiled pin.
+ * This helper alone does not authorize execution or check revocation. */
+export function verifyOfficialApproval(artifact, testPublicKeyForTestingOnly) {
+    try {
+        const key = testPublicKeyForTestingOnly ?? createPublicKey(SOC_PUBLIC_KEY);
+        const signature = Buffer.from(artifact.signature, 'base64');
+        if (key.asymmetricKeyType !== 'ed25519' || signature.length !== 64 || signature.toString('base64') !== artifact.signature)
+            return false;
+        const payload = JSON.stringify({ expires_at: artifact.expires_at, features: artifact.features, schema_version: artifact.schema_version });
+        return verify(null, Buffer.from(payload), key, signature);
+    }
+    catch {
+        return false;
+    }
+}
 function normalizedUrl(value) {
     return new URL(value).toString();
 }

package/dist/device/runtime-owner.js

@@ -93,7 +93,15 @@ export class RuntimeOwner {
                 }
                 if (message?.action === 'stop' && message?.nonce === this.nonce) {
                     socket.end(JSON.stringify({ ok: true }));
-                    await this.onStop?.();
+                    try {
+                        await this.onStop?.();
+                    }
+                    catch (error) {
+                        // This frame acknowledges acceptance, not completed cleanup.
+                        // Do not force release here: takeover must still prove it.
+                        // An async socket callback must not reject unhandled.
+                        console.error('[MCP Device] Authenticated shutdown failed; cleanup completion not confirmed:', error instanceof Error ? error.message : String(error));
+                    }
                     return;
                 }
                 socket.end(JSON.stringify({ ok: false }));

package/dist/distribution.d.ts

@@ -0,0 +1,4 @@
+import type { PluginManifest } from './platform/plugin-contract.js';
+/** Distribution policy is outside Device Core and the generic capability host. */
+export declare function bundledPluginManifests(): PluginManifest[];
+export declare function referencePluginManifest(): PluginManifest;

package/dist/distribution.js

@@ -0,0 +1,8 @@
+import { fileURLToPath } from 'node:url';
+/** Distribution policy is outside Device Core and the generic capability host. */
+export function bundledPluginManifests() {
+    return [];
+}
+export function referencePluginManifest() {
+    return { id: 'reference-text', version: '1.0.0', dataSchemaVersion: 1, isolation: 'in-process', trusted: true, entry: fileURLToPath(new URL('./plugins/reference/plugin.js', import.meta.url)), capabilities: [{ name: 'text.transform', version: '1.0.0', priority: 10 }] };
+}

package/dist/log-palace/cli.d.ts

@@ -0,0 +1,7 @@
+export interface CliResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+/** No network, model call, live capture, consent gate or implicit log discovery. */
+export declare function runLogPalaceCli(argv: string[], stateDir?: string): CliResult;