premanmcp 1.1.7 → 1.1.9

package/bin/runner.js

@@ -738,7 +738,10 @@ export async function sendHeartbeat(args, state, { busy = false, log = () => {}
 async function serveEvalTarget(args, { log }) {
   let target;
   try {
-    target = await discoverTarget(args, { log: () => {} });
+    // Cache-only, and explicitly so rather than by accident of having no
+    // terminal: `preman runner` is sometimes started from one, and a daemon
+    // that stopped to ask a question mid-heartbeat would hang the device.
+    target = await discoverTarget(args, { log: () => {}, allowSearch: false });
   } catch (error) {
     log(`no agent to evaluate on this machine (${error.message}); eval runs will not be offered`);
     return null;
@@ -758,7 +761,21 @@ async function serveEvalTarget(args, { log }) {
     log(`offering ${target.label} for evals`);
     advertise({
       agent_eval_v1: true,
-      eval_target: { url: adapter.url, label: target.label, how: target.how },
+      eval_target: {
+        // A callable has no address to advertise; what makes it runnable is
+        // that a wrapper was approved here, which the digest names.
+        ...(target.kind === "callable"
+          ? {
+              callable: target.ref,
+              entry_file: target.entryFile,
+              entry_sha256: target.sha256,
+              language: target.language,
+              framework: target.framework,
+            }
+          : { url: adapter.url }),
+        label: target.label,
+        how: target.how,
+      },
     });
     return adapter;
   } catch (error) {
@@ -787,6 +804,13 @@ export async function runnerLoop(
     // daemon; only the interactive `preman eval run` has somebody in front of it
     // to hand a run over to.
     headless = true,
+    // Lets a caller cut a stream that is open but idle. `stopWhen` cannot do
+    // that on its own: it is read in the `while` condition and after a job, and
+    // an idle stream is inside neither -- the loop is parked in `for await` on
+    // the response body, which no predicate reaches. A caller that has learnt
+    // the run is over out of band aborts this, the read throws, and the loop
+    // comes back around to `stopWhen` and leaves.
+    signal = null,
   } = {}
 ) {
   let stopped = false;
@@ -812,8 +836,23 @@ export async function runnerLoop(
       try {
         response = await fetch(eventsUrl, {
           headers: { Authorization: `Bearer ${state.runner_token}`, Accept: "text/event-stream" },
+          ...(signal ? { signal } : {}),
         });
       } catch (error) {
+        // An abort is this loop being told to stop, not a network problem.
+        // Reporting it as one would put "stream failed" in front of somebody
+        // who is about to be told the real reason the run ended.
+        //
+        // `stopped` and not just `continue`: without it this depends on the
+        // caller's `stopWhen` already answering true, and a caller that passes
+        // a signal without one gets a hot loop -- the fetch throws at once, the
+        // backoff sleep below is skipped, and the `while` condition is still
+        // true. Aborting is a decision to stop, so record it here and let the
+        // two options be correct apart as well as together.
+        if (signal?.aborted) {
+          stopped = true;
+          continue;
+        }
         log(`stream failed: ${error.message}; retrying in ${Math.round(backoff / 1000)}s`);
         await sleep(backoff);
         backoff = Math.min(backoff * 2, RECONNECT_MAX_MS);
@@ -894,7 +933,7 @@ export async function runnerLoop(
           if (terminal) break;
         }
       } catch (error) {
-        log(`stream dropped: ${error.message}`);
+        if (!signal?.aborted) log(`stream dropped: ${error.message}`);
       }
 
       if (terminal === "revoked") {

package/bin/shared.js

@@ -506,7 +506,7 @@ export async function callBackendJson(
   args,
   method,
   routePath,
-  { json, form, token, query, headers: extraHeaders } = {}
+  { json, form, token, query, headers: extraHeaders, signal } = {}
 ) {
   const url = new URL(routePath.replace(/^\/+/, ""), `${backendUrl(args)}/`);
   if (query) {
@@ -533,6 +533,7 @@ export async function callBackendJson(
       method,
       headers,
       body: form !== undefined && form !== null ? form : hasBody ? JSON.stringify(json) : undefined,
+      signal,
     });
   } catch (error) {
     // `fetch failed` is what Node says when nothing accepted the connection,

package/bin/target.js

@@ -68,6 +68,27 @@ export function findConfigRoot(from = process.cwd()) {
   }
 }
 
+/**
+ * The repository `from` sits in, by its VCS marker.
+ *
+ * `findConfigRoot` answers a different question and answers it correctly: it
+ * stops at `.git` and returns null, because a `.preman.json` *above* the
+ * repository belongs to a different project. But a first run has no
+ * `.preman.json` to find, so a caller that falls back to `from` treats whatever
+ * directory somebody happened to be standing in as the project root -- and a
+ * customer who `cd`s into `services/bot` before pasting a command gets "does not
+ * exist" for a path that plainly does.
+ */
+export function findRepoRoot(from = process.cwd()) {
+  let dir = path.resolve(from);
+  for (;;) {
+    if (existsSync(path.join(dir, ".git"))) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
 export function readConfig(root = process.cwd()) {
   try {
     const parsed = JSON.parse(readFileSync(configPath(root), "utf8"));
@@ -104,6 +125,58 @@ export function savedAgent(root = process.cwd()) {
   };
 }
 
+/**
+ * Record the code entry point somebody approved, beside the HTTP one.
+ *
+ * A sibling of `agent` rather than a replacement for it: a repository can
+ * legitimately have both, and which one an eval uses is a precedence question
+ * answered at discovery time, not a reason to discard the other.
+ */
+export function saveEntry(entry, root = process.cwd()) {
+  const config = readConfig(root);
+  const next = { ...config, entry };
+  writeFileSync(configPath(root), `${JSON.stringify(next, null, 2)}\n`, "utf8");
+  return next;
+}
+
+/**
+ * The approved shim, or null.
+ *
+ * `sha256` is returned unvalidated -- proving it still matches means reading
+ * the file, which is the caller's job because the caller is the one that knows
+ * whether a mismatch should prompt or refuse. What is enforced here is only
+ * that the record is complete enough to act on.
+ */
+export function savedEntry(root = process.cwd()) {
+  const configRoot = findConfigRoot(root) || root;
+  const entry = readConfig(configRoot).entry;
+  if (!entry || typeof entry !== "object") return null;
+  const file = String(entry.file || "").trim();
+  const ref = String(entry.ref || "").trim();
+  if (!file || !ref) return null;
+  return {
+    root: configRoot,
+    file,
+    ref,
+    sysPath: String(entry.sysPath || ""),
+    sha256: String(entry.sha256 || ""),
+    // Additional approved files, each with its own digest. Absent on a record
+    // written before two-file targets existed, which is why the caller treats
+    // an empty list as "only the wrapper" rather than as "nothing to check".
+    files: (Array.isArray(entry.files) ? entry.files : [])
+      .map((item) => ({
+        path: String(item?.path || ""),
+        sha256: String(item?.sha256 || ""),
+      }))
+      .filter((item) => item.path && item.sha256),
+    shape: String(entry.shape || ""),
+    language: String(entry.language || "python"),
+    framework: String(entry.framework || ""),
+    entryFile: String(entry.entryFile || ""),
+    approvedAt: String(entry.approvedAt || ""),
+  };
+}
+
 /**
  * Where this project's agent might be listening.
  *
@@ -271,18 +344,47 @@ export async function startProject(command, { root = process.cwd(), waitMs = 60_
     }
   };
 
+  /**
+   * Is anything in the group still running?
+   *
+   * `exited` cannot answer this, and trusting it was the bug. `shell: true`
+   * means the command runs under `/bin/sh -c`, which does not always exec, so
+   * the wrapper and the server it launched are two processes. The wrapper traps
+   * nothing, dies on the first SIGTERM and sets `exited` -- measured at 102ms --
+   * while the server that *does* trap SIGTERM keeps running. The escalation
+   * below was then skipped, and a dev server survived `stop()` still holding its
+   * port, which is exactly what the caller asked to have stopped.
+   *
+   * Signal 0 asks the kernel about the group without touching it. Negative pid
+   * for the group, matching `signal` above.
+   */
+  const groupAlive = () => {
+    try {
+      process.kill(-child.pid, 0);
+      return true;
+    } catch (error) {
+      // Somebody else's now, which is not this function's business, but it is
+      // certainly not gone.
+      return error?.code === "EPERM";
+    }
+  };
+
   const stop = async () => {
-    if (exited !== null) return;
+    if (!groupAlive()) return;
     signal("SIGTERM");
     // Then SIGKILL, and the pipes closed behind it. A dev server that ignores
     // SIGTERM keeps this process alive forever otherwise: its stdout is still
     // open here, so Node has a reason to stay, and `preman target detect`
     // simply never returns.
+    //
+    // The grace is not spent on a well-behaved server: its whole group is gone
+    // about as fast as the wrapper is, measured at 101ms, so this loop leaves on
+    // the first pass.
     const deadline = Date.now() + STOP_GRACE_MS;
-    while (exited === null && Date.now() < deadline) {
+    while (groupAlive() && Date.now() < deadline) {
       await new Promise((resume) => setTimeout(resume, 100));
     }
-    if (exited === null) {
+    if (groupAlive()) {
       log(`${command.split(" ")[0]} did not stop when asked; killing it`);
       signal("SIGKILL");
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "premanmcp",
-  "version": "1.1.7",
+  "version": "1.1.9",
   "description": "PreMan CLI and stdio proxy for PreMan's hosted MCP server",
   "type": "module",
   "bin": {
@@ -16,7 +16,7 @@
     "test:proxy": "node --test scripts/smoke-proxy.mjs",
     "test:connect": "node scripts/smoke-connect.mjs",
     "test:connect-heartbeat": "node scripts/smoke-connect-heartbeat.mjs",
-    "test:node": "node --test --test-timeout=90000 scripts/smoke-account.mjs scripts/smoke-agent-session.mjs scripts/smoke-agent-dock.mjs scripts/smoke-terminal-lifecycle.mjs scripts/smoke-cli-entrypoint.mjs scripts/smoke-cli-update.mjs scripts/smoke-launcher-config.mjs scripts/smoke-runner.mjs scripts/smoke-eval.mjs scripts/smoke-eval-behaviors.mjs scripts/smoke-repo-config.mjs scripts/smoke-onboard.mjs scripts/smoke-onboard-opening.mjs scripts/smoke-local-detect.mjs scripts/smoke-agent-target.mjs scripts/smoke-prepush-hook.mjs scripts/smoke-cli-identity.mjs scripts/smoke-runner-heartbeat.mjs scripts/smoke-verify-prepush.mjs scripts/smoke-push-diff.mjs scripts/smoke-progress-reporter.mjs scripts/smoke-verify-plan.mjs scripts/smoke-install-desktop.mjs scripts/smoke-desktop-session.mjs scripts/smoke-api-tools.mjs scripts/smoke-tests-workbench.mjs scripts/smoke-bin-scope.mjs scripts/smoke-shared-errors.mjs scripts/smoke-process-title.mjs scripts/smoke-predict.mjs",
+    "test:node": "node --test --test-timeout=90000 scripts/smoke-account.mjs scripts/smoke-agent-session.mjs scripts/smoke-agent-dock.mjs scripts/smoke-terminal-lifecycle.mjs scripts/smoke-cli-entrypoint.mjs scripts/smoke-cli-update.mjs scripts/smoke-launcher-config.mjs scripts/smoke-runner.mjs scripts/smoke-eval.mjs scripts/smoke-eval-run-watch.mjs scripts/smoke-eval-behaviors.mjs scripts/smoke-eval-runtime.mjs scripts/smoke-eval-entry.mjs scripts/smoke-eval-entry-placeholder.mjs scripts/smoke-eval-discover.mjs scripts/smoke-eval-templates.mjs scripts/smoke-eval-approval-record.mjs scripts/smoke-repo-config.mjs scripts/smoke-onboard.mjs scripts/smoke-onboard-opening.mjs scripts/smoke-local-detect.mjs scripts/smoke-agent-target.mjs scripts/smoke-prepush-hook.mjs scripts/smoke-cli-identity.mjs scripts/smoke-runner-heartbeat.mjs scripts/smoke-verify-prepush.mjs scripts/smoke-push-diff.mjs scripts/smoke-progress-reporter.mjs scripts/smoke-verify-plan.mjs scripts/smoke-install-desktop.mjs scripts/smoke-desktop-session.mjs scripts/smoke-api-tools.mjs scripts/smoke-tests-workbench.mjs scripts/smoke-bin-scope.mjs scripts/smoke-shared-errors.mjs scripts/smoke-process-title.mjs scripts/smoke-predict.mjs",
     "test:dmg": "node --test --test-timeout=300000 scripts/smoke-install-desktop-volume.mjs"
   },
   "devDependencies": {