agenticros 0.1.19 → 0.2.1

package/runtime/packages/core/package.json

@@ -1,8 +1,24 @@
 {
   "name": "@agenticros/core",
-  "version": "0.0.1",
+  "version": "0.5.0",
   "type": "module",
-  "description": "AgenticROS core — platform-agnostic ROS2 transport, types, and config",
+  "description": "AgenticROS core — platform-agnostic ROS2 transport, types, and config (the dep every AgenticROS skill imports).",
+  "keywords": [
+    "agenticros",
+    "ros2",
+    "robotics",
+    "zenoh",
+    "rosbridge",
+    "webrtc",
+    "skill-sdk"
+  ],
+  "homepage": "https://github.com/agenticros/agenticros#readme",
+  "bugs": "https://github.com/agenticros/agenticros/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/agenticros/agenticros.git",
+    "directory": "packages/core"
+  },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
@@ -12,10 +28,27 @@
       "default": "./dist/index.js"
     }
   },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "dist/**/*.js.map",
+    "dist/**/*.d.ts.map",
+    "!dist/**/__tests__/**",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
   "scripts": {
     "build": "tsc",
     "typecheck": "tsc --noEmit",
-    "test": "node --test \"dist/memory/__tests__/*.test.js\" \"dist/__tests__/*.test.js\""
+    "test": "node --test \"dist/memory/__tests__/*.test.js\" \"dist/__tests__/*.test.js\"",
+    "prepublishOnly": "npm run build",
+    "pack:dry": "npm pack --dry-run"
   },
   "dependencies": {
     "@eclipse-zenoh/zenoh-ts": "^1.9.0",

package/runtime/packages/core/src/__tests__/capabilities.test.ts

@@ -11,12 +11,12 @@
  * The most upstream of those is "the reader produces what we promised";
  * everything else depends on that contract holding. So this file pins down:
  *   - BUILTIN_CAPABILITIES has the 6 intrinsic verbs we ship.
- *   - readSkillCapabilities() picks up package.json's agenticrosSkill object form.
- *   - It also reads sibling capabilities.json files.
+ *   - readSkillCapabilities() picks up the `agenticros` block from package.json.
+ *   - It uses `agenticros.id` (not the package name) as the skill id.
  *   - It tags every capability with a source so dispatchers can filter.
  *   - It deduplicates within a skill so a malformed manifest can't blow up.
  *   - listAllCapabilities() merges intrinsic + skill in that order.
- *   - It tolerates non-skill packages (no agenticrosSkill key) silently.
+ *   - It tolerates non-skill packages (no `agenticros` key) silently.
  */
 import { test } from "node:test";
 import assert from "node:assert/strict";
@@ -40,12 +40,10 @@ async function makeSkillDir(
   root: string,
   name: string,
   pkg: Record<string, unknown>,
-  sidecar?: Record<string, unknown>,
 ): Promise<string> {
   const dir = path.join(root, name);
   await mkdir(dir, { recursive: true });
   await writeJson(path.join(dir, "package.json"), pkg);
-  if (sidecar) await writeJson(path.join(dir, "capabilities.json"), sidecar);
   return dir;
 }
 
@@ -66,14 +64,16 @@ test("BUILTIN_CAPABILITIES exposes the six intrinsic robot verbs", () => {
   }
 });
 
-test("readSkillCapabilities: reads package.json agenticrosSkill object form", async () => {
+test("readSkillCapabilities: reads capabilities from the `agenticros` block", async () => {
   const root = await mkdtemp(path.join(tmpdir(), "agenticros-caps-"));
   try {
     const skillDir = await makeSkillDir(root, "skill-alpha", {
       name: "agenticros-skill-alpha",
       version: "0.0.1",
       main: "dist/index.js",
-      agenticrosSkill: {
+      agenticros: {
+        id: "alpha",
+        displayName: "Alpha",
         capabilities: [
           {
             id: "wave_hello",
@@ -114,30 +114,23 @@ test("readSkillCapabilities: reads package.json agenticrosSkill object form", as
   }
 });
 
-test("readSkillCapabilities: also reads sibling capabilities.json", async () => {
+test("readSkillCapabilities: uses agenticros.id (not the package name) for the skill id", async () => {
   const root = await mkdtemp(path.join(tmpdir(), "agenticros-caps-"));
   try {
-    const skillDir = await makeSkillDir(
-      root,
-      "skill-beta",
-      {
-        name: "agenticros-skill-beta",
-        version: "0.0.1",
-        agenticrosSkill: true,
-      },
-      {
-        capabilities: [
-          { id: "sidecar_only", verb: "demo", description: "From sibling." },
-        ],
+    const skillDir = await makeSkillDir(root, "weird-named-repo", {
+      name: "@some-org/totally-different-name",
+      version: "0.0.1",
+      agenticros: {
+        id: "explicit-id",
+        capabilities: [{ id: "do_thing", verb: "do", description: "Do." }],
       },
-    );
-
+    });
     const caps = readSkillCapabilities(parseConfig({ skillPaths: [skillDir] }));
     assert.equal(caps.length, 1);
-    assert.equal(caps[0].id, "sidecar_only");
     assert.equal(caps[0].source?.kind, "skill");
     if (caps[0].source?.kind === "skill") {
-      assert.equal(caps[0].source.skillId, "beta");
+      assert.equal(caps[0].source.skillId, "explicit-id");
+      assert.equal(caps[0].source.package, "@some-org/totally-different-name");
     }
   } finally {
     await rm(root, { recursive: true, force: true });
@@ -158,33 +151,26 @@ test("readSkillCapabilities: silently ignores non-skill packages", async () => {
   }
 });
 
-test("readSkillCapabilities: dedupes when an id appears in both package.json and sibling", async () => {
+test("readSkillCapabilities: dedupes within a skill when an id appears twice in the array", async () => {
   const root = await mkdtemp(path.join(tmpdir(), "agenticros-caps-"));
   try {
-    const skillDir = await makeSkillDir(
-      root,
-      "skill-dupe",
-      {
-        name: "agenticros-skill-dupe",
-        version: "0.0.1",
-        agenticrosSkill: {
-          capabilities: [
-            { id: "shared_id", verb: "first", description: "From package.json." },
-          ],
-        },
-      },
-      {
+    const skillDir = await makeSkillDir(root, "skill-dupe", {
+      name: "agenticros-skill-dupe",
+      version: "0.0.1",
+      agenticros: {
+        id: "dupe",
         capabilities: [
-          { id: "shared_id", verb: "second", description: "From sidecar (ignored)." },
-          { id: "extra", verb: "demo", description: "Unique to sidecar." },
+          { id: "shared_id", verb: "first", description: "First." },
+          { id: "shared_id", verb: "second", description: "Duplicate (ignored)." },
+          { id: "extra", verb: "demo", description: "Unique." },
         ],
       },
-    );
+    });
     const caps = readSkillCapabilities(parseConfig({ skillPaths: [skillDir] }));
     const ids = caps.map((c) => c.id).sort();
     assert.deepEqual(ids, ["extra", "shared_id"]);
     const shared = caps.find((c) => c.id === "shared_id");
-    assert.equal(shared?.verb, "first", "package.json should win over sidecar");
+    assert.equal(shared?.verb, "first", "first entry should win on duplicate id");
   } finally {
     await rm(root, { recursive: true, force: true });
   }
@@ -196,7 +182,8 @@ test("readSkillCapabilities: drops entries without a valid id", async () => {
     const skillDir = await makeSkillDir(root, "skill-bad", {
       name: "agenticros-skill-bad",
       version: "0.0.1",
-      agenticrosSkill: {
+      agenticros: {
+        id: "bad",
         capabilities: [
           { verb: "noid", description: "Missing id." },
           { id: "", verb: "empty", description: "Empty id." },
@@ -214,13 +201,31 @@ test("readSkillCapabilities: drops entries without a valid id", async () => {
   }
 });
 
+test("readSkillCapabilities: skips packages with an `agenticros` block that lacks an `id`", async () => {
+  const root = await mkdtemp(path.join(tmpdir(), "agenticros-caps-"));
+  try {
+    const skillDir = await makeSkillDir(root, "skill-noid", {
+      name: "agenticros-skill-noid",
+      version: "0.0.1",
+      agenticros: {
+        capabilities: [{ id: "do_thing", verb: "do", description: "Do." }],
+      },
+    });
+    const caps = readSkillCapabilities(parseConfig({ skillPaths: [skillDir] }));
+    assert.equal(caps.length, 0);
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+});
+
 test("listAllCapabilities: built-ins first, then skill caps; counts add up", async () => {
   const root = await mkdtemp(path.join(tmpdir(), "agenticros-caps-"));
   try {
     const skillDir = await makeSkillDir(root, "skill-extra", {
       name: "agenticros-skill-extra",
       version: "0.0.1",
-      agenticrosSkill: {
+      agenticros: {
+        id: "extra",
         capabilities: [
           { id: "extra_one", verb: "demo", description: "One." },
           { id: "extra_two", verb: "demo", description: "Two." },

package/runtime/packages/core/src/capabilities.ts

@@ -169,16 +169,6 @@ export const BUILTIN_CAPABILITIES: readonly Capability[] = [
   },
 ];
 
-const SKILL_PACKAGE_PREFIX = "agenticros-skill-";
-
-function deriveSkillId(packageName: string): string {
-  const lower = packageName.toLowerCase();
-  if (lower.startsWith(SKILL_PACKAGE_PREFIX)) {
-    return lower.slice(SKILL_PACKAGE_PREFIX.length);
-  }
-  return lower.replace(/^@[^/]+\//, "").replace(/[^a-z0-9]/g, "");
-}
-
 function isCapabilityLike(value: unknown): value is Partial<Capability> & { id: string } {
   if (!value || typeof value !== "object") return false;
   const v = value as Record<string, unknown>;
@@ -204,53 +194,39 @@ function normalizeCapability(
 }
 
 /**
- * Parse the `agenticrosSkill` field from a package.json + a sibling
- * `capabilities.json` (if present). Returns the raw capability array or `null`
- * if the package isn't an AgenticROS skill.
+ * Read the `agenticros.capabilities[]` array from a skill's package.json.
+ * Returns `null` if the package doesn't declare a valid `agenticros` block.
+ *
+ * The legacy `agenticrosSkill: true | { capabilities }` form is NOT supported
+ * — every skill must use the single `agenticros` block as its source of truth.
  */
 function readSkillManifestFromDir(
   packageDir: string,
-): { packageName: string; rawCaps: Array<Partial<Capability> & { id: string }> } | null {
+): { packageName: string; skillId: string; rawCaps: Array<Partial<Capability> & { id: string }> } | null {
   const pkgJsonPath = join(packageDir, "package.json");
   if (!existsSync(pkgJsonPath)) return null;
   let pkg: {
     name?: string;
-    agenticrosSkill?: boolean | { capabilities?: unknown };
+    agenticros?: { id?: unknown; capabilities?: unknown };
   };
   try {
     pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
   } catch {
     return null;
   }
-  if (pkg.agenticrosSkill !== true && (typeof pkg.agenticrosSkill !== "object" || pkg.agenticrosSkill === null)) {
-    return null;
-  }
-  const packageName = pkg.name ?? "unknown";
+  if (!pkg.agenticros || typeof pkg.agenticros !== "object") return null;
+  if (typeof pkg.agenticros.id !== "string") return null;
 
+  const packageName = pkg.name ?? "unknown";
+  const skillId = pkg.agenticros.id;
   const rawCaps: Array<Partial<Capability> & { id: string }> = [];
 
-  if (typeof pkg.agenticrosSkill === "object" && pkg.agenticrosSkill !== null) {
-    const caps = (pkg.agenticrosSkill as { capabilities?: unknown }).capabilities;
-    if (Array.isArray(caps)) {
-      for (const c of caps) if (isCapabilityLike(c)) rawCaps.push(c);
-    }
-  }
-
-  const sidecarPath = join(packageDir, "capabilities.json");
-  if (existsSync(sidecarPath)) {
-    try {
-      const parsed = JSON.parse(readFileSync(sidecarPath, "utf-8"));
-      const arr = Array.isArray(parsed)
-        ? parsed
-        : Array.isArray((parsed as { capabilities?: unknown }).capabilities)
-        ? (parsed as { capabilities: unknown[] }).capabilities
-        : [];
-      for (const c of arr) if (isCapabilityLike(c)) rawCaps.push(c);
-    } catch {
-    }
+  const caps = pkg.agenticros.capabilities;
+  if (Array.isArray(caps)) {
+    for (const c of caps) if (isCapabilityLike(c)) rawCaps.push(c);
   }
 
-  return { packageName, rawCaps };
+  return { packageName, skillId, rawCaps };
 }
 
 function resolvePackageDir(packageName: string, searchPaths: string[]): string | null {
@@ -290,15 +266,14 @@ export function readSkillCapabilities(config: AgenticROSConfig): Capability[] {
     const absDir = resolvePath(dir);
     const manifest = readSkillManifestFromDir(absDir);
     if (!manifest) continue;
-    const skillId = deriveSkillId(manifest.packageName);
     for (const raw of manifest.rawCaps) {
-      const key = `${skillId}:${raw.id}`;
+      const key = `${manifest.skillId}:${raw.id}`;
       if (seen.has(key)) continue;
       seen.add(key);
       out.push(
         normalizeCapability(raw, {
           kind: "skill",
-          skillId,
+          skillId: manifest.skillId,
           package: manifest.packageName,
           path: absDir,
         }),
@@ -311,15 +286,14 @@ export function readSkillCapabilities(config: AgenticROSConfig): Capability[] {
     if (!packageDir) continue;
     const manifest = readSkillManifestFromDir(packageDir);
     if (!manifest) continue;
-    const skillId = deriveSkillId(manifest.packageName);
     for (const raw of manifest.rawCaps) {
-      const key = `${skillId}:${raw.id}`;
+      const key = `${manifest.skillId}:${raw.id}`;
       if (seen.has(key)) continue;
       seen.add(key);
       out.push(
         normalizeCapability(raw, {
           kind: "skill",
-          skillId,
+          skillId: manifest.skillId,
           package: manifest.packageName,
           path: packageDir,
         }),

package/runtime/packages/core/src/config.ts

@@ -413,7 +413,7 @@ export const AgenticROSConfigSchema = z.object({
   /** Per-skill config. Keys are skill ids (e.g. followme). Each skill validates its own slice. */
   skills: z.record(z.string(), z.unknown()).default({}),
 
-  /** Directories to scan for skill packages (package.json with "agenticrosSkill": true). Resolved at gateway start. */
+  /** Directories to scan for skill packages (package.json with an `agenticros` block). Resolved at gateway start. */
   skillPaths: z.array(z.string()).default([]),
 
   /** Npm (or local) package names to load as skills. Resolved via require.resolve from plugin context. */

package/runtime/scripts/pack-runtime.mjs

@@ -38,7 +38,7 @@
 
 import { execSync } from "node:child_process";
 import { cpSync, existsSync, mkdirSync, rmSync, statSync, writeFileSync } from "node:fs";
-import { dirname, join, relative, resolve } from "node:path";
+import { dirname, join, relative, resolve, sep as pathSep } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const __filename = fileURLToPath(import.meta.url);
@@ -117,8 +117,14 @@ function copyTree(src, dest, opts = {}) {
     errorOnExist: false,
     force: true,
     filter: (s, _d) => {
-      const rel = s.startsWith(src + "/") ? s.slice(src.length + 1) : "";
-      const parts = rel.split("/");
+      // On Windows, fs.cpSync hands the filter back paths with `\` separators
+      // while `src` was built with `path.join` (also `\`), so split on the
+      // OS separator. Splitting on `/` here used to silently fail on Windows
+      // and let node_modules through, which then EPERM'd on the first
+      // symlink inside `.pnpm/...` because Win32 needs elevated rights to
+      // create symlinks.
+      const rel = s.startsWith(src + pathSep) ? s.slice(src.length + 1) : "";
+      const parts = rel.split(pathSep);
       for (const p of parts) {
         if (EXCLUDED_DIR_NAMES.has(p)) return false;
       }

package/runtime/scripts/sync-skill-tools.mjs

@@ -130,8 +130,8 @@ function findSkillEntryFromPath(dirPath) {
     warn(`Invalid package.json in ${dirPath}: ${e?.message ?? e}`);
     return null;
   }
-  if (!pkg.agenticrosSkill) {
-    warn(`Not an AgenticROS skill (missing agenticrosSkill flag): ${dirPath}`);
+  if (!pkg.agenticros || typeof pkg.agenticros !== "object" || typeof pkg.agenticros.id !== "string") {
+    warn(`Not an AgenticROS skill (missing "agenticros": { "id": "..." } block): ${dirPath}`);
     return null;
   }
   const main = pkg.main ?? "index.js";