Yarn CLI

import { getCli, runExit, BaseCommand, type YarnCli, type CommandContext } from "@yarnpkg/cli";

const { getCli, runExit, BaseCommand } = require("@yarnpkg/cli");

import { getCli, runExit, getPluginConfiguration } from "@yarnpkg/cli";
import { ppath } from "@yarnpkg/fslib";

// Create a Yarn CLI instance with default plugins
const cli = await getCli({
  cwd: ppath.cwd(),
  pluginConfiguration: getPluginConfiguration()
});

// Process and execute a command
const command = cli.process(["install"], cli.defaultContext);
const exitCode = await cli.run(command, cli.defaultContext);

// Or run and exit (for standalone applications)
await runExit(["install"], {
  cwd: ppath.cwd(),
  selfPath: null,
  pluginConfiguration: getPluginConfiguration()
});

/**
 * Creates a Yarn CLI instance with initialized commands
 * @param options - Configuration options
 * @returns Promise that resolves to a configured YarnCli instance
 */
function getCli(options?: {
  cwd?: PortablePath;
  pluginConfiguration?: PluginConfiguration;
}): Promise<YarnCli>;

/**
 * Yarn CLI instance with command registration and execution capabilities
 */
interface YarnCli extends Cli<CommandContext> {
  /** Default context object used for command execution */
  readonly defaultContext: CommandContext & {
    cwd: PortablePath;
    plugins: PluginConfiguration;
    quiet: boolean;
    stdin: NodeJS.ReadableStream;
    stdout: NodeJS.WritableStream;
    stderr: NodeJS.WritableStream;
  };
  
  /** Binary label displayed in help output */
  readonly binaryLabel: string;
  
  /** Binary name used in command line */
  readonly binaryName: string;
  
  /** Binary version string */
  readonly binaryVersion: string | null;
  
  /** Register a command class with the CLI */
  register(command: new () => Command<CommandContext>): void;
  
  /** Process command line arguments and return command instance */
  process(argv: Array<string>, context: CommandContext): Command<CommandContext>;
  
  /** Execute a command instance */
  run(command: Command<CommandContext>, context: CommandContext): Promise<number>;
  
  /** Format an error for display */
  error(error: Error): string;
}

/**
 * Runs Yarn CLI with the given arguments and exits the process
 * @param argv - Command line arguments array
 * @param options - Execution options
 */
function runExit(
  argv: Array<string>,
  options: {
    cwd: PortablePath;
    selfPath: PortablePath | null;
    pluginConfiguration: PluginConfiguration;
  }
): Promise<void>;

/**
 * Base class for creating Yarn commands
 */
abstract class BaseCommand extends Command<CommandContext> {
  /** Hidden cwd option for command-line usage */
  cwd: string | undefined;
  
  /** Must be implemented by subclasses */
  abstract execute(): Promise<number | void>;
  
  /** Validates cwd option and executes command */
  validateAndExecute(): Promise<number>;
}

/**
 * Opens a workspace at the given directory
 * @param configuration - Configuration object
 * @param cwd - Working directory path
 * @returns Promise that resolves to Workspace object
 * @throws WorkspaceRequiredError if not in a workspace
 */
function openWorkspace(
  configuration: Configuration,
  cwd: PortablePath
): Promise<Workspace>;

/**
 * Error thrown when a command requires a workspace context
 */
class WorkspaceRequiredError extends UsageError {
  constructor(projectCwd: PortablePath, cwd: PortablePath);
}

/**
 * Gets the standard plugin configuration for Yarn CLI
 * @returns Configuration object with plugins and modules
 */
function getPluginConfiguration(): PluginConfiguration;

/**
 * Returns a map of dynamic libraries available to plugins
 * @returns Map containing Yarn modules and dependencies
 */
function getDynamicLibs(): Map<string, any>;

/**
 * Map of plugin names to their command arrays (auto-generated)
 */
const pluginCommands: Map<string, Array<string>>;

/**
 * Context object passed to Yarn commands with execution environment
 */
interface CommandContext {
  /** Current working directory */
  cwd: PortablePath;
  /** Plugin configuration */
  plugins: PluginConfiguration;
  /** Whether to suppress output */
  quiet: boolean;
  /** Standard input stream */
  stdin: NodeJS.ReadableStream;
  /** Standard output stream */
  stdout: NodeJS.WritableStream;
  /** Standard error stream */
  stderr: NodeJS.WritableStream;
  /** Additional properties from @yarnpkg/core CommandContext */
  [key: string]: any;
}

/**
 * Plugin configuration interface for managing Yarn plugins
 */
interface PluginConfiguration {
  /** Set of plugin names to load */
  plugins: Set<string>;
  /** Map of module names to their implementations */
  modules: Map<string, any>;
}

/**
 * Portable path type from @yarnpkg/fslib
 */
type PortablePath = import("@yarnpkg/fslib").PortablePath;

/**
 * Configuration object from @yarnpkg/core
 */
type Configuration = import("@yarnpkg/core").Configuration;

/**
 * Workspace object from @yarnpkg/core
 */
type Workspace = import("@yarnpkg/core").Workspace;

import { BaseCommand } from "@yarnpkg/cli";
import { Option } from "clipanion";

class MyCustomCommand extends BaseCommand {
  static paths = [["my", "command"]];
  
  myOption = Option.String("--option", "default-value");
  
  async execute() {
    this.context.stdout.write(`Option value: ${this.myOption}\n`);
    return 0;
  }
}

// Register with CLI instance
const cli = await getCli();
cli.register(MyCustomCommand);

import { openWorkspace, getPluginConfiguration } from "@yarnpkg/cli";
import { Configuration } from "@yarnpkg/core";
import { ppath } from "@yarnpkg/fslib";

try {
  const configuration = await Configuration.find(
    ppath.cwd(),
    getPluginConfiguration()
  );
  
  const workspace = await openWorkspace(configuration, ppath.cwd());
  console.log(`Workspace: ${workspace.locator.name}`);
} catch (error) {
  if (error instanceof WorkspaceRequiredError) {
    console.error("Not in a workspace directory");
  }
}