@stigmer/cli 3.0.8

package/src/commands/auth/index.ts

@@ -0,0 +1,87 @@
+// `stigmer auth login|logout|whoami` — manage Stigmer Cloud authentication.
+//
+// login is interactive (browser PKCE) and human-only; logout and whoami honor
+// the standard mutating-output flags.
+
+import type { Command } from "commander";
+import { ensureAuthenticated, load, resolveContextOrganization, save } from "../../config/index.js";
+import { CommandResult, type OutputFlags, renderResult } from "../../output/index.js";
+import { addResultFlags, resultFormat } from "../shared.js";
+
+export function registerAuth(program: Command): void {
+  const auth = program.command("auth").description("manage authentication with Stigmer Cloud");
+
+  auth
+    .command("login")
+    .description("log in to Stigmer Cloud via browser (PKCE OAuth)")
+    .action(async () => {
+      const { login } = await import("../../auth/index.js");
+      await login();
+      renderResult(
+        CommandResult.success("Authenticated with Stigmer Cloud")
+          .hint("Run commands against the cloud backend, e.g.:")
+          .hint("  stigmer list agents"),
+        "human",
+      );
+    });
+
+  const logout = auth
+    .command("logout")
+    .description("clear the stored authentication token")
+    .action((options: OutputFlags) => {
+      renderResult(runLogout(), resultFormat(options));
+    });
+  addResultFlags(logout);
+
+  const whoami = auth
+    .command("whoami")
+    .description("show the currently authenticated account")
+    .action(async (options: OutputFlags) => {
+      renderResult(await runWhoami(), resultFormat(options));
+    });
+  addResultFlags(whoami);
+}
+
+function runLogout(): CommandResult {
+  const config = load();
+  const cloud = config.backend.cloud;
+  if (cloud === undefined || (cloud.token === undefined && cloud.refresh_token === undefined)) {
+    return CommandResult.warning("Not currently logged in").hint("Run 'stigmer auth login' to authenticate.");
+  }
+  cloud.token = undefined;
+  cloud.refresh_token = undefined;
+  cloud.token_expiry = undefined;
+  save(config);
+  return CommandResult.success("Logged out from Stigmer Cloud").hint("Run 'stigmer auth login' to authenticate again.");
+}
+
+async function runWhoami(): Promise<CommandResult> {
+  const { connectBackend } = await import("../../backend.js");
+  const client = connectBackend();
+  ensureAuthenticated(client.config);
+
+  const account = await client.stigmer.identityAccount.whoAmI();
+  const result = CommandResult.success("Authenticated");
+  const section = result.addSection("");
+
+  if (account.metadata !== undefined) {
+    section.field("Account ID", account.metadata.id);
+    if (account.metadata.name !== "") section.field("Name", account.metadata.name);
+  }
+  if (account.spec !== undefined) {
+    if (account.spec.email !== "") section.field("Email", account.spec.email);
+    if (account.spec.firstName !== "" || account.spec.lastName !== "") {
+      section.field("Full Name", `${account.spec.firstName} ${account.spec.lastName}`.trim());
+    }
+    section.field("Account Type", account.spec.isMachineAccount ? "Machine Account" : "User Account");
+  }
+
+  const org = resolveContextOrganization(client.config);
+  if (org !== "") {
+    section.field("Organization", org);
+  } else {
+    result.hint("No organization set. Use: stigmer config context set --org <slug>");
+  }
+
+  return result;
+}

package/src/commands/completion.ts

@@ -0,0 +1,96 @@
+// `stigmer completion <shell>` — emit a shell completion script.
+//
+// Wave 1 provides top-level command completion derived from the live commander
+// tree (so new commands appear automatically — the tree is the source of
+// truth). Flag-level and dynamic resource completion are a T06 enhancement;
+// DD-001 records completion parity as a T04/T06 checklist item, not a
+// framework-selection concern.
+
+import type { Command } from "commander";
+
+const SHELLS = ["bash", "zsh", "fish", "powershell"] as const;
+type Shell = (typeof SHELLS)[number];
+
+export function registerCompletion(program: Command): void {
+  program
+    .command("completion <shell>")
+    .description(`generate a shell completion script (${SHELLS.join(", ")})`)
+    .action((shell: string) => {
+      if (!isShell(shell)) {
+        throw new Error(`unsupported shell "${shell}" (expected one of: ${SHELLS.join(", ")})`);
+      }
+      const commandNames = topLevelCommandNames(program);
+      process.stdout.write(renderScript(shell, commandNames) + "\n");
+    });
+}
+
+function isShell(value: string): value is Shell {
+  return (SHELLS as readonly string[]).includes(value);
+}
+
+function topLevelCommandNames(program: Command): string[] {
+  return program.commands
+    .map((command) => command.name())
+    .filter((name) => name.length > 0)
+    .sort();
+}
+
+function renderScript(shell: Shell, commands: string[]): string {
+  switch (shell) {
+    case "bash":
+      return renderBash(commands);
+    case "zsh":
+      return renderZsh(commands);
+    case "fish":
+      return renderFish(commands);
+    case "powershell":
+      return renderPowershell(commands);
+  }
+}
+
+function renderBash(commands: string[]): string {
+  return [
+    "# stigmer bash completion",
+    "_stigmer_complete() {",
+    '  local cur="${COMP_WORDS[COMP_CWORD]}"',
+    '  if [ "$COMP_CWORD" -eq 1 ]; then',
+    `    COMPREPLY=( $(compgen -W "${commands.join(" ")}" -- "$cur") )`,
+    "  fi",
+    "}",
+    "complete -F _stigmer_complete stigmer",
+  ].join("\n");
+}
+
+function renderZsh(commands: string[]): string {
+  return [
+    "#compdef stigmer",
+    "_stigmer() {",
+    `  local -a commands=(${commands.map((c) => `'${c}'`).join(" ")})`,
+    "  _arguments '1: :->command' '*::arg:->args'",
+    '  if [ "$state" = command ]; then',
+    "    compadd -- $commands",
+    "  fi",
+    "}",
+    "_stigmer",
+  ].join("\n");
+}
+
+function renderFish(commands: string[]): string {
+  return commands
+    .map(
+      (command) =>
+        `complete -c stigmer -n __fish_use_subcommand -a ${command} -d '${command} command'`,
+    )
+    .join("\n");
+}
+
+function renderPowershell(commands: string[]): string {
+  return [
+    "Register-ArgumentCompleter -Native -CommandName stigmer -ScriptBlock {",
+    "  param($wordToComplete, $commandAst, $cursorPosition)",
+    `  @(${commands.map((c) => `'${c}'`).join(", ")}) |`,
+    "    Where-Object { $_ -like \"$wordToComplete*\" } |",
+    "    ForEach-Object { [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_) }",
+    "}",
+  ].join("\n");
+}

package/src/commands/config/backend.ts

@@ -0,0 +1,58 @@
+// `stigmer config backend status|set` — inspect and switch the active backend.
+
+import type { Command } from "commander";
+import { type Config, isCloudMode, load, resolveEndpoint, save } from "../../config/index.js";
+import { UsageError } from "../../errors/index.js";
+import { CommandResult, type OutputFlags, renderResult } from "../../output/index.js";
+import { addResultFlags, resultFormat } from "../shared.js";
+
+const DEFAULT_CLOUD_ENDPOINT = "api.stigmer.ai:443";
+
+export function addBackendCommands(backend: Command): void {
+  const status = backend
+    .command("status")
+    .description("show the current backend")
+    .action((options: OutputFlags) => {
+      renderResult(buildStatus(load()), resultFormat(options));
+    });
+  addResultFlags(status);
+
+  const set = backend
+    .command("set <type>")
+    .description("set the backend type (local or cloud)")
+    .action((type: string, options: OutputFlags) => {
+      renderResult(applySet(type), resultFormat(options));
+    });
+  addResultFlags(set);
+}
+
+function buildStatus(config: Config): CommandResult {
+  const result = CommandResult.success("Backend configuration");
+  const section = result.addSection("").field("Type", config.backend.type).field("Endpoint", resolveEndpoint(config));
+  if (isCloudMode(config)) {
+    section.field("Auth", config.backend.cloud?.token ? "Logged in" : "Not logged in");
+  }
+  return result;
+}
+
+function applySet(type: string): CommandResult {
+  if (type !== "local" && type !== "cloud") {
+    throw new UsageError(`invalid backend type "${type}" (expected: local, cloud)`);
+  }
+
+  const config = load();
+  config.backend.type = type;
+
+  if (type === "cloud") {
+    if (config.backend.cloud === undefined) {
+      config.backend.cloud = { endpoint: DEFAULT_CLOUD_ENDPOINT };
+    }
+    save(config);
+    return CommandResult.success("Backend set to cloud")
+      .hint("Please authenticate:")
+      .hint("  stigmer auth login");
+  }
+
+  save(config);
+  return CommandResult.success("Backend set to local").hint("Make sure the Stigmer server is running.");
+}

package/src/commands/config/context.ts

@@ -0,0 +1,26 @@
+// `stigmer config context show` — display the active CLI context.
+//
+// `context set --org` validates the organization against the server before
+// persisting, so it is wired once the backend client lands (see registerConfig).
+
+import type { Command } from "commander";
+import { type Config, load, resolveContextOrganization } from "../../config/index.js";
+import { CommandResult, type OutputFlags, renderResult } from "../../output/index.js";
+import { addResultFlags, resultFormat } from "../shared.js";
+
+export function addContextCommands(context: Command): void {
+  const show = context
+    .command("show")
+    .description("show the active context")
+    .action((options: OutputFlags) => {
+      renderResult(buildShow(load()), resultFormat(options));
+    });
+  addResultFlags(show);
+}
+
+function buildShow(config: Config): CommandResult {
+  const organization = resolveContextOrganization(config) || "(not set)";
+  const result = CommandResult.success("CLI context");
+  result.addSection("").field("Organization", organization).field("Backend", config.backend.type);
+  return result;
+}

package/src/commands/config/index.ts

@@ -0,0 +1,18 @@
+// `stigmer config` — configuration management command group.
+
+import type { Command } from "commander";
+import { addBackendCommands } from "./backend.js";
+import { addContextCommands } from "./context.js";
+import { addKvCommands } from "./kv.js";
+
+export function registerConfig(program: Command): void {
+  const config = program.command("config").description("Manage CLI configuration");
+
+  addKvCommands(config);
+
+  const backend = config.command("backend").description("Manage backend configuration (local vs cloud)");
+  addBackendCommands(backend);
+
+  const context = config.command("context").description("Manage the active CLI context (organization)");
+  addContextCommands(context);
+}

package/src/commands/config/kv.ts

@@ -0,0 +1,44 @@
+// `stigmer config get|set|list|path` — generic key/value access to the config
+// file. get/list/path print plain values to stdout (pipe-friendly); set emits a
+// structured result.
+
+import type { Command } from "commander";
+import { configKeyNames, configPath, getConfigValue, load, save, setConfigValue } from "../../config/index.js";
+import { CommandResult, type OutputFlags, renderResult } from "../../output/index.js";
+import { addResultFlags, resultFormat } from "../shared.js";
+
+export function addKvCommands(config: Command): void {
+  config
+    .command("path")
+    .description("print the config file path")
+    .action(() => {
+      process.stdout.write(configPath() + "\n");
+    });
+
+  config
+    .command("get <key>")
+    .description("print a single config value")
+    .action((key: string) => {
+      process.stdout.write(getConfigValue(load(), key) + "\n");
+    });
+
+  config
+    .command("list")
+    .description("list all config values")
+    .action(() => {
+      const cfg = load();
+      const lines = configKeyNames().map((key) => `${key}=${getConfigValue(cfg, key)}`);
+      process.stdout.write(lines.join("\n") + "\n");
+    });
+
+  const set = config
+    .command("set <key> <value>")
+    .description("set a config value")
+    .action((key: string, value: string, options: OutputFlags) => {
+      const cfg = load();
+      setConfigValue(cfg, key, value);
+      save(cfg);
+      renderResult(CommandResult.success(`Set ${key} = ${value}`), resultFormat(options));
+    });
+  addResultFlags(set);
+}

package/src/commands/connect.ts

@@ -0,0 +1,75 @@
+// `stigmer connect mcp-server <slug-or-id>` — connect to an MCP server, discover
+// its tools and resource templates, and push the results to the backend (or
+// preview locally with --dry-run). Mirrors Go's connect.go.
+//
+// Thin handler: resolve the client/org, delegate to resources/connect, render.
+// Heavy modules (backend client, MCP SDK) are lazy-imported so `--help` stays
+// fast (DD-001).
+
+import type { Command } from "commander";
+import { ensureAuthenticated, resolveOrganization } from "../config/index.js";
+import { UsageError } from "../errors/index.js";
+import { shouldColorize } from "../output/style.js";
+import { globalOrg } from "./shared.js";
+
+interface ConnectFlags {
+  timeout?: string;
+  dryRun?: boolean;
+  env: string[];
+}
+
+const DEFAULT_TIMEOUT_SECONDS = 30;
+
+export function registerConnect(program: Command): void {
+  const connect = program.command("connect").description("connect to external services and discover capabilities");
+
+  connect
+    .command("mcp-server <slug-or-id>")
+    .description("connect to an MCP server and discover its tools")
+    .option("--timeout <seconds>", "timeout for connection and discovery", String(DEFAULT_TIMEOUT_SECONDS))
+    .option("--dry-run", "discover and display results without pushing to the backend")
+    .option(
+      "--env <KEY=VALUE>",
+      "environment variable for the MCP server (repeatable)",
+      (value: string, previous: string[]) => [...previous, value],
+      [],
+    )
+    .action((reference: string, options: ConnectFlags, command: Command) => runConnect(reference, options, command));
+}
+
+async function runConnect(reference: string, options: ConnectFlags, command: Command): Promise<void> {
+  const timeoutMs = parseTimeout(options.timeout);
+  const [{ connectBackend }, { connectMcpServer }, { renderConnectResult }] = await Promise.all([
+    import("../backend.js"),
+    import("../resources/connect/connect.js"),
+    import("../resources/connect/display.js"),
+  ]);
+
+  const client = connectBackend();
+  ensureAuthenticated(client.config);
+  const org = resolveOrganization(client.config, globalOrg(command));
+
+  const result = await connectMcpServer(client.stigmer, {
+    reference,
+    org,
+    timeoutMs,
+    dryRun: options.dryRun === true,
+    envOverrides: options.env,
+    backendType: client.config.backend.type,
+    interactive: process.stderr.isTTY === true,
+  });
+
+  const colorize = shouldColorize(process.stdout);
+  renderConnectResult(result, (line) => process.stdout.write(`${line}\n`), colorize);
+}
+
+// Parse --timeout seconds into milliseconds. Mirrors Go's DurationVar default
+// but accepts a plain number of seconds for a simpler CLI surface.
+function parseTimeout(raw: string | undefined): number {
+  if (raw === undefined || raw === "") return DEFAULT_TIMEOUT_SECONDS * 1000;
+  const seconds = Number(raw);
+  if (!Number.isFinite(seconds) || seconds < 0) {
+    throw new UsageError(`invalid --timeout '${raw}': expected a number of seconds`);
+  }
+  return Math.round(seconds * 1000);
+}

package/src/commands/delete.ts

@@ -0,0 +1,56 @@
+// `stigmer delete <type> <reference>` — delete a resource by type and reference.
+//
+// Thin handler: resolve credentials/org, ask the resource layer for a delete
+// plan, run the confirmation interaction, then perform and render. The plan
+// (resources/delete.ts) owns what to delete and how to describe it; this file
+// owns only the prompt flow and stream wiring. Heavy modules are lazy-imported
+// inside the action so `--help` stays fast (DD-001).
+
+import type { Command } from "commander";
+import { ensureAuthenticated, resolveOrganization } from "../config/index.js";
+import type { OutputFlags } from "../output/index.js";
+import { addResultFlags, globalOrg, resultFormat } from "./shared.js";
+
+interface DeleteFlags extends OutputFlags {
+  force?: boolean;
+}
+
+export function registerDelete(program: Command): void {
+  const del = program
+    .command("delete <type> <reference>")
+    .description("delete a resource by type and reference (slug, org/slug, or ID)")
+    .option("-f, --force", "skip the confirmation prompt")
+    .action((type: string, reference: string, options: DeleteFlags, command: Command) =>
+      runDelete(type, reference, options, command),
+    );
+  addResultFlags(del);
+}
+
+async function runDelete(type: string, reference: string, options: DeleteFlags, command: Command): Promise<void> {
+  const format = resultFormat(options);
+
+  const [{ connectBackend }, { planDelete }, { confirm }, { renderResult }] = await Promise.all([
+    import("../backend.js"),
+    import("../resources/delete.js"),
+    import("../output/confirm.js"),
+    import("../output/command-result.js"),
+  ]);
+
+  const client = connectBackend();
+  ensureAuthenticated(client.config);
+  const org = resolveOrganization(client.config, globalOrg(command));
+
+  const plan = await planDelete(client.stigmer, type, reference, org);
+
+  if (options.force !== true) {
+    renderResult(plan.warning, format);
+    const confirmed = await confirm(plan.confirmPrompt);
+    if (!confirmed) {
+      // User declined (or no TTY): a clean, intentional no-op — exit 0.
+      process.stderr.write("Aborted.\n");
+      return;
+    }
+  }
+
+  renderResult(await plan.perform(), format);
+}

package/src/commands/diff.ts

@@ -0,0 +1,97 @@
+// `stigmer diff -f <file|dir>` — show a unified diff of local YAML vs remote
+// state, per document. Auto-detects each document's kind; only workflows are
+// diffable today (others render as "new"). Heavy modules are lazy-imported
+// inside the action so `--help` stays fast (DD-001).
+
+import { basename } from "node:path";
+import type { Command } from "commander";
+import { ensureAuthenticated, resolveOrganization } from "../config/index.js";
+import { UsageError } from "../errors/index.js";
+import { shouldColorize, type Styler, styler } from "../output/index.js";
+import { defaultRegistry } from "../registry/index.js";
+import { globalOrg } from "./shared.js";
+
+interface DiffFlags {
+  file?: string;
+  context?: string;
+}
+
+const DEFAULT_CONTEXT = 3;
+
+export function registerDiff(program: Command): void {
+  program
+    .command("diff")
+    .description("compare local YAML with remote resource state")
+    .requiredOption("-f, --file <path>", "path to a YAML file or directory")
+    .option("--context <n>", "number of context lines in diff output", String(DEFAULT_CONTEXT))
+    .action((options: DiffFlags, command: Command) => runDiff(options, command));
+}
+
+async function runDiff(options: DiffFlags, command: Command): Promise<void> {
+  const path = options.file;
+  if (path === undefined || path === "") {
+    throw new UsageError("file path is required: use -f <file>");
+  }
+  const contextLines = parseContext(options.context);
+
+  const [{ connectBackend }, { loadDocuments, resolveYamlFiles }, { diffDocument }] = await Promise.all([
+    import("../backend.js"),
+    import("../resources/documents.js"),
+    import("../resources/diff.js"),
+  ]);
+
+  const files = resolveYamlFiles(path);
+  if (files.length === 0) {
+    throw new UsageError(`no YAML files found in ${path}`);
+  }
+
+  const client = connectBackend();
+  ensureAuthenticated(client.config);
+  const org = resolveOrganization(client.config, globalOrg(command));
+  const registry = defaultRegistry();
+  const style = styler(shouldColorize(process.stdout));
+
+  let hasDiffs = false;
+  for (const file of files) {
+    for (const { kind, document, raw } of loadDocuments(file)) {
+      const info = registry.getByYamlKind(kind);
+      if (info === undefined) {
+        throw new UsageError(`unknown resource kind '${kind}' in ${file}`);
+      }
+      const result = await diffDocument(client.stigmer, info.kind, raw, document, basename(file), org, contextLines);
+      if (result.status === "new") {
+        process.stdout.write(`--- ${file} (new resource, not yet deployed)\n`);
+        process.stdout.write(`${style.green("+ entire file is new")}\n\n`);
+        hasDiffs = true;
+      } else if (result.status === "changed") {
+        process.stdout.write(colorizeDiff(result.text, style));
+        hasDiffs = true;
+      }
+    }
+  }
+
+  if (!hasDiffs) {
+    process.stdout.write(`${style.green("✓ No differences found")}\n`);
+  }
+}
+
+function colorizeDiff(text: string, style: Styler): string {
+  return `${text
+    .split("\n")
+    .map((line) => colorizeLine(line, style))
+    .join("\n")}\n`;
+}
+
+function colorizeLine(line: string, style: Styler): string {
+  if (line.startsWith("+++") || line.startsWith("---")) return style.bold(line);
+  if (line.startsWith("@@")) return style.cyan(line);
+  if (line.startsWith("+")) return style.green(line);
+  if (line.startsWith("-")) return style.red(line);
+  return line;
+}
+
+function parseContext(raw: string | undefined): number {
+  if (raw === undefined || raw === "") return DEFAULT_CONTEXT;
+  if (!/^\d+$/.test(raw)) throw new UsageError(`invalid --context value "${raw}"`);
+  return Number.parseInt(raw, 10);
+}

package/src/commands/down.ts

@@ -0,0 +1,27 @@
+// `stigmer down [server]` — stop the local Stigmer stack. The daemon traps the
+// signal and tears down its children and managed Temporal in order; this command
+// signals it, waits, and falls back to cleanup if it is already gone.
+//
+// `down server` is accepted as a symmetric alias of `down` (the daemon owns the
+// whole stack, so stopping it stops everything either way).
+
+import type { Command } from "commander";
+import { CommandResult, type OutputFlags, renderResult } from "../output/index.js";
+import { addResultFlags, resultFormat } from "./shared.js";
+
+export function registerDown(program: Command): void {
+  const down = program.command("down").description("stop the local Stigmer stack").action((options: OutputFlags) => runDown(options));
+  addResultFlags(down);
+
+  const server = down.command("server").description("stop the local Stigmer stack").action((options: OutputFlags) => runDown(options));
+  addResultFlags(server);
+}
+
+async function runDown(flags: OutputFlags): Promise<void> {
+  const { down } = await import("../local/daemon/launch.js");
+  const wasRunning = await down();
+  const result = wasRunning
+    ? CommandResult.success("Stigmer local stack stopped")
+    : CommandResult.warning("Stigmer local stack was not running");
+  renderResult(result, resultFormat(flags));
+}

package/src/commands/download.ts

@@ -0,0 +1,68 @@
+// `stigmer download <type> <id>` — download artifacts produced by an execution.
+// Only agent executions (`aex_`) are supported today. Heavy modules are
+// lazy-imported inside the action so `--help` stays fast (DD-001).
+import type { Command } from "commander";
+import { ensureAuthenticated } from "../config/index.js";
+import { UsageError } from "../errors/index.js";
+
+interface DownloadFlags {
+  artifact?: string;
+  outputDir?: string;
+  all?: boolean;
+}
+
+export function registerDownload(program: Command): void {
+  program
+    .command("download <type> <id>")
+    .description("download artifacts from an execution")
+    .option("--artifact <name>", "specific artifact to download (by name)")
+    .option("-o, --output-dir <dir>", "output directory for downloaded files", ".")
+    .option("--all", "download all artifacts (default)", true)
+    .action((type: string, id: string, options: DownloadFlags) => runDownload(type, id, options));
+}
+
+function isDownloadExecutionType(type: string): boolean {
+  const normalized = type.trim().toLowerCase();
+  return normalized === "execution" || normalized === "executions" || normalized === "exec";
+}
+
+async function runDownload(type: string, id: string, options: DownloadFlags): Promise<void> {
+  if (!isDownloadExecutionType(type)) {
+    throw new UsageError(`download not supported for type: ${type}\n\nCurrently only 'execution' type supports download`);
+  }
+
+  const [{ connectBackend }, { isAgentExecutionId }, { downloadExecutionArtifacts }] = await Promise.all([
+    import("../backend.js"),
+    import("../resources/execution.js"),
+    import("../resources/download.js"),
+  ]);
+
+  if (!isAgentExecutionId(id)) {
+    throw new UsageError(`invalid execution ID: ${id}\n\nExecutions must be referenced by ID (e.g., aex_01abc123)`);
+  }
+
+  const client = connectBackend();
+  ensureAuthenticated(client.config);
+
+  const sink = (line: string): void => {
+    process.stderr.write(`${line}\n`);
+  };
+  const outcome = await downloadExecutionArtifacts(
+    client.stigmer,
+    id,
+    { artifactName: options.artifact ?? "", outputDir: options.outputDir ?? "." },
+    sink,
+  );
+
+  if (outcome.noArtifacts) {
+    process.stdout.write(`\nNo artifacts found for execution: ${id}\n\n`);
+    process.stdout.write("Tip: Artifacts are files created by the agent during execution. Not all agents produce artifacts.\n\n");
+    return;
+  }
+
+  if (outcome.downloaded === outcome.total) {
+    process.stdout.write(`\nDownloaded ${outcome.downloaded} artifact(s) successfully\n`);
+  } else {
+    process.stdout.write(`\nDownloaded ${outcome.downloaded} of ${outcome.total} artifacts\n`);
+  }
+}