@enactprotocol/cli 2.3.4 → 2.3.7

package/src/commands/org/index.ts

@@ -0,0 +1,263 @@
+/**
+ * enact org command
+ *
+ * Manage organizations for @org scoped tool namespaces.
+ *
+ * Subcommands:
+ *   - create: Create a new organization
+ *   - info: Show organization details
+ *   - list: List your organizations (TODO: requires user orgs endpoint)
+ *   - add-member: Add a member to an organization
+ *   - remove-member: Remove a member from an organization
+ *   - set-role: Change a member's role
+ */
+
+import {
+  addOrgMember,
+  createApiClient,
+  createOrg,
+  getOrg,
+  listOrgMembers,
+  removeOrgMember,
+  updateOrgMemberRole,
+} from "@enactprotocol/api";
+import { getSecret } from "@enactprotocol/secrets";
+import { loadConfig } from "@enactprotocol/shared";
+import type { OrgRole } from "@enactprotocol/shared";
+import type { Command } from "commander";
+import type { GlobalOptions } from "../../types";
+import {
+  type TableColumn,
+  dim,
+  error,
+  formatError,
+  header,
+  json,
+  keyValue,
+  newline,
+  success,
+  table,
+} from "../../utils";
+
+const AUTH_NAMESPACE = "enact:auth";
+const ACCESS_TOKEN_KEY = "access_token";
+
+const VALID_ROLES = ["owner", "admin", "member"] as const;
+
+async function getClient() {
+  const config = loadConfig();
+  const token = await getSecret(AUTH_NAMESPACE, ACCESS_TOKEN_KEY);
+  return createApiClient({
+    baseUrl: config.registry?.url,
+    authToken: token ?? undefined,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Handlers
+// ---------------------------------------------------------------------------
+
+async function createHandler(
+  name: string,
+  options: { displayName?: string; description?: string } & GlobalOptions
+) {
+  try {
+    const client = await getClient();
+    const org = await createOrg(client, {
+      name,
+      displayName: options.displayName,
+      description: options.description,
+    });
+
+    if (options.json) {
+      json(org);
+      return;
+    }
+
+    success(`Organization "@${org.name}" created`);
+    newline();
+    keyValue("Name", `@${org.name}`);
+    if (org.display_name) keyValue("Display Name", org.display_name);
+    if (org.description) keyValue("Description", org.description);
+    newline();
+    dim("You are the owner. Publish tools with:");
+    dim(`  enact publish  (with name: "@${org.name}/your-tool" in SKILL.md)`);
+  } catch (err) {
+    error(formatError(err));
+    process.exit(1);
+  }
+}
+
+async function infoHandler(name: string, options: GlobalOptions) {
+  try {
+    // Strip @ prefix if provided
+    const orgName = name.startsWith("@") ? name.substring(1) : name;
+    const client = await getClient();
+
+    const org = await getOrg(client, orgName);
+    const members = await listOrgMembers(client, orgName);
+
+    if (options.json) {
+      json({ ...org, members });
+      return;
+    }
+
+    header(`@${org.name}`);
+    if (org.display_name) keyValue("Display Name", org.display_name);
+    if (org.description) keyValue("Description", org.description);
+    keyValue("Tools", String(org.tool_count));
+    keyValue("Members", String(org.member_count));
+    keyValue("Created", org.created_at);
+
+    newline();
+    header("Members");
+    const columns: TableColumn[] = [
+      { header: "Username", key: "username", width: 20 },
+      { header: "Role", key: "role", width: 10 },
+      { header: "Added", key: "added_at", width: 20 },
+    ];
+    table(
+      members.map((m) => ({
+        username: m.username,
+        role: m.role,
+        added_at: m.added_at,
+      })),
+      columns
+    );
+  } catch (err) {
+    error(formatError(err));
+    process.exit(1);
+  }
+}
+
+async function addMemberHandler(
+  orgName: string,
+  username: string,
+  options: { role?: string } & GlobalOptions
+) {
+  try {
+    const org = orgName.startsWith("@") ? orgName.substring(1) : orgName;
+    const role = (options.role ?? "member") as OrgRole;
+
+    if (!VALID_ROLES.includes(role as (typeof VALID_ROLES)[number])) {
+      error(`Invalid role: ${role}. Must be one of: ${VALID_ROLES.join(", ")}`);
+      process.exit(1);
+    }
+
+    const client = await getClient();
+    await addOrgMember(client, org, { username, role });
+
+    if (options.json) {
+      json({ username, role, org });
+      return;
+    }
+
+    success(`Added "${username}" to @${org} as ${role}`);
+  } catch (err) {
+    error(formatError(err));
+    process.exit(1);
+  }
+}
+
+async function removeMemberHandler(orgName: string, username: string, options: GlobalOptions) {
+  try {
+    const org = orgName.startsWith("@") ? orgName.substring(1) : orgName;
+    const client = await getClient();
+    await removeOrgMember(client, org, username);
+
+    if (options.json) {
+      json({ removed: username, org });
+      return;
+    }
+
+    success(`Removed "${username}" from @${org}`);
+  } catch (err) {
+    error(formatError(err));
+    process.exit(1);
+  }
+}
+
+async function setRoleHandler(
+  orgName: string,
+  username: string,
+  role: string,
+  options: GlobalOptions
+) {
+  try {
+    const org = orgName.startsWith("@") ? orgName.substring(1) : orgName;
+
+    if (!VALID_ROLES.includes(role as (typeof VALID_ROLES)[number])) {
+      error(`Invalid role: ${role}. Must be one of: ${VALID_ROLES.join(", ")}`);
+      process.exit(1);
+    }
+
+    const client = await getClient();
+    await updateOrgMemberRole(client, org, username, role as OrgRole);
+
+    if (options.json) {
+      json({ username, role, org });
+      return;
+    }
+
+    success(`Set "${username}" role to ${role} in @${org}`);
+  } catch (err) {
+    error(formatError(err));
+    process.exit(1);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Command Configuration
+// ---------------------------------------------------------------------------
+
+export function configureOrgCommand(program: Command): void {
+  const org = program.command("org").description("Manage organizations (@org scoped namespaces)");
+
+  // enact org create <name>
+  org
+    .command("create <name>")
+    .description("Create a new organization")
+    .option("--display-name <name>", "Display name for the organization")
+    .option("--description <desc>", "Organization description")
+    .option("--json", "Output as JSON")
+    .action(async (name: string, options) => {
+      await createHandler(name, options);
+    });
+
+  // enact org info <name>
+  org
+    .command("info <name>")
+    .description("Show organization details and members")
+    .option("--json", "Output as JSON")
+    .action(async (name: string, options) => {
+      await infoHandler(name, options);
+    });
+
+  // enact org add-member <org> <username>
+  org
+    .command("add-member <org> <username>")
+    .description("Add a member to an organization")
+    .option("--role <role>", "Member role (owner, admin, member)", "member")
+    .option("--json", "Output as JSON")
+    .action(async (orgName: string, username: string, options) => {
+      await addMemberHandler(orgName, username, options);
+    });
+
+  // enact org remove-member <org> <username>
+  org
+    .command("remove-member <org> <username>")
+    .description("Remove a member from an organization")
+    .option("--json", "Output as JSON")
+    .action(async (orgName: string, username: string, options) => {
+      await removeMemberHandler(orgName, username, options);
+    });
+
+  // enact org set-role <org> <username> <role>
+  org
+    .command("set-role <org> <username> <role>")
+    .description("Change a member's role (owner, admin, member)")
+    .option("--json", "Output as JSON")
+    .action(async (orgName: string, username: string, role: string, options) => {
+      await setRoleHandler(orgName, username, role, options);
+    });
+}

package/src/commands/publish/index.ts

@@ -320,7 +320,10 @@ async function publishHandler(
     const currentUsername = await getCurrentUsername();
     if (currentUsername) {
       const toolNamespace = extractNamespace(toolName);
-      if (toolNamespace !== currentUsername) {
+      if (toolNamespace.startsWith("@")) {
+        // Org-scoped tool — server will enforce org membership
+        dim(`Publishing to organization namespace "${toolNamespace}"...`);
+      } else if (toolNamespace !== currentUsername) {
         error(
           `Namespace mismatch: Tool namespace "${toolNamespace}" does not match your username "${currentUsername}".`
         );

package/src/commands/run/README.md

@@ -10,7 +10,7 @@ enact run <tool> [options]
 
 ## Description
 
-The `run` command executes a tool using the command defined in its manifest (`skill.yaml` or `SKILL.md`). The tool runs in an isolated container environment with:
+The `run` command executes a tool using the command defined in its manifest (`skill.package.yml` or `SKILL.md`). The tool runs in an isolated container environment with:
 
 - Input validation against the tool's JSON Schema
 - Automatic secret resolution from the OS keyring

package/src/index.ts

@@ -22,6 +22,7 @@ import {
   configureLearnCommand,
   configureListCommand,
   configureMcpCommand,
+  configureOrgCommand,
   configurePublishCommand,
   configureReportCommand,
   configureRunCommand,
@@ -37,7 +38,7 @@ import {
 } from "./commands";
 import { error, formatError } from "./utils";
 
-export const version = "2.3.4";
+export const version = "2.3.7";
 
 // Export types for external use
 export type { GlobalOptions, CommandContext } from "./types";
@@ -93,6 +94,9 @@ async function main() {
   // Self-hosted registry
   configureServeCommand(program);
 
+  // Organizations
+  configureOrgCommand(program);
+
   // Global error handler - handle Commander's help/version exits gracefully
   program.exitOverride((err) => {
     // Commander throws errors for help, version, and other "exit" scenarios

package/src/utils/errors.ts

@@ -84,7 +84,7 @@ export class ManifestError extends CliError {
     super(
       fullMessage,
       EXIT_MANIFEST_ERROR,
-      "Ensure the directory contains a valid skill.yaml or SKILL.md file."
+      "Ensure the directory contains a valid skill.package.yaml, skill.package.yml, or SKILL.md file."
     );
     this.name = "ManifestError";
   }
@@ -377,7 +377,7 @@ export const ErrorMessages = {
     message: `No manifest found in ${dir}`,
     suggestions: [
       `Create a manifest: ${colors.command("enact init")}`,
-      "Ensure the directory contains skill.yaml or SKILL.md",
+      "Ensure the directory contains skill.package.yaml, skill.package.yml, or SKILL.md",
     ],
   }),
 

package/tests/commands/install-integration.test.ts

@@ -46,7 +46,7 @@ describe("install integration", () => {
     mkdirSync(join(TEST_GLOBAL_HOME, ".enact", "cache"), { recursive: true });
 
     // Create sample tool source
-    writeFileSync(join(TEST_TOOL_SRC, "skill.yaml"), SAMPLE_MANIFEST);
+    writeFileSync(join(TEST_TOOL_SRC, "skill.package.yml"), SAMPLE_MANIFEST);
   });
 
   beforeEach(() => {
@@ -92,7 +92,7 @@ describe("install integration", () => {
 
       // Verify installation
       expect(existsSync(destPath)).toBe(true);
-      expect(existsSync(join(destPath, "skill.yaml"))).toBe(true);
+      expect(existsSync(join(destPath, "skill.package.yml"))).toBe(true);
 
       // Verify manifest can be loaded from destination
       const installedManifest = loadManifestFromDir(destPath);
@@ -118,7 +118,7 @@ describe("install integration", () => {
       // Create v2 source
       const v2Source = join(TEST_BASE, "source-tool-v2");
       mkdirSync(v2Source, { recursive: true });
-      writeFileSync(join(v2Source, "skill.yaml"), SAMPLE_MANIFEST_V2);
+      writeFileSync(join(v2Source, "skill.package.yml"), SAMPLE_MANIFEST_V2);
 
       // Simulate force overwrite
       rmSync(destPath, { recursive: true, force: true });
@@ -240,7 +240,7 @@ describe("install integration", () => {
       const cachePath = join(TEST_GLOBAL_HOME, ".enact", "cache", "test", "cached-tool", "v1.0.0");
       mkdirSync(cachePath, { recursive: true });
       writeFileSync(
-        join(cachePath, "skill.yaml"),
+        join(cachePath, "skill.package.yml"),
         `
 name: test/cached-tool
 version: 1.0.0
@@ -251,7 +251,7 @@ command: echo "cached"
 
       // The resolver should be able to find this tool once it's registered
       // Note: Full resolver testing is in resolver.test.ts
-      expect(existsSync(join(cachePath, "skill.yaml"))).toBe(true);
+      expect(existsSync(join(cachePath, "skill.package.yml"))).toBe(true);
     });
   });
 });

package/tests/commands/publish.test.ts

@@ -110,7 +110,8 @@ describe("publish command", () => {
     test("identifies manifest files", () => {
       const isManifest = (filename: string): boolean => {
         return (
-          filename === "skill.yaml" ||
+          filename === "skill.package.yaml" ||
+          filename === "skill.package.yml" ||
           filename === "skill.yml" ||
           filename === "enact.yaml" ||
           filename === "enact.yml" ||
@@ -118,7 +119,8 @@ describe("publish command", () => {
         );
       };
 
-      expect(isManifest("skill.yaml")).toBe(true);
+      expect(isManifest("skill.package.yaml")).toBe(true);
+      expect(isManifest("skill.package.yml")).toBe(true);
       expect(isManifest("skill.yml")).toBe(true);
       expect(isManifest("enact.yaml")).toBe(true);
       expect(isManifest("enact.yml")).toBe(true);
@@ -132,7 +134,7 @@ describe("publish command", () => {
         return lastDot === -1 ? "" : filename.slice(lastDot + 1);
       };
 
-      expect(getExtension("skill.yaml")).toBe("yaml");
+      expect(getExtension("skill.package.yaml")).toBe("yaml");
       expect(getExtension("skill.yml")).toBe("yml");
       expect(getExtension("enact.yaml")).toBe("yaml");
       expect(getExtension("enact.yml")).toBe("yml");

package/tests/commands/sign.test.ts

@@ -17,7 +17,7 @@ describe("sign command", () => {
 
     // Create a test manifest
     writeFileSync(
-      join(FIXTURES_DIR, "skill.yaml"),
+      join(FIXTURES_DIR, "skill.package.yml"),
       `enact: "2.0.0"
 name: "test/sign-tool"
 version: "1.0.0"

package/tests/e2e.test.ts

@@ -126,7 +126,9 @@ describe("E2E: Tool Installation Flow", () => {
     expect(manifest.name).toBe("test/greeter");
     expect(existsSync(destPath)).toBe(true);
     expect(
-      existsSync(join(destPath, "enact.yaml")) || existsSync(join(destPath, "skill.yaml"))
+      existsSync(join(destPath, "enact.yaml")) ||
+        existsSync(join(destPath, "skill.package.yaml")) ||
+        existsSync(join(destPath, "skill.package.yml"))
     ).toBe(true);
 
     // Verify installed manifest can be loaded

package/tests/utils/ignore.test.ts

@@ -281,7 +281,8 @@ dist   `;
       });
 
       test("allows manifest files", () => {
-        expect(shouldIgnore("skill.yaml", "skill.yaml")).toBe(false);
+        expect(shouldIgnore("skill.package.yaml", "skill.package.yaml")).toBe(false);
+        expect(shouldIgnore("skill.package.yml", "skill.package.yml")).toBe(false);
         expect(shouldIgnore("skill.yml", "skill.yml")).toBe(false);
         expect(shouldIgnore("enact.md", "enact.md")).toBe(false);
         expect(shouldIgnore("enact.yaml", "enact.yaml")).toBe(false);