agentwheel 0.20.19 → 0.21.0

package/dist/run-as-worker.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+
+// src/transport/run-as-worker.ts
+import { lstat, readdir as readdir2, readFile as readFile2, realpath } from "fs/promises";
+import { isAbsolute, join as join2, parse, relative as relative2, resolve, sep } from "path";
+
+// src/utils/fs.ts
+import { createHash } from "crypto";
+import {
+  copyFile,
+  cp,
+  mkdir,
+  readdir,
+  readFile,
+  rename,
+  rm,
+  stat,
+  writeFile
+} from "fs/promises";
+import { dirname, join, relative } from "path";
+var IGNORED_ENTRY_NAMES = /* @__PURE__ */ new Set([".git", "node_modules", "__pycache__", ".DS_Store"]);
+var IGNORED_SUFFIXES = [".pyc", ".pyo"];
+async function hashPath(path) {
+  const stats = await stat(path);
+  if (stats.isFile()) {
+    const content = await readFile(path);
+    return createHash("sha256").update("file\0").update(content).digest("hex");
+  }
+  if (!stats.isDirectory()) {
+    throw new Error(`Unsupported path kind: ${path}`);
+  }
+  const hash = createHash("sha256").update("dir\0");
+  const files = await listFiles(path);
+  for (const file of files) {
+    hash.update(relative(path, file).replaceAll("\\", "/")).update("\0");
+    hash.update(await hashPath(file)).update("\0");
+  }
+  return hash.digest("hex");
+}
+async function listFiles(root) {
+  const out = [];
+  async function walk(dir) {
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+      if (isIgnoredGeneratedEntry(entry.name)) continue;
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(full);
+      } else if (entry.isFile()) {
+        out.push(full);
+      }
+    }
+  }
+  await walk(root);
+  return out;
+}
+function isIgnoredGeneratedEntry(name) {
+  return IGNORED_ENTRY_NAMES.has(name) || IGNORED_SUFFIXES.some((suffix) => name.endsWith(suffix));
+}
+
+// src/transport/run-as-worker.ts
+async function containedReadPath(root, requested) {
+  if (!isAbsolute(root) || resolve(root) !== root || !requested || requested.includes("\0") || requested.includes("\\") || isAbsolute(requested) || requested !== "." && requested.split(sep).some((part) => part === ".." || part === "." || part === "")) {
+    throw new Error("Run-as read path is not a contained relative path.");
+  }
+  let current = parse(root).root;
+  for (const part of root.slice(current.length).split(sep).filter(Boolean)) {
+    current = join2(current, part);
+    if ((await lstat(current)).isSymbolicLink()) throw new Error("Run-as root contains a symlink.");
+  }
+  if (await realpath(root) !== root) throw new Error("Run-as root changed.");
+  if (requested === ".") return root;
+  current = root;
+  for (const part of requested.split(sep)) {
+    current = join2(current, part);
+    try {
+      if ((await lstat(current)).isSymbolicLink()) throw new Error("Run-as path contains a symlink.");
+    } catch (error) {
+      if (error.code === "ENOENT") break;
+      throw error;
+    }
+  }
+  const rel = relative2(root, current);
+  if (!rel || rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) throw new Error("Run-as path escapes target root.");
+  return current;
+}
+async function rejectNestedLinks(path) {
+  const stat2 = await lstat(path);
+  if (stat2.isSymbolicLink()) throw new Error("Run-as read path contains a symlink.");
+  if (!stat2.isDirectory()) return;
+  for (const entry of await readdir2(path)) await rejectNestedLinks(join2(path, entry));
+}
+async function executeRead(root, request) {
+  if (request.version !== 1 || !["pathExists", "hashPath", "readFile", "listDir"].includes(request.operation)) {
+    throw new Error("Unsupported run-as read protocol request.");
+  }
+  const path = await containedReadPath(root, request.path);
+  let exists = true;
+  try {
+    await lstat(path);
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+    exists = false;
+  }
+  if (request.operation === "pathExists") return exists;
+  if (request.operation === "listDir" && !exists) return [];
+  if (!exists) throw new Error("Run-as target path does not exist.");
+  if (request.operation === "hashPath") {
+    await rejectNestedLinks(path);
+    return hashPath(path);
+  }
+  if (request.operation === "readFile") {
+    if (!(await lstat(path)).isFile()) throw new Error("Run-as readFile requires a regular file.");
+    return readFile2(path, "utf8");
+  }
+  return readdir2(path);
+}
+async function main() {
+  const [flagRoot, root, flagUid, rawUid, flagGid, rawGid] = process.argv.slice(2);
+  if (flagRoot !== "--root" || flagUid !== "--uid" || flagGid !== "--gid" || !root || !rawUid || !rawGid || process.argv.length !== 8) {
+    throw new Error("Invalid run-as worker arguments.");
+  }
+  const uid = Number(rawUid);
+  const gid = Number(rawGid);
+  if (!Number.isSafeInteger(uid) || uid <= 0 || !Number.isSafeInteger(gid) || gid < 0 || process.getuid?.() !== uid || process.getgid?.() !== gid || (await lstat(root)).uid !== uid) {
+    throw new Error("Run-as worker UID or root ownership mismatch.");
+  }
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of process.stdin) {
+    size += chunk.length;
+    if (size > 65536) throw new Error("Run-as request exceeds 64 KiB.");
+    chunks.push(chunk);
+  }
+  const request = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  const result = await executeRead(root, request);
+  process.stdout.write(`${JSON.stringify({ version: 1, result })}
+`);
+}
+if (process.argv[1] && /run-as-worker\.(?:js|mjs|ts)$/.test(process.argv[1])) {
+  main().catch((error) => {
+    process.stderr.write(`run-as worker: ${error instanceof Error ? error.message : String(error)}
+`);
+    process.exitCode = 1;
+  });
+}
+export {
+  containedReadPath,
+  executeRead
+};

package/openpack.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 2,
   "name": "NestDevLab/agentwheel",
-  "version": "0.20.19",
+  "version": "0.21.0",
   "provides": [
     { "type": "skills", "path": "skills" }
   ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentwheel",
-  "version": "0.20.19",
+  "version": "0.21.0",
   "description": "Weave skills, rules, and instructions across every AI agent.",
   "type": "module",
   "license": "MIT",

package/skills/agentwheel/SKILL.md

@@ -5,7 +5,7 @@ allowed-tools: [Bash]
 license: MIT
 metadata:
   author: NestDevLab
-  version: "0.20.19"
+  version: "0.21.0"
 ---
 
 # agentwheel
@@ -357,6 +357,12 @@ Current config shape:
 
 Use named targets:
 
+Configured packages may declare `"runtimes": ["claude"]` to select adapter runtimes. All
+configured-package plans honor it, including `--agent`, `--profile`, status, and update. Named
+targets match their declared adapter; plain workspace commands match each package's adapter.
+Agents sharing an adapter cannot be selected separately. Upgrade all members to a version
+supporting this field before adding it to shared configuration.
+
 ```bash
 agentwheel fleet register example-fleet --root /srv/agentwheel/fleets/example-fleet --required-package core-agent-pack
 agentwheel fleet list
@@ -475,6 +481,9 @@ Drift means a managed runtime output changed outside agentwheel. Fix drift by ch
   colliding upstream artifact.
 - Eject an item into `.agentwheel/ejected` when the user wants local ownership.
 
+When the plan instead keeps a file as foreign or refuses because another workspace owns it, that is
+an ownership problem, not drift: see "Choosing an ownership command" under Troubleshooting.
+
 Append durable local instruction text:
 
 ```bash
@@ -646,3 +655,23 @@ before Fleet qualification, owns paths under a fingerprint-only legacy key, run
 --from-workspace-root <previous-owner-root> --json` from that workspace. It moves only proven,
 still-desired entries into the stable state; add `--carry-drift` only after reviewing the drifted
 paths. Apply the emitted command, then require a normal install plan without force flags.
+
+### Choosing an ownership command
+
+`agentwheel ownership --help` lists the commands; each subcommand's `--help` is the authoritative flag
+reference. All of them dry-run by default and change only manifest metadata.
+
+| Situation | Command |
+|---|---|
+| Unclear who owns what | `ownership recovery-plan` (read-only evidence report) |
+| Refused: paths owned under a fingerprint-only legacy key | `ownership adopt-legacy` |
+| `adopt-legacy` says entries are "already owned by the destination owner" (mixed legacy manifest) | Run a normal `install --agent <agent>` first; it migrates the state and keeps the foreign entry. Then hand off that entry. |
+| Plan keeps one file as a `foreign artifact owned by …` in a stable manifest | `ownership handoff <type/name>` with `--from-workspace-root <root>`, or `--from-unknown-owner` for `workspace:unknown`; add `--to-fleet <id>` for a Fleet owner |
+| Stale foreign entry already covered by the Fleet manifest | `ownership retire-stale` |
+
+`handoff` refuses a file whose runtime hash differs from the manifest. If the drift is reviewed and
+harmless, add `--carry-drift`; applying then also needs `--expected-runtime-hash` from the dry-run.
+The recorded hash is kept, so the next install reports `DRIFT` for that file. Replacing it needs
+`install --agent <agent> --force-drift`, which also force-refreshes every merge contribution of that
+target (for example hooks): check that each merge destination is byte-identical afterwards. Never
+narrow that install with `--select`: it removes unselected merge contributions.

package/skills/agentwheel-discovery/SKILL.md

@@ -5,7 +5,7 @@ allowed-tools: [Bash]
 license: MIT
 metadata:
   author: NestDevLab
-  version: "0.20.19"
+  version: "0.21.0"
 ---
 
 # Agentwheel Discovery

package/dist/apply-QJHTL7IK.js

@@ -1,17 +0,0 @@
-#!/usr/bin/env node
-import {
-  applyCombinedInstallPlan,
-  applyInstallPlan,
-  commitManifestMetadataJournal,
-  recoverPendingApply,
-  uninstall
-} from "./chunk-L37KQVRS.js";
-import "./chunk-BHT57MK5.js";
-import "./chunk-BNIF3FUR.js";
-export {
-  applyCombinedInstallPlan,
-  applyInstallPlan,
-  commitManifestMetadataJournal,
-  recoverPendingApply,
-  uninstall
-};