@schlenkr/ragents 0.1.5 → 0.1.7

package/plugins/ragents.workspace/server/runtime.ts

@@ -1,25 +1,44 @@
 import { mkdir, realpath } from "node:fs/promises";
 import path from "node:path";
-import type { JsonValue, RunState, WorkspaceToolNaming } from "@aicontainer/ragents";
-import { DomainError } from "@aicontainer/ragents";
-import type { SandboxHomeEnvironment, WorkspaceExecutor } from "@aicontainer/workspace-executor";
+import type { JsonValue, RunState, WorkspaceToolNaming } from "@ragents/engine";
+import { DomainError } from "@ragents/engine";
+import {
+  RUN_FOLDER_OPERATIONS,
+  type RunFolderCreated,
+  type SandboxHomeEnvironment,
+  type WorkspaceExecuteOptions,
+  type WorkspaceExecutor,
+} from "@ragents/workspace-executor";
 import type {
   SessionWorkspace,
+  WorkspaceFolderStep,
+  WorkspacePlacement,
   WorkspaceResolver,
   WorkspaceRuntime,
   WorkspaceRuntimeDescription,
   WorkspaceTransfer,
-} from "@aicontainer/server/ragents/workspace-runtime.js";
-import { storedStartOption } from "@aicontainer/server/ragents/start-option-state.js";
-import { sandboxToolNaming } from "@aicontainer/server/plugin-support/workspace-tool-naming.js";
-import { WorkspaceSandboxHost } from "@aicontainer/server/plugin-support/workspace-sandbox-host.js";
-import type { WorkspaceBinding } from "../contract.js";
-import { bindingOf, boundServerDirectory, serverDirectoryBinding } from "./binding.js";
+  WorkstationFolderContext,
+} from "@ragents/host/ragents/workspace-runtime.js";
+import { storedStartOption } from "@ragents/host/ragents/start-option-state.js";
+import { sandboxToolNaming } from "./workspace-tool-naming.js";
+import { WorkspaceSandboxHost, type ServerRootDescription } from "@ragents/host/plugin-support/workspace-sandbox-host.js";
+import type { RunProcessSandboxes } from "@ragents/host/plugin-support/process-sandbox.js";
+import { FRESH_WORKSPACE_LABEL, isFreshFolder, type ExistingWorkspaceFolder, type WorkspaceBinding } from "../contract.js";
+import {
+  bindingOf,
+  boundServerDirectory,
+  isWorkstationBinding,
+  serverDirectoryFolder,
+  workspaceOwnerOf,
+  type WorkstationBinding,
+} from "./binding.js";
 import type { WorkspaceClientRegistry } from "./clients.js";
 
 export interface RunWorkspaceRuntimeOptions {
   globalDirectory: string;
   sessionDirectory: (runId: string, ...segments: string[]) => string;
+  /** Die Speichergrenze eines Runs; innerhalb davon gehören private Arbeitsdateien seinem Konto. */
+  storageRootFor: (runId: string) => string;
   sessionsDirectoryPattern: string;
   sessionWorkspaceFor: (runId: string) => Promise<SessionWorkspace>;
   skillPaths: () => Promise<readonly string[]>;
@@ -27,27 +46,97 @@ export interface RunWorkspaceRuntimeOptions {
   runState: (runId: string) => RunState | null;
   storeBinding: (runId: string, binding: WorkspaceBinding) => void;
   clients: WorkspaceClientRegistry;
+  /** Die Prozess-Sandbox des Servers; ohne sie laufen die Prozesse des Servers ohne. */
+  processSandbox?: RunProcessSandboxes;
+  /** Die Bash des Servers aus RAGENTS_BASH; unter Windows Pflicht für das Werkzeug bash. */
+  bash?: string;
 }
 
 const runNotStarted = (): DomainError => new DomainError(
   "run-not-started",
-  "Die Unterhaltung ist noch nicht gestartet; das Arbeitsverzeichnis entsteht mit der ersten Nachricht.",
+  "Der Run ist noch nicht gestartet; das Arbeitsverzeichnis entsteht mit der ersten Nachricht.",
   409,
 );
 
+const lookAround = "Look around in it before you say anything about the project.";
+
+const serverProjectDescription = (cwd: string): string => [
+  "# Working directory",
+  "",
+  `Your working directory is \`${cwd}\` on the server: the project folder the user picked.`,
+  `It is a real project. Work inside it, keep its structure, and never delete or reorganize files unless you are asked to. ${lookAround}`,
+].join("\n");
+
+const clientProjectDescription = (projectPath: string, label: string): string => [
+  "# Working directory",
+  "",
+  `Your working directory is the project folder \`${projectPath}\` on the workstation "${label}", not on the server.`,
+  "Every workspace tool runs there, and a relative path refers to that folder.",
+  `It is a real project. Keep its structure, and never delete or reorganize files unless you are asked to. ${lookAround}`,
+].join("\n");
+
+const freshWorkstationDescription = (folderPath: string, label: string): string => [
+  "# Working directory",
+  "",
+  `Your working directory is \`${folderPath}\` on the workstation "${label}", not on the server: a folder of this run alone.`,
+  "Every workspace tool runs there, and a relative path refers to that folder.",
+  "It starts empty unless the profile prepared content in it. Look around in it before you say anything about what is already there.",
+].join("\n");
+
+const freshDescription = (cwd: string): string => [
+  "# Working directory",
+  "",
+  `Your working directory is \`${cwd}\`, a private folder of this conversation on the server.`,
+  "No other conversation sees it, and it starts empty unless the profile prepared content in it.",
+  "Look around in it before you say anything about what is already there.",
+].join("\n");
+
+const listed = (entries: readonly string[]): string =>
+  entries.length === 1 ? entries[0]! : `${entries.slice(0, -1).join(", ")} and ${entries.at(-1)!}`;
+
+const rootList = (roots: readonly ServerRootDescription[]): string =>
+  listed(roots.map((root) => `\`${root.alias}\` (${root.writable ? "read and write" : "read only"})`));
+
+const variableList = (roots: readonly ServerRootDescription[]): string => listed(roots
+  .flatMap((root) => root.environmentVariable === undefined ? [] : [`\`$${root.environmentVariable}\` for \`${root.alias}\``]));
+
+const hasVariables = (roots: readonly ServerRootDescription[]): boolean => roots.some((root) => root.environmentVariable !== undefined);
+
+/** Auf dem Server liegen Arbeitsbereich und Wurzeln auf einer Maschine; jede Bash sieht beide. */
+const serverRootsDescription = (roots: readonly ServerRootDescription[]): string => [
+  "## Roots besides the working directory",
+  "",
+  `This run also reaches ${rootList(roots)}. File tools and language servers take a path that starts with the alias, `
+    + `such as \`${roots[0]!.alias}/<path>\`; \`bash\` runs in such a root with that path as \`cwd\`.`
+    + (hasVariables(roots) ? ` \`bash\` also has ${variableList(roots)}.` : ""),
+].join("\n");
+
+/** Die Wurzeln liegen auf dem Server, der Arbeitsbereich auf dem Arbeitsplatz; eine Bash sieht immer nur eine der beiden Maschinen. */
+const workstationRootsDescription = (roots: readonly ServerRootDescription[]): string => [
+  "## Roots on the server",
+  "",
+  `This run also reaches roots on the server: ${rootList(roots)}. File tools and language servers reach them from the `
+    + `workstation as well: pass a path that starts with the alias, such as \`${roots[0]!.alias}/<path>\`. \`bash\` runs on `
+    + "the workstation; with a `cwd` that starts with an alias it runs on the server instead and sees only the server"
+    + (hasVariables(roots) ? `, and only that bash has ${variableList(roots)}` : "")
+    + ". One call reaches one machine: never combine a path with an alias and a path in the working directory in one call.",
+].join("\n");
+
 export class RunWorkspaceRuntime implements WorkspaceRuntime {
   readonly sandbox: WorkspaceSandboxHost;
   readonly toolNaming: WorkspaceToolNaming = sandboxToolNaming;
   readonly transfer: WorkspaceTransfer;
   readonly #options: RunWorkspaceRuntimeOptions;
   readonly #nugetCacheDirectory: string;
+  /** Die neuen Ordner auf Arbeitsplätzen, die in diesem Serverlauf schon angelegt oder in Arbeit sind. */
+  readonly #preparations = new Map<string, Promise<void>>();
 
   constructor(options: RunWorkspaceRuntimeOptions) {
     this.#options = options;
     this.transfer = {
       boundDirectory: (runId) => boundServerDirectory(options.runState(runId)),
-      assertDirectory: (directory) => void serverDirectoryBinding(directory),
-      rebind: (runId, directory) => options.storeBinding(runId, serverDirectoryBinding(directory)),
+      assertDirectory: (directory) => void serverDirectoryFolder(directory),
+      rebind: (runId, directory) => options.storeBinding(runId, { machine: "server", folder: serverDirectoryFolder(directory) }),
     };
     this.#nugetCacheDirectory = path.join(options.globalDirectory, "nuget-cache");
     this.sandbox = new WorkspaceSandboxHost({
@@ -55,11 +144,22 @@ export class RunWorkspaceRuntime implements WorkspaceRuntime {
       workspaceFor: options.sessionWorkspaceFor,
       identFor: () => Promise.resolve(undefined),
       skillPaths: options.skillPaths,
+      storageRootFor: options.storageRootFor,
       homeFor: (runId) => this.#homeFor(runId),
       executorFor: (runId) => Promise.resolve(this.#executorFor(runId)),
+      serverDirectoryFor: (runId) => this.#serverDirectoryFor(runId),
+      ...(options.processSandbox ? { processSandbox: options.processSandbox } : {}),
+      ...(options.bash === undefined ? {} : { bash: options.bash }),
     });
   }
 
+  /** Arbeit eines Runs, die auf dem Server läuft, während sein Arbeitsbereich auf einem Arbeitsplatz liegt. */
+  async #serverDirectoryFor(runId: string): Promise<string> {
+    const directory = this.#options.sessionDirectory(runId, "server");
+    await mkdir(directory, { recursive: true });
+    return realpath(directory);
+  }
+
   async #homeFor(runId: string): Promise<SandboxHomeEnvironment> {
     const home = this.#options.sessionDirectory(runId, "home");
     await mkdir(home, { recursive: true });
@@ -67,36 +167,118 @@ export class RunWorkspaceRuntime implements WorkspaceRuntime {
     return { home, nugetPackages: this.#nugetCacheDirectory };
   }
 
-  /** Bei Bindung `client` führt der Executor des Arbeitsplatzes aus, sonst der des Servers. */
+  /** Auf einem Arbeitsplatz führt dessen Executor im Namen des Run-Eigentümers aus, sonst der des Servers. */
   #executorFor(runId: string): WorkspaceExecutor | undefined {
-    const binding = bindingOf(this.#options.runState(runId));
-    return binding.kind === "client"
-      ? this.#options.clients.executorFor(binding.client, binding.label, binding.path)
-      : undefined;
+    const state = this.#options.runState(runId);
+    const binding = bindingOf(state);
+    if (!isWorkstationBinding(binding)) return undefined;
+    const { machine, folder } = binding;
+    const executor = this.#options.clients.executorFor(workspaceOwnerOf(state), machine.client, machine.label, folder.path);
+    return "fresh" in folder ? this.#preparing(state, binding, executor) : executor;
+  }
+
+  /** Vor dem ersten Auftrag eines Runs legt der Arbeitsplatz dessen neuen Ordner an; Aufräumen legt nie einen an. */
+  #preparing(state: RunState | null, binding: WorkstationBinding, executor: WorkspaceExecutor): WorkspaceExecutor {
+    return {
+      ...executor,
+      execute: async (runId, operation, input, options = {}) => {
+        if (!options.whenReachable) await this.#prepared(runId, state, binding, executor);
+        return executor.execute(runId, operation, input, options);
+      },
+    };
+  }
+
+  #prepared(runId: string, state: RunState | null, binding: WorkstationBinding, executor: WorkspaceExecutor): Promise<void> {
+    const known = this.#preparations.get(runId);
+    if (known) return known;
+    const preparation = this.#prepare(runId, state, binding, executor).catch((error: unknown) => {
+      this.#preparations.delete(runId);
+      throw error;
+    });
+    this.#preparations.set(runId, preparation);
+    return preparation;
+  }
+
+  /** Nur ein eben angelegter Ordner bekommt die Schritte des Beitrags; scheitert einer, verschwindet er wieder, und der nächste Auftrag beginnt neu. */
+  async #prepare(runId: string, state: RunState | null, binding: WorkstationBinding, executor: WorkspaceExecutor): Promise<void> {
+    const { created } = await executor.execute(runId, RUN_FOLDER_OPERATIONS.create, null) as RunFolderCreated;
+    const steps = created ? this.#contribution()?.workstation?.prepare(this.#workstationContext(runId, state, binding)) ?? [] : [];
+    try {
+      await this.#runSteps(runId, executor, steps);
+    } catch (error) {
+      await executor.execute(runId, RUN_FOLDER_OPERATIONS.remove, null, { whenReachable: true });
+      throw error;
+    }
+  }
+
+  async #runSteps(runId: string, executor: WorkspaceExecutor, steps: readonly WorkspaceFolderStep[], options: WorkspaceExecuteOptions = {}): Promise<void> {
+    for (const step of steps) await executor.execute(runId, step.operation, step.input, options);
+  }
+
+  #workstationContext(runId: string, state: RunState | null, binding: WorkstationBinding): WorkstationFolderContext {
+    const contribution = this.#contribution();
+    return {
+      runId,
+      path: binding.folder.path,
+      label: binding.machine.label,
+      choice: contribution && state ? this.#choiceFor(state, contribution) : null,
+    };
   }
 
   async resolve(runId: string, emitSystem: (text: string) => void): Promise<SessionWorkspace> {
     const state = this.#options.runState(runId);
     if (!state) throw runNotStarted();
     const binding = bindingOf(state);
-    switch (binding.kind) {
-      case "fresh": return this.#fresh(runId, state);
-      case "path": return this.#bound(binding, emitSystem);
-      case "client": return this.#serverSide(runId, binding, emitSystem);
-    }
+    const { folder } = binding;
+    const onWorkstation = isWorkstationBinding(binding);
+    const workspace = onWorkstation ? this.#workstation(runId, state, binding, emitSystem)
+      : isFreshFolder(folder) ? await this.#fresh(runId, state, emitSystem) : this.#bound(folder, emitSystem);
+    return this.#withRoots(workspace, onWorkstation);
   }
 
-  async #fresh(runId: string, state: RunState): Promise<SessionWorkspace> {
-    const directory = await this.#sessionWorkspace(runId);
+  /** Was der Prompt über Wurzeln sagt, hängt an der Maschine des Runs: nur eine Bash auf dem Server kennt ihre Variablen. */
+  async #withRoots(workspace: SessionWorkspace, onWorkstation: boolean): Promise<SessionWorkspace> {
+    const roots = await this.sandbox.serverRoots();
+    if (roots.length === 0) return workspace;
+    const described = onWorkstation ? workstationRootsDescription(roots) : serverRootsDescription(roots);
+    return { ...workspace, description: [workspace.description, described].filter(Boolean).join("\n\n") };
+  }
+
+  placementOf(runId: string): WorkspacePlacement {
+    const { machine, folder } = bindingOf(this.#options.runState(runId));
+    const placement: WorkspacePlacement = {
+      machine: machine === "server" ? "server" : "client",
+      folder: isFreshFolder(folder) ? "fresh" : "existing",
+    };
+    const contribution = this.#contribution();
+    const contributed = placement.folder === "fresh" && (placement.machine === "server" || contribution?.workstation !== undefined);
+    const kind = contributed ? contribution?.kind?.id : undefined;
+    return kind === undefined ? placement : { ...placement, kind };
+  }
+
+  async #fresh(runId: string, state: RunState, emitSystem: (text: string) => void): Promise<SessionWorkspace> {
     const resolver = this.#options.resolver();
-    const resolution = resolver
-      ? await resolver.resolve({ runId, directory, choice: this.#choiceFor(state, resolver), emitSystem: () => undefined })
-      : { cwd: directory };
-    return this.#directory(path.resolve(resolution.cwd), resolution.extraEnv);
+    const directory = resolver?.kind
+      ? this.#options.sessionDirectory(runId, "workspace")
+      : await this.#sessionWorkspace(runId);
+    if (!resolver) return this.#directory(directory, freshDescription(directory));
+    const { cwd, description, currentRoot, runOperation, ...rest } = await resolver.resolve({
+      runId,
+      directory,
+      choice: this.#choiceFor(state, resolver),
+      emitSystem,
+    });
+    const resolved = path.resolve(cwd);
+    return {
+      ...this.#directory(resolved, description ?? freshDescription(resolved)),
+      ...rest,
+      ...(currentRoot ? { currentRoot } : {}),
+      ...(runOperation ? { runOperation } : {}),
+    };
   }
 
-  #bound(binding: Extract<WorkspaceBinding, { kind: "path" }>, emitSystem: (text: string) => void): SessionWorkspace {
-    const cwd = path.resolve(binding.path);
+  #bound(folder: ExistingWorkspaceFolder, emitSystem: (text: string) => void): SessionWorkspace {
+    const cwd = path.resolve(folder.path);
     const existing = async (): Promise<string> => {
       try {
         return await realpath(cwd);
@@ -107,20 +289,33 @@ export class RunWorkspaceRuntime implements WorkspaceRuntime {
     emitSystem(`Arbeitsbereich: ${cwd} (Projektordner auf dem Server)`);
     return {
       cwd,
+      description: serverProjectDescription(cwd),
       currentRoot: existing,
-      ensureWritable: existing,
       runOperation: (operation) => operation(),
     };
   }
 
-  /** Der Ordner des Servers für einen Run, dessen Werkzeuge auf dem Arbeitsplatz laufen: Ablage für typescript_eval und Actor-Programme. */
-  async #serverSide(
-    runId: string,
-    binding: Extract<WorkspaceBinding, { kind: "client" }>,
-    emitSystem: (text: string) => void,
-  ): Promise<SessionWorkspace> {
-    emitSystem(`Arbeitsbereich: ${binding.path} (Projektordner auf dem Arbeitsplatz ${binding.label})`);
-    return this.#directory(await this.#sessionWorkspace(runId));
+  /** Der Arbeitsbereich liegt auf dem Arbeitsplatz; der Server kennt nur seinen Pfad, und jeder lokale Griff darauf scheitert laut. */
+  #workstation(runId: string, state: RunState, binding: WorkstationBinding, emitSystem: (text: string) => void): SessionWorkspace {
+    const { machine: { label }, folder } = binding;
+    const fresh = "fresh" in folder;
+    const workstation = this.#contribution()?.workstation;
+    emitSystem(fresh
+      ? `Arbeitsbereich: ${folder.path} (${workstation?.label ?? FRESH_WORKSPACE_LABEL} auf dem Arbeitsplatz ${label})`
+      : `Arbeitsbereich: ${folder.path} (Projektordner auf dem Arbeitsplatz ${label})`);
+    const remote = (): Promise<string> => Promise.reject(new Error(
+      `Der Arbeitsbereich ${folder.path} liegt auf dem Arbeitsplatz ${label}, nicht auf dem Server; `
+      + "er ist nur über den Executor des Runs (SandboxServices.execute) erreichbar.",
+    ));
+    const description = !fresh
+      ? clientProjectDescription(folder.path, label)
+      : workstation?.description?.(this.#workstationContext(runId, state, binding)) ?? freshWorkstationDescription(folder.path, label);
+    return {
+      cwd: folder.path,
+      description,
+      currentRoot: remote,
+      runOperation: (operation) => operation(),
+    };
   }
 
   async #sessionWorkspace(runId: string): Promise<string> {
@@ -129,12 +324,12 @@ export class RunWorkspaceRuntime implements WorkspaceRuntime {
     return directory;
   }
 
-  #directory(cwd: string, extraEnv?: NodeJS.ProcessEnv): SessionWorkspace {
+  #directory(cwd: string, description: string, extraEnv?: NodeJS.ProcessEnv): SessionWorkspace {
     return {
       cwd,
+      description,
       ...(extraEnv ? { extraEnv } : {}),
       currentRoot: () => realpath(cwd),
-      ensureWritable: () => realpath(cwd),
       runOperation: (operation) => operation(),
     };
   }
@@ -143,7 +338,7 @@ export class RunWorkspaceRuntime implements WorkspaceRuntime {
     if (resolver.optionId === undefined) return null;
     const choice = storedStartOption(state, resolver.optionId);
     if (choice === undefined) {
-      throw new Error(`Die Startoption ${resolver.optionId} des Workspace-Resolvers ist in der Unterhaltung nicht gespeichert`);
+      throw new Error(`Die Startoption ${resolver.optionId} des Workspace-Resolvers ist im Run nicht gespeichert`);
     }
     return choice;
   }
@@ -151,16 +346,46 @@ export class RunWorkspaceRuntime implements WorkspaceRuntime {
   describe(): WorkspaceRuntimeDescription {
     return {
       mode: "per-run",
-      directoryPattern: path.join(this.#options.sessionsDirectoryPattern, "workspace"),
+      directoryPattern: this.#contribution()?.kind?.directoryPattern
+        ?? path.join(this.#options.sessionsDirectoryPattern, "workspace"),
     };
   }
 
-  deleteSession(runId: string): Promise<void> {
-    return this.stopSession(runId);
+  #contribution(): WorkspaceResolver | undefined {
+    return this.#options.resolver();
+  }
+
+  /** Auf dem Server gehört ein neuer Ordner samt Stopp und Löschen dem Beitrag; auf einem Arbeitsplatz räumt ihn der Host weg. */
+  #serverContributionFor(runId: string): WorkspaceResolver | undefined {
+    const { machine, folder } = bindingOf(this.#options.runState(runId));
+    return machine === "server" && isFreshFolder(folder) ? this.#contribution() : undefined;
+  }
+
+  /** Ist der Arbeitsplatz nicht erreichbar, bleibt der Ordner dort mit Hinweis liegen; der Run ist trotzdem gelöscht. */
+  async #removeWorkstationFolder(runId: string): Promise<void> {
+    this.#preparations.delete(runId);
+    const state = this.#options.runState(runId);
+    const binding = bindingOf(state);
+    if (!isWorkstationBinding(binding) || !("fresh" in binding.folder)) return;
+    const { machine, folder } = binding;
+    const executor = this.#options.clients.executorFor(workspaceOwnerOf(state), machine.client, machine.label, folder.path);
+    const steps = this.#contribution()?.workstation?.release?.(this.#workstationContext(runId, state, binding)) ?? [];
+    await this.#runSteps(runId, executor, steps, { whenReachable: true });
+    if (await executor.execute(runId, RUN_FOLDER_OPERATIONS.remove, null, { whenReachable: true }) !== null) return;
+    console.warn(`Der Ordner ${folder.path} des Runs ${runId} bleibt auf dem Arbeitsplatz ${machine.label}, weil er nicht erreichbar war.`);
+  }
+
+  async deleteSession(runId: string): Promise<void> {
+    const contribution = this.#serverContributionFor(runId);
+    await this.stopSession(runId);
+    await this.#removeWorkstationFolder(runId);
+    await contribution?.deleteSession?.(runId);
   }
 
   stopSession(runId: string): Promise<void> {
-    return this.sandbox.shutdown(runId);
+    const contribution = this.#serverContributionFor(runId);
+    const sandbox = (): Promise<void> => this.sandbox.shutdown(runId);
+    return contribution?.stopSession ? contribution.stopSession(runId, sandbox) : sandbox();
   }
 
   async shutdown(): Promise<void> {

package/{apps/server/src/plugin-support → plugins/ragents.workspace/server}/shell-platform.ts

@@ -1,8 +1,6 @@
-import type { PromptContribution } from "@aicontainer/ragents";
-import { shellPlatformText } from "@aicontainer/workspace-executor";
-import { boundToTools } from "./prompt.js";
-
-export { shellPlatformText };
+import type { PromptContribution } from "@ragents/engine";
+import { shellPlatformText } from "@ragents/workspace-executor";
+import { boundToTools } from "@ragents/host/plugin-support/prompt.js";
 
 export const shellPlatformChapter = (platform: NodeJS.Platform): string =>
   `## Shell platform\n\n${shellPlatformText(platform)}`;

package/{apps/server/src/plugin-support → plugins/ragents.workspace/server}/workspace-tool-naming.ts

@@ -1,4 +1,4 @@
-import type { WorkspaceToolNaming } from "@aicontainer/ragents";
+import type { WorkspaceToolNaming } from "@ragents/engine";
 
 const workspaceToolTable = {
   manual: { read: [], write: [], execute: [] },
@@ -9,3 +9,9 @@ const workspaceToolTable = {
 export const sandboxToolNaming: WorkspaceToolNaming = {
   agentToolNames: (driver) => workspaceToolTable[driver],
 };
+
+export const agentWorkspaceToolNames: readonly string[] = [
+  ...workspaceToolTable.agent.read,
+  ...workspaceToolTable.agent.write,
+  ...workspaceToolTable.agent.execute,
+];

package/plugins/ragents.workspace/web/FileBrowser.tsx

@@ -7,15 +7,15 @@ import {
   EmptyMedia,
   EmptyTitle,
   Toggle,
-} from "@aicontainer/web/ui";
+} from "@ragents/web/ui";
 import { useEffect, useRef, useState, type CSSProperties, type ReactNode } from "react";
 import { ChevronRight, Eye, EyeOff, FolderOpen, RefreshCw } from "lucide-react";
-import type { WorkspaceTabContext } from "@aicontainer/web/PluginRegistry";
-import { rpc } from "@aicontainer/web/rpc";
+import { workspaceAccessible, type WorkspaceTabContext } from "@ragents/web/PluginRegistry";
+import { rpc } from "@ragents/web/rpc";
 import { BROWSE_ROOTS, workspaceContracts, type BrowseListing, type BrowsePreview, type BrowseRoot } from "../contract";
 import { fetchBrowseListing, fetchBrowsePreview } from "./api";
 import { fileIconFor, fileToneClass } from "./file-icons";
-import { SourceCode } from "@aicontainer/web/SourceCode";
+import { SourceCode } from "@ragents/web/SourceCode";
 
 const rowClass = "h-auto w-full justify-start gap-1.5 rounded-none py-[3px] pr-2.5 pl-(--row-indent) text-[0.7rem] font-normal data-selected:bg-primary/12 data-selected:text-primary";
 const previewSourceClass = "min-w-0 px-2.5 pt-0 pb-2.5 text-xs leading-[1.45] whitespace-pre-wrap break-words";
@@ -27,8 +27,8 @@ const rootLabels: Readonly<Record<BrowseRoot, string>> = {
 };
 
 const emptyHints: Readonly<Record<BrowseRoot, string>> = {
-  workspace: "Im Arbeitsverzeichnis des Laufs liegt noch nichts.",
-  files: "In der Dateiablage des Laufs liegt noch nichts.",
+  workspace: "Im Arbeitsverzeichnis des Runs liegt noch nichts.",
+  files: "In der Dateiablage des Runs liegt noch nichts.",
 };
 
 const messageOf = (cause: unknown): string => cause instanceof Error ? cause.message : String(cause);
@@ -52,7 +52,10 @@ interface BrowserMemory {
 export function FileBrowserPanel({ active, session }: WorkspaceTabContext) {
   const runId = session.session.id;
   const treeMemory = useRef(new Map<string, BrowserMemory>());
-  const [root, setRoot] = useState<BrowseRoot>("workspace");
+  const reachable = workspaceAccessible(session.session);
+  const roots: readonly BrowseRoot[] = reachable ? BROWSE_ROOTS : ["files"];
+  const [chosenRoot, setRoot] = useState<BrowseRoot>("workspace");
+  const root: BrowseRoot = reachable ? chosenRoot : "files";
   const stateKey = `${runId}|${root}`;
   const [listings, setListings] = useState<ReadonlyMap<string, BrowseListing>>(() => new Map());
   const [expanded, setExpanded] = useState<ReadonlySet<string>>(() => new Set());
@@ -218,7 +221,7 @@ export function FileBrowserPanel({ active, session }: WorkspaceTabContext) {
     <div className="flex h-full min-h-0 flex-col">
       <header className="flex items-center gap-2 px-2.5 py-2">
         <div className="flex min-w-0 flex-1 gap-1">
-          {BROWSE_ROOTS.map((value) => (
+          {roots.map((value) => (
             <Toggle key={value} onPressedChange={() => setRoot(value)} pressed={value === root} size="sm" variant="outline">
               {rootLabels[value]}
             </Toggle>