mtech-ai-local-runner 0.1.72 → 0.1.73

package/dist/src/cli.js

@@ -518,5 +518,9 @@ export function isDirectCliInvocation(moduleUrl, argvPath) {
 if (isDirectCliInvocation(import.meta.url, process.argv[1])) {
     main(process.argv.slice(2), process.env).then((code) => {
         process.exitCode = code;
+        // A daemon that stopped (to apply Fix consent, decision baf0cd89) must leave so launchd starts a fresh one.
+        // The unref'd timer only fires if a socket or timer still holds the event loop five seconds later.
+        if (process.argv[2] === "run")
+            setTimeout(() => process.exit(code), 5000).unref();
     });
 }

package/dist/src/commands/fix.js

@@ -25,19 +25,108 @@ function flags(argv) {
     return values;
 }
 /** A job owns the host until it ends: never replace or restart under it. */
-async function idle(io) {
+export async function fixHostBusy(stateRoot) {
     for (const file of BUSY)
-        if (await exists(path.join(io.stateRoot, file))) {
-            io.stderr('FIX_HOST_JOB_ACTIVE: wait until the current job ends, then run this again.');
-            return false;
-        }
+        if (await exists(path.join(stateRoot, file)))
+            return true;
+    return false;
+}
+const JOB_ACTIVE = 'FIX_HOST_JOB_ACTIVE: wait until the current job ends, then run this again.';
+async function idle(io) {
+    if (await fixHostBusy(io.stateRoot)) {
+        io.stderr(JOB_ACTIVE);
+        return false;
+    }
     return true;
 }
-async function backup(io, file) {
-    const dir = path.join(io.stateRoot, 'backups');
+async function backup(stateRoot, file) {
+    const dir = path.join(stateRoot, 'backups');
     await mkdir(dir, { recursive: true, mode: 0o700 });
     await copyFile(file, path.join(dir, `local-fix-host-${new Date().toISOString().replace(/[:.]/g, '-')}.json`));
 }
+/** The existing host, when it is a v3 host this runner would load; anything else is replaced whole. */
+async function currentConsentHost(file, runnerId) {
+    let raw;
+    try {
+        const s = await lstat(file);
+        if (!s.isFile() || s.isSymbolicLink() || s.size > 128 * 1024)
+            return undefined;
+        raw = JSON.parse(await readFile(file, 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw) || Object.keys(raw).sort().join() !== 'consent,enabled,git,runnerId,schema')
+        return undefined;
+    if (raw.schema !== 'local-fix-host-installation-v3' || raw.enabled !== true || raw.runnerId !== runnerId)
+        return undefined;
+    const git = raw.git;
+    if (!git || typeof git !== 'object' || Array.isArray(git) || Object.keys(git).sort().join() !== 'executable,sha256' || typeof git.executable !== 'string' || typeof git.sha256 !== 'string')
+        return undefined;
+    try {
+        assertLocalFixConsent(raw.consent);
+    }
+    catch {
+        return undefined;
+    }
+    return raw;
+}
+const union = (first, second) => [...first, ...second.filter(value => !first.includes(value))];
+/**
+ * The one writer of local-fix-host.json consent, shared by `fix enable` (replace) and the daemon applying a Slack
+ * grant (extend; Work Item 6f9e64ae, decision baf0cd89). Refuses while a job or recovery is pending. Extend merges
+ * into a v3 host this runner would load and keeps its pinned Git; any other file is backed up and replaced by a
+ * fresh v3 host with newly pinned Git, as `fix enable` writes. Writes are owner-only and atomic; a replaced file is
+ * kept under backups/. Restarting the runner is the caller's job.
+ */
+export async function applyFixConsent(input) {
+    const requested = { repository_keys: [...input.repositoryKeys], verification_modes: [...input.verificationModes] };
+    try {
+        assertLocalFixConsent(requested);
+    }
+    catch {
+        return { ok: false, code: 'FIX_CONSENT_INVALID' };
+    }
+    if (await fixHostBusy(input.stateRoot))
+        return { ok: false, code: 'FIX_HOST_JOB_ACTIVE' };
+    const file = path.join(input.stateRoot, HOST_FILE);
+    const existing = input.mode === 'extend' ? await currentConsentHost(file, input.runnerId) : undefined;
+    let host;
+    if (existing) {
+        const consent = { repository_keys: union(existing.consent.repository_keys, requested.repository_keys), verification_modes: union(existing.consent.verification_modes, requested.verification_modes) };
+        try {
+            assertLocalFixConsent(consent);
+        }
+        catch {
+            return { ok: false, code: 'FIX_CONSENT_INVALID' };
+        }
+        if (consent.repository_keys.length === existing.consent.repository_keys.length && consent.verification_modes.length === existing.consent.verification_modes.length)
+            return { ok: true, changed: false, consent: existing.consent };
+        host = { schema: 'local-fix-host-installation-v3', enabled: true, runnerId: input.runnerId, git: { executable: existing.git.executable, sha256: existing.git.sha256 }, consent };
+    }
+    else {
+        const executable = await realpath(input.git ?? await (input.findGit ?? defaultGit)());
+        const git = { executable, sha256: await measureCommandFile(executable) };
+        await assertPinnedGit(git);
+        host = { schema: 'local-fix-host-installation-v3', enabled: true, runnerId: input.runnerId, git, consent: requested };
+    }
+    const privateRoot = path.join(input.stateRoot, 'local-fix-publication');
+    if (!await exists(privateRoot))
+        await mkdir(privateRoot, { mode: 0o700 });
+    const s = await lstat(privateRoot);
+    if (!s.isDirectory() || s.isSymbolicLink() || (s.mode & 0o077) !== 0)
+        return { ok: false, code: 'FIX_HOST_PRIVATE_DIRECTORY_INSECURE', privateRoot };
+    const serialized = JSON.stringify(host, null, 1);
+    let previous;
+    if (await exists(file)) {
+        previous = await readFile(file, 'utf8').catch(() => undefined);
+        await backup(input.stateRoot, file);
+    }
+    const temporary = path.join(input.stateRoot, `.${HOST_FILE}.${randomUUID()}`);
+    await writeFile(temporary, serialized, { mode: 0o600, flag: 'wx' });
+    await rename(temporary, file);
+    return { ok: true, changed: previous !== serialized, consent: host.consent };
+}
 async function restart(io, summary) {
     if (await io.serviceLoaded()) {
         await io.restartService();
@@ -77,7 +166,7 @@ export async function runFixCommand(argv, io) {
             io.stdout(JSON.stringify({ ok: true, removed: false }));
             return 0;
         }
-        await backup(io, file);
+        await backup(io.stateRoot, file);
         await rm(file);
         return restart(io, { ok: true, removed: true });
     }
@@ -103,24 +192,15 @@ export async function runFixCommand(argv, io) {
         io.stderr('MESSENGER_MODE_HAS_NO_EXECUTOR: log in to Claude Code or Codex, then rerun npx mtech-ai-local-runner@latest setup before fix enable.');
         return 1;
     }
-    if (!await idle(io))
-        return 1;
-    const executable = await realpath(values.get('git') ?? await (io.findGit ?? defaultGit)());
-    const git = { executable, sha256: await measureCommandFile(executable) };
-    await assertPinnedGit(git);
-    const privateRoot = path.join(io.stateRoot, 'local-fix-publication');
-    if (!await exists(privateRoot))
-        await mkdir(privateRoot, { mode: 0o700 });
-    const s = await lstat(privateRoot);
-    if (!s.isDirectory() || s.isSymbolicLink() || (s.mode & 0o077) !== 0) {
-        io.stderr('FIX_HOST_PRIVATE_DIRECTORY_INSECURE: ' + privateRoot + ' must be a 0700 directory owned by this user.');
+    const applied = await applyFixConsent({ stateRoot: io.stateRoot, runnerId: local.runnerId, repositoryKeys: consent.repository_keys, verificationModes: consent.verification_modes, mode: 'replace', git: values.get('git'), findGit: io.findGit });
+    if (!applied.ok) {
+        if (applied.code === 'FIX_HOST_JOB_ACTIVE')
+            io.stderr(JOB_ACTIVE);
+        else if (applied.code === 'FIX_HOST_PRIVATE_DIRECTORY_INSECURE')
+            io.stderr('FIX_HOST_PRIVATE_DIRECTORY_INSECURE: ' + applied.privateRoot + ' must be a 0700 directory owned by this user.');
+        else
+            io.stderr('FIX_CONSENT_INVALID: give registered repository keys (lowercase, comma separated, no repeats) and modes gateway_publish_v1 or gateway_ci_v1.');
         return 1;
     }
-    const host = { schema: 'local-fix-host-installation-v3', enabled: true, runnerId: local.runnerId, git, consent };
-    if (await exists(file))
-        await backup(io, file);
-    const temporary = path.join(io.stateRoot, `.${HOST_FILE}.${randomUUID()}`);
-    await writeFile(temporary, JSON.stringify(host, null, 1), { mode: 0o600, flag: 'wx' });
-    await rename(temporary, file);
-    return restart(io, { ok: true, repository_keys: consent.repository_keys, verification_modes: consent.verification_modes });
+    return restart(io, { ok: true, repository_keys: applied.consent.repository_keys, verification_modes: applied.consent.verification_modes });
 }

package/dist/src/daemon/fix-consent.js

@@ -0,0 +1,98 @@
+import { applyFixConsent, fixHostBusy } from "../commands/fix.js";
+const covers = (report, grant) => !!report && report.repository_keys.includes(grant.repositoryKey) && report.verification_modes.includes(grant.verificationMode);
+export class FixConsentRuntime {
+    deps;
+    /** Grants deferred while busy. Each later sync's own list replaces them, so a grant the Gateway dropped is never applied from memory. */
+    deferred = [];
+    due = false;
+    stopping = false;
+    logged = new Set();
+    queue = Promise.resolve();
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /** True once a changed host waits for the restart; new claims are held until then. */
+    get restartDue() { return this.due; }
+    /** Applies the grants of one sync when idle. The restart waits for afterSync, so the rest of that sync (its session opens) is still handled. */
+    handleGrants(grants) {
+        return this.serial(async () => { this.deferred = grants.slice(0, 20); await this.apply(); });
+    }
+    /** After every sync: drops deferred grants the sync no longer lists, and restarts once a changed host is due and the runner is idle. */
+    afterSync(result) {
+        return this.serial(async () => {
+            if (!Array.isArray(result.fixConsentGrants) || result.fixConsentGrants.length === 0)
+                this.deferred = [];
+            await this.apply();
+            await this.restartWhenIdle();
+        });
+    }
+    serial(task) {
+        const next = this.queue.then(task, task);
+        this.queue = next.catch(() => undefined);
+        return next;
+    }
+    async busy() {
+        return this.deps.jobRunning() || await fixHostBusy(this.deps.stateRoot);
+    }
+    once(key, event) {
+        if (this.logged.has(key))
+            return;
+        this.logged.add(key);
+        this.deps.log(event);
+    }
+    async apply() {
+        if (this.stopping)
+            return;
+        const pending = this.deferred.filter(grant => !covers(this.deps.report(), grant));
+        if (pending.length > 0 && await this.busy()) {
+            this.deferred = pending;
+            for (const grant of pending)
+                this.once(`deferred:${grant.id}`, { event: "fix_consent_deferred", grant_id: grant.id, repository_key: grant.repositoryKey, reason: "job_active" });
+            return;
+        }
+        this.deferred = [];
+        const applied = [];
+        for (const grant of pending) {
+            let result;
+            try {
+                result = await applyFixConsent({ stateRoot: this.deps.stateRoot, runnerId: this.deps.runnerId,
+                    repositoryKeys: [grant.repositoryKey], verificationModes: [grant.verificationMode], mode: "extend" });
+            }
+            catch {
+                // Git could not be pinned or the file could not be written; the error text may name local paths, so only the code is logged.
+                result = { ok: false, code: "FIX_CONSENT_APPLY_FAILED" };
+            }
+            if (!result.ok && result.code === "FIX_HOST_JOB_ACTIVE") {
+                this.deferred.push(grant);
+                continue;
+            }
+            if (!result.ok) {
+                this.reject(grant, result.code);
+                continue;
+            }
+            if (result.changed) {
+                this.due = true;
+                applied.push(grant);
+                continue;
+            }
+            // Already on disk, yet the host loaded at start does not report it: a restart would load the same file again.
+            if (!this.due)
+                this.reject(grant, "FIX_HOST_NOT_LOADED");
+        }
+        if (applied.length > 0) {
+            this.deps.log({ event: "fix_consent_applied", grant_ids: applied.map(grant => grant.id),
+                repository_keys: [...new Set(applied.map(grant => grant.repositoryKey))], verification_modes: [...new Set(applied.map(grant => grant.verificationMode))] });
+        }
+    }
+    async restartWhenIdle() {
+        if (this.stopping || !this.due || await fixHostBusy(this.deps.stateRoot) || this.deps.jobRunning())
+            return;
+        // No await between the last check and the stop: the daemon stops its job runner first, so no claim starts after it.
+        this.stopping = true;
+        this.deps.log({ event: "runner_restarting", reason: "fix_consent" });
+        this.deps.restart();
+    }
+    reject(grant, code) {
+        this.once(`rejected:${grant.id}:${code}`, { event: "fix_consent_rejected", grant_id: grant.id, repository_key: grant.repositoryKey, code });
+    }
+}

package/dist/src/daemon/runtime.js

@@ -34,6 +34,7 @@ import { packagedHookCommandParts } from "../safety/hook-command.js";
 import { composeReviewedP1Host } from '../verification/p1-host-composition.js';
 import { AskRuntime, withAsks } from '../asks/runtime.js';
 import { GuideRuntime, withGuide } from '../guide/runtime.js';
+import { FixConsentRuntime } from './fix-consent.js';
 export async function buildDaemon(input) {
     const claudeParts = [input.claudeSecurityHost, input.claudeSupportedProbe, input.claudeBinaryIdentity].filter(Boolean).length;
     if (claudeParts !== 0 && claudeParts !== 3)
@@ -254,6 +255,12 @@ export async function buildDaemon(input) {
     });
     const stopping = new AbortController();
     const closureAcks = new PendingClosureAcks();
+    // Slack Fix consent (Work Item 6f9e64ae, decision baf0cd89): applied for this runner only while idle; a changed host
+    // restarts the daemon through its graceful stop, and launchd (KeepAlive) starts it again with the new host.
+    const fixConsent = new FixConsentRuntime({ stateRoot: input.stateRoot, runnerId: input.runnerId,
+        report: () => localFixHost?.report, jobRunning: () => poller.running,
+        restart: () => { daemon.stop(); },
+        log: event => { process.stderr.write(`${JSON.stringify(event)}\n`); } });
     const opener = new SessionOpener({ home: input.env.HOME ?? "" });
     const dispatch = createSyncDispatcher({
         open: request => opener.open(request),
@@ -263,9 +270,12 @@ export async function buildDaemon(input) {
         },
         guide,
         ...(claudeProduction ? { claude: claudeProduction } : {}),
+        fixConsent,
         asks,
         closureAcks,
-        jobs: poller,
+        // While a changed Fix host waits for its restart, the next runner claims the job instead.
+        jobs: { notify: () => { if (!fixConsent.restartDue)
+                poller.notify(); } },
         delay: abortableDelay,
         signal: stopping.signal,
         reportError: diagnostic => { process.stderr.write(`${JSON.stringify({ event: "session_open_poller_failed", ...diagnostic })}\n`); },
@@ -283,7 +293,12 @@ export async function buildDaemon(input) {
             }
         },
         authorize: (socketId, signal) => gateway.authorizeRunnerChannel(socketId, signal),
-        dispatch,
+        dispatch: async (result) => { try {
+            await dispatch(result);
+        }
+        finally {
+            await fixConsent.afterSync(result);
+        } },
         openSocket: (target, events) => new ReverbSocket(target, events, { packageVersion: packageVersion() }),
         report: event => { process.stderr.write(`${JSON.stringify(event)}\n`); },
     });

package/dist/src/gateway-client.js

@@ -17,6 +17,28 @@ export class GatewayToolError extends Error {
         this.code = code;
     }
 }
+const FIX_CONSENT_GRANT_ID = /^[a-zA-Z0-9-]{1,64}$/;
+const FIX_CONSENT_REPOSITORY_KEY = /^[a-z0-9][a-z0-9._-]{0,99}$/;
+const FIX_CONSENT_GRANTS_MAX = 20;
+/** Keeps the well-formed grants, at most 20; a malformed entry is dropped, never a reason to refuse the sync. */
+function parseFixConsentGrants(value) {
+    const grants = [];
+    for (const item of value) {
+        if (grants.length >= FIX_CONSENT_GRANTS_MAX)
+            break;
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            continue;
+        const { id, repository_key: repositoryKey, verification_mode: verificationMode } = item;
+        if (typeof id !== "string" || !FIX_CONSENT_GRANT_ID.test(id))
+            continue;
+        if (typeof repositoryKey !== "string" || !FIX_CONSENT_REPOSITORY_KEY.test(repositoryKey))
+            continue;
+        if (verificationMode !== "gateway_publish_v1" && verificationMode !== "gateway_ci_v1")
+            continue;
+        grants.push({ id, repositoryKey, verificationMode });
+    }
+    return grants;
+}
 const PUSH_CHANNEL = /^private-ai-gateway\.[a-z0-9_-]{1,32}\.runner\.[a-z0-9:_-]{1,128}$/;
 const PUSH_APP_KEY = /^[A-Za-z0-9_-]{1,128}$/;
 const CHANNEL_AUTH = /^[^:\s]{1,128}:[a-f0-9]{64}$/;
@@ -38,6 +60,7 @@ export function parseRunnerSync(result, runnerId) {
         ...(typeof body.guidance_policy_version === "string" ? { guidancePolicyVersion: body.guidance_policy_version } : {}),
         ...("claude_release" in body ? { claudeRelease: parseClaudeSyncRelease(body.claude_release) } : {}),
         ...(body.ask_alert === true ? { askAlert: true } : {}),
+        ...(Array.isArray(body.fix_consent_grants) ? { fixConsentGrants: parseFixConsentGrants(body.fix_consent_grants) } : {}),
         jobAvailable: body.job_available === true,
         push: parsePush(body.push, runnerId),
         syncSeconds: clampSeconds(body.sync_seconds, 15, 120, 30),

package/dist/src/transport/sync-dispatch.js

@@ -102,6 +102,15 @@ export function createSyncDispatcher(deps) {
                 fail("asks", "ASK_DISPATCH_FAILED", error);
             }
         }
+        // Before the job hint: applying a grant may restart an idle runner, which should win over a new claim.
+        if (deps.fixConsent && Array.isArray(result.fixConsentGrants) && result.fixConsentGrants.length > 0) {
+            try {
+                await deps.fixConsent.handleGrants(result.fixConsentGrants);
+            }
+            catch (error) {
+                fail("fix_consent", "FIX_CONSENT_DISPATCH_FAILED", error);
+            }
+        }
         if (result.jobAvailable)
             deps.jobs?.notify();
         for (const request of result.opens) {

package/package.json

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