pi-microsandbox 0.1.1 → 0.3.0

package/extensions/pi-msb/control.ts

@@ -1,8 +1,5 @@
-import { promises as fs } from "node:fs";
-import { execFile as execFileCallback } from "node:child_process";
-import { promisify } from "node:util";
 import { homedir } from "node:os";
-import { isAbsolute, join, resolve, basename, relative as relativePath } from "node:path";
+import { join } from "node:path";
 
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import {
@@ -15,47 +12,42 @@ import {
   removeOverride,
   toEffectiveToml,
 } from "./config.ts";
-import { createSeedBundle, detectGitRepo } from "./git.ts";
-import { buildSandboxLabels, buildVolumeLabels, decodeSessionState, normalizeSandboxRecord, normalizeVolumeRecord, encodeSessionState } from "./labels.ts";
+import { buildSandboxLabels, decodeSessionState, normalizeSandboxRecord, encodeSessionState } from "./labels.ts";
 import { acquireOwnerLock, createLocksPort } from "./locks.ts";
 import { createBashOps, createFindOps, createGrepOps } from "./operations-exec.ts";
 import { createEditOps, createLsOps, createReadOps, createWriteOps } from "./operations.ts";
 import { pruneStale, type PrunePort } from "./prune.ts";
-import { buildStoragePlan, seedGitVolume, validateReusableVolume } from "./storage.ts";
 import { createSdkTransport } from "./transport.ts";
+import { discoverWorkspace } from "./workspace.ts";
 import { createSandboxManager, type InspectedSandbox, type SandboxManagerDeps } from "./sandbox-manager.ts";
 import {
-  LABEL_KEYS,
+  LOCKFILE_VERSION,
   sandboxNameFor,
-  volumeNameFor,
   type BootRequest,
   type Config,
-  type GitRepoInfo,
   type LockInfo,
   type LocksPort,
   type MsbControl,
   type PersistedSandboxState,
   type ResolvedConfig,
   type RuntimeExecution,
+  type RuntimePreparation,
   type RuntimeState,
-  type StoragePlan,
   type ToolOperations,
   type ToolOpsProvider,
-  type VolumeRecord,
+  type Workspace,
   type DeepPartial,
 } from "./types.ts";
 
-const execFile = promisify(execFileCallback);
 const STATE_ENTRY = "pi-msb.state";
 const OVERRIDE_ENTRY = "pi-msb.override";
-const REQUIRED_GUEST_COMMANDS = ["bash", "git", "rg", "file", "cat", "mkdir", "rm"] as const;
+const REQUIRED_GUEST_COMMANDS = ["bash", "rg", "file", "cat", "mkdir", "rm"] as const;
 
 type AnyRecord = Record<string, any>;
 
 /** The deliberately small SDK surface used by the adapter. Tests can inject this. */
 export interface MicrosandboxModule {
   Sandbox: AnyRecord;
-  Volume: AnyRecord;
   NetworkPolicy?: AnyRecord;
   Rule?: AnyRecord;
 }
@@ -63,7 +55,6 @@ export interface MicrosandboxModule {
 export interface SessionSetup {
   sessionId: string;
   cwd: string;
-  repoRoot?: string | null;
   projectTrusted: boolean;
   config?: ResolvedConfig;
   restored?: PersistedSandboxState | null;
@@ -108,7 +99,7 @@ function expandHome(path: string): string {
 function sdkNotFound(error: unknown): boolean {
   const value = error as AnyRecord;
   const name = typeof value?.constructor?.name === "string" ? value.constructor.name : "";
-  return name.includes("NotFound") || ["NOT_FOUND", "ENOENT", "volumeNotFound", "sandboxNotFound"].includes(value?.code);
+  return name.includes("NotFound") || ["NOT_FOUND", "ENOENT", "sandboxNotFound"].includes(value?.code);
 }
 
 function objectConfig(value: unknown): AnyRecord {
@@ -158,116 +149,12 @@ function inspectedFromHandle(handle: AnyRecord, config: AnyRecord = {}): Inspect
   };
 }
 
-function volumeHostPath(value: AnyRecord): string | undefined {
-  // VolumeHandle has no path getter. Only use a path
-  // when the SDK object explicitly exposes one (the Volume returned by create)
-  // or a future metadata object documents one; never manufacture a host path.
-  const direct = typeof value.path === "string" ? value.path : typeof value.hostPath === "string" ? value.hostPath : undefined;
-  if (direct && isAbsolute(direct)) return direct;
-  const metadata = objectConfig(value.metadata ?? value.info);
-  const documented = typeof metadata.hostPath === "string" ? metadata.hostPath : typeof metadata.path === "string" ? metadata.path : undefined;
-  return documented && isAbsolute(documented) ? documented : undefined;
-}
-
-function volumeIdentityFromHandle(handle: AnyRecord): { name: string; labels: Record<string, string> } | null {
-  const name = typeof handle.name === "string" ? handle.name : undefined;
-  const labels = sdkLabels(handle);
-  return name && Object.keys(labels).length ? { name, labels } : null;
-}
-
-function volumeFromHandle(handle: AnyRecord): VolumeRecord | null {
-  const identity = volumeIdentityFromHandle(handle);
-  const hostPath = volumeHostPath(handle);
-  if (!identity || !hostPath) return null;
-  return normalizeVolumeRecord({
-    name: identity.name,
-    hostPath,
-    labels: identity.labels,
-    kind: handle.kind,
-    usedBytes: handle.usedBytes,
-    createdAt: handle.createdAt instanceof Date ? handle.createdAt.getTime() : handle.createdAt,
-  });
-}
-
-function reusableVolumeIdentity(plan: Extract<StoragePlan, { kind: "git-volume" }>, identity: { name: string; labels: Record<string, string> }): boolean {
-  const labels = identity.labels;
-  return identity.name === plan.volumeName &&
-    labels[LABEL_KEYS.managed] === "true" &&
-    labels[LABEL_KEYS.schema] === "1" &&
-    labels[LABEL_KEYS.session] === plan.sessionId &&
-    labels[LABEL_KEYS.cwd] === plan.workdir &&
-    labels[LABEL_KEYS.mode] === "git" &&
-    labels[LABEL_KEYS.keep] === "true";
-}
-
-function labelsForVolume(input: { sessionId: string; cwd: string }): Record<string, string> {
-  return { ...buildVolumeLabels(input), [LABEL_KEYS.mode]: "git" };
-}
-
-interface ManagedVolumeTarget {
-  sessionId: string;
-  cwd: string;
-  name: string;
-}
-
-function managedVolumeTarget(requestedName: string, identity: { name: string; labels: Record<string, string> }): ManagedVolumeTarget | null {
-  const labels = identity.labels;
-  const sessionId = labels[LABEL_KEYS.session];
-  const cwd = labels[LABEL_KEYS.cwd];
-  if (!sessionId || !cwd || !isAbsolute(cwd)) return null;
-  const expectedLabels = labelsForVolume({ sessionId, cwd });
-  if (identity.name !== requestedName || requestedName !== volumeNameFor(sessionId)) return null;
-  if (Object.entries(expectedLabels).some(([key, value]) => labels[key] !== value)) return null;
-  return { sessionId, cwd, name: requestedName };
-}
-
-function namedMountVolume(mount: unknown): string | undefined {
-  const value = objectConfig(mount);
-  const kind = value.kind ?? value.type;
-  if (typeof kind === "string" && kind.toLowerCase() === "named" && typeof value.name === "string") return value.name;
-  const nested = objectConfig(value.named ?? value.Named);
-  return typeof nested.name === "string" ? nested.name : undefined;
-}
-
-async function volumeIsMounted(msb: MicrosandboxModule, name: string): Promise<boolean> {
-  let cursor: string | undefined;
-  const seenCursors = new Set<string>();
-  while (true) {
-    const page = await msb.Sandbox.listWith((list: AnyRecord) => {
-      if (cursor) list.cursor(cursor);
-      return list;
-    });
-    if (!page || !Array.isArray(page.sandboxes)) throw new Error("unable to verify volume mount state: malformed sandbox list");
-    for (const listed of page.sandboxes) {
-      if (typeof listed?.name !== "string" || !listed.name) throw new Error("unable to verify volume mount state: malformed sandbox handle");
-      let handle: AnyRecord;
-      try {
-        handle = await msb.Sandbox.get(listed.name);
-      } catch (error) {
-        if (sdkNotFound(error)) continue;
-        throw error;
-      }
-      const status = sdkStatus(handle)?.trim().toLowerCase();
-      if (status === "stopped" || status === "crashed") continue;
-      const config = await handleConfig(handle);
-      if (!Array.isArray(config.mounts)) throw new Error(`unable to verify volume mount state for sandbox ${listed.name}`);
-      if (config.mounts.some((mount: unknown) => namedMountVolume(mount) === name)) return true;
-    }
-    if (page.nextCursor === undefined) return false;
-    if (typeof page.nextCursor !== "string" || !page.nextCursor || seenCursors.has(page.nextCursor)) {
-      throw new Error("unable to verify volume mount state: invalid sandbox page cursor");
-    }
-    seenCursors.add(page.nextCursor);
-    cursor = page.nextCursor;
-  }
-}
-
 function parsePort(value: string): { bind: string; host: number; guest: number } {
   const parts = value.split(":");
   const numbers = parts.slice(-2).map((item) => Number(item));
   if (parts.length === 1) return { bind: "127.0.0.1", host: numbers[0], guest: numbers[0] };
   if (parts.length === 2) return { bind: "127.0.0.1", host: numbers[0], guest: numbers[1] };
-  return { bind: parts[0], host: numbers[1], guest: numbers[2] };
+  return { bind: parts[0], host: numbers[0], guest: numbers[1] };
 }
 
 function applyMount(builder: AnyRecord, mount: Config["mounts"][number]): void {
@@ -306,7 +193,7 @@ function applyNetwork(builder: AnyRecord, config: Config, sdk: MicrosandboxModul
           return destination.domain(host);
         }));
       }
-      if (network.allowDns) policy.egress((rule: AnyRecord) => rule.allowDns());
+      if (network.allowDns) policy.egress((rule: AnyRecord) => rule.udp().tcp().port(53).allowHost());
       builder.network((n: AnyRecord) => n.policy(policy));
     }
   }
@@ -318,14 +205,12 @@ function applyNetwork(builder: AnyRecord, config: Config, sdk: MicrosandboxModul
 }
 
 function lockInfoFor(request: BootRequest): LockInfo {
-  const mode = request.config.mode === "direct" || request.config.mode === "none" ? request.config.mode : "git";
   return {
-    version: 1,
+    version: LOCKFILE_VERSION,
     sessionId: request.sessionId,
     sandboxName: request.config.sandboxName ?? sandboxNameFor(request.sessionId),
-    volumeName: mode === "git" ? volumeNameFor(request.sessionId) : undefined,
-    mode,
     cwd: request.cwd,
+    root: request.workspace.hostRoot,
     pid: process.pid,
     createdAt: Date.now(),
   };
@@ -347,11 +232,10 @@ function sanitizeOverride(key: string, value: unknown): unknown {
 }
 
 export function createMsbIntegration(options: MsbControlOptions): MsbIntegration {
-  const configRef = { value: { ...DEFAULT_CONFIG, network: { ...DEFAULT_CONFIG.network } } as Config };
+  const configRef = { value: { ...DEFAULT_CONFIG, network: { ...DEFAULT_CONFIG.network }, docker: { ...DEFAULT_CONFIG.docker } } as Config };
   let sessionId = options.sessionId;
   let cwd = options.cwd;
-  let repoRoot: string | null = null;
-  let currentGit: GitRepoInfo = { isGitRepo: false, repoRoot: null, branch: null, headSha: null, unborn: false, isLinkedWorktree: false };
+  let workspace: Workspace | null = null;
   let resolved: ResolvedConfig = { config: configRef.value, provenance: {}, warnings: [] };
   let overrides: DeepPartial<Config> = {};
   let projectTrusted = true;
@@ -406,55 +290,6 @@ export function createMsbIntegration(options: MsbControlOptions): MsbIntegration
       ? options.acquireOwnerLock(request)
       : acquireOwnerLock({ lockDir: expandHome(request.config.lockDir) }, lockInfoFor(request)),
     pruneOthers: async (currentSessionId) => pruneStale({ port: prunePort, locks: lockPort(), currentSessionId, stopTimeoutMs: configRef.value.stopTimeoutMs }),
-    detectGit: async (path) => {
-      currentGit = await detectGitRepo(path);
-      currentGit = currentGit;
-      return currentGit;
-    },
-    buildStoragePlan: (input) => {
-      const plan = buildStoragePlan(input);
-      activeProjectRoot = plan.kind === "git-volume" ? plan.mountGuestPath : input.cwd;
-      return plan;
-    },
-    prepareStorage: async (plan, restored) => {
-      if (plan.kind !== "git-volume") return { plan, createdVolume: false };
-      const msb = await sdk();
-      let volume: VolumeRecord | undefined;
-      let createdVolume = false;
-      try {
-        const handle = await msb.Volume.get(plan.volumeName);
-        const identity = volumeIdentityFromHandle(handle);
-        if (!identity || !reusableVolumeIdentity(plan, identity)) throw new Error(`managed volume identity mismatch: ${plan.volumeName}`);
-        const record = volumeFromHandle(handle);
-        if (record && !validateReusableVolume(plan, record)) throw new Error(`managed volume identity mismatch: ${plan.volumeName}`);
-        // VolumeHandle has no supported host path. Reuse is safe
-        // because mounting uses the name; status/export report no fabricated path.
-        volume = record ?? undefined;
-      } catch (error) {
-        if (!sdkNotFound(error)) throw error;
-        const labels = labelsForVolume({ sessionId: plan.sessionId, cwd: plan.workdir });
-        let builder = msb.Volume.builder(plan.volumeName).directory().quota(plan.volumeQuotaMiB);
-        for (const [key, value] of Object.entries(labels)) builder = builder.label(key, value);
-        const created = await builder.create();
-        const createdVolumeRecord = volumeFromHandle({
-          name: created.name,
-          path: volumeHostPath(created),
-          labels,
-          kind: created.kind,
-          usedBytes: created.usedBytes,
-          createdAt: created.createdAt,
-        });
-        if (!createdVolumeRecord) throw new Error("microsandbox returned invalid volume metadata");
-        volume = createdVolumeRecord;
-        createdVolume = true;
-      }
-      let bundle = null;
-      if (createdVolume && plan.seedRequired && !plan.unborn) {
-        bundle = await createSeedBundle(currentGit, { branch: configRef.value.cloneBranch, depth: configRef.value.cloneDepth });
-      }
-      // The manager owns cleanup after seed/boot failure; storage owns only the bundle creation.
-      return { plan, volume, bundle, createdVolume };
-    },
     inspectSandbox: async (name) => {
       const msb = await sdk();
       try {
@@ -467,16 +302,12 @@ export function createMsbIntegration(options: MsbControlOptions): MsbIntegration
     },
     connectSandbox: async (value) => objectConfig(value)._handle.connect(),
     startSandbox: async (value) => objectConfig(value)._handle.startDetached(),
-    createSandbox: async (request, prepared) => {
+    createSandbox: async (request) => {
       const msb = await sdk();
       const name = request.config.sandboxName ?? sandboxNameFor(request.sessionId);
-      const plan = prepared.plan;
-      const mode = plan.kind === "git-volume" ? "git" : plan.kind === "direct-mount" ? "direct" : "none";
-      const labels = buildSandboxLabels({ sessionId: request.sessionId, mode, cwd: request.cwd, pid: process.pid, image: request.config.image, volumeName: plan.kind === "git-volume" ? plan.volumeName : undefined, seedBranch: plan.kind === "git-volume" ? plan.branch : null, seedSha: plan.kind === "git-volume" ? plan.headSha : null });
-      let builder = msb.Sandbox.builder(name).image(request.config.image).pullPolicy(request.config.pullPolicy).cpus(request.config.cpus).memory(request.config.memoryMiB).idleTimeout(request.config.idleTimeoutSec).detached(request.config.detached).workdir(plan.kind === "git-volume" ? plan.workdir : request.cwd).labels(labels);
-      if (plan.kind === "git-volume") builder.volume(plan.mountGuestPath, (m: AnyRecord) => m.named(plan.volumeName));
-      else if (plan.kind === "direct-mount") builder.volume(plan.guestPath, (m: AnyRecord) => m.bind(plan.hostPath));
-      else builder.volume(plan.guestPath, (m: AnyRecord) => m.tmpfs());
+      const labels = buildSandboxLabels({ sessionId: request.sessionId, cwd: request.cwd, root: request.workspace.hostRoot, guestRoot: request.workspace.guestRoot, pid: process.pid, image: request.config.image });
+      let builder = msb.Sandbox.builder(name).image(request.config.image).pullPolicy(request.config.pullPolicy).cpus(request.config.cpus).memory(request.config.memoryMiB).idleTimeout(request.config.idleTimeoutSec).detached(request.config.detached).workdir(request.workspace.cwd).labels(labels);
+      builder.volume(request.workspace.guestRoot, (m: AnyRecord) => m.bind(request.workspace.hostRoot));
       for (const mount of request.config.mounts) applyMount(builder, mount);
       applyNetwork(builder, request.config, msb);
       const envValues: Record<string, string> = {};
@@ -531,23 +362,101 @@ export function createMsbIntegration(options: MsbControlOptions): MsbIntegration
         bash: createBashOps({ withRuntime: async (callback) => callback({ transport, operations: undefined as never }) }),
       } as ToolOperations;
     },
-    probeAndBootstrap: async (runtime, config) => {
-      const missing = async () => {
-        const result = await Promise.all(REQUIRED_GUEST_COMMANDS.map(async (command) => ({ command, result: await runtime.transport.exec("sh", ["-lc", `command -v ${command}`]) })));
+    prepareRuntime: async (runtime, config): Promise<RuntimePreparation> => {
+      const commandsMissing = async (commandNames: readonly string[]) => {
+        const result = await Promise.all(commandNames.map(async (command) => ({
+          command,
+          result: await runtime.transport.exec("sh", ["-c", 'command -v "$1" >/dev/null 2>&1', "pi-msb-probe", command]),
+        })));
         return result.filter((item) => item.result.exitCode !== 0).map((item) => item.command);
       };
-      let commands = await missing();
+      let commands = await commandsMissing(REQUIRED_GUEST_COMMANDS);
       if (commands.length && config.bootstrapTools !== false) {
-        const apt = await runtime.transport.exec("sh", ["-lc", "command -v apt-get"]);
+        const apt = await runtime.transport.exec("sh", ["-c", 'command -v "$1" >/dev/null 2>&1', "pi-msb-probe", "apt-get"]);
         if (apt.exitCode === 0) {
           await runtime.transport.exec("apt-get", ["update", "-y"]);
-          await runtime.transport.exec("apt-get", ["install", "-y", "--no-install-recommends", "bash", "git", "ripgrep", "file", "coreutils", "ca-certificates"]);
-          commands = await missing();
+          await runtime.transport.exec("apt-get", ["install", "-y", "--no-install-recommends", "bash", "ripgrep", "file", "coreutils", "ca-certificates"]);
+          commands = await commandsMissing(REQUIRED_GUEST_COMMANDS);
         }
       }
       if (commands.length) throw new Error(`sandbox is missing required commands: ${commands.join(", ")}; install them or use bootstrapTools=true`);
+
+      const mode = config.docker.mode;
+      if (mode === "disabled") return { docker: { mode, readiness: "disabled" } };
+
+      const dockerComponents = [
+        { name: "docker", path: "/usr/local/bin/docker" },
+        { name: "dockerd", path: "/usr/local/bin/dockerd" },
+        { name: "pi-msb-docker-start", path: "/usr/local/sbin/pi-msb-docker-start" },
+      ] as const;
+      const dockerChecks = await Promise.all(dockerComponents.map(async (component) => ({
+        ...component,
+        result: await runtime.transport.exec("/usr/bin/test", ["-x", component.path]),
+      })));
+      const missingDocker = dockerChecks.filter((item) => item.result.exitCode !== 0).map((item) => item.name);
+      if (missingDocker.length) {
+        const reason = `image is missing Docker components: ${missingDocker.join(", ")}`;
+        if (mode === "require") throw new Error(reason);
+        return { docker: { mode, readiness: "missing", reason } };
+      }
+
+      let started = false;
+      try {
+        const result = await runtime.transport.exec(
+          "/usr/bin/env",
+          [
+            "-i",
+            "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
+            "HOME=/root",
+            "/usr/local/sbin/pi-msb-docker-start",
+            String(config.docker.startupTimeoutMs),
+          ],
+          { timeoutMs: config.docker.startupTimeoutMs + 2_000 },
+        );
+        started = result.exitCode === 0;
+      } catch {
+        // Keep host-visible status bounded so transport errors cannot expose
+        // environment or secret values.
+      }
+      if (!started) {
+        const reason = "Docker daemon did not become ready; inspect /var/log/pi-msb-dockerd.log inside the sandbox";
+        if (mode === "require") throw new Error(reason);
+        return { docker: { mode, readiness: "unavailable", reason } };
+      }
+
+      const inspectLocalDocker = (args: string[]) => runtime.transport.exec(
+        "/usr/bin/env",
+        [
+          "-i",
+          "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
+          "HOME=/root",
+          "/usr/local/bin/docker",
+          "--host=unix:///var/run/docker.sock",
+          ...args,
+        ],
+        { timeoutMs: 5_000 },
+      );
+      let version: string | undefined;
+      let storageDriver: string | undefined;
+      try {
+        const [versionResult, driverResult] = await Promise.all([
+          inspectLocalDocker(["version", "--format", "{{.Server.Version}}"]),
+          inspectLocalDocker(["info", "--format", "{{.Driver}}"]),
+        ]);
+        if (versionResult.exitCode === 0 && driverResult.exitCode === 0) {
+          version = versionResult.stdout.toString("utf8").trim().split(/\r?\n/, 1)[0]?.slice(0, 128);
+          storageDriver = driverResult.stdout.toString("utf8").trim().split(/\r?\n/, 1)[0]?.slice(0, 128);
+        }
+      } catch {
+        // Report a bounded capability error below.
+      }
+      if (!version || !storageDriver) {
+        const reason = "Docker daemon became reachable but capability inspection failed";
+        if (mode === "require") throw new Error(reason);
+        return { docker: { mode, readiness: "unavailable", reason } };
+      }
+      return { docker: { mode, readiness: "ready", version, storageDriver } };
     },
-    seed: async (runtime, prepared) => seedGitVolume(runtime.transport, prepared.plan as any, prepared.bundle ?? null),
     persist: (state) => options.appendEntry?.(STATE_ENTRY, encodeSessionState(state)),
   };
 
@@ -564,6 +473,7 @@ export function createMsbIntegration(options: MsbControlOptions): MsbIntegration
     withRuntime: (callback) => manager.withRuntime(callback),
   };
   const effective = (): ResolvedConfig => resolved;
+  const configSnapshot = (): Config => structuredClone(configRef.value);
   const overrideEntries = (entries: readonly unknown[]): DeepPartial<Config> => {
     let result: DeepPartial<Config> = {};
     for (const entry of entries) {
@@ -576,16 +486,15 @@ export function createMsbIntegration(options: MsbControlOptions): MsbIntegration
     }
     return result;
   };
-  const resolveForSession = async (setup: SessionSetup): Promise<ResolvedConfig> => {
+  const resolveForSession = async (setup: SessionSetup, selected: Workspace): Promise<ResolvedConfig> => {
     if (setup.config) return setup.config;
-    return resolveConfig({ cwd: setup.cwd, repoRoot: setup.repoRoot, projectTrusted: setup.projectTrusted, configDirName: options.configDirName, env: options.env, cliOverridesToml: overridesToToml(overrides) });
+    return resolveConfig({ cwd: selected.cwd, repoRoot: selected.guestRoot, projectTrusted: setup.projectTrusted, configDirName: options.configDirName, env: options.env, cliOverridesToml: overridesToToml(overrides) });
   };
 
   const configureSession = async (setup: SessionSetup): Promise<RuntimeState> => {
     sessionId = setup.sessionId;
     cwd = setup.cwd;
     configReady = false;
-    repoRoot = setup.repoRoot ?? null;
     projectTrusted = setup.projectTrusted;
     explicitOff = isDisabledByEnv(options.env ?? process.env);
     if (explicitOff) {
@@ -593,14 +502,13 @@ export function createMsbIntegration(options: MsbControlOptions): MsbIntegration
       notifyState(failureState);
       return visibleState();
     }
-    currentGit = await detectGitRepo(cwd);
-    repoRoot = currentGit.guestRepoRoot === null
-      ? cwd
-      : currentGit.guestRepoRoot ?? currentGit.repoRoot;
-    overrides = overrideEntries(options.entries?.() ?? []);
     let next: ResolvedConfig;
     try {
-      next = await resolveForSession({ ...setup, repoRoot });
+      overrides = overrideEntries(options.entries?.() ?? []);
+      workspace = await discoverWorkspace(cwd);
+      cwd = workspace.cwd;
+      activeProjectRoot = workspace.guestRoot;
+      next = await resolveForSession(setup, workspace);
     } catch (error) {
       failureState = { status: "unavailable", info: null, reason: redactedError(error, configRef.value).message };
       notifyState(failureState);
@@ -608,7 +516,7 @@ export function createMsbIntegration(options: MsbControlOptions): MsbIntegration
     }
     resolved = next;
     configReady = true;
-    Object.assign(configRef.value, next.config, { network: { ...next.config.network }, secrets: [...next.config.secrets], mounts: [...next.config.mounts] });
+    Object.assign(configRef.value, next.config, { network: { ...next.config.network }, docker: { ...next.config.docker }, secrets: [...next.config.secrets], mounts: [...next.config.mounts] });
     const state = setup.restored ?? persistenceState(options.entries?.() ?? [], sessionId);
     explicitOff = isDisabledByEnv(options.env ?? process.env);
     failureState = explicitOff ? { status: "off", info: null } : null;
@@ -616,7 +524,7 @@ export function createMsbIntegration(options: MsbControlOptions): MsbIntegration
       if (!explicitOff) { await manager.setEnabled(false); failureState = { status: "off", info: null }; }
       return visibleState();
     }
-    const result = await manager.boot({ sessionId, cwd, config: configRef.value, restored: state });
+    const result = await manager.boot({ sessionId, cwd, workspace, config: configSnapshot(), restored: state });
     if (result.status === "unavailable") failureState = result;
     notifyState(visibleState());
     return visibleState();
@@ -644,8 +552,19 @@ export function createMsbIntegration(options: MsbControlOptions): MsbIntegration
         await manager.setEnabled(false);
         failureState = { status: "off", info: null };
       } else {
-        const result = await manager.boot({ sessionId, cwd, config: configRef.value, restored: persistenceState(options.entries?.() ?? [], sessionId) });
-        if (result.status === "unavailable") failureState = result;
+        try {
+          workspace = await discoverWorkspace(cwd);
+          cwd = workspace.cwd;
+          activeProjectRoot = workspace.guestRoot;
+          const next = await resolveConfig({ cwd, repoRoot: workspace.guestRoot, projectTrusted, configDirName: options.configDirName, env: options.env, cliOverridesToml: overridesToToml(overrides) });
+          resolved = next;
+          configReady = true;
+          Object.assign(configRef.value, next.config, { network: { ...next.config.network }, docker: { ...next.config.docker }, secrets: [...next.config.secrets], mounts: [...next.config.mounts] });
+          const result = await manager.boot({ sessionId, cwd, workspace, config: configSnapshot(), restored: persistenceState(options.entries?.() ?? [], sessionId) });
+          if (result.status === "unavailable") failureState = result;
+        } catch (error) {
+          failureState = { status: "unavailable", info: null, reason: redactedError(error, configRef.value).message };
+        }
       }
       notifyState(visibleState());
     },
@@ -658,7 +577,10 @@ export function createMsbIntegration(options: MsbControlOptions): MsbIntegration
       }
       let next: ResolvedConfig;
       try {
-        next = await resolveConfig({ cwd, repoRoot, projectTrusted, configDirName: options.configDirName, env: options.env, cliOverridesToml: overridesToToml(overrides) });
+        workspace = await discoverWorkspace(cwd);
+        cwd = workspace.cwd;
+        activeProjectRoot = workspace.guestRoot;
+        next = await resolveConfig({ cwd, repoRoot: workspace.guestRoot, projectTrusted, configDirName: options.configDirName, env: options.env, cliOverridesToml: overridesToToml(overrides) });
       } catch (error) {
         configReady = false;
         if (!manager.isActive()) failureState = { status: "unavailable", info: null, reason: redactedError(error, configRef.value).message };
@@ -667,10 +589,10 @@ export function createMsbIntegration(options: MsbControlOptions): MsbIntegration
       }
       resolved = next;
       configReady = true;
-      Object.assign(configRef.value, next.config, { network: { ...next.config.network }, secrets: [...next.config.secrets], mounts: [...next.config.mounts] });
+      Object.assign(configRef.value, next.config, { network: { ...next.config.network }, docker: { ...next.config.docker }, secrets: [...next.config.secrets], mounts: [...next.config.mounts] });
       failureState = null;
-      if (!explicitOff && configRef.value.autoStart) {
-        const result = await manager.boot({ sessionId, cwd, config: configRef.value, restored: persistenceState(options.entries?.() ?? [], sessionId) });
+      if (!explicitOff && configRef.value.autoStart && workspace) {
+        const result = await manager.boot({ sessionId, cwd, workspace, config: configSnapshot(), restored: persistenceState(options.entries?.() ?? [], sessionId) });
         if (result.status === "unavailable") failureState = result;
       }
       notifyState(visibleState());
@@ -680,94 +602,6 @@ export function createMsbIntegration(options: MsbControlOptions): MsbIntegration
       notifyState(visibleState());
       return report;
     },
-    async listVolumes() {
-      const msb = await sdk();
-      const handles = await msb.Volume.list();
-      const volumes: VolumeRecord[] = [];
-      for (const handle of handles) {
-        const identity = volumeIdentityFromHandle(handle);
-        if (!identity || identity.labels[LABEL_KEYS.managed] !== "true") continue;
-        const record = volumeFromHandle(handle);
-        if (!record) throw new Error(`host path metadata is unavailable for managed volume ${identity.name}; refusing to fabricate a path`);
-        volumes.push(record);
-      }
-      return volumes;
-    },
-    async describeVolume(name) {
-      const msb = await sdk();
-      const handle = await msb.Volume.get(name);
-      const volume = volumeFromHandle(handle);
-      if (!volume) throw new Error("microsandbox returned invalid volume metadata");
-      if (volume.labels[LABEL_KEYS.managed] !== "true") throw new Error("refusing to inspect an unmanaged volume");
-      let branch: string | undefined;
-      let lastCommit: string | undefined;
-      let dirtyCount: number | undefined;
-      try {
-        const head = await execFile("git", ["-C", volume.hostPath, "symbolic-ref", "--quiet", "--short", "HEAD"]);
-        branch = head.stdout.trim() || undefined;
-      } catch { /* detached/uninitialized volumes are valid */ }
-      try {
-        const head = await execFile("git", ["-C", volume.hostPath, "rev-parse", "HEAD"]);
-        lastCommit = head.stdout.trim() || undefined;
-      } catch { /* no commit */ }
-      try {
-        const status = await execFile("git", ["-C", volume.hostPath, "status", "--porcelain"]);
-        dirtyCount = status.stdout.trim() ? status.stdout.trim().split("\n").length : 0;
-      } catch { /* non-git volume */ }
-      return { volume, branch, lastCommit, dirtyCount, mounted: visibleState().info?.volumeName === name };
-    },
-    async removeVolume(name) {
-      const msb = await sdk();
-      const initialIdentity = volumeIdentityFromHandle(await msb.Volume.get(name));
-      const target = initialIdentity ? managedVolumeTarget(name, initialIdentity) : null;
-      if (!target) throw new Error(`managed volume identity mismatch: ${name}`);
-      const targetRequest: BootRequest = {
-        sessionId: target.sessionId,
-        cwd: target.cwd,
-        config: { ...configRef.value, mode: "git", sandboxName: sandboxNameFor(target.sessionId) },
-        restored: null,
-      };
-      const owner = options.acquireOwnerLock
-        ? await options.acquireOwnerLock(targetRequest)
-        : await acquireOwnerLock({ lockDir: expandHome(configRef.value.lockDir) }, lockInfoFor(targetRequest));
-      if (!owner) throw new Error("another process owns the target session; volume removal is blocked");
-      try {
-        const lockedIdentity = volumeIdentityFromHandle(await msb.Volume.get(name));
-        const lockedTarget = lockedIdentity ? managedVolumeTarget(name, lockedIdentity) : null;
-        if (!lockedTarget || lockedTarget.sessionId !== target.sessionId || lockedTarget.cwd !== target.cwd || lockedTarget.name !== target.name) {
-          throw new Error(`managed volume identity mismatch: ${name}`);
-        }
-        if (visibleState().info?.volumeName === name || await volumeIsMounted(msb, name)) {
-          throw new Error("refusing to remove a mounted volume");
-        }
-        // Volume.remove is the final atomic mount check: microsandbox rejects
-        // deletion if a sandbox mounts the volume after the list recheck.
-        await msb.Volume.remove(name);
-      } finally {
-        await owner.release();
-      }
-    },
-    async exportPaths(paths, destination) {
-      if (!manager.isActive()) throw new Error("sandbox is not active");
-      const target = destination ? resolve(destination) : await fs.mkdtemp(join((process.env.TMPDIR ?? "/tmp"), "pi-msb-export-"));
-      await fs.mkdir(target, { recursive: true, mode: 0o700 });
-      const results: Array<{ source: string; destination: string }> = [];
-      await manager.withRuntime(async (runtime) => {
-        for (const requested of paths) {
-          const source = requested.startsWith("/") ? resolve(requested) : resolve(cwd, requested);
-          const sourceRoot = resolve(activeProjectRoot);
-          const sourceRelative = relativePath(sourceRoot, source);
-          if (sourceRelative === ".." || sourceRelative.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) || isAbsolute(sourceRelative)) {
-            throw new Error(`refusing to export a path outside the sandbox project: ${requested}`);
-          }
-          const output = join(target, basename(source));
-          if (resolve(output) !== output || await fs.lstat(output).then(() => true, () => false)) throw new Error(`export destination exists: ${output}`);
-          await runtime.transport.copyToHost(source, output);
-          results.push({ source, destination: output });
-        }
-      });
-      return results;
-    },
     async getLogs(tailLines) {
       const name = visibleState().info?.name;
       if (!name) return "";
@@ -795,8 +629,6 @@ export function createMsbIntegration(options: MsbControlOptions): MsbIntegration
     },
   };
 
-  // Keep the returned config facade useful to callers without exposing mutable internals.
-  void repoRoot;
   return { control, manager, provider, configRef, configureSession };
 }
 

package/extensions/pi-msb/index.ts

@@ -117,8 +117,8 @@ export default function registerPiMsb(pi: ExtensionAPI): void {
     currentContext = ctx;
     updateStatus(ctx, { status: "booting", info: null });
     try {
-      // configureSession performs Git discovery before project config resolution,
-      // so trust and the nearest project file are evaluated against the real root.
+      // configureSession discovers the workspace once before project config
+      // resolution, and passes that same identity through sandbox boot.
       const state = await integration.configureSession({
         sessionId: ctx.sessionManager.getSessionId(),
         cwd: ctx.cwd,