@parall/daemon 1.29.2 → 1.30.0

package/bundle/parall-daemon.js

@@ -5,7 +5,8 @@ function createLogger(prefix) {
   return {
     info: (msg) => console.log(`${(/* @__PURE__ */ new Date()).toISOString()} [${prefix}] ${msg}`),
     warn: (msg) => console.warn(`${(/* @__PURE__ */ new Date()).toISOString()} [${prefix}] ${msg}`),
-    error: (msg) => console.error(`${(/* @__PURE__ */ new Date()).toISOString()} [${prefix}] ${msg}`)
+    error: (msg) => console.error(`${(/* @__PURE__ */ new Date()).toISOString()} [${prefix}] ${msg}`),
+    child: (sub) => createLogger(`${prefix}:${sub}`)
   };
 }
 
@@ -82,6 +83,7 @@ var ENDPOINTS = {
   AGENT_ACTIVITY: (orgId, agentId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/activity`,
   AGENT_MONITOR: (orgId, agentId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/monitor`,
   AGENT_ME: (orgId) => `${API_BASE}/orgs/${orgId}/agents/me`,
+  AGENT_NEW_SESSION: (orgId, agentId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/new-session`,
   AGENT_SESSIONS: (orgId, agentId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/sessions`,
   AGENT_SESSION: (orgId, agentId, sessionId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/sessions/${sessionId}`,
   AGENT_SESSION_STEPS: (orgId, agentId, sessionId) => `${API_BASE}/orgs/${orgId}/agents/${agentId}/sessions/${sessionId}/steps`,
@@ -120,6 +122,7 @@ var ENDPOINTS = {
   MACHINE_KEY: (orgId, machineId, keyId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/keys/${keyId}`,
   MACHINE_RUNTIME_AUTH_SESSIONS: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/runtime-auth-sessions`,
   MACHINE_RUNTIME_AUTH_SESSION_COMPLETE: (orgId, machineId, sessionId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/runtime-auth-sessions/${sessionId}/complete`,
+  MACHINE_BROWSE: (orgId, machineId) => `${API_BASE}/orgs/${orgId}/machines/${machineId}/browse`,
   // Machine self-control-plane (mck_-scoped). The bearer token implicitly
   // identifies the Machine, so there is no `:mid` URL parameter — these are
   // "self" routes called by the daemon for its own host.
@@ -129,6 +132,7 @@ var ENDPOINTS = {
   MACHINES_ME_AGENT_LAUNCH_CREDENTIAL: (agentId) => `${API_BASE}/machines/me/agents/${agentId}/launch-credential`,
   MACHINES_ME_AGENT_WORKSPACE_STATE: (agentId) => `${API_BASE}/machines/me/agents/${agentId}/workspace-state`,
   MACHINES_ME_WS_TICKET: `${API_BASE}/machines/me/ws/ticket`,
+  MACHINES_ME_BROWSE_RESPONSE: (requestId) => `${API_BASE}/machines/me/browse-response/${requestId}`,
   // Tasks (org-scoped)
   TASKS: (orgId) => `${API_BASE}/orgs/${orgId}/tasks`,
   TASK: (orgId, taskId) => `${API_BASE}/orgs/${orgId}/tasks/${taskId}`,
@@ -308,7 +312,9 @@ var WS_EVENTS = {
   MACHINE_AGENT_ATTACHED: "machine.agent.attached",
   MACHINE_AGENT_DETACHED: "machine.agent.detached",
   MACHINE_STOP: "machine.stop",
-  MACHINE_WORKSPACE_SETUP_REQUESTED: "machine.workspace.setup.requested"
+  MACHINE_WORKSPACE_SETUP_REQUESTED: "machine.workspace.setup.requested",
+  MACHINE_FILESYSTEM_BROWSE: "machine.filesystem.browse",
+  AGENT_NEW_SESSION: "agent.new_session"
 };
 
 // ts/sdk/dist/client.js
@@ -391,10 +397,10 @@ var ParallClient = class _ParallClient {
    * REFRESH_THRESHOLD_S, refresh it **before** sending the request.
    * No-op when the token is still fresh, missing, or un-parseable.
    */
-  async ensureFreshToken(path6) {
+  async ensureFreshToken(path7) {
     if (!this.token || !this.getRefreshToken)
       return;
-    const pathSuffix = path6.replace(/^\/api\/v1/, "");
+    const pathSuffix = path7.replace(/^\/api\/v1/, "");
     if (_ParallClient.AUTH_PATHS.has(pathSuffix))
       return;
     const exp = _ParallClient.decodeJwtExp(this.token);
@@ -426,11 +432,11 @@ var ParallClient = class _ParallClient {
       this.refreshPromise = null;
     }
   }
-  async request(method, path6, body, query, retried = false, opts) {
+  async request(method, path7, body, query, retried = false, opts) {
     if (!retried) {
-      await this.ensureFreshToken(path6);
+      await this.ensureFreshToken(path7);
     }
-    let url = `${this.baseUrl}${path6}`;
+    let url = `${this.baseUrl}${path7}`;
     if (query) {
       const params = new URLSearchParams();
       for (const [key, value] of Object.entries(query)) {
@@ -455,12 +461,12 @@ var ParallClient = class _ParallClient {
       throw _ParallClient.normalizeFetchError(err);
     }
     if (res.status === 401) {
-      const pathSuffix = path6.replace(/^\/api\/v1/, "");
+      const pathSuffix = path7.replace(/^\/api\/v1/, "");
       const isAuthPath = _ParallClient.AUTH_PATHS.has(pathSuffix);
       if (!retried && !isAuthPath && this.getRefreshToken) {
         const refreshed = await this.tryRefresh();
         if (refreshed) {
-          return this.request(method, path6, body, query, true, opts);
+          return this.request(method, path7, body, query, true, opts);
         }
       }
       if (this.onTokenExpired && !isAuthPath) {
@@ -497,15 +503,15 @@ var ParallClient = class _ParallClient {
    * hit the 100 MiB cap, so a longer 5-minute timeout is used so a
    * 50 MiB blob on a slow connection doesn't get chopped at 15 s.
    */
-  async multipartRequest(method, path6, body, retried = false) {
+  async multipartRequest(method, path7, body, retried = false) {
     if (!retried) {
-      await this.ensureFreshToken(path6);
+      await this.ensureFreshToken(path7);
     }
     const { "Content-Type": _drop, ...headers } = this.buildHeaders();
     void _drop;
     let res;
     try {
-      res = await fetch(`${this.baseUrl}${path6}`, {
+      res = await fetch(`${this.baseUrl}${path7}`, {
         method,
         headers,
         body,
@@ -515,12 +521,12 @@ var ParallClient = class _ParallClient {
       throw _ParallClient.normalizeFetchError(err);
     }
     if (res.status === 401) {
-      const pathSuffix = path6.replace(/^\/api\/v1/, "");
+      const pathSuffix = path7.replace(/^\/api\/v1/, "");
       const isAuthPath = _ParallClient.AUTH_PATHS.has(pathSuffix);
       if (!retried && !isAuthPath && this.getRefreshToken) {
         const refreshed = await this.tryRefresh();
         if (refreshed) {
-          return this.multipartRequest(method, path6, body, true);
+          return this.multipartRequest(method, path7, body, true);
         }
       }
       if (this.onTokenExpired && !isAuthPath) {
@@ -854,6 +860,9 @@ var ParallClient = class _ParallClient {
     return this.request("GET", ENDPOINTS.AGENT_ME(orgId));
   }
   // ---- Agent Sessions (org-scoped) ----
+  async requestNewAgentSession(orgId, agentId) {
+    return this.request("POST", ENDPOINTS.AGENT_NEW_SESSION(orgId, agentId));
+  }
   async createAgentSession(orgId, agentId, req) {
     return this.request("POST", ENDPOINTS.AGENT_SESSIONS(orgId, agentId), req);
   }
@@ -1053,9 +1062,15 @@ var ParallClient = class _ParallClient {
   async getMachineWsTicket() {
     return this.request("POST", ENDPOINTS.MACHINES_ME_WS_TICKET);
   }
+  async postBrowseResponse(requestId, response) {
+    return this.request("POST", ENDPOINTS.MACHINES_ME_BROWSE_RESPONSE(requestId), response);
+  }
   async resizeMachine(orgId, machineId, spec) {
     return this.request("PATCH", ENDPOINTS.MACHINE_SPEC(orgId, machineId), spec);
   }
+  async browseMachineFilesystem(orgId, machineId, path7) {
+    return this.request("POST", ENDPOINTS.MACHINE_BROWSE(orgId, machineId), { path: path7 }, void 0, false, { timeoutMs: 15e3 });
+  }
   /** Create a new machine key. Returns the raw key string (shown once) + metadata. */
   async createMachineKey(orgId, machineId, name) {
     return this.request("POST", ENDPOINTS.MACHINE_KEYS(orgId, machineId), name ? { name } : void 0);
@@ -1404,8 +1419,8 @@ var ParallClient = class _ParallClient {
   async deleteWikiPathScope(orgId, wikiId, scopeId) {
     await this.request("DELETE", ENDPOINTS.WIKI_PATH_SCOPE(orgId, wikiId, scopeId));
   }
-  async getWikiAccessStatus(orgId, wikiId, path6) {
-    return this.request("GET", ENDPOINTS.WIKI_ACCESS_STATUS(orgId, wikiId), void 0, path6 ? { path: path6 } : void 0);
+  async getWikiAccessStatus(orgId, wikiId, path7) {
+    return this.request("GET", ENDPOINTS.WIKI_ACCESS_STATUS(orgId, wikiId), void 0, path7 ? { path: path7 } : void 0);
   }
   async createWikiAccessRequest(orgId, wikiId, data) {
     await this.request("POST", ENDPOINTS.WIKI_ACCESS_REQUESTS(orgId, wikiId), data);
@@ -1414,11 +1429,11 @@ var ParallClient = class _ParallClient {
   async getWikiCommits(orgId, wikiId, params) {
     return this.request("GET", ENDPOINTS.WIKI_COMMITS(orgId, wikiId), void 0, params);
   }
-  async getWikiFileCommits(orgId, wikiId, path6, params) {
-    return this.request("GET", ENDPOINTS.WIKI_FILE_COMMITS(orgId, wikiId), void 0, { path: path6, ...params });
+  async getWikiFileCommits(orgId, wikiId, path7, params) {
+    return this.request("GET", ENDPOINTS.WIKI_FILE_COMMITS(orgId, wikiId), void 0, { path: path7, ...params });
   }
-  async getWikiBlame(orgId, wikiId, path6, ref) {
-    return this.request("GET", ENDPOINTS.WIKI_BLAME(orgId, wikiId), void 0, { path: path6, ref });
+  async getWikiBlame(orgId, wikiId, path7, ref) {
+    return this.request("GET", ENDPOINTS.WIKI_BLAME(orgId, wikiId), void 0, { path: path7, ref });
   }
   // ---- Wiki Operations (audit log) ----
   async getWikiOperations(orgId, wikiId, params) {
@@ -2016,11 +2031,125 @@ function resolveWsUrl(apiUrl, explicitWsUrl, swimlaneName) {
 
 // ts/daemon/dist/supervisor.js
 import { spawn as spawn2 } from "node:child_process";
-import * as fs3 from "node:fs";
-import * as path4 from "node:path";
+import * as fs4 from "node:fs";
+import * as path5 from "node:path";
+
+// ts/daemon/dist/filesystem.js
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as os2 from "os";
+var MAX_ENTRIES = 200;
+var SYSTEM_DIR_PREFIXES = [
+  "/Applications",
+  "/bin",
+  "/boot",
+  "/dev",
+  "/etc",
+  "/Library",
+  "/private",
+  "/proc",
+  "/root",
+  "/run",
+  "/sbin",
+  "/System",
+  "/sys",
+  "/usr",
+  "/var"
+];
+var CREDENTIAL_DIR_NAMES = /* @__PURE__ */ new Set([
+  ".aws",
+  ".azure",
+  ".claude",
+  ".codex",
+  ".config",
+  ".docker",
+  ".gnupg",
+  ".kube",
+  ".npm",
+  ".ssh",
+  ".parall-agent",
+  ".parall-daemon"
+]);
+function browseDenyReason(value) {
+  const normalized = path2.resolve(value).split(path2.sep).join("/");
+  if (normalized === "/")
+    return "";
+  for (const prefix of SYSTEM_DIR_PREFIXES) {
+    if (normalized === prefix || normalized.startsWith(`${prefix}/`)) {
+      return "a system directory";
+    }
+  }
+  const parts = normalized.split("/").filter(Boolean);
+  for (const part of parts) {
+    if (CREDENTIAL_DIR_NAMES.has(part)) {
+      return "a credential or application state directory";
+    }
+  }
+  return "";
+}
+function syntheticRoots() {
+  const roots = [];
+  const platform2 = os2.platform();
+  const candidates = platform2 === "darwin" ? ["/Users", os2.homedir()] : ["/home", os2.homedir()];
+  for (const dir of [...new Set(candidates)]) {
+    try {
+      fs2.accessSync(dir, fs2.constants.R_OK);
+      roots.push({ name: dir, type: "dir" });
+    } catch {
+    }
+  }
+  return roots;
+}
+async function listDirectory(dirPath) {
+  const resolved = path2.resolve(dirPath);
+  const normalized = resolved.split(path2.sep).join("/");
+  if (normalized === "/") {
+    return { entries: syntheticRoots() };
+  }
+  const deny = browseDenyReason(normalized);
+  if (deny) {
+    return { entries: [], error: `Access denied: ${deny}` };
+  }
+  let realPath;
+  try {
+    realPath = fs2.realpathSync(resolved);
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT")
+      return { entries: [], error: "Directory not found" };
+    return { entries: [], error: "Permission denied" };
+  }
+  const realDeny = browseDenyReason(realPath.split(path2.sep).join("/"));
+  if (realDeny) {
+    return { entries: [], error: `Access denied: ${realDeny}` };
+  }
+  let dirents;
+  try {
+    dirents = fs2.readdirSync(realPath, { withFileTypes: true });
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT")
+      return { entries: [], error: "Directory not found" };
+    if (code === "EACCES" || code === "EPERM")
+      return { entries: [], error: "Permission denied" };
+    return { entries: [], error: `Failed to read directory: ${code ?? String(err)}` };
+  }
+  const entries = [];
+  for (const d of dirents) {
+    if (!d.isDirectory())
+      continue;
+    if (d.name.startsWith("."))
+      continue;
+    entries.push({ name: d.name, type: "dir" });
+    if (entries.length >= MAX_ENTRIES)
+      break;
+  }
+  entries.sort((a, b) => a.name.localeCompare(b.name));
+  return { entries };
+}
 
 // ts/daemon/dist/runtimes.js
-import * as path2 from "node:path";
+import * as path3 from "node:path";
 function llmSource(pc) {
   if (pc?.llm_source)
     return pc.llm_source;
@@ -2077,7 +2206,7 @@ var codexAdapter = {
     env.PRLL_AGENT_ID = agentId;
     env.PRLL_CODEX_STATE_DIR = dirs.stateDir;
     env.PRLL_CODEX_WORKSPACE_DIR = dirs.workspaceDir;
-    env.PRLL_CODEX_HOME = path2.join(dirs.stateDir, ".codex");
+    env.PRLL_CODEX_HOME = path3.join(dirs.stateDir, ".codex");
     const source = llmSource(pc);
     if (source === "parall") {
       env.OPENAI_API_KEY = apiKey;
@@ -2139,14 +2268,15 @@ function assertAgentKey(apiKey) {
 // ts/daemon/dist/workspace.js
 import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
-import * as fs2 from "node:fs";
-import * as path3 from "node:path";
+import * as fs3 from "node:fs";
+import * as path4 from "node:path";
 var OUTPUT_TAIL_LIMIT = 32 * 1024;
 var DEFAULT_SETUP_TIMEOUT_SEC = 600;
 async function prepareWorkspace(opts) {
   const prior = opts.attached.workspace_state;
   const plan = buildWorkspacePlan(opts.attached.daemon_config, opts.defaultWorkspaceDir, prior?.config_hash);
-  if (!opts.attached.daemon_config && !prior) {
+  const hasConfig = opts.attached.daemon_config && Object.keys(opts.attached.daemon_config).length > 0;
+  if (!hasConfig && !prior) {
     return plan.workspaceDir;
   }
   let forceSetup = false;
@@ -2256,7 +2386,7 @@ function resolveWorkspaceDir(workspace, defaultWorkspaceDir) {
 async function ensureWorkspace(plan, log2) {
   const ws = plan.workspace;
   if (ws.mode === "default") {
-    fs2.mkdirSync(plan.workspaceDir, { recursive: true });
+    fs3.mkdirSync(plan.workspaceDir, { recursive: true });
     assertWritableWorkspaceDir(plan.workspaceDir);
     return;
   }
@@ -2264,7 +2394,7 @@ async function ensureWorkspace(plan, log2) {
     assertSafeCustomWorkspacePath(plan);
     let st;
     try {
-      st = fs2.statSync(plan.workspaceDir);
+      st = fs3.statSync(plan.workspaceDir);
     } catch (err) {
       if (isNodeError(err) && err.code === "ENOENT") {
         throw new Error(`workspace path does not exist: ${plan.workspaceDir}`);
@@ -2274,7 +2404,7 @@ async function ensureWorkspace(plan, log2) {
     if (!st.isDirectory()) {
       throw new Error(`workspace path is not a directory: ${plan.workspaceDir}`);
     }
-    assertSafeCustomWorkspacePath(plan, fs2.realpathSync(plan.workspaceDir));
+    assertSafeCustomWorkspacePath(plan, fs3.realpathSync(plan.workspaceDir));
     assertWritableWorkspaceDir(plan.workspaceDir);
     return;
   }
@@ -2285,17 +2415,17 @@ async function ensureWorkspace(plan, log2) {
     if (plan.customWorkspaceField) {
       assertSafeCustomWorkspacePath(plan);
     }
-    if (!fs2.existsSync(plan.workspaceDir)) {
-      fs2.mkdirSync(path3.dirname(plan.workspaceDir), { recursive: true });
-      assertWritableWorkspaceDir(path3.dirname(plan.workspaceDir));
+    if (!fs3.existsSync(plan.workspaceDir)) {
+      fs3.mkdirSync(path4.dirname(plan.workspaceDir), { recursive: true });
+      assertWritableWorkspaceDir(path4.dirname(plan.workspaceDir));
       await runCommand("git", ["clone", remote, plan.workspaceDir], process.cwd());
     } else {
-      const st = fs2.statSync(plan.workspaceDir);
+      const st = fs3.statSync(plan.workspaceDir);
       if (!st.isDirectory()) {
         throw new Error(`workspace path is not a directory: ${plan.workspaceDir}`);
       }
       if (plan.customWorkspaceField) {
-        assertSafeCustomWorkspacePath(plan, fs2.realpathSync(plan.workspaceDir));
+        assertSafeCustomWorkspacePath(plan, fs3.realpathSync(plan.workspaceDir));
       }
       assertWritableWorkspaceDir(plan.workspaceDir);
       await ensureGitWorktree(plan.workspaceDir);
@@ -2319,13 +2449,13 @@ async function verifyExistingWorkspace(plan, log2) {
     if (plan.customWorkspaceField) {
       assertSafeCustomWorkspacePath(plan);
     }
-    const st = fs2.statSync(plan.workspaceDir);
+    const st = fs3.statSync(plan.workspaceDir);
     if (!st.isDirectory()) {
       log2.warn(`workspace ready state ignored: path is not a directory: ${plan.workspaceDir}`);
       return false;
     }
     if (plan.customWorkspaceField) {
-      assertSafeCustomWorkspacePath(plan, fs2.realpathSync(plan.workspaceDir));
+      assertSafeCustomWorkspacePath(plan, fs3.realpathSync(plan.workspaceDir));
     }
     assertWritableWorkspaceDir(plan.workspaceDir);
     if (plan.workspace.mode === "git") {
@@ -2418,7 +2548,7 @@ async function tryGitOutput(cmd, args, cwd) {
   }
 }
 function runCommand(cmd, args, cwd, timeoutMs = 12e4, env = process.env) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     let tail = "";
     let timedOut = false;
     let settled = false;
@@ -2460,7 +2590,7 @@ ${tail}`)));
         return;
       }
       if (code === 0) {
-        settle(() => resolve4(tail));
+        settle(() => resolve5(tail));
       } else {
         settle(() => reject(new Error(`command failed (${code ?? signal}): ${cmd} ${args.join(" ")}
 ${tail}`)));
@@ -2469,10 +2599,10 @@ ${tail}`)));
   });
 }
 function requireAbsolute(value, field) {
-  if (!value || !path3.isAbsolute(value)) {
+  if (!value || !path4.isAbsolute(value)) {
     throw new Error(`${field} must be an absolute path`);
   }
-  return path3.resolve(value);
+  return path4.resolve(value);
 }
 function assertSafeCustomWorkspacePath(plan, candidate = plan.workspaceDir) {
   if (!plan.customWorkspaceField)
@@ -2482,17 +2612,17 @@ function assertSafeCustomWorkspacePath(plan, candidate = plan.workspaceDir) {
   if (reason) {
     throw new Error(`${plan.customWorkspaceField} must point to a project folder, not ${reason}: ${normalized}`);
   }
-  const defaultWorkspace = path3.resolve(plan.defaultWorkspaceDir);
+  const defaultWorkspace = path4.resolve(plan.defaultWorkspaceDir);
   if (isAncestorPath(normalized, defaultWorkspace) || normalized === defaultWorkspace) {
     throw new Error(`${plan.customWorkspaceField} must not point at daemon state directories: ${normalized}`);
   }
 }
 function assertWritableWorkspaceDir(dir) {
-  fs2.accessSync(dir, fs2.constants.R_OK | fs2.constants.W_OK | fs2.constants.X_OK);
-  const probe = path3.join(dir, `.parall-workspace-check-${process.pid}-${Date.now()}`);
-  const fd = fs2.openSync(probe, "wx", 384);
-  fs2.closeSync(fd);
-  fs2.unlinkSync(probe);
+  fs3.accessSync(dir, fs3.constants.R_OK | fs3.constants.W_OK | fs3.constants.X_OK);
+  const probe = path4.join(dir, `.parall-workspace-check-${process.pid}-${Date.now()}`);
+  const fd = fs3.openSync(probe, "wx", 384);
+  fs3.closeSync(fd);
+  fs3.unlinkSync(probe);
 }
 function workspacePathDenyReason(value) {
   if (value === "/")
@@ -2553,11 +2683,11 @@ function workspacePathDenyReason(value) {
   return "";
 }
 function isAncestorPath(parent, child) {
-  const relative2 = path3.relative(parent, child);
-  return relative2 !== "" && !relative2.startsWith("..") && !path3.isAbsolute(relative2);
+  const relative2 = path4.relative(parent, child);
+  return relative2 !== "" && !relative2.startsWith("..") && !path4.isAbsolute(relative2);
 }
 function toPolicyPath(value) {
-  return path3.resolve(value).split(path3.sep).join("/");
+  return path4.resolve(value).split(path4.sep).join("/");
 }
 function isNodeError(err) {
   return err instanceof Error && "code" in err;
@@ -2573,14 +2703,14 @@ var WORKSPACE_SETUP_RETRY_DELAY_MS = 5e3;
 function sleepCancellable(ms, signal) {
   if (signal.aborted)
     return Promise.resolve(false);
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const timer = setTimeout(() => {
       signal.removeEventListener("abort", onAbort);
-      resolve4(true);
+      resolve5(true);
     }, ms);
     const onAbort = () => {
       clearTimeout(timer);
-      resolve4(false);
+      resolve5(false);
     };
     signal.addEventListener("abort", onAbort, { once: true });
   });
@@ -2658,6 +2788,10 @@ var DaemonSupervisor = class {
       this.log.info(`WS: workspace setup requested for agent ${data.agent_id}`);
       void this.handleWorkspaceSetupRequested(data.agent_id);
     });
+    this.ws.on("machine.filesystem.browse", (data) => {
+      this.log.info(`WS: filesystem browse requested: ${data.path}`);
+      void this.handleFilesystemBrowse(data.request_id, data.path);
+    });
     this.ws.on("machine.stop", (data) => {
       this.log.info(`WS: machine.stop received (reason=${data.reason ?? "none"})`);
       void this.stop();
@@ -2668,8 +2802,8 @@ var DaemonSupervisor = class {
       }
     });
     await this.ws.connect();
-    await new Promise((resolve4) => {
-      this.stopResolve = resolve4;
+    await new Promise((resolve5) => {
+      this.stopResolve = resolve5;
     });
     signal.removeEventListener("abort", onAbort);
   }
@@ -2788,15 +2922,15 @@ var DaemonSupervisor = class {
    */
   migrateFlatLayout() {
     const root = this.config.rootStateDir;
-    const agentsDir = path4.join(root, "agents");
-    const flatWorkspace = path4.join(root, "workspace");
-    if (!fs3.existsSync(flatWorkspace) || fs3.existsSync(agentsDir))
+    const agentsDir = path5.join(root, "agents");
+    const flatWorkspace = path5.join(root, "workspace");
+    if (!fs4.existsSync(flatWorkspace) || fs4.existsSync(agentsDir))
       return;
     let ownerAgentId;
-    const sessionsDir = path4.join(root, "sessions");
-    if (fs3.existsSync(sessionsDir)) {
+    const sessionsDir = path5.join(root, "sessions");
+    if (fs4.existsSync(sessionsDir)) {
       try {
-        for (const file of fs3.readdirSync(sessionsDir)) {
+        for (const file of fs4.readdirSync(sessionsDir)) {
           if (!file.endsWith(".json"))
             continue;
           const decoded = Buffer.from(file.replace(".json", ""), "base64url").toString();
@@ -2810,13 +2944,13 @@ var DaemonSupervisor = class {
       }
     }
     const targetId = ownerAgentId ?? "_orphan";
-    const targetDir = path4.join(agentsDir, targetId);
+    const targetDir = path5.join(agentsDir, targetId);
     try {
-      fs3.mkdirSync(targetDir, { recursive: true });
+      fs4.mkdirSync(targetDir, { recursive: true });
       for (const sub of ["workspace", "sessions", "dispatch-context"]) {
-        const src = path4.join(root, sub);
-        if (fs3.existsSync(src)) {
-          fs3.renameSync(src, path4.join(targetDir, sub));
+        const src = path5.join(root, sub);
+        if (fs4.existsSync(src)) {
+          fs4.renameSync(src, path5.join(targetDir, sub));
         }
       }
       this.log.info(`migrated legacy flat state \u2192 agents/${targetId}/`);
@@ -2876,6 +3010,28 @@ var DaemonSupervisor = class {
     await this.terminateChild(state);
     this.children.delete(agentId);
   }
+  async handleFilesystemBrowse(requestId, dirPath) {
+    try {
+      const result = await listDirectory(dirPath);
+      await this.client.postBrowseResponse(requestId, {
+        request_id: requestId,
+        path: dirPath,
+        entries: result.entries,
+        error: result.error
+      });
+    } catch (err) {
+      this.log.warn(`filesystem browse failed: ${String(err)}`);
+      try {
+        await this.client.postBrowseResponse(requestId, {
+          request_id: requestId,
+          path: dirPath,
+          entries: [],
+          error: String(err)
+        });
+      } catch {
+      }
+    }
+  }
   async handleWorkspaceSetupRequested(agentId) {
     if (this.spawningAgents.has(agentId)) {
       this.log.info(`agent ${agentId}: workspace setup already in progress; queueing one restart`);
@@ -3001,9 +3157,9 @@ var DaemonSupervisor = class {
     const isK8s = !!process.env.KUBERNETES_SERVICE_HOST;
     const claudeHome = isK8s ? agentClaudeHomeFor(this.config.rootClaudeHome, agentId) : this.config.rootClaudeHome;
     try {
-      fs3.mkdirSync(stateDir, { recursive: true });
+      fs4.mkdirSync(stateDir, { recursive: true });
       if (isK8s) {
-        fs3.mkdirSync(claudeHome, { recursive: true });
+        fs4.mkdirSync(claudeHome, { recursive: true });
         this.ensureSharedCredentialLink(claudeHome, agentId);
       }
     } catch (err) {
@@ -3108,15 +3264,15 @@ var DaemonSupervisor = class {
     const child = state.child;
     if (!child)
       return;
-    return new Promise((resolve4) => {
-      const onExit = () => resolve4();
+    return new Promise((resolve5) => {
+      const onExit = () => resolve5();
       child.once("exit", onExit);
       try {
         child.kill("SIGTERM");
       } catch (err) {
         this.log.warn(`SIGTERM ${state.agentId} threw: ${String(err)}`);
         child.off("exit", onExit);
-        resolve4();
+        resolve5();
         return;
       }
       const hardKill = setTimeout(() => {
@@ -3129,60 +3285,60 @@ var DaemonSupervisor = class {
     });
   }
   ensureSharedCredentialLink(agentClaudeHome, agentId) {
-    const sharedCredentials = path4.resolve(sharedClaudeCredentialsFileFor(this.config.rootClaudeHome));
+    const sharedCredentials = path5.resolve(sharedClaudeCredentialsFileFor(this.config.rootClaudeHome));
     const agentCredentials = agentClaudeCredentialsFileFor(agentClaudeHome);
-    const agentCredentialsDir = path4.dirname(agentCredentials);
-    fs3.mkdirSync(path4.dirname(sharedCredentials), { recursive: true });
-    fs3.mkdirSync(agentCredentialsDir, { recursive: true });
+    const agentCredentialsDir = path5.dirname(agentCredentials);
+    fs4.mkdirSync(path5.dirname(sharedCredentials), { recursive: true });
+    fs4.mkdirSync(agentCredentialsDir, { recursive: true });
     try {
-      const existing = fs3.lstatSync(agentCredentials);
+      const existing = fs4.lstatSync(agentCredentials);
       if (existing.isSymbolicLink()) {
-        const currentTarget = fs3.readlinkSync(agentCredentials);
-        if (path4.resolve(agentCredentialsDir, currentTarget) === sharedCredentials) {
+        const currentTarget = fs4.readlinkSync(agentCredentials);
+        if (path5.resolve(agentCredentialsDir, currentTarget) === sharedCredentials) {
           return;
         }
-        fs3.unlinkSync(agentCredentials);
+        fs4.unlinkSync(agentCredentials);
       } else if (existing.isDirectory()) {
         this.log.warn(`agent ${agentId}: credential path is a directory, cannot link ${agentCredentials}`);
         return;
       } else {
-        fs3.unlinkSync(agentCredentials);
+        fs4.unlinkSync(agentCredentials);
       }
     } catch (err) {
       if (err.code !== "ENOENT") {
         throw err;
       }
     }
-    fs3.symlinkSync(sharedCredentials, agentCredentials);
+    fs4.symlinkSync(sharedCredentials, agentCredentials);
   }
 };
 
 // ts/daemon/dist/cli.js
-import * as fs4 from "node:fs";
-import * as path5 from "node:path";
-import * as os2 from "node:os";
+import * as fs5 from "node:fs";
+import * as path6 from "node:path";
+import * as os3 from "node:os";
 import * as readline from "node:readline";
 import { spawn as spawn3, execSync } from "node:child_process";
 var CONFIG_DIR = daemonConfigDir();
 var CONFIG_PATH = daemonConfigPath();
 function readConfig() {
   try {
-    return JSON.parse(fs4.readFileSync(CONFIG_PATH, "utf-8"));
+    return JSON.parse(fs5.readFileSync(CONFIG_PATH, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeConfig(config) {
-  fs4.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
-  fs4.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 384 });
-  fs4.chmodSync(CONFIG_PATH, 384);
+  fs5.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  fs5.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 384 });
+  fs5.chmodSync(CONFIG_PATH, 384);
 }
 function prompt(question) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve4(answer.trim());
+      resolve5(answer.trim());
     });
   });
 }
@@ -3194,10 +3350,10 @@ function isLinux() {
 }
 var PLIST_LABEL = "com.parall.daemon";
 function plistPath() {
-  return path5.join(os2.homedir(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
+  return path6.join(os3.homedir(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
 }
 function systemdUnitPath() {
-  return path5.join(os2.homedir(), ".config", "systemd", "user", "parall-daemon.service");
+  return path6.join(os3.homedir(), ".config", "systemd", "user", "parall-daemon.service");
 }
 function getDaemonBin() {
   try {
@@ -3207,7 +3363,7 @@ function getDaemonBin() {
   }
 }
 function generatePlist(daemonBin) {
-  const logPath = path5.join(os2.homedir(), "Library", "Logs", "parall-daemon.log");
+  const logPath = path6.join(os3.homedir(), "Library", "Logs", "parall-daemon.log");
   return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -3254,16 +3410,16 @@ function installService() {
   }
   const bin = getDaemonBin();
   if (isMacOS()) {
-    const dir = path5.dirname(plistPath());
-    fs4.mkdirSync(dir, { recursive: true });
-    fs4.writeFileSync(plistPath(), generatePlist(bin));
+    const dir = path6.dirname(plistPath());
+    fs5.mkdirSync(dir, { recursive: true });
+    fs5.writeFileSync(plistPath(), generatePlist(bin));
     execSync(`launchctl bootout gui/$(id -u) ${plistPath()} 2>/dev/null || true`);
     execSync(`launchctl bootstrap gui/$(id -u) ${plistPath()}`);
     console.log(`launchd agent installed: ${plistPath()}`);
   } else if (isLinux()) {
-    const dir = path5.dirname(systemdUnitPath());
-    fs4.mkdirSync(dir, { recursive: true });
-    fs4.writeFileSync(systemdUnitPath(), generateSystemdUnit(bin));
+    const dir = path6.dirname(systemdUnitPath());
+    fs5.mkdirSync(dir, { recursive: true });
+    fs5.writeFileSync(systemdUnitPath(), generateSystemdUnit(bin));
     execSync("systemctl --user daemon-reload");
     execSync("systemctl --user enable --now parall-daemon");
     console.log(`systemd service installed: ${systemdUnitPath()}`);
@@ -3330,8 +3486,8 @@ function cmdLogs(lines) {
     child2.on("exit", (code) => process.exit(code ?? 0));
     return;
   }
-  const logPath = path5.join(os2.homedir(), "Library", "Logs", "parall-daemon.log");
-  if (!fs4.existsSync(logPath)) {
+  const logPath = path6.join(os3.homedir(), "Library", "Logs", "parall-daemon.log");
+  if (!fs5.existsSync(logPath)) {
     console.log("No log file found at", logPath);
     return;
   }
@@ -3341,14 +3497,14 @@ function cmdLogs(lines) {
 function cmdServiceUninstall() {
   if (isMacOS()) {
     execSync(`launchctl bootout gui/$(id -u) ${plistPath()} 2>/dev/null || true`);
-    if (fs4.existsSync(plistPath()))
-      fs4.unlinkSync(plistPath());
+    if (fs5.existsSync(plistPath()))
+      fs5.unlinkSync(plistPath());
     console.log("launchd agent uninstalled.");
   } else if (isLinux()) {
     execSync("systemctl --user stop parall-daemon 2>/dev/null || true");
     execSync("systemctl --user disable parall-daemon 2>/dev/null || true");
-    if (fs4.existsSync(systemdUnitPath()))
-      fs4.unlinkSync(systemdUnitPath());
+    if (fs5.existsSync(systemdUnitPath()))
+      fs5.unlinkSync(systemdUnitPath());
     execSync("systemctl --user daemon-reload");
     console.log("systemd service uninstalled.");
   } else {