@ricsam/r5d-worker 0.0.137 → 0.0.139

package/dist/mjs/package.json

@@ -1,5 +1,5 @@
 {
   "name": "@ricsam/r5d-worker",
-  "version": "0.0.137",
+  "version": "0.0.139",
   "type": "module"
 }

package/dist/mjs/personal/action-scheduler.mjs

@@ -0,0 +1,31 @@
+class PersonalActionScheduler {
+  constructor(execute, failed, limit = 8) {
+    this.execute = execute;
+    this.failed = failed;
+    this.limit = limit;
+  }
+  execute;
+  failed;
+  limit;
+  active = /* @__PURE__ */ new Map();
+  accept(actions) {
+    for (const action of actions) {
+      const previous = this.active.get(action.id);
+      if (previous) {
+        if (previous.hash !== action.requestHash) throw new Error("Personal action identity changed while active");
+        continue;
+      }
+      const request = action.request;
+      const lane = request.kind === "tcp" && typeof request.command?.streamId === "string" ? `tcp:${request.sessionId}:${request.command.streamId}` : request.kind === "inspect" && ["processes", "status"].includes(request.command?.method ?? "") ? `inspect:${request.sessionId}` : "mutation";
+      if (this.active.size >= this.limit || [...this.active.values()].some((value) => value.lane === lane)) continue;
+      const task = Promise.resolve().then(() => this.execute(action)).catch(this.failed).finally(() => this.active.delete(action.id));
+      this.active.set(action.id, { hash: action.requestHash, lane, task });
+    }
+  }
+  async drain() {
+    await Promise.all([...this.active.values()].map((value) => value.task));
+  }
+}
+export {
+  PersonalActionScheduler
+};

package/dist/mjs/personal/client.mjs

@@ -0,0 +1,215 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import os from "node:os";
+import { createHash, randomUUID } from "node:crypto";
+import { promises as fs, openSync, closeSync } from "node:fs";
+import { Database } from "bun:sqlite";
+import { canonicalJson } from "@ricsam/r5d-api/runtime-protocol";
+import { privateDirectory, readPrivateJson } from "../runtime/storage.mjs";
+import { openPersonalWorkerRuntime, PersonalWorkerGrant } from "./runtime.mjs";
+import { installCliUpdate, readInstalledCliVersion } from "../cli-update.mjs";
+import { WorkspaceError } from "../runtime/workspace/contracts.mjs";
+import { PersonalActionScheduler } from "./action-scheduler.mjs";
+class PersonalResponseError extends Error {
+  constructor(code, status, rejectedBeforeAdmission) {
+    super(`Personal worker request failed (${status})`);
+    this.code = code;
+    this.status = status;
+    this.rejectedBeforeAdmission = rejectedBeforeAdmission;
+  }
+  code;
+  status;
+  rejectedBeforeAdmission;
+}
+const storageErrorCodes = /* @__PURE__ */ new Set(["invalid_input", "conflict", "not_found", "busy", "stale_fence", "unknown", "unsafe_path", "git_failed"]);
+function parsePersonalWorkerOptions(args, environment = process.env) {
+  const values = {};
+  const allowed = /* @__PURE__ */ new Set(["label", "base-url", "token", "api-key", "config", "root"]);
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    const match = /^--([^=]+)(?:=(.*))?$/.exec(arg);
+    if (!match || !allowed.has(match[1])) throw new Error("Unknown worker option");
+    const key = match[1];
+    if (key in values) throw new Error("Duplicate worker option");
+    const value = match[2] ?? args[++index];
+    if (!value || value.startsWith("--")) throw new Error(`Missing value for --${key}`);
+    values[key] = value;
+  }
+  const configPath = values.config ?? path.join(os.homedir(), ".config/r5d/r5dctl/config.json");
+  let saved = {};
+  try {
+    saved = readPrivateJson(configPath);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  const string = (value) => typeof value === "string" ? value : void 0;
+  const label = values.label;
+  if (!label || !/^[A-Za-z0-9][A-Za-z0-9_.-]{0,62}$/.test(label))
+    throw new Error("A worker --label is required (letters, numbers, dots, underscores or hyphens)");
+  const origin = new URL(values["base-url"] ?? environment.R5D_BASE_URL ?? string(saved.baseUrl) ?? "https://r5d.dev");
+  if (origin.username || origin.password || origin.search || origin.hash || origin.pathname !== "/" || origin.protocol !== "https:" && !(origin.protocol === "http:" && ["127.0.0.1", "localhost", "[::1]"].includes(origin.hostname)))
+    throw new Error("Worker base URL must use HTTPS or local loopback");
+  const credential = values.token ?? values["api-key"] ?? environment.R5D_TOKEN ?? environment.R5D_API_KEY ?? string(saved.token) ?? string(saved.apiKey);
+  if (!credential) throw new Error(`Authenticate this worker with: r5dctl auth login --worker-label ${label}`);
+  return {
+    label,
+    baseUrl: origin.origin,
+    credential,
+    root: path.resolve(values.root ?? environment.R5D_ROOT ?? path.join(os.homedir(), ".r5d"))
+  };
+}
+function safeError(error) {
+  const value = error.code;
+  return typeof value === "string" && /^[a-zA-Z0-9_-]{1,100}$/.test(value) ? value : "personal_operation_unknown";
+}
+async function startPersonalWorker(options, version) {
+  const key = createHash("sha256").update(canonicalJson([options.baseUrl, options.label])).digest("hex").slice(0, 32), root = path.join(options.root, "personal", key);
+  privateDirectory(root);
+  const identityFile = path.join(root, "identity.json");
+  let identity;
+  try {
+    identity = readPrivateJson(identityFile);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+    identity = { resourceId: `worker-${randomUUID()}`, instanceId: `host-${randomUUID()}` };
+    const handle = await fs.open(identityFile, "wx", 384);
+    try {
+      await handle.writeFile(canonicalJson(identity));
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+  }
+  const endpoint = `/api/personal/resources/worker/${encodeURIComponent(identity.resourceId)}`;
+  async function request(pathname, body) {
+    const response = await fetch(options.baseUrl + pathname, {
+      method: "POST",
+      headers: { authorization: `Bearer ${options.credential}`, "content-type": "application/json" },
+      redirect: "error",
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(3e4)
+    });
+    const data = await response.json();
+    if (!response.ok) {
+      throw new PersonalResponseError(typeof data.error === "string" ? data.error : "personal_transport_rejected", response.status, data.rejectedBeforeAdmission === true);
+    }
+    return data;
+  }
+  const metadata = () => ({
+    version,
+    r5dctlVersion: readInstalledCliVersion("r5dctl"),
+    platform: process.platform,
+    arch: process.arch,
+    hostname: os.hostname(),
+    capabilities: { updateClis: true, durableWorkspace: true }
+  });
+  const grant = PersonalWorkerGrant.parse(
+    await request("/api/personal/resources/register", { kind: "worker", ...identity, label: options.label, metadata: metadata() })
+  );
+  let cliEntrypoint = options.cliEntrypoint ?? Bun.which("r5dctl");
+  if (!cliEntrypoint) {
+    try {
+      const module = fileURLToPath(import.meta.resolve("@ricsam/r5dctl/cli"));
+      cliEntrypoint = path.join(path.dirname(module), path.extname(module) === ".cjs" ? "main.cjs" : "main.mjs");
+    } catch {
+    }
+  }
+  if (!cliEntrypoint) throw new Error("Install @ricsam/r5dctl before starting this worker");
+  const runtime = await openPersonalWorkerRuntime({
+    root,
+    cliEntrypoint,
+    grant,
+    storage: (sessionId) => async (storageRequest) => {
+      try {
+        const response = await request(`${endpoint}/storage`, {
+          instanceId: identity.instanceId,
+          request: { sessionId, envelope: { protocol: 1, installationId: grant.installationId, request: storageRequest } }
+        });
+        if (!response || !("result" in response)) throw new Error("Invalid scoped storage response");
+        return response.result;
+      } catch (error) {
+        if (error instanceof PersonalResponseError && storageErrorCodes.has(error.code))
+          throw new WorkspaceError(error.code, "Scoped storage rejected the request; retain its original operation identity", error.rejectedBeforeAdmission);
+        throw error;
+      }
+    }
+  });
+  const ledgerFile = path.join(root, "relay.sqlite");
+  try {
+    closeSync(openSync(ledgerFile, "wx", 384));
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+  }
+  const ledger = new Database(ledgerFile);
+  ledger.exec(
+    "PRAGMA journal_mode=WAL;PRAGMA synchronous=FULL;CREATE TABLE IF NOT EXISTS actions(id TEXT PRIMARY KEY,hash TEXT NOT NULL,state TEXT NOT NULL,result TEXT)"
+  );
+  let stopped = false, metadataAt = 0;
+  async function action(input) {
+    if (createHash("sha256").update(canonicalJson(input.request)).digest("hex") !== input.requestHash)
+      throw new Error("Personal action digest mismatch");
+    const previous = ledger.query("SELECT * FROM actions WHERE id=?").get(input.id);
+    if (previous && previous.hash !== input.requestHash) throw new Error("Personal action identity changed");
+    let state = previous?.state, result = previous?.result ? JSON.parse(previous.result) : void 0;
+    if (!previous || state === "pending") {
+      if (!previous) ledger.query("INSERT INTO actions VALUES(?,?,'pending',NULL)").run(input.id, input.requestHash);
+      try {
+        if (input.request.kind === "update-clis") {
+          const command = input.request.command;
+          if (input.request.userId !== grant.userId || !/^\d+\.\d+\.\d+(?:-[a-zA-Z0-9.-]+)?$/.test(command.version))
+            throw new Error("Invalid CLI update");
+          if (previous) throw new Error("Inspect interrupted CLI installation before retrying");
+          result = await installCliUpdate({
+            workerPackageSpec: `@ricsam/r5d-worker@${command.version}`,
+            r5dctlPackageSpec: `@ricsam/r5dctl@${command.version}`,
+            targetWorkerVersion: command.version,
+            targetR5dctlVersion: command.version
+          });
+        } else result = await runtime.dispatch(input.request);
+        state = "completed";
+      } catch (error) {
+        state = error.rejectedBeforeAdmission === true ? "rejected" : "unknown";
+        result = { error: safeError(error), ...error.rejectedBeforeAdmission === true ? { rejectedBeforeAdmission: true } : {} };
+      }
+      ledger.query("UPDATE actions SET state=?,result=? WHERE id=?").run(state, canonicalJson(result), input.id);
+    }
+    await request(`${endpoint}/ack`, { instanceId: identity.instanceId, id: input.id, requestHash: input.requestHash, state, result });
+  }
+  const scheduler = new PersonalActionScheduler(action, (error) => {
+    process.stderr.write(`[r5d-worker] ${safeError(error)}; retaining original action for reconnect
+`);
+  });
+  const loop = (async () => {
+    while (!stopped) {
+      try {
+        const sendMetadata = Date.now() - metadataAt > 6e4;
+        const response = await request(`${endpoint}/poll`, {
+          instanceId: identity.instanceId,
+          ...sendMetadata ? { metadata: metadata() } : {}
+        });
+        if (sendMetadata) metadataAt = Date.now();
+        await runtime.renew({ ...grant, ...response });
+        scheduler.accept(response.actions ?? []);
+      } catch (error) {
+        process.stderr.write(`[r5d-worker] ${safeError(error)}; reconnecting without replacing the local keeper
+`);
+      }
+      await Bun.sleep(250);
+    }
+  })();
+  return {
+    resourceId: identity.resourceId,
+    root,
+    async close() {
+      stopped = true;
+      await loop;
+      await scheduler.drain();
+      await runtime.close();
+      ledger.close();
+    }
+  };
+}
+export {
+  parsePersonalWorkerOptions,
+  startPersonalWorker
+};

package/dist/mjs/personal/runtime.mjs

@@ -0,0 +1,359 @@
+import path from "node:path";
+import { PersonalTcpManager } from "./tcp.mjs";
+import { createHash, randomBytes } from "node:crypto";
+import { promises as fs } from "node:fs";
+import { z } from "zod";
+import { RuntimeHello, RuntimeId, OwnershipFence, OperationEnvelope, canonicalJson } from "@ricsam/r5d-api/runtime-protocol";
+import { startHostExecutor } from "../runtime/daemon.mjs";
+import { HostExecutorClient } from "../runtime/client.mjs";
+import { tokenHash } from "../runtime/executor.mjs";
+import { EXECUTOR_CAPABILITY, ExecutorCredential } from "../runtime/protocol.mjs";
+import { privateDirectory, readPrivateJson } from "../runtime/storage.mjs";
+import { WorkspaceAuthority } from "../runtime/workspace/authority.mjs";
+import { ApprovedWorkbench, WorkspaceError } from "../runtime/workspace/contracts.mjs";
+import { WorkspaceStorageClient } from "../runtime/workspace/storage-client.mjs";
+import { BranchName, StorageId } from "../runtime/workspace/storage-wire.mjs";
+const PersonalWorkerGrant = z.object({
+  installationId: RuntimeId,
+  userId: RuntimeId,
+  resourceId: RuntimeId,
+  instanceId: RuntimeId,
+  label: z.string().optional(),
+  workerFence: OwnershipFence,
+  workerHello: RuntimeHello,
+  leaseExpiresAt: z.coerce.number().int().positive()
+}).passthrough();
+const Workbench = z.object({ id: StorageId, repositoryId: StorageId, branch: BranchName, sessionId: RuntimeId, sharedSessionId: RuntimeId.optional() }).strict();
+const PersonalWorkspaceRequest = z.object({
+  protocol: z.literal(1),
+  userId: RuntimeId,
+  sessionId: RuntimeId,
+  workbench: Workbench,
+  sourceWorkbench: Workbench.optional(),
+  sharedWorkbenches: z.array(Workbench).max(32).optional(),
+  kind: z.enum(["inspect", "terminal", "product", "agent", "tcp"]),
+  command: z.record(z.string(), z.unknown()),
+  credentials: z.array(ExecutorCredential).max(32).optional()
+}).strict();
+async function personalExecutorToken(root, grant) {
+  const identity = { installationId: grant.installationId, userId: grant.userId, resourceId: grant.resourceId, instanceId: grant.instanceId, workerId: grant.workerFence.resourceId };
+  const file = path.join(root, "executor-identity.json");
+  try {
+    const handle = await fs.open(file, "wx", 384);
+    try {
+      await handle.writeFile(canonicalJson({ version: 1, ...identity, token: randomBytes(32).toString("hex") }));
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    const directory = await fs.open(root, "r");
+    try {
+      await directory.sync();
+    } finally {
+      await directory.close();
+    }
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+  }
+  const stat = await fs.lstat(file);
+  if (stat.nlink !== 1) throw new Error("Personal executor identity must be a private single-link file");
+  const stored = z.object({ version: z.literal(1), installationId: RuntimeId, userId: RuntimeId, resourceId: RuntimeId, instanceId: RuntimeId, workerId: RuntimeId, token: z.string().regex(/^[a-f0-9]{64}$/) }).strict().parse(readPrivateJson(file));
+  const { token, version: _, ...bound } = stored;
+  if (canonicalJson(bound) !== canonicalJson(identity)) throw new Error("Personal executor identity changed; retain the original keeper");
+  return token;
+}
+async function openPersonalWorkerRuntime(options) {
+  const grant = PersonalWorkerGrant.parse(options.grant), root = path.resolve(options.root);
+  privateDirectory(root);
+  if (grant.workerFence.installationId !== grant.installationId || grant.workerHello.installationId !== grant.installationId || grant.workerHello.instanceId !== grant.workerFence.ownerId || grant.workerHello.role !== "worker-adapter")
+    throw new Error("Invalid personal worker grant");
+  const credentialsRoot = path.join(root, "credentials"), workspaceRoot = path.join(root, "workspace", grant.installationId);
+  privateDirectory(credentialsRoot);
+  privateDirectory(workspaceRoot);
+  const token = await personalExecutorToken(root, grant), controllerId = `controller-${createHash("sha256").update(grant.instanceId).digest("hex").slice(0, 24)}`;
+  const daemon = await startHostExecutor({
+    installationId: grant.installationId,
+    workerId: grant.workerFence.resourceId,
+    instanceId: `keeper-${grant.resourceId}`,
+    releaseId: "personal-keeper-v1",
+    stateDir: path.join(root, "executor"),
+    productCredentialDirectory: credentialsRoot,
+    capacity: { general: 8, utility: 8, control: 4 },
+    principals: [
+      {
+        id: controllerId,
+        role: "controller",
+        ownerId: controllerId,
+        tokenHash: tokenHash(token),
+        userIds: [grant.userId],
+        cwdRoots: [workspaceRoot],
+        lanes: ["general", "utility", "control"],
+        credentialIds: []
+      }
+    ]
+  });
+  try {
+    let cliDirectory;
+    if (options.cliEntrypoint) {
+      const cli = await fs.realpath(options.cliEntrypoint), executable = await fs.realpath(process.execPath), stat = await fs.lstat(cli);
+      if (!stat.isFile() || stat.mode & 18 || ![0, process.getuid?.()].includes(stat.uid))
+        throw new Error("Untrusted installed r5dctl entrypoint");
+      cliDirectory = path.join(root, "bin");
+      privateDirectory(cliDirectory);
+      const quote = (value) => "'" + value.replace(/'/g, "'\\''") + "'";
+      const wrapper = `#!/bin/sh
+exec ${quote(executable)} ${quote(cli)} "$@"
+`;
+      const file = path.join(cliDirectory, "r5dctl"), temporary = `${file}.${randomBytes(8).toString("hex")}.next`;
+      await fs.writeFile(temporary, wrapper, { mode: 448, flag: "wx" });
+      await fs.rename(temporary, file);
+    }
+    const controller = new HostExecutorClient({
+      socketPath: daemon.socketPath,
+      principalId: controllerId,
+      token,
+      hello: { ...grant.workerHello, instanceId: controllerId, role: "scheduler", capabilities: [EXECUTOR_CAPABILITY] },
+      timeoutMs: 1e4
+    });
+    let client = new HostExecutorClient({
+      socketPath: daemon.socketPath,
+      principalId: grant.workerHello.instanceId,
+      token,
+      hello: grant.workerHello,
+      timeoutMs: 1e4
+    });
+    let current = grant, installed = false, retirementPending = false;
+    const manifests = /* @__PURE__ */ new Map();
+    const manifestFile = path.join(root, "workbenches.json");
+    try {
+      const rows = z.array(ApprovedWorkbench).parse(readPrivateJson(manifestFile));
+      for (const row of rows) {
+        if (row.userId !== grant.userId || !row.cwd.startsWith(workspaceRoot + path.sep)) throw new Error("Invalid retained workbench");
+        manifests.set(row.sessionId, row);
+      }
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    const artifactDigest = createHash("sha256").update(await fs.readFile(new URL(import.meta.url))).digest("hex");
+    async function retireObsoleteAdapters(retain) {
+      const status = await controller.status();
+      for (const adapter of status.adapters) {
+        if (adapter.state === "registered" && adapter.ownerId !== status.authority?.fence.ownerId && !retain.includes(adapter.ownerId))
+          await controller.retireAdapter(adapter.principalId);
+      }
+    }
+    async function renew(value) {
+      const next = PersonalWorkerGrant.parse(value);
+      if (next.instanceId !== grant.instanceId || next.installationId !== grant.installationId || next.resourceId !== grant.resourceId || next.userId !== grant.userId || next.workerFence.installationId !== grant.installationId || next.workerHello.installationId !== grant.installationId || next.workerHello.role !== "worker-adapter" || next.workerFence.resourceId !== grant.workerFence.resourceId || next.workerHello.instanceId !== next.workerFence.ownerId)
+        throw new Error("Personal worker resource identity changed; inspect retained keeper before rebinding");
+      let successor = client;
+      if (!installed || canonicalJson(next.workerHello) !== canonicalJson(current.workerHello)) {
+        await retireObsoleteAdapters([next.workerHello.instanceId]);
+        await controller.registerAdapter({
+          installationId: grant.installationId,
+          workerId: grant.workerFence.resourceId,
+          hello: next.workerHello,
+          artifactDigest,
+          principal: {
+            id: next.workerHello.instanceId,
+            role: "adapter",
+            ownerId: next.workerHello.instanceId,
+            tokenHash: tokenHash(token),
+            userIds: [grant.userId],
+            cwdRoots: [workspaceRoot],
+            lanes: ["general", "utility", "control"],
+            credentialIds: []
+          }
+        });
+        successor = new HostExecutorClient({
+          socketPath: daemon.socketPath,
+          principalId: next.workerHello.instanceId,
+          token,
+          hello: next.workerHello,
+          timeoutMs: 1e4
+        });
+      }
+      await controller.setAuthority(next.workerFence, next.leaseExpiresAt);
+      if (!installed || canonicalJson(next.workerHello) !== canonicalJson(current.workerHello)) retirementPending = true;
+      client = successor;
+      current = next;
+      installed = true;
+      if (retirementPending) {
+        await retireObsoleteAdapters([next.workerHello.instanceId]);
+        retirementPending = false;
+      }
+    }
+    await renew(grant);
+    const authority = await WorkspaceAuthority.open({
+      config: { installationId: grant.installationId, root: workspaceRoot, dynamicWorkbenches: true, workbenches: [] },
+      executor: async () => ({ client, workerFence: current.workerFence }),
+      resolveWorkbench: async (identity) => identity.userId === grant.userId ? manifests.get(identity.sessionId) ?? null : null,
+      storage: async (identity) => new WorkspaceStorageClient(grant.installationId, options.storage(identity.sessionId), async () => current.workerFence)
+    });
+    async function approve(input) {
+      const row = ApprovedWorkbench.parse({
+        ...input,
+        userId: grant.userId,
+        cwd: path.join(workspaceRoot, "workbenches", input.id),
+        nonmutatingArgv: []
+      });
+      const previous = manifests.get(input.sessionId);
+      if (previous && canonicalJson(previous) !== canonicalJson(row)) throw new Error("Personal workbench identity changed");
+      if (!previous) {
+        manifests.set(input.sessionId, row);
+        const tmp = `${manifestFile}.${randomBytes(8).toString("hex")}.next`;
+        const handle = await fs.open(tmp, "wx", 384);
+        try {
+          await handle.writeFile(canonicalJson([...manifests.values()]));
+          await handle.sync();
+        } finally {
+          await handle.close();
+        }
+        await fs.rename(tmp, manifestFile);
+      }
+    }
+    async function installCredentials(values) {
+      for (const source of values) {
+        const credential = cliDirectory ? { ...source, env: { ...source.env, PATH: `${cliDirectory}:/usr/local/bin:/usr/bin:/bin` } } : source;
+        if (credential.installationId !== grant.installationId || credential.userId !== grant.userId || !/^product-[a-f0-9]{40}$/.test(credential.id))
+          throw new Error("Invalid personal credential scope");
+        const destination = path.join(credentialsRoot, `${credential.id}-${credential.generation}.json`), data = canonicalJson(credential);
+        try {
+          const handle = await fs.open(destination, "wx", 384);
+          try {
+            await handle.writeFile(data);
+            await handle.sync();
+          } finally {
+            await handle.close();
+          }
+        } catch (error) {
+          if (error.code !== "EEXIST" || canonicalJson(readPrivateJson(destination)) !== data) throw error;
+        }
+      }
+    }
+    const tcp = new PersonalTcpManager(path.join(root, "tcp"));
+    async function dispatch(raw) {
+      const request = PersonalWorkspaceRequest.parse(raw);
+      if (request.userId !== grant.userId || request.workbench.sessionId !== request.sessionId)
+        throw new Error("Wrong personal worker principal");
+      if (request.kind === "tcp") return tcp.dispatch(request.sessionId, request.command);
+      for (const parent of request.sharedWorkbenches ?? []) await approve(parent);
+      await approve(request.workbench);
+      if (request.sourceWorkbench) await approve(request.sourceWorkbench);
+      await installCredentials(request.credentials ?? []);
+      const identity = { userId: grant.userId, sessionId: request.sessionId }, command = request.command, run = (operationId) => ({ ...identity, operationId: RuntimeId.parse(operationId), fence: current.workerFence });
+      if (request.kind === "inspect") {
+        if (command.method === "fileWriteResult") return authority.fileWriteResult(identity, { id: command.id });
+        if (command.method === "processes") return authority.processes(identity);
+        if (command.method === "status") return { ...await authority.status(identity), workerLabel: grant.label ?? grant.resourceId };
+        await authority.ensureHydrated(identity);
+        if (command.method === "file") return authority.readFile(identity, command.path);
+        if (command.method === "git") return authority.inspectGit(identity, { ...command, method: command.action });
+        if (command.method === "fileHistoryDates") return authority.fileHistoryDates(identity, command.path);
+        if (command.method === "directory" || command.method === "raw") return authority.inspectFiles(identity, command);
+      }
+      if (request.kind === "terminal") {
+        await authority.ensureHydrated(identity);
+        if (command.method === "open" || command.method === "start") {
+          const argv = command.method === "open" ? ["/bin/bash", "--noprofile", "--norc", ...command.command ? ["-c", command.command] : []] : ["/bin/sh", "-c", command.command];
+          return {
+            ...await authority.start(
+              identity,
+              OperationEnvelope.parse({
+                protocol: 1,
+                installationId: grant.installationId,
+                operationId: `terminal:${command.id}`,
+                ...identity,
+                kind: "host.shell",
+                fence: current.workerFence,
+                payload: {
+                  argv,
+                  cwd: manifests.get(identity.sessionId).cwd,
+                  ...command.method === "open" ? { interactive: true, pty: { cols: command.cols, rows: command.rows } } : {},
+                  credentials: (request.credentials ?? []).map(({ id, generation }) => ({ id, generation }))
+                }
+              })
+            ),
+            workerLabel: grant.label ?? grant.resourceId
+          };
+        }
+        const ref = run(command.operationId ?? `terminal:${command.runId}`);
+        if (command.method === "poll" || command.method === "processPoll")
+          return authority.poll(identity, ref, command.stdoutOffset ?? 0, command.stderrOffset ?? 0, command.maxBytes ?? 32768);
+        if (command.method === "write") return authority.write(identity, ref, command.id, command.data, command.eof ?? false);
+        if (command.method === "resize") return authority.resize(identity, ref, command.id, command.cols, command.rows);
+        if (command.method === "cancel" || command.method === "processCancel") return authority.cancel(identity, ref, command.id);
+      }
+      if (request.kind === "product") {
+        if (command.method === "fileWrite") {
+          await authority.ensureHydrated(identity);
+          return authority.fileWrite(identity, command);
+        }
+        if (command.method === "materializeArtifact") return authority.materializeArtifact(identity, command);
+        if (command.method === "seed") return authority.seedReadme(identity, command.readme);
+        if (command.method === "hydrate") return authority.hydrate(identity, command.expectedBase);
+        if (command.method === "import") return authority.importRepository(identity, command);
+        if (command.method === "clone")
+          return authority.cloneBranch(identity, { userId: grant.userId, sessionId: command.sourceSessionId }, command);
+        if (command.method === "archive") return authority.archiveBranch(identity, command);
+        if (command.method === "commit") return authority.commit(identity, command);
+        if (command.method === "push") return authority.push(identity, command);
+        if (command.method === "reset") return authority.reset(identity, command);
+        if (command.method === "publish") return authority.publish(identity);
+        if (command.method === "reconcilePublication") return authority.reconcilePublication(identity);
+      }
+      if (request.kind === "agent") {
+        if (command.method === "status") return { ...await authority.status(identity), workerLabel: grant.label ?? grant.resourceId };
+        if (command.method === "ensureHydrated") {
+          await authority.ensureHydrated(identity);
+          return { ready: true };
+        }
+        if (command.method === "hydrate") return authority.hydrate(identity, command.expectedBase);
+        if (command.method === "seedReadme") return authority.seedReadme(identity, command.readme);
+        if (command.method === "publish") return authority.publish(identity);
+        if (command.method === "reconcilePublication") return authority.reconcilePublication(identity);
+        if (command.method === "start") {
+          const operation = OperationEnvelope.parse(command.operation);
+          if (operation.userId !== grant.userId || operation.sessionId !== identity.sessionId)
+            throw new Error("Wrong personal shell principal");
+          return authority.start(identity, {
+            ...operation,
+            fence: current.workerFence,
+            payload: {
+              ...operation.payload,
+              cwd: manifests.get(identity.sessionId).cwd,
+              credentials: (request.credentials ?? []).map(({ id, generation }) => ({ id, generation }))
+            }
+          });
+        }
+        if (command.method === "poll")
+          return authority.poll(identity, run(command.run.operationId), command.stdoutOffset, command.stderrOffset, command.maxBytes);
+        if (command.method === "write")
+          return authority.write(identity, run(command.run.operationId), command.actionId, command.data, command.eof);
+        if (command.method === "resize")
+          return authority.resize(identity, run(command.run.operationId), command.actionId, command.cols, command.rows);
+        if (command.method === "cancel") return authority.cancel(identity, run(command.run.operationId), command.actionId);
+      }
+      throw new WorkspaceError("invalid_request", "Unsupported personal workspace operation");
+    }
+    return {
+      grant,
+      renew,
+      dispatch,
+      authority,
+      async close() {
+        await tcp.close();
+        await authority.close();
+        await daemon.close();
+      }
+    };
+  } catch (error) {
+    await daemon.close();
+    throw error;
+  }
+}
+export {
+  PersonalWorkerGrant,
+  PersonalWorkspaceRequest,
+  openPersonalWorkerRuntime
+};