@enactprotocol/shared 2.2.2 → 2.3.1

package/tests/config-normalization.test.ts

@@ -0,0 +1,279 @@
+/**
+ * Tests for config normalization — alias fields added in the README update.
+ *
+ * TrustConfig aliases: require_signatures → policy, trusted_publishers → auditors
+ * ExecutionConfig routing: default, fallback, trusted_scopes
+ */
+
+import { describe, expect, test } from "bun:test";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import yaml from "js-yaml";
+import {
+  DEFAULT_CONFIG,
+  getTrustPolicy,
+  getTrustedIdentities,
+  loadConfig,
+  saveConfig,
+} from "../src/config";
+
+describe("config normalization", () => {
+  describe("TrustConfig aliases", () => {
+    test("require_signatures: true sets policy to require_attestation", () => {
+      const configPath = join(homedir(), ".enact", "config.yaml");
+      mkdirSync(join(homedir(), ".enact"), { recursive: true });
+      writeFileSync(
+        configPath,
+        yaml.dump({
+          trust: {
+            require_signatures: true,
+          },
+        }),
+        "utf-8"
+      );
+
+      const config = loadConfig();
+      expect(config.trust?.policy).toBe("require_attestation");
+    });
+
+    test("require_signatures: false sets policy to allow", () => {
+      const configPath = join(homedir(), ".enact", "config.yaml");
+      writeFileSync(
+        configPath,
+        yaml.dump({
+          trust: {
+            require_signatures: false,
+          },
+        }),
+        "utf-8"
+      );
+
+      const config = loadConfig();
+      expect(config.trust?.policy).toBe("allow");
+    });
+
+    test("explicit policy takes precedence over require_signatures", () => {
+      const configPath = join(homedir(), ".enact", "config.yaml");
+      writeFileSync(
+        configPath,
+        yaml.dump({
+          trust: {
+            policy: "prompt",
+            require_signatures: true,
+          },
+        }),
+        "utf-8"
+      );
+
+      const config = loadConfig();
+      // When policy is explicitly set, require_signatures should not override it
+      expect(config.trust?.policy).toBe("prompt");
+    });
+
+    test("trusted_publishers merges into auditors", () => {
+      const configPath = join(homedir(), ".enact", "config.yaml");
+      writeFileSync(
+        configPath,
+        yaml.dump({
+          trust: {
+            auditors: ["github:existing-user"],
+            trusted_publishers: ["@my-org"],
+          },
+        }),
+        "utf-8"
+      );
+
+      const config = loadConfig();
+      expect(config.trust?.auditors).toContain("github:existing-user");
+      expect(config.trust?.auditors).toContain("@my-org");
+    });
+
+    test("trusted_publishers does not create duplicates", () => {
+      const configPath = join(homedir(), ".enact", "config.yaml");
+      writeFileSync(
+        configPath,
+        yaml.dump({
+          trust: {
+            auditors: ["@my-org", "github:alice"],
+            trusted_publishers: ["@my-org"],
+          },
+        }),
+        "utf-8"
+      );
+
+      const config = loadConfig();
+      const orgCount = config.trust?.auditors?.filter((a) => a === "@my-org").length;
+      expect(orgCount).toBe(1);
+    });
+
+    test("trusted_publishers works without existing auditors", () => {
+      const configPath = join(homedir(), ".enact", "config.yaml");
+      writeFileSync(
+        configPath,
+        yaml.dump({
+          trust: {
+            trusted_publishers: ["@my-org", "@other-org"],
+          },
+        }),
+        "utf-8"
+      );
+
+      const config = loadConfig();
+      // Should merge with default auditors
+      expect(config.trust?.auditors).toContain("@my-org");
+      expect(config.trust?.auditors).toContain("@other-org");
+    });
+
+    test("getTrustPolicy respects require_signatures alias", () => {
+      const configPath = join(homedir(), ".enact", "config.yaml");
+      writeFileSync(
+        configPath,
+        yaml.dump({
+          trust: {
+            require_signatures: true,
+          },
+        }),
+        "utf-8"
+      );
+
+      expect(getTrustPolicy()).toBe("require_attestation");
+    });
+
+    test("getTrustedIdentities includes trusted_publishers", () => {
+      const configPath = join(homedir(), ".enact", "config.yaml");
+      writeFileSync(
+        configPath,
+        yaml.dump({
+          trust: {
+            auditors: ["github:alice"],
+            trusted_publishers: ["@acme"],
+          },
+        }),
+        "utf-8"
+      );
+
+      const identities = getTrustedIdentities();
+      expect(identities).toContain("github:alice");
+      expect(identities).toContain("@acme");
+    });
+  });
+
+  describe("ExecutionConfig routing fields", () => {
+    test("default execution backend is preserved", () => {
+      const configPath = join(homedir(), ".enact", "config.yaml");
+      writeFileSync(
+        configPath,
+        yaml.dump({
+          execution: {
+            default: "docker",
+          },
+        }),
+        "utf-8"
+      );
+
+      const config = loadConfig();
+      expect(config.execution?.default).toBe("docker");
+    });
+
+    test("fallback execution backend is preserved", () => {
+      const configPath = join(homedir(), ".enact", "config.yaml");
+      writeFileSync(
+        configPath,
+        yaml.dump({
+          execution: {
+            default: "container",
+            fallback: "remote",
+          },
+        }),
+        "utf-8"
+      );
+
+      const config = loadConfig();
+      expect(config.execution?.default).toBe("container");
+      expect(config.execution?.fallback).toBe("remote");
+    });
+
+    test("trusted_scopes is preserved as array", () => {
+      const configPath = join(homedir(), ".enact", "config.yaml");
+      writeFileSync(
+        configPath,
+        yaml.dump({
+          execution: {
+            default: "container",
+            fallback: "remote",
+            trusted_scopes: ["@my-org/*", "@internal/*"],
+          },
+        }),
+        "utf-8"
+      );
+
+      const config = loadConfig();
+      expect(config.execution?.trusted_scopes).toEqual(["@my-org/*", "@internal/*"]);
+    });
+
+    test("routing fields coexist with existing fields", () => {
+      const configPath = join(homedir(), ".enact", "config.yaml");
+      writeFileSync(
+        configPath,
+        yaml.dump({
+          execution: {
+            defaultTimeout: "1m",
+            verbose: true,
+            default: "docker",
+            fallback: "local",
+            trusted_scopes: ["@my-org/*"],
+          },
+        }),
+        "utf-8"
+      );
+
+      const config = loadConfig();
+      expect(config.execution?.defaultTimeout).toBe("1m");
+      expect(config.execution?.verbose).toBe(true);
+      expect(config.execution?.default).toBe("docker");
+      expect(config.execution?.fallback).toBe("local");
+      expect(config.execution?.trusted_scopes).toEqual(["@my-org/*"]);
+    });
+
+    test("missing routing fields default to undefined", () => {
+      saveConfig({ ...DEFAULT_CONFIG });
+      const config = loadConfig();
+      expect(config.execution?.default).toBeUndefined();
+      expect(config.execution?.fallback).toBeUndefined();
+      expect(config.execution?.trusted_scopes).toBeUndefined();
+    });
+  });
+
+  describe("full README-style config", () => {
+    test("parses complete README example correctly", () => {
+      const configPath = join(homedir(), ".enact", "config.yaml");
+      writeFileSync(
+        configPath,
+        yaml.dump({
+          trust: {
+            require_signatures: true,
+            trusted_publishers: ["@my-org"],
+          },
+          execution: {
+            default: "container",
+            fallback: "remote",
+            trusted_scopes: ["@my-org/*"],
+          },
+        }),
+        "utf-8"
+      );
+
+      const config = loadConfig();
+
+      // Trust
+      expect(config.trust?.policy).toBe("require_attestation");
+      expect(config.trust?.auditors).toContain("@my-org");
+
+      // Execution
+      expect(config.execution?.default).toBe("container");
+      expect(config.execution?.fallback).toBe("remote");
+      expect(config.execution?.trusted_scopes).toEqual(["@my-org/*"]);
+    });
+  });
+});

package/tests/config.test.ts

@@ -534,7 +534,7 @@ describe("configuration manager", () => {
       expect(existsSync(enactHome)).toBe(true);
     });
 
-    test("creates ~/.enact/cache/ directory", () => {
+    test("creates ~/.agent/skills/ directory", () => {
       const enactHome = getEnactHome();
       const cacheDir = getCacheDir();
 
@@ -542,6 +542,9 @@ describe("configuration manager", () => {
       if (existsSync(enactHome)) {
         rmSync(enactHome, { recursive: true, force: true });
       }
+      if (existsSync(cacheDir)) {
+        rmSync(cacheDir, { recursive: true, force: true });
+      }
 
       ensureGlobalSetup();
 

package/tests/effective-input-schema.test.ts

@@ -0,0 +1,86 @@
+/**
+ * Tests for getEffectiveInputSchema and DEFAULT_INPUT_SCHEMA.
+ */
+
+import { describe, expect, test } from "bun:test";
+import { DEFAULT_INPUT_SCHEMA, getEffectiveInputSchema } from "../src/types/actions";
+import type { Action } from "../src/types/actions";
+
+describe("DEFAULT_INPUT_SCHEMA", () => {
+  test("is an object type schema", () => {
+    expect(DEFAULT_INPUT_SCHEMA.type).toBe("object");
+  });
+
+  test("has empty properties", () => {
+    expect(DEFAULT_INPUT_SCHEMA.properties).toEqual({});
+  });
+
+  test("has no required fields", () => {
+    expect(DEFAULT_INPUT_SCHEMA.required).toBeUndefined();
+  });
+});
+
+describe("getEffectiveInputSchema", () => {
+  test("returns action inputSchema when provided", () => {
+    const action: Action = {
+      description: "test",
+      command: ["echo"],
+      inputSchema: {
+        type: "object",
+        properties: { name: { type: "string" } },
+        required: ["name"],
+      },
+    };
+
+    const schema = getEffectiveInputSchema(action);
+    expect(schema).toBe(action.inputSchema!);
+    expect(schema.required).toEqual(["name"]);
+  });
+
+  test("returns DEFAULT_INPUT_SCHEMA when no inputSchema", () => {
+    const action: Action = {
+      description: "test",
+      command: "echo hello",
+    };
+
+    const schema = getEffectiveInputSchema(action);
+    expect(schema).toBe(DEFAULT_INPUT_SCHEMA);
+    expect(schema.type).toBe("object");
+    expect(schema.properties).toEqual({});
+  });
+
+  test("returns DEFAULT_INPUT_SCHEMA when inputSchema is undefined", () => {
+    const action = {
+      description: "test",
+      command: ["echo", "hello"],
+    } as Action;
+
+    const schema = getEffectiveInputSchema(action);
+    expect(schema).toBe(DEFAULT_INPUT_SCHEMA);
+  });
+
+  test("preserves complex inputSchema with nested properties", () => {
+    const action: Action = {
+      description: "test",
+      command: ["cmd"],
+      inputSchema: {
+        type: "object",
+        properties: {
+          config: {
+            type: "object",
+            properties: {
+              depth: { type: "number", default: 3 },
+              format: { type: "string", enum: ["json", "csv"] },
+            },
+          },
+        },
+        required: ["config"],
+      },
+    };
+
+    const schema = getEffectiveInputSchema(action);
+    expect(schema.required).toEqual(["config"]);
+    const props = schema.properties as Record<string, { type: string }>;
+    expect(props.config!.type).toBe("object");
+  });
+});

package/tests/fixtures/valid-tool.md

@@ -1,23 +1,16 @@
 ---
 enact: "2.0.0"
-name: acme/docs/analyzer
+name: acme/analyzer
 description: Analyzes documentation for completeness
 version: "1.2.0"
 from: python:3.11-slim
-command: "python analyze.py ${file}"
 timeout: 5m
 license: Apache-2.0
 tags:
   - documentation
   - analysis
-inputSchema:
-  type: object
-  properties:
-    file:
-      type: string
-      description: Path to the documentation file
-  required:
-    - file
+scripts:
+  analyze: "python analyze.py {{file}}"
 outputSchema:
   type: object
   properties:
@@ -39,7 +32,7 @@ Provide a path to a documentation file and get a quality score along with
 any issues found.
 
 ```bash
-enact run acme/docs/analyzer --file README.md
+enact run acme/analyzer --file README.md
 ```
 
 ## Output
@@ -54,7 +47,7 @@ The tool returns a JSON object with:
 ### Basic Analysis
 
 ```bash
-enact run acme/docs/analyzer --file docs/api.md
+enact run acme/analyzer --file docs/api.md
 ```
 
 ### Integration with CI

package/tests/fixtures/valid-tool.yaml

@@ -1,22 +1,15 @@
 enact: "2.0.0"
-name: acme/utils/greeter
+name: acme/greeter
 description: Greets users by name
 version: "1.0.0"
 from: node:18-alpine
-command: "echo 'Hello ${name}!'"
 timeout: 30s
 license: MIT
 tags:
   - greeting
   - utility
-inputSchema:
-  type: object
-  properties:
-    name:
-      type: string
-      description: The name to greet
-  required:
-    - name
+scripts:
+  greet: "echo 'Hello {{name}}!'"
 outputSchema:
   type: object
   properties:

package/tests/hooks.test.ts

@@ -0,0 +1,177 @@
+/**
+ * Tests for the ToolHooks type and postinstall hook behavior.
+ */
+
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import type { ToolHooks, ToolManifest } from "../src/types/manifest";
+
+const FIXTURES_DIR = join(import.meta.dir, "fixtures", "hooks-test");
+
+beforeAll(() => {
+  mkdirSync(FIXTURES_DIR, { recursive: true });
+});
+
+afterAll(() => {
+  if (existsSync(FIXTURES_DIR)) {
+    rmSync(FIXTURES_DIR, { recursive: true, force: true });
+  }
+});
+
+describe("ToolHooks type", () => {
+  test("manifest accepts hooks with postinstall string", () => {
+    const manifest: ToolManifest = {
+      name: "@test/with-hook",
+      description: "A tool with a postinstall hook",
+      hooks: {
+        postinstall: "npm install",
+      },
+    };
+    expect(manifest.hooks?.postinstall).toBe("npm install");
+  });
+
+  test("manifest accepts hooks with postinstall array", () => {
+    const manifest: ToolManifest = {
+      name: "@test/with-hooks",
+      description: "A tool with multiple postinstall commands",
+      hooks: {
+        postinstall: ["npm install", "npm run build"],
+      },
+    };
+    expect(manifest.hooks?.postinstall).toEqual(["npm install", "npm run build"]);
+  });
+
+  test("manifest works without hooks", () => {
+    const manifest: ToolManifest = {
+      name: "@test/no-hooks",
+      description: "A tool without hooks",
+    };
+    expect(manifest.hooks).toBeUndefined();
+  });
+
+  test("hooks field can be empty object", () => {
+    const hooks: ToolHooks = {};
+    expect(hooks.postinstall).toBeUndefined();
+  });
+});
+
+describe("postinstall hook execution", () => {
+  test("single command creates expected side-effect", async () => {
+    const toolDir = join(FIXTURES_DIR, "single-cmd");
+    mkdirSync(toolDir, { recursive: true });
+
+    const markerFile = join(toolDir, "postinstall-ran.txt");
+    const cmd = `echo "hook executed" > postinstall-ran.txt`;
+
+    const proc = Bun.spawn(["sh", "-c", cmd], {
+      cwd: toolDir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    await proc.exited;
+
+    expect(existsSync(markerFile)).toBe(true);
+    const content = await Bun.file(markerFile).text();
+    expect(content.trim()).toBe("hook executed");
+  });
+
+  test("multiple commands run sequentially", async () => {
+    const toolDir = join(FIXTURES_DIR, "multi-cmd");
+    mkdirSync(toolDir, { recursive: true });
+
+    const commands = [
+      'echo "step1" > step1.txt',
+      'echo "step2" > step2.txt',
+      "cat step1.txt step2.txt > combined.txt",
+    ];
+
+    for (const cmd of commands) {
+      const proc = Bun.spawn(["sh", "-c", cmd], {
+        cwd: toolDir,
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+      const exitCode = await proc.exited;
+      expect(exitCode).toBe(0);
+    }
+
+    const combined = await Bun.file(join(toolDir, "combined.txt")).text();
+    expect(combined).toContain("step1");
+    expect(combined).toContain("step2");
+  });
+
+  test("failing command returns non-zero exit code", async () => {
+    const toolDir = join(FIXTURES_DIR, "fail-cmd");
+    mkdirSync(toolDir, { recursive: true });
+
+    const proc = Bun.spawn(["sh", "-c", "exit 1"], {
+      cwd: toolDir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    const exitCode = await proc.exited;
+
+    expect(exitCode).toBe(1);
+  });
+
+  test("command runs in the tool directory (cwd)", async () => {
+    const toolDir = join(FIXTURES_DIR, "cwd-check");
+    mkdirSync(toolDir, { recursive: true });
+
+    const proc = Bun.spawn(["sh", "-c", "pwd"], {
+      cwd: toolDir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+    await proc.exited;
+
+    const output = await new Response(proc.stdout).text();
+    expect(output.trim()).toBe(toolDir);
+  });
+
+  test("command inherits environment variables", async () => {
+    const toolDir = join(FIXTURES_DIR, "env-check");
+    mkdirSync(toolDir, { recursive: true });
+
+    const proc = Bun.spawn(["sh", "-c", "echo $HOME"], {
+      cwd: toolDir,
+      stdout: "pipe",
+      stderr: "pipe",
+      env: { ...process.env },
+    });
+    await proc.exited;
+
+    const output = await new Response(proc.stdout).text();
+    expect(output.trim()).toBeTruthy();
+    expect(output.trim()).toBe(process.env.HOME!);
+  });
+});
+
+describe("manifest with hooks serialization", () => {
+  test("hooks survive JSON round-trip (single command)", () => {
+    const manifest: ToolManifest = {
+      name: "@test/roundtrip",
+      description: "test",
+      hooks: { postinstall: "make build" },
+    };
+
+    const json = JSON.stringify(manifest);
+    const parsed = JSON.parse(json) as ToolManifest;
+
+    expect(parsed.hooks?.postinstall).toBe("make build");
+  });
+
+  test("hooks survive JSON round-trip (command array)", () => {
+    const manifest: ToolManifest = {
+      name: "@test/roundtrip-array",
+      description: "test",
+      hooks: { postinstall: ["npm ci", "npm run build"] },
+    };
+
+    const json = JSON.stringify(manifest);
+    const parsed = JSON.parse(json) as ToolManifest;
+
+    expect(parsed.hooks?.postinstall).toEqual(["npm ci", "npm run build"]);
+  });
+});