@stigmer/cli 3.16.0 → 3.17.0

package/src/marketplace/read.test.ts

@@ -0,0 +1,94 @@
+// Pins the CLI's edge for the marketplace reader: a tree read through the one
+// walker, the refusal shape, entry lookup and directory resolution, and the
+// official tree in this repository reading clean with `assistant` offered.
+
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { writeCursorMarketplace } from "./__fixtures__/cursor-marketplace.js";
+import { resolveOfficialMarketplace } from "./official.js";
+import { entryDirectory, findEntry, readMarketplaceTree } from "./read.js";
+
+let root: string;
+
+beforeAll(() => {
+  root = mkdtempSync(join(tmpdir(), "stigmer-marketplace-read-"));
+  writeCursorMarketplace(root);
+});
+
+afterAll(() => {
+  rmSync(root, { recursive: true, force: true });
+});
+
+describe("readMarketplaceTree", () => {
+  it("reads a Cursor-dialect tree into the one shape, dropping the missing entry with its sentence", () => {
+    const tree = readMarketplaceTree(root);
+    expect(tree.marketplace.name).toBe("cursor-plugins");
+    expect(tree.marketplace.dialect).toBe("cursor");
+    expect(tree.marketplace.plugins.map((entry) => entry.name)).toEqual([
+      "thermos",
+      "github",
+    ]);
+    expect(tree.warnings).toHaveLength(1);
+    expect(tree.warnings[0]?.kind).toBe("entry-directory-missing");
+    expect(tree.warnings[0]?.subject).toBe("ghost");
+  });
+
+  it("refuses a directory with no marketplace file, naming the four locations", () => {
+    const empty = mkdtempSync(join(tmpdir(), "stigmer-marketplace-empty-"));
+    try {
+      writeFileSync(join(empty, "README.md"), "nothing here");
+      expect(() => readMarketplaceTree(empty, "github.com/a/b")).toThrow(
+        /github\.com\/a\/b: not a marketplace this CLI can read, 1 problem found:\n  - .*marketplace\.json/,
+      );
+    } finally {
+      rmSync(empty, { recursive: true, force: true });
+    }
+  });
+
+  it("refuses a broken file with every problem and every warning", () => {
+    const broken = mkdtempSync(join(tmpdir(), "stigmer-marketplace-broken-"));
+    try {
+      writeFileSync(
+        join(broken, "marketplace.json"),
+        JSON.stringify({
+          plugins: [
+            { name: "a", source: "../out" },
+            { name: "b", source: "https://x" },
+          ],
+        }),
+      );
+      expect(() => readMarketplaceTree(broken)).toThrow(
+        /2 problems found:[\s\S]*and 1 warning:/,
+      );
+    } finally {
+      rmSync(broken, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("findEntry and entryDirectory", () => {
+  it("resolves an offered entry to its absolute directory and an unknown name to undefined", () => {
+    const tree = readMarketplaceTree(root);
+    const github = findEntry(tree.marketplace, "github");
+    expect(github?.dir).toBe("third_party/github");
+    expect(entryDirectory(tree, github!)).toBe(
+      join(root, "third_party", "github"),
+    );
+    expect(findEntry(tree.marketplace, "ghost")).toBeUndefined();
+  });
+});
+
+describe("the official tree in this repository", () => {
+  it("reads clean through the CLI walker and offers assistant as its one default", () => {
+    const official = resolveOfficialMarketplace();
+    expect(official.source).toBe("repo");
+    const tree = readMarketplaceTree(official.dir);
+    expect(tree.marketplace.name).toBe("stigmer");
+    expect(tree.marketplace.dialect).toBe("stigmer");
+    expect(tree.warnings).toEqual([]);
+    expect(tree.marketplace.defaults).toEqual(["assistant"]);
+    expect(findEntry(tree.marketplace, "assistant")?.dir).toBe("assistant");
+  });
+});

package/src/marketplace/read.ts

@@ -0,0 +1,76 @@
+// A marketplace tree on disk, read into the library's one shape.
+//
+// `@stigmer/plugin-package` is pure over a `PluginFiles`; the CLI feeds it
+// the same gitignore-aware walk `push plugin` uses (`readPluginDirectory`),
+// rooted at the marketplace tree, so what `show` lists is what the tree
+// holds after the ignore rules that would apply to a push from it. The
+// library's refusal (a broken marketplace FILE) becomes one `UsageError`
+// with every sentence, the shape `pluginRefusal` prints for a plugin; its
+// warnings (entries the tree cannot offer) travel with the marketplace so
+// `show` can say why an entry is missing.
+
+import { join } from "node:path";
+import {
+  type Marketplace,
+  type MarketplaceEntry,
+  type MarketplaceFinding,
+  readMarketplace,
+} from "@stigmer/plugin-package";
+import { UsageError } from "../errors/index.js";
+import { count, readPluginDirectory } from "../resources/plugin.js";
+
+export interface ReadMarketplaceTree {
+  readonly root: string;
+  readonly marketplace: Marketplace;
+  /** The library's warnings: entries dropped, each with its own sentence. */
+  readonly warnings: readonly MarketplaceFinding[];
+}
+
+/** Read the tree at `root`; a marketplace the library refuses throws with every problem named. */
+export function readMarketplaceTree(
+  root: string,
+  describe: string = root,
+): ReadMarketplaceTree {
+  const directory = readPluginDirectory(root);
+  const outcome = readMarketplace(directory.files);
+  if (!outcome.ok)
+    throw marketplaceRefusal(describe, outcome.errors, outcome.warnings);
+  return { root, marketplace: outcome.marketplace, warnings: outcome.warnings };
+}
+
+/** The library's refusal as the CLI's one UsageError: every problem, then every warning. */
+export function marketplaceRefusal(
+  describe: string,
+  errors: readonly MarketplaceFinding[],
+  warnings: readonly MarketplaceFinding[],
+): UsageError {
+  const lines = [
+    `${describe}: not a marketplace this CLI can read, ${count(errors.length, "problem")} found:`,
+    ...errors.map((finding) => `  - ${finding.message}`),
+  ];
+  if (warnings.length > 0) {
+    lines.push(
+      `and ${count(warnings.length, "warning")}:`,
+      ...warnings.map((finding) => `  - ${finding.message}`),
+    );
+  }
+  return new UsageError(lines.join("\n"));
+}
+
+/** The offered entry called `name`, or `undefined`. */
+export function findEntry(
+  marketplace: Marketplace,
+  name: string,
+): MarketplaceEntry | undefined {
+  return marketplace.plugins.find((entry) => entry.name === name);
+}
+
+/** The absolute directory of an offered entry: what the plugin walker reads next. */
+export function entryDirectory(
+  tree: ReadMarketplaceTree,
+  entry: MarketplaceEntry,
+): string {
+  return entry.dir === ""
+    ? tree.root
+    : join(tree.root, ...entry.dir.split("/"));
+}

package/src/marketplace/ref.test.ts

@@ -0,0 +1,179 @@
+// Pins the two grammars: every accepted form of `[marketplace/]name[@version]`
+// and every refusal with its sentence; every accepted form of an `add`
+// source (a directory wins, then owner/repo[@ref], then the GitHub URL) and
+// the refusals.
+
+import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { formatInstallRef, parseAddSource, parseInstallRef } from "./ref.js";
+
+describe("parseInstallRef", () => {
+  it("reads a bare name, a marketplace prefix, a version, and all three", () => {
+    expect(parseInstallRef("thermos")).toEqual({ name: "thermos" });
+    expect(parseInstallRef("cursor-plugins/thermos")).toEqual({
+      marketplace: "cursor-plugins",
+      name: "thermos",
+    });
+    expect(parseInstallRef("thermos@1.0.0")).toEqual({
+      name: "thermos",
+      version: "1.0.0",
+    });
+    expect(parseInstallRef("stigmer/assistant@1.0.0")).toEqual({
+      marketplace: "stigmer",
+      name: "assistant",
+      version: "1.0.0",
+    });
+    expect(parseInstallRef("third.party-x@v2-rc.1")).toEqual({
+      name: "third.party-x",
+      version: "v2-rc.1",
+    });
+  });
+
+  it("round-trips through formatInstallRef", () => {
+    for (const text of [
+      "thermos",
+      "cursor-plugins/thermos",
+      "thermos@1.0.0",
+      "a/b@c",
+    ]) {
+      expect(formatInstallRef(parseInstallRef(text))).toBe(text);
+    }
+  });
+
+  it("refuses a path toward push plugin", () => {
+    for (const path of [
+      "./thermos",
+      "../x",
+      "/tmp/plugin",
+      ".",
+      "..",
+      "~/plugins",
+      "C:\\plugins",
+    ]) {
+      expect(() => parseInstallRef(path)).toThrow(
+        /is a path.*stigmer push plugin/s,
+      );
+    }
+  });
+
+  it("refuses names and versions outside the grammar, naming the part", () => {
+    expect(() => parseInstallRef("Thermos")).toThrow(
+      /'Thermos' is not a plugin name/,
+    );
+    expect(() => parseInstallRef("a/b/c")).toThrow(
+      /'b\/c' is not a plugin name/,
+    );
+    expect(() => parseInstallRef("Bad/thermos")).toThrow(
+      /'Bad' is not a marketplace name/,
+    );
+    expect(() => parseInstallRef("thermos@")).toThrow(/'' is not a version/);
+    expect(() => parseInstallRef("thermos@1.0+build")).toThrow(
+      /'1.0\+build' is not a version/,
+    );
+    expect(() => parseInstallRef("")).toThrow(/'' is not a plugin name/);
+    expect(() => parseInstallRef("a@b@c")).toThrow(/'b@c' is not a version/);
+  });
+});
+
+describe("parseAddSource", () => {
+  let cwd: string;
+
+  beforeAll(() => {
+    cwd = mkdtempSync(join(tmpdir(), "stigmer-add-source-"));
+    mkdirSync(join(cwd, "plugins"));
+    mkdirSync(join(cwd, "cursor", "plugins"), { recursive: true });
+  });
+
+  afterAll(() => {
+    rmSync(cwd, { recursive: true, force: true });
+  });
+
+  it("reads an existing directory as local, stored absolute, before any other reading", () => {
+    expect(parseAddSource("plugins", cwd)).toEqual({
+      type: "local",
+      path: join(cwd, "plugins"),
+    });
+    expect(parseAddSource("./plugins/", cwd)).toEqual({
+      type: "local",
+      path: join(cwd, "plugins"),
+    });
+    expect(parseAddSource(join(cwd, "plugins"), cwd)).toEqual({
+      type: "local",
+      path: join(cwd, "plugins"),
+    });
+    // A directory named like an owner/repo is the directory.
+    expect(parseAddSource("cursor/plugins", cwd)).toEqual({
+      type: "local",
+      path: join(cwd, "cursor", "plugins"),
+    });
+  });
+
+  it("reads owner/repo and owner/repo@ref as github when no such directory exists", () => {
+    expect(parseAddSource("anthropics/claude-code", cwd)).toEqual({
+      type: "github",
+      repo: "anthropics/claude-code",
+    });
+    expect(parseAddSource("anthropics/claude-code@v1.0", cwd)).toEqual({
+      type: "github",
+      repo: "anthropics/claude-code",
+      ref: "v1.0",
+    });
+    expect(parseAddSource("openai/codex@refs/heads/main", cwd)).toEqual({
+      type: "github",
+      repo: "openai/codex",
+      ref: "refs/heads/main",
+    });
+  });
+
+  it("unwraps the GitHub URL a browser shows, with or without a tree ref", () => {
+    expect(parseAddSource("https://github.com/cursor/plugins", cwd)).toEqual({
+      type: "github",
+      repo: "cursor/plugins",
+    });
+    expect(parseAddSource("https://github.com/cursor/plugins/", cwd)).toEqual({
+      type: "github",
+      repo: "cursor/plugins",
+    });
+    expect(
+      parseAddSource("https://github.com/cursor/plugins.git", cwd),
+    ).toEqual({ type: "github", repo: "cursor/plugins" });
+    expect(
+      parseAddSource("https://www.github.com/cursor/plugins/tree/main", cwd),
+    ).toEqual({
+      type: "github",
+      repo: "cursor/plugins",
+      ref: "main",
+    });
+    expect(
+      parseAddSource("http://github.com/openai/codex/tree/release/1.2", cwd),
+    ).toEqual({
+      type: "github",
+      repo: "openai/codex",
+      ref: "release/1.2",
+    });
+  });
+
+  it("refuses what is neither, naming the three forms", () => {
+    expect(() => parseAddSource("", cwd)).toThrow(/source is required/);
+    expect(() => parseAddSource("missing-dir", cwd)).toThrow(
+      /not a marketplace source/,
+    );
+    expect(() => parseAddSource("./missing-dir", cwd)).toThrow(
+      /not a directory on this machine and not a GitHub/,
+    );
+    expect(() => parseAddSource("a/b/c", cwd)).toThrow(
+      /not a directory on this machine and not a GitHub/,
+    );
+    expect(() => parseAddSource("cursor/plugins@", cwd)).toThrow(
+      /not a marketplace source|not a directory/,
+    );
+    expect(() => parseAddSource("https://gitlab.com/a/b", cwd)).toThrow(
+      /not a directory on this machine and not a GitHub/,
+    );
+    expect(() => parseAddSource("https://github.com/cursor", cwd)).toThrow(
+      /not a directory on this machine and not a GitHub/,
+    );
+  });
+});

package/src/marketplace/ref.ts

@@ -0,0 +1,74 @@
+// The two grammars a user types at the marketplace surface, as the CLI's
+// errors.
+//
+// The grammars themselves (`[marketplace/]name[@version]` and the GitHub
+// `owner/repo[@ref]` or URL forms) live in `@stigmer/plugin-package/client`,
+// where the console parses the same text and gets the same sentence. This
+// module adds what only the CLI has: a `UsageError` carrying the sentence
+// plus the paragraph naming the CLI command to run instead, and the reading
+// of `marketplace add <source>` as a directory on this machine, which wins
+// over every other reading (`add plugins` in a checkout means the folder,
+// not a GitHub owner).
+
+import { statSync } from "node:fs";
+import { resolve } from "node:path";
+import {
+  GITHUB_SOURCE_SHAPE,
+  INSTALL_REF_SHAPE,
+  type InstallRef,
+  formatInstallRef,
+  looksLikePath,
+  parseGitHubSource,
+  parseInstallRef as parseInstallRefText,
+} from "@stigmer/plugin-package/client";
+import { UsageError } from "../errors/index.js";
+import { type MarketplaceSource } from "./config.js";
+
+export { type InstallRef, formatInstallRef };
+
+export function parseInstallRef(text: string): InstallRef {
+  const outcome = parseInstallRefText(text);
+  if (outcome.ok) return outcome.ref;
+  if (outcome.kind === "path") {
+    throw new UsageError(
+      `${outcome.message}\n\nTo install a plugin from a folder, run: stigmer push plugin ${text}`,
+    );
+  }
+  throw new UsageError(`${outcome.message}\n\nA ref is ${INSTALL_REF_SHAPE}.`);
+}
+
+/**
+ * What `marketplace add <source>` was given, as a source. An existing
+ * directory wins over every other reading; otherwise the shared GitHub
+ * grammar decides, and what it refuses is refused here with the shape.
+ */
+export function parseAddSource(
+  text: string,
+  cwd: string = process.cwd(),
+): Exclude<MarketplaceSource, { type: "official" }> {
+  if (text === "")
+    throw new UsageError(`a marketplace source is required\n\n${ADD_SHAPE}`);
+
+  const asDirectory = resolve(cwd, text);
+  if (isDirectory(asDirectory)) return { type: "local", path: asDirectory };
+
+  const github = parseGitHubSource(text);
+  if (github.ok) return github.source;
+
+  if (looksLikePath(text) || text.includes("/")) {
+    throw new UsageError(
+      `'${text}' is not a directory on this machine and not a GitHub 'owner/repo'\n\n${ADD_SHAPE}`,
+    );
+  }
+  throw new UsageError(`'${text}' is not a marketplace source\n\n${ADD_SHAPE}`);
+}
+
+const ADD_SHAPE = `A source is a directory holding a marketplace file, or ${GITHUB_SOURCE_SHAPE}.`;
+
+function isDirectory(path: string): boolean {
+  try {
+    return statSync(path).isDirectory();
+  } catch {
+    return false;
+  }
+}

package/src/marketplace/render.ts

@@ -0,0 +1,154 @@
+// What `stigmer marketplace list` and `show` print, as `CommandResult`s: the
+// human form on stderr, the same facts as `data` on stdout under `--json`.
+// The marketplace group renders the way `config backend list` does (a
+// mutating-class result rather than a read-verb table) because it is the
+// same kind of thing: client-side configuration, not a server collection.
+
+import { readPluginPackage } from "@stigmer/plugin-package";
+import { CommandResult } from "../output/index.js";
+import { count, readPluginDirectory } from "../resources/plugin.js";
+import {
+  type KnownMarketplace,
+  type MarketplaceListing,
+  describeSource,
+} from "./config.js";
+import { type ReadMarketplaceTree, entryDirectory } from "./read.js";
+
+export function renderMarketplaceList(
+  listing: MarketplaceListing,
+): CommandResult {
+  const total = listing.known.length + listing.unreadable.length;
+  const result =
+    listing.unreadable.length === 0
+      ? CommandResult.success(`${count(total, "marketplace")} configured`)
+      : CommandResult.warning(
+          `${count(total, "marketplace")} configured, ${count(listing.unreadable.length, "entry")} this CLI cannot read`,
+        );
+  const section = result.addSection("Marketplaces");
+  for (const marketplace of listing.known) {
+    section.field(marketplace.name, describeSource(marketplace.source));
+  }
+  for (const marketplace of listing.unreadable) {
+    section.field(marketplace.name, `cannot be read: ${marketplace.reason}`);
+  }
+  result.hint("Show what one offers with: stigmer marketplace show <name>");
+  result.hint("Install from one with:      stigmer install [<name>/]<plugin>");
+  return result.withData({
+    marketplaces: [
+      ...listing.known.map((marketplace) => ({
+        name: marketplace.name,
+        source: marketplace.source,
+      })),
+      ...listing.unreadable.map((marketplace) => ({
+        name: marketplace.name,
+        unreadable: marketplace.reason,
+      })),
+    ],
+  });
+}
+
+/** One offered entry as `show` reports it, after its own manifest has been read. */
+export interface ShownEntry {
+  readonly name: string;
+  readonly dir: string;
+  readonly version?: string;
+  readonly description?: string;
+  /** Set when the entry's own package refuses to read; `show` still lists it so the gap is visible. */
+  readonly problems?: number;
+}
+
+/**
+ * Read each offered entry's own package for its version and description.
+ * The marketplace file's description is a fallback (Stigmer's own catalogue
+ * carries none, so nothing is written twice); the plugin's manifest is the
+ * truth a user installs.
+ */
+export function inspectEntries(tree: ReadMarketplaceTree): ShownEntry[] {
+  return tree.marketplace.plugins.map((entry) => {
+    const outcome = readPluginPackage(
+      readPluginDirectory(entryDirectory(tree, entry)).files,
+    );
+    if (!outcome.ok) {
+      return {
+        name: entry.name,
+        dir: entry.dir,
+        ...(entry.description !== undefined && {
+          description: entry.description,
+        }),
+        problems: outcome.errors.length,
+      };
+    }
+    const description = outcome.plugin.description ?? entry.description;
+    return {
+      name: entry.name,
+      dir: entry.dir,
+      ...(outcome.plugin.version !== undefined && {
+        version: outcome.plugin.version,
+      }),
+      ...(description !== undefined && { description }),
+    };
+  });
+}
+
+export function renderMarketplaceShow(
+  marketplace: KnownMarketplace,
+  tree: ReadMarketplaceTree,
+  entries: readonly ShownEntry[],
+): CommandResult {
+  const installable = entries.filter(
+    (entry) => entry.problems === undefined,
+  ).length;
+  const headline = `Marketplace '${marketplace.name}' offers ${count(installable, "plugin")}`;
+  const result =
+    tree.warnings.length === 0 && installable === entries.length
+      ? CommandResult.success(headline)
+      : CommandResult.warning(
+          `${headline}, with ${count(tree.warnings.length + (entries.length - installable), "warning")}`,
+        );
+
+  const about = result.addSection("Marketplace");
+  about.field("Name", tree.marketplace.name);
+  about.field("Source", describeSource(marketplace.source));
+  if (tree.marketplace.description !== undefined)
+    about.field("Description", tree.marketplace.description);
+  if (tree.marketplace.owner?.name !== undefined)
+    about.field("Owner", tree.marketplace.owner.name);
+  about.field("Format", tree.marketplace.path);
+  if (tree.marketplace.defaults.length > 0)
+    about.field("Defaults", tree.marketplace.defaults.join(", "));
+
+  const plugins = result.addSection("Plugins");
+  for (const entry of entries) {
+    const version = entry.version === undefined ? "" : `@${entry.version}`;
+    const tail =
+      entry.problems !== undefined
+        ? `  (not installable: ${count(entry.problems, "problem")}; run 'stigmer validate -f' on it)`
+        : entry.description === undefined
+          ? ""
+          : `  ${entry.description}`;
+    plugins.item(`${entry.name}${version}${tail}`);
+  }
+
+  if (tree.warnings.length > 0) {
+    const section = result.addSection("Not offered");
+    for (const warning of tree.warnings) section.item(warning.message);
+  }
+  result.hint(`Install one with: stigmer install ${marketplace.name}/<plugin>`);
+  return result.withData({
+    marketplace: {
+      name: tree.marketplace.name,
+      source: marketplace.source,
+      dialect: tree.marketplace.dialect,
+      path: tree.marketplace.path,
+      ...(tree.marketplace.description !== undefined && {
+        description: tree.marketplace.description,
+      }),
+      ...(tree.marketplace.owner !== undefined && {
+        owner: tree.marketplace.owner,
+      }),
+      defaults: tree.marketplace.defaults,
+    },
+    plugins: entries,
+    warnings: tree.warnings,
+  });
+}

package/src/output/ndjson.ts

@@ -1,4 +1,4 @@
-// NDJSON envelope + writer for streaming commands (run/resume/draft).
+// NDJSON envelope + writer for streaming commands (run/resume).
 //
 // The wire shape mirrors the Go CLI's run --json output (run_stream_json.go):
 // every line is a `{type, ts, payload}` object, and the payload is cleaned of

package/src/program.test.ts

@@ -25,22 +25,13 @@ describe("buildProgram", () => {
   it("registers the Wave 3c streaming commands", () => {
     const program = buildProgram();
     const names = program.commands.map((command) => command.name());
-    expect(names).toEqual(expect.arrayContaining(["run", "resume", "draft"]));
+    expect(names).toEqual(expect.arrayContaining(["run", "resume"]));
   });
 
-  it("exposes the draft subcommands", () => {
+  it("has no draft command: a plugin is authored outside Stigmer and installed, never drafted by a system agent", () => {
     const program = buildProgram();
-    const draft = program.commands.find((command) => command.name() === "draft");
-    const subs = draft?.commands.map((command) => command.name()).sort();
-    expect(subs).toEqual(["agent", "mcp-server", "skill"]);
-  });
-
-  it("marks draft subcommands' --message as required", () => {
-    const program = buildProgram();
-    const draft = program.commands.find((command) => command.name() === "draft");
-    const skill = draft?.commands.find((command) => command.name() === "skill");
-    const message = skill?.options.find((option) => option.long === "--message");
-    expect(message?.required).toBe(true);
+    const names = program.commands.map((command) => command.name());
+    expect(names).not.toContain("draft");
   });
 
   it("exposes the share subcommands", () => {

package/src/program.ts

@@ -17,12 +17,13 @@ import { registerDelete } from "./commands/delete.js";
 import { registerDiff } from "./commands/diff.js";
 import { registerDown } from "./commands/down.js";
 import { registerDownload } from "./commands/download.js";
-import { registerDraft } from "./commands/draft.js";
 import { registerExecution } from "./commands/execution/index.js";
 import { registerGet } from "./commands/get.js";
+import { registerInstall } from "./commands/install.js";
 import { registerInternalDaemon } from "./commands/internal-daemon.js";
 import { registerList } from "./commands/list.js";
 import { registerLogs } from "./commands/logs.js";
+import { registerMarketplace } from "./commands/marketplace.js";
 import { registerMcpServer } from "./commands/mcp-server.js";
 import { registerPush } from "./commands/push.js";
 import { registerReset } from "./commands/reset.js";
@@ -83,11 +84,12 @@ export function buildProgram(): Command {
   registerDiff(program);
   registerUsage(program);
   registerPush(program);
+  registerInstall(program);
+  registerMarketplace(program);
   registerDownload(program);
   registerApply(program);
   registerRun(program);
   registerResume(program);
-  registerDraft(program);
   registerExecution(program);
   registerConnect(program);
   registerMcpServer(program);