mtech-ai-local-runner 0.1.81 → 0.1.82

package/dist/src/asks/messenger.js

@@ -1,9 +1,8 @@
-import { createHash } from "node:crypto";
 import { join } from "node:path";
 import { McpGatewayClient } from "../gateway-client.js";
 import { Daemon } from "../daemon/daemon.js";
 import { ProcessLock } from "../daemon/process-lock.js";
-import { runnerDisplayName } from "../daemon/runtime.js";
+import { runnerDeviceFingerprint, runnerDisplayName } from "../daemon/runtime.js";
 import { SessionOpener, sessionOpenAdvertisement } from "../daemon/session-opener.js";
 import { RunnerTransport } from "../transport/runner-transport.js";
 import { ReverbSocket } from "../transport/reverb-socket.js";
@@ -108,7 +107,7 @@ export async function buildMessengerDaemon(input) {
         const askInbox = await asks.advertisement();
         const guidance = await guide.advertisement();
         await gateway.heartbeatLocalRunner({
-            deviceFingerprint: createHash("sha256").update(`${process.getuid?.() ?? 0}|${runnerDisplayName()}|${input.gatewayMcpUrl}`).digest("hex"),
+            deviceFingerprint: runnerDeviceFingerprint(input.gatewayMcpUrl),
             displayName: runnerDisplayName(), packageVersion: packageVersion(), capabilities: [], mode: "messenger",
             // Without an integration, session_open still goes out (clients only): the Gateway keeps the last one it stored, and would keep long-polling for asks.
             ...(sessionOpen ? { sessionOpen: { ...sessionOpen, ...(askInbox ? { ask_inbox: askInbox } : {}) } } : {}),

package/dist/src/cli.js

@@ -25,8 +25,10 @@ import { createBrowserOpener } from "./auth/browser-opener.js";
 import { FileLocalConfigStore, runnerMode } from "./registration/local-config.js";
 import { LaunchdService } from "./platform/macos/launchd.js";
 import { installStableRelease } from "./platform/macos/stable-release.js";
-import { buildDaemon, runnerDisplayName } from "./daemon/runtime.js";
-import { createHash } from "node:crypto";
+import { packageVersion } from "./package-version.js";
+import { reportRefusal } from "./registration/refusal-report.js";
+import { selfChecksReport } from "./safety/self-checks.js";
+import { buildDaemon, runnerDeviceFingerprint, runnerDisplayName } from "./daemon/runtime.js";
 import { discoverEmployeeAdapters, hasUsableAdapter, adapterDiagnosticsWithRemedies } from "./adapters/discovery.js";
 import { verifyPackagedHook } from "./safety/hook-command.js";
 import { access, mkdir, rm } from "node:fs/promises";
@@ -259,6 +261,8 @@ export async function main(argv, env, io = {}) {
                     const hook = await hookSelfTest(config.workspaceRoot);
                     if (!hook.enforcing) {
                         stdout(JSON.stringify({ ok: false, configured: false, hook: hookReport(hook), action: hookAction(hook) }));
+                        await reportRefusal({ stateRoot: config.stateRoot, env, fetchFn, report: selfChecksReport({ source: "setup", packageVersion: packageVersion(),
+                                checkedAt: Math.floor(Date.now() / 1000), tools: null, hook, refusalCode: "hook_not_enforcing" }) });
                         throw new Error(`The PreToolUse hook did not deny the probe call (hook_not_enforcing: ${hook.reason})`);
                     }
                     // A full runner whose job file tools cannot read here would take jobs and stop executor_blocked on every one
@@ -268,6 +272,8 @@ export async function main(argv, env, io = {}) {
                     if (tools.status !== "passed") {
                         const report = localToolsReport(tools);
                         stdout(JSON.stringify({ ok: false, configured: false, local_tools: report, action: report.action }));
+                        await reportRefusal({ stateRoot: config.stateRoot, env, fetchFn, report: selfChecksReport({ source: "setup", packageVersion: packageVersion(),
+                                checkedAt: Math.floor(Date.now() / 1000), tools, hook, refusalCode: "local_tools_failed" }) });
                         throw new Error(`The job file tools failed on this Mac (local_tools_failed: ${tools.tool ?? "setup"}: ${tools.detail ?? "unknown"})`);
                     }
                 }
@@ -285,8 +291,8 @@ export async function main(argv, env, io = {}) {
                     throw new Error("No usable authenticated runtime adapter is available. Run doctor for adapter diagnostics.");
                 }
                 const registered = await gateway.registerLocalRunner({
-                    deviceFingerprint: createHash("sha256").update(`${process.getuid?.() ?? 0}|${runnerDisplayName()}|${config.gatewayMcpUrl}`).digest("hex"),
-                    displayName: runnerDisplayName(), packageVersion: "0.1.11",
+                    deviceFingerprint: runnerDeviceFingerprint(config.gatewayMcpUrl),
+                    displayName: runnerDisplayName(), packageVersion: packageVersion(),
                     capabilities: mode === "full" ? adapters.map(probe => ({ adapter: probe.id, version: probe.version, capabilities: probe.capabilities, ...adapterStatus(probe) })) : [],
                     mode,
                 });
@@ -418,6 +424,8 @@ export async function main(argv, env, io = {}) {
                 if (!hook.enforcing) {
                     stderr(JSON.stringify({ event: "hook_not_enforcing", reason: hook.reason,
                         ...(hook.exitCode === null ? {} : { exit_code: hook.exitCode }), ...(hook.detail ? { detail: hook.detail } : {}) }));
+                    await reportRefusal({ stateRoot: config.stateRoot, env, fetchFn, report: selfChecksReport({ source: "daemon_start", packageVersion: packageVersion(),
+                            checkedAt: Math.floor(Date.now() / 1000), tools: null, hook, refusalCode: "hook_not_enforcing" }) });
                     return 1;
                 }
             }

package/dist/src/daemon/runtime.js

@@ -30,7 +30,9 @@ import { PendingClosureAcks, createSyncDispatcher } from "../transport/sync-disp
 import { abortableDelay } from "../transport/abortable-delay.js";
 import { sideLoops } from "../transport/side-loops.js";
 import { buildTerminalEvidenceCollector } from "../safety/terminal-evidence.js";
-import { packagedHookCommandParts } from "../safety/hook-command.js";
+import { packagedHookCommandParts, verifyPackagedHook } from "../safety/hook-command.js";
+import { localToolSelfTest } from "../safety/local-tool-self-test.js";
+import { SelfCheckMonitor } from "./self-check-monitor.js";
 import { composeReviewedP1Host } from '../verification/p1-host-composition.js';
 import { AskRuntime, withAsks } from '../asks/runtime.js';
 import { GuideRuntime, withGuide } from '../guide/runtime.js';
@@ -196,6 +198,15 @@ export async function buildDaemon(input) {
         // Until now the heartbeat said this runner takes no jobs; tell the Gateway at once, and ask whether one waits.
         onArmed: () => { void heartbeats.tick(); transport?.requestSync("start"); },
     });
+    // Work Item 2549b1b0: the file tools and hook checked with this daemon's node, sent in every heartbeat.
+    const selfChecks = new SelfCheckMonitor({
+        workspaceRoot: input.workspaceRoot,
+        localTools: input.selfChecks?.localTools ?? localToolSelfTest,
+        hook: input.selfChecks?.hook ?? verifyPackagedHook,
+        packageVersion: () => packageVersion(),
+        changed: () => { void heartbeats.tick(); },
+        ...(input.selfChecks?.intervalMs ? { intervalMs: input.selfChecks.intervalMs } : {}),
+    });
     const heartbeats = new HeartbeatScheduler({
         intervalMs: 30_000,
         snapshot: async () => {
@@ -259,13 +270,14 @@ export async function buildDaemon(input) {
             const askInbox = await asks.advertisement();
             const guidance = await guide.advertisement();
             return {
-                deviceFingerprint: createHash("sha256").update(`${process.getuid?.() ?? 0}|${runnerDisplayName()}|${input.gatewayMcpUrl}`).digest("hex"),
+                deviceFingerprint: runnerDeviceFingerprint(input.gatewayMcpUrl),
                 displayName: runnerDisplayName(), packageVersion: packageVersion(),
                 capabilities: acceptingJobs(localRunnerCapabilities(probes, !!localFixHost, localFixHost?.verificationModes ?? localFixHost?.verificationMode), poller.accepting),
                 mode: "full",
                 ...(sessionOpen ? { sessionOpen: { ...sessionOpen, ...(askInbox ? { ask_inbox: askInbox } : {}) } } : {}),
                 ...(guidance ? { guidance } : {}),
                 localFix: localFixReport(),
+                ...(selfChecks.report() ? { selfChecks: selfChecks.report() } : {}),
             };
         },
         send: async (payload) => { await gateway.heartbeatLocalRunner(payload); },
@@ -340,6 +352,7 @@ export async function buildDaemon(input) {
     });
     transport = pushTransport;
     const sessionOpens = sideLoops({ heartbeat: heartbeats, transport: pushTransport, onStop: () => stopping.abort() });
+    selfChecks.start();
     const daemon = new Daemon({
         lock: new ProcessLock(join(input.stateRoot, "daemon.lock")), state,
         reconcile: async (stored) => {
@@ -358,6 +371,7 @@ export async function buildDaemon(input) {
     // Model tools have no Gateway relay. Each adapter owns and closes its job endpoint.
     // The Claude host always closes; a failing Claude close never masks a Codex close failure.
     return { daemon, close: async () => {
+            selfChecks.stop();
             daemon.stop();
             try {
                 await production?.close();
@@ -370,6 +384,10 @@ export async function buildDaemon(input) {
         } };
 }
 export function runnerDisplayName() { return `${hostname()} local AI`; }
+/** The fingerprint setup registers and every heartbeat repeats; a refusal report must match it too (Work Item 2549b1b0). */
+export function runnerDeviceFingerprint(gatewayMcpUrl) {
+    return createHash("sha256").update(`${process.getuid?.() ?? 0}|${runnerDisplayName()}|${gatewayMcpUrl}`).digest("hex");
+}
 /** The execution blocker a full runner reports for every adapter while it takes no jobs. */
 export const RUNNER_NOT_ACCEPTING_JOBS = "RUNNER_NOT_ACCEPTING_JOBS";
 /*

package/dist/src/daemon/self-check-monitor.js

@@ -0,0 +1,43 @@
+import { selfChecksReport } from "../safety/self-checks.js";
+export const SELF_CHECK_INTERVAL_MS = 6 * 60 * 60 * 1000;
+/**
+ * Runs the job file tool and hook self-checks with this daemon's own node (Work Item 2549b1b0): the node every job uses,
+ * which doctor's terminal node may not be. A check that throws counts as failed; nothing here stops job claims.
+ */
+export class SelfCheckMonitor {
+    deps;
+    latest;
+    timer;
+    stopped = false;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    report() { return this.latest; }
+    start() {
+        const loop = () => {
+            if (this.stopped)
+                return;
+            void this.check().finally(() => {
+                if (!this.stopped)
+                    this.timer = setTimeout(loop, this.deps.intervalMs ?? SELF_CHECK_INTERVAL_MS);
+            });
+        };
+        loop();
+    }
+    stop() {
+        this.stopped = true;
+        if (this.timer)
+            clearTimeout(this.timer);
+    }
+    async check() {
+        const [tools, hook] = await Promise.all([
+            this.deps.localTools(this.deps.workspaceRoot).catch(() => ({ status: "failed", node: process.execPath })),
+            this.deps.hook(this.deps.workspaceRoot).catch(() => ({ enforcing: false, reason: "failed", exitCode: null })),
+        ]);
+        if (this.stopped)
+            return;
+        this.latest = selfChecksReport({ source: "daemon", packageVersion: this.deps.packageVersion(),
+            checkedAt: Math.floor((this.deps.now?.() ?? Date.now()) / 1000), tools, hook });
+        this.deps.changed();
+    }
+}

package/dist/src/gateway-client.js

@@ -568,9 +568,18 @@ export class McpGatewayClient {
                 ...(input.sessionOpen ? { session_open: input.sessionOpen } : {}),
                 ...(input.guidance ? { guidance: input.guidance } : {}),
                 ...(input.localFix !== undefined ? { local_fix: input.localFix } : {}),
+                ...(input.selfChecks ? { self_checks: input.selfChecks } : {}),
             },
         }, signal);
     }
+    /** A refused setup or daemon start, reported once before the process exits (Work Item 2549b1b0). */
+    async reportRunnerChecks(input, signal) {
+        return this.callTool("local_agent_runner_check_report", {
+            runner_id: this.runnerId,
+            device_fingerprint: input.deviceFingerprint,
+            self_checks: input.selfChecks,
+        }, signal);
+    }
     async waitForSessionOpens(waitSeconds = 25, signal) {
         const result = await this.callTool("local_agent_session_opens_wait", {
             runner_id: this.runnerId,

package/dist/src/registration/refusal-report.js

@@ -0,0 +1,27 @@
+import { FileOAuthCredentialStore } from "../auth/credential-store.js";
+import { OAuthClient } from "../auth/oauth-client.js";
+import { OAuthTokenProvider } from "../auth/token-provider.js";
+import { McpGatewayClient } from "../gateway-client.js";
+import { FileLocalConfigStore } from "./local-config.js";
+import { runnerDeviceFingerprint } from "../daemon/runtime.js";
+const REPORT_TIMEOUT_MS = 5000;
+/**
+ * Tell the Gateway once that setup or the daemon start refused (Work Item 2549b1b0), with the identity and login an
+ * earlier setup saved. A first install has neither, so it reports nothing. Advisory: it never throws and never waits
+ * more than 5 seconds, so the refusal's message and exit code stay as they were.
+ */
+export async function reportRefusal(input) {
+    try {
+        const local = await new FileLocalConfigStore(input.stateRoot).load();
+        if (!local)
+            return;
+        const tokenProvider = new OAuthTokenProvider({ store: new FileOAuthCredentialStore(input.stateRoot),
+            oauthClient: new OAuthClient({ resource: local.gatewayMcpUrl, fetchFn: input.fetchFn }), resource: local.gatewayMcpUrl,
+            tokenOverride: input.env.AI_GATEWAY_LOCAL_RUNNER_TOKEN, clock: () => Date.now() });
+        const gateway = new McpGatewayClient({ mcpUrl: local.gatewayMcpUrl, tokenProvider, runnerId: local.runnerId, fetchFn: input.fetchFn });
+        await gateway.reportRunnerChecks({ deviceFingerprint: runnerDeviceFingerprint(local.gatewayMcpUrl), selfChecks: input.report }, AbortSignal.timeout(REPORT_TIMEOUT_MS));
+    }
+    catch {
+        // The refusal itself is what the employee must act on; the report is only for the owner.
+    }
+}

package/dist/src/safety/self-checks.js

@@ -0,0 +1,31 @@
+/** A hint for the reader; local_tools.status is the signal. */
+export function nodeKind(execPath) {
+    if (execPath.includes("/opt/homebrew/") || execPath.includes("/Cellar/"))
+        return "homebrew";
+    if (execPath.includes("/.nvm/"))
+        return "nvm";
+    if (execPath === "/usr/local/bin/node")
+        return "official";
+    return "other";
+}
+export function selfChecksReport(input) {
+    const tools = input.tools;
+    return {
+        version: 1,
+        source: input.source,
+        package_version: input.packageVersion,
+        checked_at: input.checkedAt,
+        local_tools: tools === null ? null : {
+            status: tools.status,
+            ...(tools.status === "failed" && tools.tool ? { tool: tools.tool } : {}),
+            ...(tools.sandbox?.reason ? { sandbox_reason: tools.sandbox.reason } : {}),
+            node_kind: nodeKind(tools.node),
+            node_version: input.nodeVersion ?? process.version,
+        },
+        hook: input.hook === null ? null : {
+            status: input.hook.enforcing ? "enforcing" : "hook_not_enforcing",
+            ...(input.hook.enforcing ? {} : { reason: input.hook.reason }),
+        },
+        ...(input.refusalCode ? { refusal_code: input.refusalCode } : {}),
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mtech-ai-local-runner",
-  "version": "0.1.81",
+  "version": "0.1.82",
   "private": false,
   "license": "UNLICENSED",
   "bin": {