@enactprotocol/cli 1.2.13 → 2.0.0

package/src/commands/unyank/index.ts

@@ -0,0 +1,107 @@
+/**
+ * enact unyank command
+ *
+ * Restore a previously yanked tool version.
+ */
+
+import { createApiClient, unyankVersion } from "@enactprotocol/api";
+import { getSecret } from "@enactprotocol/secrets";
+import type { Command } from "commander";
+import type { CommandContext, GlobalOptions } from "../../types";
+import { dim, error, formatError, info, json, keyValue, newline, success } from "../../utils";
+
+/** Auth namespace for token storage */
+const AUTH_NAMESPACE = "enact:auth";
+const ACCESS_TOKEN_KEY = "access_token";
+
+interface UnyankOptions extends GlobalOptions {}
+
+/**
+ * Parse tool@version syntax
+ */
+function parseToolSpec(spec: string): { name: string; version: string } {
+  const atIndex = spec.lastIndexOf("@");
+  if (atIndex === -1 || atIndex === 0) {
+    throw new Error(
+      `Invalid tool specification: ${spec}\nExpected format: tool-name@version (e.g., alice/utils/greeter@1.0.0)`
+    );
+  }
+
+  return {
+    name: spec.slice(0, atIndex),
+    version: spec.slice(atIndex + 1),
+  };
+}
+
+/**
+ * Unyank command handler
+ */
+async function unyankHandler(
+  toolSpec: string,
+  options: UnyankOptions,
+  _ctx: CommandContext
+): Promise<void> {
+  // Parse tool@version
+  const { name, version } = parseToolSpec(toolSpec);
+
+  // Check for auth token
+  const authToken = await getSecret(AUTH_NAMESPACE, ACCESS_TOKEN_KEY);
+  if (!authToken) {
+    error("Not authenticated. Please run: enact auth login");
+    process.exit(1);
+  }
+
+  const client = createApiClient();
+  client.setAuthToken(authToken);
+
+  info(`Restoring ${name}@${version}...`);
+  newline();
+
+  try {
+    const result = await unyankVersion(client, name, version);
+
+    if (options.json) {
+      json({
+        yanked: result.yanked,
+        name,
+        version: result.version,
+        unyankedAt: result.unyankedAt.toISOString(),
+      });
+      return;
+    }
+
+    success(`Restored ${name}@${version}`);
+    keyValue("Unyanked At", result.unyankedAt.toISOString());
+    newline();
+    dim("The version is now visible in version listings again.");
+  } catch (err) {
+    error(`Failed to restore version: ${formatError(err)}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Configure the unyank command
+ */
+export function configureUnyankCommand(program: Command): void {
+  program
+    .command("unyank <tool@version>")
+    .description("Restore a previously yanked tool version")
+    .option("-v, --verbose", "Show detailed output")
+    .option("--json", "Output as JSON")
+    .action(async (toolSpec: string, options: UnyankOptions) => {
+      const ctx: CommandContext = {
+        cwd: process.cwd(),
+        options,
+        isCI: Boolean(process.env.CI),
+        isInteractive: process.stdout.isTTY ?? false,
+      };
+
+      try {
+        await unyankHandler(toolSpec, options, ctx);
+      } catch (err) {
+        error(formatError(err));
+        process.exit(1);
+      }
+    });
+}

package/src/commands/yank/index.ts

@@ -0,0 +1,143 @@
+/**
+ * enact yank command
+ *
+ * Yank a published tool version from the registry.
+ * Yanked versions remain downloadable but are excluded from version listings
+ * and show warnings to users.
+ */
+
+import { createApiClient, yankVersion } from "@enactprotocol/api";
+import { getSecret } from "@enactprotocol/secrets";
+import type { Command } from "commander";
+import type { CommandContext, GlobalOptions } from "../../types";
+import {
+  dim,
+  error,
+  formatError,
+  info,
+  json,
+  keyValue,
+  newline,
+  success,
+  warning,
+} from "../../utils";
+
+/** Auth namespace for token storage */
+const AUTH_NAMESPACE = "enact:auth";
+const ACCESS_TOKEN_KEY = "access_token";
+
+interface YankOptions extends GlobalOptions {
+  reason?: string;
+  replacement?: string;
+}
+
+/**
+ * Parse tool@version syntax
+ */
+function parseToolSpec(spec: string): { name: string; version: string } {
+  const atIndex = spec.lastIndexOf("@");
+  if (atIndex === -1 || atIndex === 0) {
+    throw new Error(
+      `Invalid tool specification: ${spec}\nExpected format: tool-name@version (e.g., alice/utils/greeter@1.0.0)`
+    );
+  }
+
+  return {
+    name: spec.slice(0, atIndex),
+    version: spec.slice(atIndex + 1),
+  };
+}
+
+/**
+ * Yank command handler
+ */
+async function yankHandler(
+  toolSpec: string,
+  options: YankOptions,
+  _ctx: CommandContext
+): Promise<void> {
+  // Parse tool@version
+  const { name, version } = parseToolSpec(toolSpec);
+
+  // Check for auth token
+  const authToken = await getSecret(AUTH_NAMESPACE, ACCESS_TOKEN_KEY);
+  if (!authToken) {
+    error("Not authenticated. Please run: enact auth login");
+    process.exit(1);
+  }
+
+  const client = createApiClient();
+  client.setAuthToken(authToken);
+
+  info(`Yanking ${name}@${version}...`);
+
+  if (options.reason) {
+    dim(`Reason: ${options.reason}`);
+  }
+  if (options.replacement) {
+    dim(`Replacement: ${options.replacement}`);
+  }
+  newline();
+
+  try {
+    const result = await yankVersion(client, name, version, {
+      reason: options.reason,
+      replacementVersion: options.replacement,
+    });
+
+    if (options.json) {
+      json({
+        yanked: result.yanked,
+        name,
+        version: result.version,
+        reason: result.reason,
+        replacementVersion: result.replacementVersion,
+        yankedAt: result.yankedAt.toISOString(),
+      });
+      return;
+    }
+
+    success(`Yanked ${name}@${version}`);
+    keyValue("Yanked At", result.yankedAt.toISOString());
+    if (result.reason) {
+      keyValue("Reason", result.reason);
+    }
+    if (result.replacementVersion) {
+      keyValue("Replacement", result.replacementVersion);
+    }
+    newline();
+    warning("Note: Yanked versions can still be downloaded but show warnings.");
+    dim("Use 'enact unyank' to restore the version.");
+  } catch (err) {
+    error(`Failed to yank version: ${formatError(err)}`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Configure the yank command
+ */
+export function configureYankCommand(program: Command): void {
+  program
+    .command("yank <tool@version>")
+    .description("Yank a published tool version from the registry")
+    .option("-r, --reason <reason>", "Reason for yanking (e.g., security issue)")
+    .option("--replacement <version>", "Recommend a replacement version (e.g., 1.2.1)")
+    .option("-v, --verbose", "Show detailed output")
+    .option("--json", "Output as JSON")
+    .action(async (toolSpec: string, options: YankOptions) => {
+      const ctx: CommandContext = {
+        cwd: process.cwd(),
+        options,
+        isCI: Boolean(process.env.CI),
+        isInteractive: process.stdout.isTTY ?? false,
+      };
+
+      try {
+        await yankHandler(toolSpec, options, ctx);
+      } catch (err) {
+        error(formatError(err));
+        process.exit(1);
+      }
+    });
+}

package/src/index.ts

@@ -0,0 +1,96 @@
+#!/usr/bin/env bun
+
+/**
+ * @enactprotocol/cli
+ *
+ * Command-line interface for Enact.
+ * User-facing commands for tool execution, discovery, and management.
+ */
+
+import { Command } from "commander";
+import {
+  configureAuthCommand,
+  configureCacheCommand,
+  configureConfigCommand,
+  configureEnvCommand,
+  configureExecCommand,
+  configureGetCommand,
+  configureInspectCommand,
+  configureInstallCommand,
+  configureListCommand,
+  configurePublishCommand,
+  configureReportCommand,
+  configureRunCommand,
+  configureSearchCommand,
+  configureSetupCommand,
+  configureSignCommand,
+  configureTrustCommand,
+  configureUnyankCommand,
+  configureYankCommand,
+} from "./commands";
+import { error, formatError } from "./utils";
+
+export const version = "0.1.0";
+
+// Export types for external use
+export type { GlobalOptions, CommandContext } from "./types";
+
+// Main CLI entry point
+async function main() {
+  const program = new Command();
+
+  program
+    .name("enact")
+    .description("Enact - Verified, portable protocol for AI-executable tools")
+    .version(version)
+    .option("--json", "Output as JSON")
+    .option("-v, --verbose", "Enable verbose output");
+
+  // Configure all commands
+  configureSetupCommand(program);
+  configureRunCommand(program);
+  configureExecCommand(program);
+  configureInstallCommand(program);
+  configureListCommand(program);
+  configureEnvCommand(program);
+  configureTrustCommand(program);
+  configureConfigCommand(program);
+
+  // Registry commands (Phase 8)
+  configureSearchCommand(program);
+  configureGetCommand(program);
+  configurePublishCommand(program);
+  configureAuthCommand(program);
+  configureCacheCommand(program);
+
+  // CLI solidification commands (Phase 9)
+  configureSignCommand(program);
+  configureReportCommand(program);
+  configureInspectCommand(program);
+
+  // API v2 migration commands
+  configureYankCommand(program);
+  configureUnyankCommand(program);
+
+  // Global error handler
+  program.exitOverride((err) => {
+    if (err.code === "commander.help" || err.code === "commander.version") {
+      process.exit(0);
+    }
+    throw err;
+  });
+
+  try {
+    await program.parseAsync(process.argv);
+  } catch (err) {
+    error(formatError(err));
+    process.exit(1);
+  }
+}
+
+if (import.meta.main) {
+  main().catch((err) => {
+    error(formatError(err));
+    process.exit(1);
+  });
+}

package/src/types.ts

@@ -0,0 +1,81 @@
+/**
+ * CLI Types
+ */
+
+import type { Command } from "commander";
+
+/**
+ * Global CLI options available to all commands
+ */
+export interface GlobalOptions {
+  /** Enable verbose output */
+  verbose?: boolean;
+  /** Output as JSON */
+  json?: boolean;
+  /** Suppress all output except errors */
+  quiet?: boolean;
+  /** Run without making changes (preview mode) */
+  dryRun?: boolean;
+}
+
+/**
+ * Context passed to command handlers
+ */
+export interface CommandContext {
+  /** Current working directory */
+  cwd: string;
+  /** Global options */
+  options: GlobalOptions;
+  /** Whether running in CI environment */
+  isCI: boolean;
+  /** Whether running interactively (TTY) */
+  isInteractive: boolean;
+}
+
+/**
+ * Command handler function signature
+ */
+export type CommandHandler<T = Record<string, unknown>> = (
+  args: T,
+  context: CommandContext
+) => Promise<void>;
+
+/**
+ * Command definition for registration
+ */
+export interface CommandDefinition {
+  /** Command name */
+  name: string;
+  /** Command description */
+  description: string;
+  /** Command aliases */
+  aliases?: string[];
+  /** Configure the command (add options, arguments, subcommands) */
+  configure: (cmd: Command) => void;
+}
+
+/**
+ * Result from a command execution
+ */
+export interface CommandResult {
+  success: boolean;
+  message?: string;
+  data?: unknown;
+}
+
+/**
+ * Exit codes
+ */
+export const ExitCode = {
+  Success: 0,
+  Error: 1,
+  InvalidArgs: 2,
+  NotFound: 3,
+  PermissionDenied: 4,
+  Cancelled: 130, // Standard for Ctrl+C
+} as const;
+
+export type ExitCode = (typeof ExitCode)[keyof typeof ExitCode];
+
+// Legacy placeholder
+export type CLIConfig = Record<string, unknown>;