@runuai/host 0.4.3 → 0.6.0

package/src/index.ts

@@ -1,5 +1,6 @@
 import { agent, AgentError } from "../lib/agent";
 import { cloneRepo } from "../lib/repo-clone";
+import { handleFilesOp } from "../lib/shared-files";
 import { getOrchestrator } from "../lib/orchestrator";
 import { storeTaskCliSecret } from "../lib/agent-cli";
 import { setupTaskGithub, clearRefresh } from "../lib/github-tokens";
@@ -308,6 +309,15 @@ export const hostCommands: HostCommands = {
     }
   },
 
+  async filesOp(ctx, input) {
+    logCommand(ctx, "filesOp", input.op, `${input.scope}:${input.path}`);
+    try {
+      return ok(await handleFilesOp(input));
+    } catch (err) {
+      return failFromUnknown(err);
+    }
+  },
+
   async channelInterrupt(ctx, taskId, agentId) {
     logCommand(ctx, "channelInterrupt", taskId, agentId);
     try {

package/src/main.ts

@@ -84,6 +84,7 @@ import {
   type TaskDiffInput,
   type TaskDownInput,
   type TaskLaunchInput,
+  FilesOpInput,
 } from "./protocol";
 
 const PING_INTERVAL_MS = 15_000;
@@ -875,6 +876,8 @@ function dispatchCommand(
         ctx,
         expectAttachmentReadInput(args, 0),
       );
+    case "filesOp":
+      return hostCommands.filesOp(ctx, expectFilesOpInput(args, 0));
     case "channelInterrupt":
       return hostCommands.channelInterrupt(
         ctx,
@@ -1123,6 +1126,7 @@ function isHostCommand(command: string): command is keyof HostCommands {
     "taskDiff",
     "attachmentWrite",
     "attachmentRead",
+    "filesOp",
     "channelInterrupt",
     "appendTranscript",
     "previewEnsure",
@@ -1277,6 +1281,37 @@ function expectAttachmentReadInput(
   };
 }
 
+/** ADR-062: the THIRD whitelist for filesOp — op/scope enums, relative path
+ *  only (containment is re-checked in lib/shared-files.ts, the final gate). */
+function expectFilesOpInput(args: unknown[], index: number): FilesOpInput {
+  const input = expectRecord(args[index], "files op input");
+  const op = expectStringValue(input.op, "op");
+  if (!["list", "read", "write", "mkdir", "delete"].includes(op)) {
+    throw new Error(`invalid files op: ${op}`);
+  }
+  const scope = expectStringValue(input.scope, "scope");
+  if (scope !== "org" && scope !== "me") {
+    throw new Error(`invalid files scope: ${scope}`);
+  }
+  const out: FilesOpInput = {
+    op: op as FilesOpInput["op"],
+    hostId: typeof input.hostId === "string" ? input.hostId : "",
+    scope,
+    orgId: typeof input.orgId === "string" ? input.orgId : "",
+    userId: typeof input.userId === "string" ? input.userId : "",
+    path: typeof input.path === "string" ? input.path : "",
+  };
+  if (typeof input.offset === "number" && Number.isFinite(input.offset)) {
+    out.offset = input.offset;
+  }
+  if (typeof input.length === "number" && Number.isFinite(input.length)) {
+    out.length = input.length;
+  }
+  if (typeof input.dataBase64 === "string") out.dataBase64 = input.dataBase64;
+  if (input.append === true) out.append = true;
+  return out;
+}
+
 function expectChannelEnsureInput(
   args: unknown[],
   index: number,
@@ -1334,6 +1369,14 @@ function expectChannelEnsureInput(
     });
     if (connections.length > 0) out.mcpConnections = connections;
   }
+  // ADR-062: shared-files mode for the preamble "## Files" section.
+  if (
+    input.sharedFiles === "off" ||
+    input.sharedFiles === "ro" ||
+    input.sharedFiles === "rw"
+  ) {
+    out.sharedFiles = input.sharedFiles;
+  }
   return out;
 }
 
@@ -1373,6 +1416,14 @@ function expectTaskCommandTask(value: unknown): TaskCommandTask {
     }
     if (Object.keys(pe).length > 0) out.previewEnv = pe;
   }
+  if (typeof row.ownerOrgId === "string") out.ownerOrgId = row.ownerOrgId;
+  if (
+    row.sharedFiles === "off" ||
+    row.sharedFiles === "ro" ||
+    row.sharedFiles === "rw"
+  ) {
+    out.sharedFiles = row.sharedFiles;
+  }
   return out;
 }
 

package/src/protocol.ts

@@ -144,6 +144,10 @@ export interface TaskCommandTask {
    * `urlEnv` and the cloud has a preview base domain configured.
    */
   previewEnv?: Record<string, string>;
+  /** ADR-062: owning org — locates the org shared-files root on the host. */
+  ownerOrgId?: string;
+  /** ADR-062: shared-files mount mode ("off" | "ro" | "rw"; default "ro"). */
+  sharedFiles?: string;
 }
 
 /**
@@ -203,6 +207,9 @@ export interface ChannelEnsureInput {
   /** ADR-057: the owner's usable MCP connections (policy "on", connected,
    *  remote). The host writes gateway-URL MCP configs at session start. */
   mcpConnections?: Array<{ id: string; slug: string }>;
+  /** ADR-062: shared-files mount mode — drives the preamble "## Files"
+   *  section ("off" | "ro" | "rw"). */
+  sharedFiles?: string;
   globalContext?: string;
   projects: Array<{ slug: string; defaultPrompt: string }>;
   branch: string;
@@ -256,6 +263,39 @@ export interface TaskDiffResult {
   repos: TaskDiffRepo[];
 }
 
+/** ADR-062 shared-files op (cloud → host). Scope picks the root:
+ *  "org" → <workspaceRoot>/shared/orgs/<orgId>, "me" → shared/users/<userId>. */
+export interface FilesOpInput {
+  op: "list" | "read" | "write" | "mkdir" | "delete";
+  /** Routing only (cloud→bridge): which host's roots to touch. */
+  hostId: string;
+  scope: "org" | "me";
+  orgId: string;
+  userId: string;
+  /** Relative path inside the scope root ("" = root). */
+  path: string;
+  /** read: byte offset; default 0. */
+  offset?: number;
+  /** read: max bytes per chunk (host caps it regardless). */
+  length?: number;
+  /** write: base64 chunk. */
+  dataBase64?: string;
+  /** write: append to existing (true) or truncate/create (false/absent). */
+  append?: boolean;
+}
+
+export interface FilesEntry {
+  name: string;
+  dir: boolean;
+  size: number;
+  mtimeMs: number;
+}
+
+export type FilesOpValue =
+  | { entries: FilesEntry[] } // list
+  | { dataBase64: string; size: number; eof: boolean } // read
+  | Record<string, never>; // write / mkdir / delete
+
 export interface HostCommands {
   taskUp(
     ctx: CommandContext,
@@ -321,6 +361,13 @@ export interface HostCommands {
     ctx: CommandContext,
     input: { taskId: string; filename: string },
   ): Promise<HostCommandResult<{ dataBase64: string }>>;
+  /** ADR-062 shared files — list/read/write/mkdir/delete inside the host's
+   *  org or personal shared root. Paths are RELATIVE; the host normalizes and
+   *  rejects escapes. Reads/writes are chunked base64 (offset/append). */
+  filesOp(
+    ctx: CommandContext,
+    input: FilesOpInput,
+  ): Promise<HostCommandResult<FilesOpValue>>;
   channelInterrupt(
     ctx: CommandContext,
     taskId: string,