@ai-sdk/harness-pi 1.0.0-canary.2 → 1.0.0-canary.4

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # @ai-sdk/harness-pi
 
+## 1.0.0-canary.4
+
+### Patch Changes
+
+- Updated dependencies [aae0138]
+  - @ai-sdk/harness@1.0.0-canary.8
+
+## 1.0.0-canary.3
+
+### Patch Changes
+
+- 1ea15a3: fix(harness): fix various bugs with harness skills not being correctly processed by the harness adapters
+- e551763: fix(harness): avoid using peer dependencies for underlying harness and sandbox SDKs
+- Updated dependencies [3d87086]
+- Updated dependencies [aeda373]
+- Updated dependencies [1ea15a3]
+- Updated dependencies [375fdd7]
+- Updated dependencies [b4507d5]
+  - @ai-sdk/harness@1.0.0-canary.7
+  - @ai-sdk/provider-utils@5.0.0-canary.48
+
 ## 1.0.0-canary.2
 
 ### Patch Changes

package/README.md

@@ -5,7 +5,7 @@
 ## Setup
 
 ```bash
-npm i @ai-sdk/harness-pi @ai-sdk/harness @ai-sdk/sandbox-vercel @earendil-works/pi-coding-agent
+npm i @ai-sdk/harness-pi @ai-sdk/harness @ai-sdk/sandbox-vercel
 ```
 
 ## Usage

package/dist/index.js

@@ -298,27 +298,44 @@ function canonicalizeForContainment(inputPath) {
     );
   }
 }
-function createPiPathMapper(hostWorkDir, sandboxWorkDir) {
-  const normalizedHost = path2.resolve(hostWorkDir);
-  const normalizedSandbox = path2.posix.normalize(sandboxWorkDir);
+function createPiPathMapper(options) {
+  const normalizedHost = path2.resolve(options.hostWorkDir);
+  const normalizedSandbox = path2.posix.normalize(options.sandboxWorkDir);
   const canonicalHost = canonicalizeForContainment(normalizedHost);
+  const readableRoots = options.readableRoots?.map((root) => ({
+    sandboxDir: path2.posix.normalize(root.sandboxDir)
+  })) ?? [];
+  const toWorkspaceSandboxPath = (inputPath) => {
+    if (path2.posix.isAbsolute(inputPath)) {
+      const normalizedInput = path2.posix.normalize(inputPath);
+      if (isInsidePosixPath(normalizedSandbox, normalizedInput)) {
+        return normalizedInput;
+      }
+    }
+    const resolvedHost = path2.isAbsolute(inputPath) ? path2.resolve(inputPath) : path2.resolve(normalizedHost, inputPath);
+    const canonicalResolvedHost = canonicalizeForContainment(resolvedHost);
+    if (!isInsidePath(normalizedHost, resolvedHost) || !isInsidePath(canonicalHost, canonicalResolvedHost)) {
+      throw new Error(`Pi path escapes the workspace: ${inputPath}`);
+    }
+    const relative = path2.relative(normalizedHost, resolvedHost).split(path2.sep).join("/");
+    return relative ? path2.posix.join(normalizedSandbox, relative) : normalizedSandbox;
+  };
   return {
     hostWorkDir: normalizedHost,
     sandboxWorkDir: normalizedSandbox,
     toSandboxPath(inputPath) {
+      return toWorkspaceSandboxPath(inputPath);
+    },
+    toReadableSandboxPath(inputPath) {
       if (path2.posix.isAbsolute(inputPath)) {
         const normalizedInput = path2.posix.normalize(inputPath);
-        if (isInsidePosixPath(normalizedSandbox, normalizedInput)) {
+        if (isInsidePosixPath(normalizedSandbox, normalizedInput) || readableRoots.some(
+          (root) => isInsidePosixPath(root.sandboxDir, normalizedInput)
+        )) {
           return normalizedInput;
         }
       }
-      const resolvedHost = path2.isAbsolute(inputPath) ? path2.resolve(inputPath) : path2.resolve(normalizedHost, inputPath);
-      const canonicalResolvedHost = canonicalizeForContainment(resolvedHost);
-      if (!isInsidePath(normalizedHost, resolvedHost) || !isInsidePath(canonicalHost, canonicalResolvedHost)) {
-        throw new Error(`Pi path escapes the workspace: ${inputPath}`);
-      }
-      const relative = path2.relative(normalizedHost, resolvedHost).split(path2.sep).join("/");
-      return relative ? path2.posix.join(normalizedSandbox, relative) : normalizedSandbox;
+      return toWorkspaceSandboxPath(inputPath);
     },
     toRelativePath(inputPath) {
       const sandboxPath = path2.posix.isAbsolute(inputPath) ? path2.posix.normalize(inputPath) : path2.posix.join(
@@ -416,7 +433,7 @@ function createPiRemoteOps(options) {
   };
   const readBuffer = async (inputPath) => {
     const bytes = await options.sandbox.readBinaryFile({
-      path: options.paths.toSandboxPath(inputPath)
+      path: options.paths.toReadableSandboxPath(inputPath)
     });
     if (!bytes) {
       throw new Error(`Path not found: ${inputPath}`);
@@ -447,7 +464,7 @@ function createPiRemoteOps(options) {
     return updated;
   };
   const listDirectory = async (inputPath = ".", limit = 500) => {
-    const remotePath = options.paths.toSandboxPath(inputPath);
+    const remotePath = options.paths.toReadableSandboxPath(inputPath);
     const result = await runShell(
       [
         `if [ ! -e ${shellQuote(remotePath)} ]; then echo "__PI_LS_NOT_FOUND__"; exit 2; fi`,
@@ -468,7 +485,7 @@ function createPiRemoteOps(options) {
     ).slice(0, limit);
   };
   const findFiles = async (pattern, inputPath = ".", limit = 1e3) => {
-    const remotePath = options.paths.toSandboxPath(inputPath);
+    const remotePath = options.paths.toReadableSandboxPath(inputPath);
     const result = await runShell(
       [
         `if [ ! -e ${shellQuote(remotePath)} ]; then echo "__PI_FIND_NOT_FOUND__"; exit 2; fi`,
@@ -492,8 +509,9 @@ function createPiRemoteOps(options) {
     ).slice(0, limit);
   };
   const grepFiles = async (pattern, input) => {
-    const remotePath = options.paths.toSandboxPath(input.path ?? ".");
+    const remotePath = options.paths.toReadableSandboxPath(input.path ?? ".");
     const relativeTarget = options.paths.toRelativePath(remotePath);
+    const targetPath = relativeTarget.startsWith("../") || path3.posix.isAbsolute(relativeTarget) ? remotePath : relativeTarget;
     const flags = [
       "-R",
       "-n",
@@ -508,7 +526,7 @@ function createPiRemoteOps(options) {
       [
         `if [ ! -e ${shellQuote(remotePath)} ]; then echo "__PI_GREP_NOT_FOUND__"; exit 2; fi`,
         `cd ${shellQuote(options.paths.sandboxWorkDir)}`,
-        `grep ${flags.map(shellQuote).join(" ")} -- ${shellQuote(pattern)} ${shellQuote(relativeTarget)} 2>/dev/null | head -n ${limit}`
+        `grep ${flags.map(shellQuote).join(" ")} -- ${shellQuote(pattern)} ${shellQuote(targetPath)} 2>/dev/null | head -n ${limit}`
       ].join("; ")
     );
     const output = result.output.toString("utf8").trim();
@@ -554,22 +572,49 @@ function createPiRemoteOps(options) {
 // src/pi-skills.ts
 import path4 from "path";
 async function writePiSkills(args) {
+  for (const skill of args.skills) {
+    safePiMetadataSegment(skill.name, "skill");
+    for (const file of skill.files ?? []) {
+      safePiSkillFilePath({ skillName: skill.name, filePath: file.path });
+    }
+  }
   for (const skill of args.skills) {
     const name = safePiMetadataSegment(skill.name, "skill");
-    const remotePath = path4.posix.join(
-      args.sessionWorkDir,
-      ".pi",
+    const sandboxSkillDir = path4.posix.join(
+      args.sandboxHomeDir,
+      ".agents",
       "skills",
-      name,
-      "SKILL.md"
+      name
     );
+    const content = renderPiSkillFile(skill);
     await args.sandbox.writeTextFile({
-      path: remotePath,
-      content: renderPiSkillFile(skill),
+      path: path4.posix.join(sandboxSkillDir, "SKILL.md"),
+      content,
       ...args.abortSignal ? { abortSignal: args.abortSignal } : {}
     });
+    for (const file of skill.files ?? []) {
+      const filePath = safePiSkillFilePath({
+        skillName: skill.name,
+        filePath: file.path
+      });
+      await args.sandbox.writeTextFile({
+        path: path4.posix.join(sandboxSkillDir, filePath),
+        content: file.content,
+        ...args.abortSignal ? { abortSignal: args.abortSignal } : {}
+      });
+    }
   }
 }
+function safePiSkillFilePath({
+  skillName,
+  filePath
+}) {
+  const normalized = path4.posix.normalize(filePath);
+  if (normalized === "." || normalized.startsWith("../") || path4.posix.isAbsolute(normalized)) {
+    throw new Error(`Invalid Pi skill file path for ${skillName}: ${filePath}`);
+  }
+  return normalized;
+}
 
 // src/pi-translate.ts
 import { randomBytes } from "crypto";
@@ -1238,12 +1283,52 @@ async function syncHostWorkspaceFromSandbox(args) {
 // src/pi-session.ts
 var HARNESS_ID2 = "pi";
 var parkedPiSessions = /* @__PURE__ */ new Map();
+function isWithinDirectory(parent, child) {
+  const rel = path7.relative(parent, child);
+  return rel === "" || !rel.startsWith("..") && !path7.isAbsolute(rel);
+}
 function isWithinWorkspace(candidate, sessionWorkDir, hostWorkDir) {
-  const inside = (parent, child) => {
-    const rel = path7.relative(parent, child);
-    return rel === "" || !rel.startsWith("..") && !path7.isAbsolute(rel);
-  };
-  return inside(sessionWorkDir, candidate) || inside(hostWorkDir, candidate);
+  return isWithinDirectory(sessionWorkDir, candidate) || isWithinDirectory(hostWorkDir, candidate);
+}
+function createHarnessPiSkills({
+  skills,
+  sandboxSkillRootDir
+}) {
+  return skills.map((skill) => {
+    const name = safePiMetadataSegment(skill.name, "skill");
+    const baseDir = path7.posix.join(sandboxSkillRootDir, name);
+    const filePath = path7.posix.join(baseDir, "SKILL.md");
+    return {
+      name: skill.name,
+      description: skill.description,
+      filePath,
+      baseDir,
+      sourceInfo: {
+        path: filePath,
+        source: "harness",
+        scope: "temporary",
+        origin: "top-level",
+        baseDir
+      },
+      disableModelInvocation: false
+    };
+  });
+}
+async function resolveSandboxHomeDir({
+  sandbox,
+  abortSignal
+}) {
+  const result = await sandbox.run({
+    command: 'printf "%s" "$HOME"',
+    ...abortSignal ? { abortSignal } : {}
+  });
+  const homeDir = result.stdout.trim();
+  if (result.exitCode !== 0 || !homeDir || !path7.posix.isAbsolute(homeDir)) {
+    throw new Error(
+      `Unable to resolve sandbox HOME directory: ${result.stderr || result.stdout}`
+    );
+  }
+  return homeDir;
 }
 var PI_NATIVE_BUILTIN_NAMES = [
   "read",
@@ -1288,10 +1373,21 @@ async function createPiSession(input) {
   await mkdir3(hostSessionDir, { recursive: true });
   const sandbox = input.sandboxSession.restricted();
   const permissionMode = input.permissionMode ?? "allow-all";
+  let sandboxSkillRootDir;
+  let harnessSkills = [];
   if (input.skills.length > 0) {
+    const sandboxHomeDir = await resolveSandboxHomeDir({
+      sandbox,
+      ...input.abortSignal ? { abortSignal: input.abortSignal } : {}
+    });
+    sandboxSkillRootDir = path7.posix.join(sandboxHomeDir, ".agents", "skills");
+    harnessSkills = createHarnessPiSkills({
+      skills: input.skills,
+      sandboxSkillRootDir
+    });
     await writePiSkills({
       sandbox,
-      sessionWorkDir: input.sessionWorkDir,
+      sandboxHomeDir,
       skills: input.skills,
       ...input.abortSignal ? { abortSignal: input.abortSignal } : {}
     });
@@ -1313,7 +1409,11 @@ async function createPiSession(input) {
   });
   const workspaceVfs = new PiWorkspaceVfs();
   workspaceVfs.mount(hostWorkDir, sessionWorkDir);
-  const paths = createPiPathMapper(hostWorkDir, sessionWorkDir);
+  const paths = createPiPathMapper({
+    hostWorkDir,
+    sandboxWorkDir: sessionWorkDir,
+    readableRoots: sandboxSkillRootDir ? [{ sandboxDir: sandboxSkillRootDir }] : []
+  });
   const authStorage = AuthStorage.create(path7.join(hostAgentDir, "auth.json"));
   const modelRegistry = ModelRegistry.create(
     authStorage,
@@ -1337,16 +1437,19 @@ async function createPiSession(input) {
     // The harness does not expose extensions, themes, or prompt templates, so
     // disable those entirely — this also avoids loading and executing a host
     // developer's personal Pi extensions inside the server process. Skills are
-    // kept (the harness writes project skills into `.pi/skills`) but filtered
-    // to the workspace so host-home skills never reach the model.
+    // kept but filtered to workspace project skills plus harness-provided
+    // skills whose files live in sandbox HOME.
     noExtensions: true,
     noThemes: true,
     noPromptTemplates: true,
     skillsOverride: (base) => ({
       ...base,
-      skills: base.skills.filter(
-        (skill) => isWithinWorkspace(skill.filePath, sessionWorkDir, hostWorkDir)
-      )
+      skills: [
+        ...base.skills.filter(
+          (skill) => isWithinWorkspace(skill.filePath, sessionWorkDir, hostWorkDir)
+        ),
+        ...harnessSkills
+      ]
     })
   });
   await resourceLoader.reload();