@piagent/platform 1.48.4 → 1.48.5

package/packages/piagent-core/managed/runtime-snapshot.mjs

@@ -0,0 +1,63 @@
+// The code a company session's sandbox runs, kept apart from the install.
+//
+// A session pins the hash of its workers and refuses every tool when one
+// changes. piagent-update rewrites the install in place, so a task running
+// across an update lost all its tools (managed-runtime-changed) while a helper
+// started afterwards worked. A session now runs its workers from a private
+// copy named by their content: an update leaves it alone, the pins keep
+// guarding it, and the next process takes a copy of the new release.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createHash, randomUUID } from 'node:crypto';
+
+const KEEP_MS = 30 * 24 * 60 * 60 * 1000;
+const hash = file => createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+const cacheRoot = home => path.join(home, process.platform === 'darwin' ? 'Library/Caches/Piagent/runtime' : '.cache/piagent/runtime');
+
+function runtimeFiles(source) {
+  const files = fs.readdirSync(source, { withFileTypes: true }).filter(entry => entry.isFile() && entry.name.endsWith('.mjs')).map(entry => entry.name);
+  const walk = relative => {
+    let entries;
+    try { entries = fs.readdirSync(path.join(source, relative), { withFileTypes: true }); } catch { return; }
+    for (const entry of entries) {
+      const name = path.join(relative, entry.name);
+      if (entry.isDirectory()) walk(name); else if (entry.isFile()) files.push(name);
+    }
+  };
+  walk(path.join('dist', 'workspace'));
+  return files.sort();
+}
+
+const intact = (directory, listing) => listing.every(([file, digest]) => { try { return hash(path.join(directory, file)) === digest; } catch { return false; } });
+
+// The copy of `source` under the member's cache folder; an old one is removed
+// once no process has asked for it for a month.
+export function snapshotRuntime(source, { home = os.homedir(), now = Date.now() } = {}) {
+  const listing = runtimeFiles(source).map(file => [file, hash(path.join(source, file))]);
+  const id = createHash('sha256').update(JSON.stringify(listing)).digest('hex').slice(0, 32);
+  const root = cacheRoot(home), target = path.join(root, id);
+  fs.mkdirSync(root, { recursive: true, mode: 0o700 });
+  if (!intact(target, listing)) {
+    const building = path.join(root, `.${id}.${randomUUID()}`);
+    try {
+      for (const [file] of listing) {
+        fs.mkdirSync(path.dirname(path.join(building, file)), { recursive: true, mode: 0o700 });
+        fs.copyFileSync(path.join(source, file), path.join(building, file));
+        fs.chmodSync(path.join(building, file), 0o400);
+      }
+      // Without it the workspace worker's .js files would load as CommonJS.
+      fs.writeFileSync(path.join(building, 'package.json'), '{"type":"module"}\n', { mode: 0o400 });
+      fs.rmSync(target, { recursive: true, force: true });
+      // Another session may have built the same copy meanwhile.
+      try { fs.renameSync(building, target); } catch (error) { if (!intact(target, listing)) throw error; }
+    } finally { fs.rmSync(building, { recursive: true, force: true }); }
+  }
+  fs.utimesSync(target, new Date(now), new Date(now));
+  for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+    if (!entry.isDirectory() || entry.name === id) continue;
+    const old = path.join(root, entry.name);
+    try { if (now - fs.statSync(old).mtimeMs > KEEP_MS) fs.rmSync(old, { recursive: true, force: true }); } catch { /* another session removes it */ }
+  }
+  return fs.realpathSync(target);
+}

package/packages/piagent-core/managed/terminal-boundary.mjs

@@ -9,18 +9,19 @@ import { companyTerminalRuntime } from './terminal-runtime.mjs';
 import { terminalChannel } from './terminal-channel.mjs';
 import { SEATBELT_TERMINAL_RULES, seatbeltTerminal } from './terminal-seatbelt.mjs';
 
-const worker = fileURLToPath(new URL('./terminal-worker.mjs', import.meta.url));
+const installedWorker = fileURLToPath(new URL('./terminal-worker.mjs', import.meta.url));
 const hash = file => createHash('sha256').update(fs.readFileSync(file)).digest('hex');
 const inside = (file, root) => file === root || file.startsWith(root + path.sep);
 const dimensions = ({ cols, rows }) => Number.isInteger(cols) && cols >= 2 && cols <= 500 && Number.isInteger(rows) && rows >= 1 && rows <= 200;
 
 export class BoundaryTerminals {
-  #boundary; #runtime; #workerDigest; #entries = new Map(); #closed = false;
+  #boundary; #runtime; #worker; #workerDigest; #entries = new Map(); #closed = false;
   reasonCode = null;
   constructor(boundary) {
     this.#boundary = boundary;
     try {
       this.#runtime = companyTerminalRuntime();
+      const worker = this.#worker = boundary.runtimeFile?.('terminal-worker.mjs') ?? installedWorker; // the session's own copy (runtime-snapshot.mjs)
       if (inside(this.#runtime.root, boundary.cwd) || inside(worker, boundary.cwd)) throw Error('managed-terminal-runtime-overlap');
       this.#workerDigest = hash(worker);
     } catch (error) { this.reasonCode = /^managed-terminal-/.test(error.message) ? error.message : 'managed-terminal-runtime-invalid'; }
@@ -33,6 +34,7 @@ export class BoundaryTerminals {
     if (!dimensions(size)) throw Error('managed-terminal-invalid-size');
     if (this.#entries.size >= 4) throw Error('managed-terminal-limit');
     this.#runtime.assertCurrent();
+    const worker = this.#worker;
     if (hash(worker) !== this.#workerDigest) throw Error('managed-terminal-runtime-changed');
     for (const [file, digest] of boundary.pins) if (hash(file) !== digest) throw Error('managed-runtime-changed');
     const temporary = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'piagent-terminal-')));

package/packages/piagent-core/managed/tool-boundary.mjs

@@ -3,7 +3,7 @@ import { SessionMutationObservations } from "./session-mutation-observations.mjs
 import { BoundaryTerminals } from './terminal-boundary.mjs';
 import { ToolFreshness } from './tool-freshness.mjs';
 import { BoundaryQueue } from './boundary-queue.mjs';
-import { workspaceWorkerPins, verifyWorkspaceWorker } from './workspace-worker-pins.mjs';
+import { workspaceWorkerPins, verifyWorkspaceWorker } from './workspace-worker-pins.mjs'; import { snapshotRuntime } from './runtime-snapshot.mjs';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -202,7 +202,7 @@ export class ManagedToolBoundary {
   get sourceControlRevision() { return this.#sourceRequests.revision; }
   source(request, binding) { return this.invoke("workspace", this.#sourceRequests.request(request, binding)); }
   #mutationObservations = new SessionMutationObservations();
-  mutationObservation(file) { return this.#mutationObservations.get(file); }
+  mutationObservation(file) { return this.#mutationObservations.get(file); } runtimeFile(name) { return path.join(this.runtimeRoot, name); }
   #children = new Set();
   #closed = false;
   // readOnly: the project cannot be written. commands: bash is offered all
@@ -214,16 +214,16 @@ export class ManagedToolBoundary {
     if (process.platform !== 'darwin' && !(this.linux && BWRAP)) throw new Error('managed-sandbox-unavailable');
     this.cwd = fs.realpathSync(cwd); this.sdkRoot = fs.realpathSync(sdkRoot);
     this.node = fs.realpathSync(node);
-    this.runtimeRoot = fs.realpathSync(path.dirname(workerPath));
+    this.sourceRoot = fs.realpathSync(path.dirname(workerPath)); this.runtimeRoot = snapshotRuntime(this.sourceRoot, { home: home ?? os.homedir() }); this.workerPath = this.runtimeFile('tool-worker.mjs'); // an update leaves a running session's workers alone
     this.workspacePins = workspaceWorkerPins(this.runtimeRoot);
     this.sdkPath = path.join(this.sdkRoot, 'dist/index.js');
     this.git = managedGit();
     if (JSON.parse(fs.readFileSync(path.join(this.sdkRoot, 'package.json'), 'utf8')).version !== PI_HOST_VERSION) throw new Error('managed-sdk-version-unqualified');
     const workerModules = ['review-snapshot-worker.mjs', 'tool-freshness.mjs', 'search-fallback.mjs', 'sandbox-diagnostic.mjs', 'ts-diagnostics-server.mjs', 'workspace-worker-pins.mjs'].map(name => path.join(this.runtimeRoot, name));
-    this.pins = new Map([this.node, this.git, workerPath, ...workerModules, this.sdkPath].map(file => [file, hash(file)]));
+    this.pins = new Map([this.node, this.git, this.workerPath, ...workerModules, this.sdkPath].map(file => [file, hash(file)]));
     const userHome = fs.realpathSync(home ?? os.homedir());
-    if ([userHome, '/', this.sdkRoot, this.runtimeRoot].includes(this.cwd)
-      || [this.sdkRoot,this.runtimeRoot,this.node,this.git,...['/opt/homebrew/bin/gh','/usr/local/bin/gh'].filter(p=>fs.existsSync(p)).map(p=>fs.realpathSync(p))].some(p=>inside(p,this.cwd))) throw new Error('managed-project-overlaps-runtime');
+    if ([userHome, '/', this.sdkRoot, this.runtimeRoot, this.sourceRoot].includes(this.cwd)
+      || [this.sdkRoot,this.runtimeRoot,this.sourceRoot,this.node,this.git,...['/opt/homebrew/bin/gh','/usr/local/bin/gh'].filter(p=>fs.existsSync(p)).map(p=>fs.realpathSync(p))].some(p=>inside(p,this.cwd))) throw new Error('managed-project-overlaps-runtime');
     this.temporary = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), 'piagent-tools-')));
     fs.chmodSync(this.temporary, 0o700);
     this.home = path.join(this.temporary, 'home'); fs.mkdirSync(this.home, { mode: 0o700 });
@@ -371,7 +371,7 @@ export class ManagedToolBoundary {
       guard?.();
       const [sandbox, sandboxArgs] = this.linux ? [BWRAP, this.bubblewrap(network, docker)]
         : ['/usr/bin/sandbox-exec', ['-p', docker ? this.dockerProfile : network ? this.networkProfile : isolated ? this.isolatedProfile : this.profile]];
-      const child = spawn(sandbox, [...sandboxArgs, this.node, workerPath, this.sdkPath, this.cwd], {
+      const child = spawn(sandbox, [...sandboxArgs, this.node, this.workerPath, this.sdkPath, this.cwd], {
         cwd: this.cwd, detached: true, stdio: ['pipe', 'pipe', 'pipe'],
         env: docker ? this.environment.docker : network ? this.environment.network : this.environment.offline,
       });

package/packages/piagent-core/managed/ts-diagnostics.mjs

@@ -21,7 +21,7 @@ export class TsDiagnostics {
     if (this.#child) return this.#child;
     if (this.#starts >= RESTARTS) { this.#off = true; return null; }
     this.#starts += 1;
-    const { child } = await this.boundary.spawnSandboxed([this.boundary.node, SERVER, this.boundary.cwd], randomUUID(), { stdin: 'pipe' });
+    const { child } = await this.boundary.spawnSandboxed([this.boundary.node, this.boundary.runtimeFile?.('ts-diagnostics-server.mjs') ?? SERVER, this.boundary.cwd], randomUUID(), { stdin: 'pipe' });
     child.stdout.on('data', chunk => {
       this.#buffer += chunk.toString('utf8');
       for (let at; (at = this.#buffer.indexOf('\n')) >= 0;) {

package/packages/piagent-core/managed/workflow.mjs

@@ -273,6 +273,7 @@ export class RunProcess {
     this.unplannedChange = true; this.planSkipped = true;
   }
   async afterTool(name, args, ok, digestOf) {
+    if (['write', 'edit'].includes(name) && ok) this.edited = true;
     if (name === 'bash' && isCheckCommand(args?.command, this.checks.commands)) {
       this.checksRun += 1; if (!ok) this.checksFailed += 1;
       this.lastCheck = { ok, digest: await digestOf(), mutations: this.mutations };
@@ -334,7 +335,7 @@ export async function completionGate(managed, run, signal) {
   let digest = null, interrupted = false, verifyGaveUp = false;
   for (let step = 0; step < 16; step += 1) {
     digest = await digestOf();
-    run.changed = run.startDigest !== null && digest !== null ? digest !== run.startDigest : run.mutations > 0;
+    run.changed = run.startDigest !== null && digest !== null ? digest !== run.startDigest : run.startDigest !== null ? run.edited === true : run.mutations > 0; // code that cannot be read now: only a real edit says it changed
     // A check that passed still counts when the turn was cut off after it.
     if (run.changed) run.verified = run.verifiedOn(digest);
     run.docsOnly = run.changed && onlyNonCode(managed.ownPaths);

package/packages/piagent-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@piagent/core",
-  "version": "1.48.4",
+  "version": "1.48.5",
   "type": "module",
   "private": true,
   "license": "MIT",