@awak-app/simy-cli 0.7.11 → 0.7.12

package/src/update-detachment/worker-ledger.js

@@ -0,0 +1,138 @@
+import { normalizeDispatchIdentity } from './provenance.js';
+import { realpathSync } from 'node:fs';
+import { ownedProcessIdentity } from './worker-storage.js';
+import { recordWorkerEvidence } from './worker-ledger-runtime.js';
+import * as ledgerStore from './state-store.js';
+import * as ledgerGate from './dispatch-gate.js';
+import path from 'node:path';
+import { readFile, readdir, realpath } from 'node:fs/promises';
+import { createStateStore, digest, atomicSave, readState, withLock } from './state-store.js';
+import { captureDispatchOwner, dispatchWithFence, readDispatchGate, confirmDispatch, detachmentRoot } from './dispatch-gate.js';
+import { createExecutionWorker } from './worker.js';
+
+// Identical canonical fields/order are used by scopes, root dispatch and IPC.
+export function workerScopeIdentity(value) {
+  return normalizeDispatchIdentity(value);
+}
+export function createLedgerExecutionWorker({ identity, worker } = {}) {
+  identity = workerScopeIdentity(identity);
+  const store = createStateStore(identity);
+  const storageRoot = path.join(identity.root, 'execution-workers');
+  worker ||= createExecutionWorker({ root: storageRoot });
+  const dispatchOwner = captureDispatchOwner(identity.root);
+  const binding = handle => {
+    if (digest(workerScopeIdentity(handle.identity)) !== digest(identity)) throw new Error('Worker scope mismatch');
+    const gate = readDispatchGate(identity.root);
+    const attempt = gate.attempts[digest(handle.attemptId)];
+    if (!attempt || attempt.identityHash !== digest(identity) || attempt.taskHash !== digest(handle.taskId) || attempt.generation !== handle.generation) throw new Error('Worker attempt/generation mismatch');
+    const expectedRef = path.join(storageRoot, 'attempts', handle.attemptId, 'snapshot.json');
+    if (handle.recordRef !== expectedRef || store.read().tasks[digest(handle.taskId)]?.recordRef !== expectedRef) throw new Error('Worker registered snapshot mismatch');
+    const snapshot = readState(expectedRef);
+    if (!snapshot || snapshot.task.id !== handle.taskId || snapshot.attemptId !== handle.attemptId || snapshot.generation !== handle.generation || digest(snapshot.identity) !== digest(identity)) throw new Error('Worker preservation snapshot mismatch');
+    return attempt;
+  };
+  return {
+    identity, root: identity.root, scope: store,
+    canHandoff: worker.canHandoff,
+    async start(spec) {
+      if (realpathSync(spec.cwd) !== identity.worktree) throw new Error('Worker execution binding mismatch');
+      const taskId = spec.taskId || spec.attemptId;
+      const attemptId = spec.attemptId;
+      if (!spec.preservation || !['model', 'permissions', 'approvals', 'budget', 'deadline'].every(key => Object.hasOwn(spec.preservation.policy || {}, key))) throw new Error('Original preservation policy required');
+      if (spec.preservation.policy.deadline !== spec.deadlineAt || spec.backend !== identity.provider) throw new Error('Worker preservation binding mismatch');
+      const recordRef = path.join(storageRoot, 'attempts', attemptId, 'snapshot.json');
+      const generation = dispatchOwner.generation;
+      const ledger = { identity, identityHash: store.identityHash, taskId, attemptId, generation, recordRef };
+      const handle = { attemptId, taskId, identity, generation, recordRef };
+      try { await worker.start({ ...spec, cwd: identity.worktree, identity, ledger,
+        beforeDispatch: () => {
+          // Immutable authority copy is recorded before fenced transport initiation.
+          atomicSave(recordRef, { schemaVersion: 1, revision: 1, identity, generation, attemptId,
+            task: { id: taskId, state: spec.preservation.taskState || 'active', stopRequested: false },
+            metadata: structuredClone(spec.preservation.metadata || null),
+            policy: structuredClone(spec.preservation.policy), artifacts: structuredClone(spec.preservation.artifacts || []) });
+          store.registerTask({ taskId, recordRef, identity });
+        },
+        dispatch: send => dispatchWithFence(dispatchOwner, { taskId, attemptId, identity }, send),
+      }); } catch (error) { error.workerHandle = handle; throw error; }
+      return handle;
+    },
+    async adopt(handle) {
+      binding(handle);
+      const state = await worker.adopt(handle);
+      const directory = path.dirname(handle.recordRef);
+      if (state.owner && (state.owner.generation !== handle.generation || state.owner.identityHash !== store.identityHash)) throw new Error('Worker owner scope/generation mismatch');
+      if (state.state === 'completed') {
+        if (state.receipt.generation !== handle.generation || state.receipt.identityHash !== store.identityHash) throw new Error('Worker result scope/generation mismatch');
+        // Worker intake is ordered after result commit; an interrupted intake can be retried read-only.
+        // Late result intake can be repaired from the bound durable receipt,
+        // including after worker/old host exit. It never dispatches another turn.
+        try {
+          recordWorkerEvidence({ ledger: { ...handle, identityHash: store.identityHash }, directory, runtime: state.receipt.runtime }, 'result', state.receipt, { ...ledgerStore, ...ledgerGate });
+        } catch (error) {
+          if (error.code === 'state_busy' || error.code === 'revision_conflict') return { state: 'reconciling', reason: 'result_intake_busy' };
+          throw error;
+        }
+      }
+      return state;
+    },
+    async result(handle) { return this.adopt(handle); },
+    async stop(handle) {
+      binding(handle);
+      // Persist stop intent before signalling; both result intake and stop use
+      // the same snapshot lock so neither can discard the other's references.
+      withLock(handle.recordRef, () => {
+        const snapshot = readState(handle.recordRef);
+        if (!snapshot.task.stopRequested) {
+          snapshot.task.stopRequested = true; snapshot.task.state = 'stopped'; snapshot.revision++;
+          atomicSave(handle.recordRef, snapshot);
+        }
+      });
+      const acknowledgement = await worker.stop(handle);
+      return acknowledgement;
+    },
+    async handoff(handle) {
+      const state = await this.adopt(handle);
+      if (state.state === 'completed') return { verified: true, pendingWrites: 0, unsettledPermissions: 0, state, preservation: this.readSnapshot(handle), identityHash: store.identityHash, generation: handle.generation };
+      if (!state.owner || state.storageError || state.state !== 'running' && state.state !== 'stopping') return { verified: false, state };
+      const ack = JSON.parse(await readFile(path.join(path.dirname(handle.recordRef), 'handoff.json'), 'utf8'));
+      const snapshot = readState(handle.recordRef);
+      if (!ack.providerProcessIdentity || await ownedProcessIdentity(ack.providerPid) !== ack.providerProcessIdentity) return { verified: false, reason: 'owned_provider_process_unconfirmed', state };
+      if (ack.generation !== handle.generation || ack.identityHash !== store.identityHash || ack.pid !== state.owner.pid || digest(snapshot.identity) !== digest(identity)) throw new Error('Handoff proof mismatch');
+      return { verified: true, pendingWrites: 0, unsettledPermissions: 0, state, acknowledgement: ack, preservation: snapshot, identityHash: store.identityHash, generation: handle.generation };
+    },
+    async collect(handle) {
+      const state = await this.adopt(handle);
+      if (state.state === 'completed') confirmDispatch({ root: identity.root, attemptId: handle.attemptId });
+      return state;
+    },
+    readSnapshot(handle) { binding(handle); return readState(handle.recordRef); },
+  };
+}
+
+export const workerStorageRoot = (root = detachmentRoot()) => path.join(path.resolve(root), 'execution-workers');
+
+// Enumerate only this authenticated SIMY actor's registered worker records.
+// Returning an empty list is allowed only for an absent store, never corruption.
+export async function discoverLedgerWorkers({ root = detachmentRoot(), account, device, origin }) {
+  if (![account, device, origin].every(value => typeof value === 'string' && value)) throw new Error('Authenticated worker actor required');
+  root = realpathSync(root); origin = new URL(origin).origin;
+  const scopes = path.join(root, 'update-detachment/scopes');
+  let names;
+  try { names = await readdir(scopes); } catch (error) { if (error.code === 'ENOENT') return []; throw error; }
+  const handles = [];
+  for (const name of names.filter(name => /^[a-f0-9]{64}\.json$/.test(name))) {
+    const scope = readState(path.join(scopes, name));
+    for (const { recordRef } of Object.values(scope.tasks)) {
+      const relative = path.relative(workerStorageRoot(root), path.resolve(recordRef));
+      if (relative.startsWith('..') || path.isAbsolute(relative) || path.basename(recordRef) !== 'snapshot.json') continue;
+      const snapshot = readState(recordRef);
+      const identity = workerScopeIdentity(snapshot.identity);
+      if (identity.root !== root || identity.account !== account || identity.device !== device || identity.origin !== origin) continue;
+      const store = createStateStore(identity);
+      if (store.identityHash !== scope.identityHash) throw new Error('Registered worker scope mismatch');
+      handles.push({ identity, attemptId: snapshot.attemptId, taskId: snapshot.task.id, generation: snapshot.generation, recordRef });
+    }
+  }
+  return handles;
+}

package/src/update-detachment/worker-storage.js

@@ -0,0 +1,29 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { open, rename, lstat, mkdir } from 'node:fs/promises';
+import path from 'node:path';
+
+export async function privateDirectory(directory, { create = true } = {}) {
+  if (create) await mkdir(directory, { recursive: true, mode: 0o700 });
+  const info = await lstat(directory);
+  if (!info.isDirectory() || info.isSymbolicLink() || (info.mode & 0o077) || info.uid !== process.getuid()) {
+    throw new Error('Worker storage must be a private owned directory.');
+  }
+}
+
+export async function durableJson(directory, name, value) {
+  const temporary = path.join(directory, `${name}.tmp`);
+  const file = await open(temporary, 'w', 0o600);
+  try { await file.writeFile(JSON.stringify(value)); await file.sync(); } finally { await file.close(); }
+  await rename(temporary, path.join(directory, name));
+  const parent = await open(directory, 'r');
+  try { await parent.sync(); } finally { await parent.close(); }
+}
+
+export async function ownedProcessIdentity(pid) {
+  if (!Number.isSafeInteger(pid) || pid < 2) return null;
+  try {
+    const { stdout } = await promisify(execFile)('/bin/ps', ['-p', String(pid), '-o', 'lstart=,pgid='], { timeout: 2000, maxBuffer: 2048 });
+    return stdout.trim() || null;
+  } catch { return null; }
+}

package/src/update-detachment/worker.js

@@ -0,0 +1,167 @@
+import { fork } from 'node:child_process';
+import { createHash, randomUUID } from 'node:crypto';
+import { connect } from 'node:net';
+import { readFile, mkdir, writeFile, rm, readdir, lstat, realpath } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { privateDirectory, durableJson, ownedProcessIdentity } from './worker-storage.js';
+
+const source = path.dirname(fileURLToPath(import.meta.url));
+const identityKeys = ['provider', 'session', 'account', 'origin', 'worktree'];
+export function canHandoff({ runner, platform = process.platform } = {}) {
+  const supported = runner === 'direct' && platform !== 'win32';
+  return { supported, action: supported ? 'adopt_worker' : 'wait_for_safe_boundary', reason: supported ? null : 'executor_owner_not_transferable' };
+}
+function identityOf(identity) {
+  if (!identity || identityKeys.some((key) => typeof identity[key] !== 'string' || !identity[key])) throw new Error('Complete worker binding required.');
+  return Object.fromEntries([...identityKeys, ...["device", "root"].filter(key => Object.hasOwn(identity, key))].map((key) => [key, identity[key]]));
+}
+function attemptDirectory(root, attemptId) {
+  if (!/^[a-zA-Z0-9_-]{1,100}$/.test(attemptId)) throw new Error('Invalid worker attempt ID.');
+  return path.join(root, 'attempts', attemptId);
+}
+async function json(directory, name) {
+  try { return JSON.parse(await readFile(path.join(directory, name), 'utf8')); }
+  catch (error) { if (error.code === 'ENOENT') return null; throw error; }
+}
+async function request(owner, operation) {
+  return new Promise((resolve, reject) => {
+    const socket = connect(owner.socket);
+    let data = '';
+    socket.setTimeout(2000, () => socket.destroy(new Error('Worker IPC timed out.')));
+    socket.on('error', reject);
+    socket.on('connect', () => socket.write(JSON.stringify({ attemptId: owner.attemptId, identity: owner.identity, operation }) + '\n'));
+    socket.on('data', (chunk) => { data += chunk; if (Buffer.byteLength(data) > 1024 * 1024) socket.destroy(new Error('Invalid owner response.')); });
+    socket.on('end', () => {
+      try {
+        const response = JSON.parse(data);
+        if (response.attemptId !== owner.attemptId || response.pid !== owner.pid || response.runtime !== owner.runtime || response.ownerToken !== owner.ownerToken || response.processIdentity !== owner.processIdentity || JSON.stringify(response.identity) !== JSON.stringify(owner.identity) || !response.acknowledged) throw new Error('Worker owner identity mismatch.');
+        resolve(response);
+      } catch (error) { reject(error); }
+    });
+  });
+}
+async function runtimeMutation(root, operation) {
+  const lock = path.join(root, 'runtime-mutation');
+  for (let i = 0; ; i++) {
+    try { await mkdir(lock, { mode: 0o700 }); break; }
+    catch (error) {
+      if (error.code !== 'EEXIST' || i >= 100) throw error;
+      await new Promise((resolve) => setTimeout(resolve, 20));
+    }
+  }
+  // A crash leaves the lock in place: never steal a potentially live writer's lease.
+  try { return await operation(); } finally { await rm(lock, { recursive: true }); }
+}
+export function createExecutionWorker({ root = path.join(homedir(), '.simy', 'execution-workers') } = {}) {
+  root = path.resolve(root);
+  return {
+    canHandoff,
+    async start({ attemptId = randomUUID(), identity, command, cwd, backend, deadlineAt, ledger = null, beforeDispatch = () => {}, dispatch = send => send() }) {
+      if (!canHandoff({ runner: 'direct' }).supported) throw new Error('Worker handoff unsupported.');
+      identity = identityOf(identity);
+      if (deadlineAt !== null && (!Number.isSafeInteger(deadlineAt) || deadlineAt <= Date.now() || deadlineAt - Date.now() > 2147483647)) throw new Error('An original deadline must be valid when supplied.');
+      let matchingWorktree = false;
+      let verifiedCwd;
+      try { verifiedCwd = await realpath(cwd); matchingWorktree = verifiedCwd === await realpath(identity.worktree); } catch { /* An unavailable scope is not an execution binding. */ }
+      if (!['codex', 'claude'].includes(backend) || backend !== identity.provider || !matchingWorktree) throw new Error('Worker execution binding mismatch.');
+      // Later async preparation or caller hooks must not redirect a verified alias.
+      cwd = verifiedCwd;
+      if (!command || typeof command.bin !== 'string' || !Array.isArray(command.args) || command.args.some((arg) => typeof arg !== 'string')) throw new Error('Invalid worker command.');
+      await privateDirectory(root);
+      await privateDirectory(path.join(root, 'attempts'));
+      await privateDirectory(path.join(root, 'runtimes'));
+      // Content addressing fixes the worker/decoder version across install replacement and rollback.
+      const files = [
+        ['worker-entry.mjs', await readFile(path.join(source, 'worker-entry.js'))],
+        ['worker-storage.mjs', await readFile(path.join(source, 'worker-storage.js'))],
+        ['provider-stream.mjs', await readFile(path.join(source, '..', 'provider-stream.js'))],
+        ['worker-ledger-runtime.mjs', await readFile(path.join(source, 'worker-ledger-runtime.js'))],
+        ...await Promise.all(['update-state-store.mjs', 'update-dispatch-gate.mjs', 'update-dispatch-identity.mjs'].map(async name => [name, await readFile(path.join(source, '..', 'codex-plugins/simy/hooks', name))])),
+      ];
+      const runtime = createHash('sha256').update(Buffer.concat(files.map(([, bytes]) => bytes))).digest('hex');
+      const runtimeDirectory = path.join(root, 'runtimes', runtime);
+      const directory = attemptDirectory(root, attemptId);
+      await runtimeMutation(root, async () => {
+      await privateDirectory(runtimeDirectory);
+      for (const [name, bytes] of files) {
+        try { await writeFile(path.join(runtimeDirectory, name), bytes, { flag: 'wx', mode: 0o600 }); }
+        catch (error) { if (error.code !== 'EEXIST') throw error; }
+        if (!(await readFile(path.join(runtimeDirectory, name))).equals(bytes)) throw new Error('Retained worker runtime integrity mismatch.');
+      }
+      // Permanent exclusive claim. Even orphaned/ambiguous attempts are never relaunched.
+      await mkdir(directory, { mode: 0o700 });
+      await durableJson(directory, 'intent.json', { attemptId, identity, runtime, deadlineAt, ledger, createdAt: Date.now() });
+      });
+      const child = dispatch(() => {
+        beforeDispatch();
+        return fork(path.join(runtimeDirectory, 'worker-entry.mjs'), [], { detached: true, stdio: ['ignore', 'ignore', 'ignore', 'ipc'], execArgv: [] });
+      });
+      const acknowledgement = new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error('Worker launch ACK unknown; do not replay.')), 30000);
+        const done = (error, value) => { clearTimeout(timer); error ? reject(error) : resolve(value); };
+        child.once('error', (error) => done(error));
+        child.once('exit', () => done(new Error('Worker exited before launch ACK; reconcile receipts.')));
+        child.once('message', (message) => done(message.error ? new Error(message.error) : null, message));
+      });
+      child.send({ attemptId, identity, runtime, deadlineAt, directory, ledger, command: { bin: command.bin, args: command.args, env: command.env || {} }, cwd, backend });
+      try {
+        const ack = await acknowledgement;
+        if (ack.attemptId !== attemptId || ack.runtime !== runtime || JSON.stringify(ack.identity) !== JSON.stringify(identity)) throw new Error('Invalid launch ACK.');
+        return { attemptId, identity, runtime };
+      } finally {
+        if (child.connected) child.disconnect();
+        child.unref();
+      }
+    },
+    async adopt({ attemptId, identity }) {
+      identity = identityOf(identity);
+      const directory = attemptDirectory(root, attemptId);
+      await privateDirectory(directory, { create: false });
+      const intent = await json(directory, 'intent.json');
+      if (!intent || JSON.stringify(intent.identity) !== JSON.stringify(identity)) throw new Error('Worker binding mismatch.');
+      const receipt = await json(directory, 'result.json');
+      if (receipt) {
+        if (receipt.attemptId !== attemptId || receipt.runtime !== intent.runtime || JSON.stringify(receipt.identity) !== JSON.stringify(identity)) throw new Error('Result binding mismatch.');
+        return { state: 'completed', receipt };
+      }
+      const owner = await json(directory, 'owner.json');
+      try {
+        if (!owner || owner.attemptId !== attemptId || owner.runtime !== intent.runtime || JSON.stringify(owner.identity) !== JSON.stringify(identity)) throw new Error('Owner unavailable');
+        if (!owner.processIdentity || await ownedProcessIdentity(owner.pid) !== owner.processIdentity) throw new Error('Owner process identity changed');
+        const live = await request(owner, 'inspect');
+        return { state: live.storageError ? 'recovery_required' : live.stopped ? 'stopping' : 'running', owner: live, deadlineAt: intent.deadlineAt, output: live.output, token_usage: live.token_usage, storageError: live.storageError };
+      } catch {
+        // PID liveness is not proof of ownership. Keep all evidence and require reconciliation.
+        const lateReceipt = await json(directory, 'result.json');
+        if (lateReceipt && lateReceipt.attemptId === attemptId && lateReceipt.runtime === intent.runtime && JSON.stringify(lateReceipt.identity) === JSON.stringify(identity)) return { state: 'completed', receipt: lateReceipt };
+        return { state: 'recovery_required', reason: 'owner_unconfirmed_no_replay' };
+      }
+    },
+    async stop(handle) {
+      const state = await this.adopt(handle);
+      if (state.state === 'completed') return state;
+      if (!state.owner) throw new Error('Cannot stop an unconfirmed owner.');
+      const owner = await json(attemptDirectory(root, handle.attemptId), 'owner.json');
+      return request(owner, 'stop');
+    },
+    async result(handle) { return this.adopt(handle); },
+    async cleanupRuntime(runtime) {
+      if (!/^[a-f0-9]{64}$/.test(runtime)) throw new Error('Invalid retained runtime.');
+      await privateDirectory(root, { create: false });
+      return runtimeMutation(root, async () => {
+      // Conservatively retain every version referenced by an attempt, including ambiguous orphans.
+      for (const name of await readdir(path.join(root, 'attempts'))) {
+        const intent = await json(attemptDirectory(root, name), 'intent.json');
+        if (!intent || intent.runtime === runtime) return { removed: false, reason: 'retained_attempt' };
+      }
+      const directory = path.join(root, 'runtimes', runtime);
+      const info = await lstat(directory);
+      if (!info.isDirectory() || info.isSymbolicLink()) throw new Error('Unsafe retained runtime.');
+      await rm(directory, { recursive: true });
+      return { removed: true };
+      });
+    },
+  };
+}