@myvillage/cli 1.87.0 → 1.88.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myvillage/cli",
-  "version": "1.87.0",
+  "version": "1.88.1",
   "description": "MyVillageOS CLI for community developers",
   "type": "module",
   "bin": {

package/src/agent-runtime/runner.js

@@ -8,10 +8,15 @@
  * acquires the lease, and stops+releases anything it holds that is no longer
  * assigned-and-running here.
  *
- * Auth model: the runner authenticates to the control plane with a
- * `machine:runner` API key (MYVILLAGE_MACHINE_KEY) sent as `x-api-key`. Spawned
- * agent daemons still use the owner's OAuth token (from ~/.myvillage/
- * credentials.json), which must be provisioned on the machine once.
+ * Auth model: the runner authenticates as a machine with a `machine:runner` API
+ * key sent as `x-api-key`. That key is normally provisioned automatically — on
+ * first start the runner registers using the signed-in user's OAuth token and
+ * the control plane mints + returns a machine-scoped credential, which is saved
+ * to ~/.myvillage/runner.json (0600) and reused thereafter. So a machine that
+ * has run `myvillage login` (or Studio) never needs a hand-made key; supplying
+ * MYVILLAGE_MACHINE_KEY / --key stays supported for unattended provisioning.
+ * Spawned agent daemons still use the owner's OAuth token from
+ * ~/.myvillage/credentials.json.
  */
 import os from 'os';
 import fs from 'fs';
@@ -45,7 +50,9 @@ function collectMetadata() {
 function persistRunnerState(state) {
   try {
     fs.mkdirSync(path.dirname(RUNNER_STATE_FILE), { recursive: true });
-    fs.writeFileSync(RUNNER_STATE_FILE, JSON.stringify(state, null, 2));
+    // 0600: the file holds this machine's credential.
+    fs.writeFileSync(RUNNER_STATE_FILE, JSON.stringify(state, null, 2), { mode: 0o600 });
+    try { fs.chmodSync(RUNNER_STATE_FILE, 0o600); } catch { /* best-effort */ }
   } catch { /* best-effort */ }
 }
 
@@ -64,18 +71,36 @@ function makeClient(machineKey, machineId) {
   return async function cp(pathname, { method = 'GET', body } = {}) {
     const headers = { 'Content-Type': 'application/json', 'x-api-key': machineKey };
     if (machineId) headers['X-Machine-Id'] = machineId;
-    const res = await fetch(`${networkBaseUrl}${pathname}`, {
-      method,
-      headers,
-      body: body ? JSON.stringify(body) : undefined,
-    });
-    const text = await res.text();
-    let json;
-    try { json = text ? JSON.parse(text) : {}; } catch { json = { raw: text }; }
-    return { status: res.status, ok: res.ok, json };
+    return request(networkBaseUrl, pathname, method, body, headers);
+  };
+}
+
+/**
+ * One-shot client authenticated as the signed-in *user* (OAuth bearer). Used
+ * only to register a machine and receive its minted credential.
+ */
+function makeUserClient() {
+  const { networkBaseUrl } = getConfig();
+  const token = getAccessToken();
+  if (!token) return null;
+  return async function cp(pathname, { method = 'GET', body } = {}) {
+    const headers = { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` };
+    return request(networkBaseUrl, pathname, method, body, headers);
   };
 }
 
+async function request(networkBaseUrl, pathname, method, body, headers) {
+  const res = await fetch(`${networkBaseUrl}${pathname}`, {
+    method,
+    headers,
+    body: body ? JSON.stringify(body) : undefined,
+  });
+  const text = await res.text();
+  let json;
+  try { json = text ? JSON.parse(text) : {}; } catch { json = { raw: text }; }
+  return { status: res.status, ok: res.ok, json };
+}
+
 // ── Local agent indexing ─────────────────────────────────────────────────────
 
 // Map control-plane agentProfileId -> local agent { name, config } via the
@@ -118,7 +143,57 @@ async function register(cp, opts) {
   };
   const { ok, status, json } = await cp('/machines', { method: 'POST', body });
   if (!ok) throw new Error(`register failed (${status}): ${JSON.stringify(json)}`);
-  return json.data.id;
+  // machineKey is present only on the user-auth path (minted once, server-side).
+  return { machineId: json.data.id, machineKey: json.data.machineKey ?? null };
+}
+
+/**
+ * Resolve this machine's credential without asking a human for one:
+ *   1. an explicit --key / MYVILLAGE_MACHINE_KEY (unattended provisioning)
+ *   2. the credential saved on a previous start (~/.myvillage/runner.json)
+ *   3. otherwise register as the signed-in user; the control plane mints one
+ *
+ * Returns { machineId, machineKey }.
+ */
+async function resolveMachineIdentity(opts) {
+  const explicitKey = opts.machineKey || process.env.MYVILLAGE_MACHINE_KEY || null;
+  const saved = readRunnerState();
+
+  if (explicitKey) {
+    const { machineId } = await register(makeClient(explicitKey, null), opts);
+    persistRunnerState({
+      machineId,
+      machineKey: explicitKey,
+      name: opts.name || os.hostname(),
+      registeredAt: new Date().toISOString(),
+    });
+    return { machineId, machineKey: explicitKey };
+  }
+
+  if (saved?.machineKey) {
+    // Re-register with the stored credential so name/metadata/version refresh.
+    const { machineId } = await register(makeClient(saved.machineKey, null), opts);
+    persistRunnerState({ ...saved, machineId, name: opts.name || saved.name, registeredAt: new Date().toISOString() });
+    return { machineId, machineKey: saved.machineKey };
+  }
+
+  const userClient = makeUserClient();
+  if (!userClient) {
+    throw new Error(
+      'Not signed in. Run `myvillage login` on this machine (or pass --key with a machine:runner API key).',
+    );
+  }
+  const { machineId, machineKey } = await register(userClient, opts);
+  if (!machineKey) {
+    throw new Error('The control plane did not return a machine credential. Update the backend and retry.');
+  }
+  persistRunnerState({
+    machineId,
+    machineKey,
+    name: opts.name || os.hostname(),
+    registeredAt: new Date().toISOString(),
+  });
+  return { machineId, machineKey };
 }
 
 async function reconcileOnce(ctx) {
@@ -176,6 +251,21 @@ async function reconcileOnce(ctx) {
       continue;
     }
     const epoch = lease.json.data.leaseEpoch;
+
+    // Never fork a second daemon on top of a live one. An agent started outside
+    // the fleet (Studio's local Start, or a previous CLI `agent start`) has no
+    // lease, so it reaches here with a fresh lease and an already-running
+    // process; forking again would double-run it and orphan the first daemon
+    // (the pid file is last-writer-wins). Adopt it instead.
+    if (isDaemonRunning(entry.name)) {
+      ctx.leases.set(a.agentProfileId, { name: entry.name, epoch });
+      log(
+        `adopted already-running ${entry.name} under lease (epoch ${epoch}) — started outside the fleet, so it ` +
+          `reports no fence; stop/start it from Studio to relaunch it fenced`,
+      );
+      continue;
+    }
+
     const pid = startAgent(entry.name, entry.config, ctx.machineId, epoch);
     ctx.leases.set(a.agentProfileId, { name: entry.name, epoch });
     log(`started ${entry.name} (pid ${pid}, epoch ${epoch})`);
@@ -199,17 +289,20 @@ function sleep(ms, signal) {
 }
 
 export async function runRunner(opts = {}) {
-  const machineKey = opts.machineKey || process.env.MYVILLAGE_MACHINE_KEY;
-  if (!machineKey) {
-    throw new Error('MYVILLAGE_MACHINE_KEY is required (a machine:runner API key). Set the env var or pass --key.');
-  }
-
-  const cpForRegister = makeClient(machineKey, null);
   log(`registering machine "${opts.name || os.hostname()}" (${process.platform}/${process.arch})…`);
-  const machineId = await register(cpForRegister, opts);
-  persistRunnerState({ machineId, name: opts.name || os.hostname(), registeredAt: new Date().toISOString() });
+  const { machineId, machineKey } = await resolveMachineIdentity(opts);
   log(`registered as machine ${machineId}`);
 
+  // Record our pid so Studio (or `runner status`) can tell whether this
+  // machine's runner is alive, and stop it. Cleared on exit.
+  const markRunning = (pid) => {
+    const s = readRunnerState() || {};
+    persistRunnerState({ ...s, pid, startedAt: pid ? new Date().toISOString() : undefined });
+  };
+  markRunning(process.pid);
+  const clearPid = () => { try { markRunning(null); } catch { /* best-effort */ } };
+  process.on('exit', clearPid);
+
   const ctx = {
     cp: makeClient(machineKey, machineId),
     machineId,