@ericsanchezok/synergy-plugin-kit 2.2.1

package/dist/commands/dev.js

@@ -0,0 +1,192 @@
+import path from "path";
+import fs from "fs";
+import { PluginManifest } from "@ericsanchezok/synergy-plugin";
+import { cmd } from "../cmd";
+import { UI } from "../ui";
+import { computeRisk } from "../lib/risk";
+function timestamp() {
+    return new Date().toLocaleTimeString("en-US", { hour12: false });
+}
+function debounce(ms) {
+    let timer;
+    return (fn) => {
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(fn, ms);
+    };
+}
+function overallRisk(manifest) {
+    const caps = [];
+    const pt = manifest.permissions?.tools;
+    if (pt?.shell)
+        caps.push("shell");
+    if (pt?.filesystem === "write")
+        caps.push("filesystem:write");
+    else if (pt?.filesystem === "read")
+        caps.push("filesystem:read");
+    if (pt?.network)
+        caps.push("network");
+    if (pt?.mcp === "invoke")
+        caps.push("mcp:invoke");
+    if (pt?.mcp === "spawn")
+        caps.push("mcp:spawn");
+    const pd = manifest.permissions?.data;
+    if (pd?.session === "read")
+        caps.push("session_data");
+    if (pd?.workspace === "read")
+        caps.push("workspace_data");
+    if (pd?.secrets === "own")
+        caps.push("secrets");
+    if (pd?.config === "global")
+        caps.push("config:write");
+    if (pd?.config === "plugin")
+        caps.push("config:read");
+    return computeRisk(caps, manifest);
+}
+function riskLabel(risk) {
+    if (risk === "high")
+        return UI.Style.TEXT_DANGER + "high" + UI.Style.TEXT_NORMAL;
+    if (risk === "medium")
+        return UI.Style.TEXT_WARNING + "medium" + UI.Style.TEXT_NORMAL;
+    return UI.Style.TEXT_SUCCESS + "low" + UI.Style.TEXT_NORMAL;
+}
+function printPermissionPreview(manifest) {
+    const pt = manifest.permissions?.tools;
+    const pd = manifest.permissions?.data;
+    const risk = overallRisk(manifest);
+    const caps = [];
+    if (pt?.shell)
+        caps.push(`shell (${UI.Style.TEXT_DANGER}high${UI.Style.TEXT_NORMAL})`);
+    if (pt?.filesystem === "write")
+        caps.push(`filesystem: write (${UI.Style.TEXT_DANGER}high${UI.Style.TEXT_NORMAL})`);
+    else if (pt?.filesystem === "read")
+        caps.push(`filesystem: read (${UI.Style.TEXT_WARNING}medium${UI.Style.TEXT_NORMAL})`);
+    UI.println(`✓ permissions: ${riskLabel(risk)} risk`);
+    if (caps.length > 0)
+        UI.println(`  -> tools: ${caps.join(", ")}`);
+    if (pt?.network) {
+        const net = pt.network === true
+            ? "all hosts"
+            : typeof pt.network === "object" && "hosts" in pt.network
+                ? pt.network.hosts.join(", ")
+                : String(pt.network);
+        UI.println(`  -> network: ${net}`);
+    }
+    if (pd?.session === "read")
+        UI.println("  -> data: session read");
+    if (pd?.workspace === "read")
+        UI.println("  -> data: workspace read");
+    if (pd?.secrets === "own")
+        UI.println("  -> data: secrets");
+}
+function countUiContributions(manifest) {
+    const ui = manifest.contributes?.ui;
+    if (!ui)
+        return 0;
+    return ((ui.toolRenderers?.length ?? 0) +
+        (ui.partRenderers?.length ?? 0) +
+        (ui.workspacePanels?.length ?? 0) +
+        (ui.globalPanels?.length ?? 0) +
+        (ui.settings?.length ?? 0) +
+        (ui.chatComponents?.length ?? 0) +
+        (ui.themes?.length ?? 0) +
+        (ui.icons?.length ?? 0) +
+        (ui.commands?.length ?? 0) +
+        (ui.routes?.length ?? 0));
+}
+function readManifest(manifestPath) {
+    const raw = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+    return PluginManifest.parse(raw);
+}
+export const PluginDevCommand = cmd({
+    command: "dev [path]",
+    describe: "start plugin development mode with file watching",
+    builder: (yargs) => yargs
+        .positional("path", {
+        type: "string",
+        describe: "path to plugin directory (defaults to cwd)",
+    })
+        .option("sandbox-preview", {
+        type: "boolean",
+        default: false,
+        describe: "print Synergy sandbox preview URLs for UI panels",
+    })
+        .option("port", {
+        type: "number",
+        default: 3000,
+        describe: "Synergy server port for preview URLs",
+    }),
+    async handler(args) {
+        const pluginDir = path.resolve(args.path ?? process.cwd());
+        const manifestPath = path.join(pluginDir, "plugin.json");
+        if (!fs.existsSync(manifestPath)) {
+            UI.error(`No plugin.json found at ${manifestPath}`);
+            process.exitCode = 1;
+            return;
+        }
+        let manifest;
+        try {
+            manifest = readManifest(manifestPath);
+        }
+        catch (error) {
+            UI.error(`Failed to read manifest: ${error instanceof Error ? error.message : String(error)}`);
+            process.exitCode = 1;
+            return;
+        }
+        UI.println(`${UI.Style.TEXT_NORMAL_BOLD}Synergy Plugin Dev${UI.Style.TEXT_NORMAL} - ${manifest.name} v${manifest.version}`);
+        UI.println();
+        UI.println(`${UI.Style.TEXT_SUCCESS}✓${UI.Style.TEXT_NORMAL} manifest valid`);
+        printPermissionPreview(manifest);
+        const uiContribs = countUiContributions(manifest);
+        if (uiContribs > 0) {
+            UI.println();
+            UI.println(`UI: ${uiContribs} contribution${uiContribs !== 1 ? "s" : ""}`);
+        }
+        if (args["sandbox-preview"]) {
+            for (const panel of manifest.contributes?.ui?.workspacePanels ?? []) {
+                if (panel.sandbox) {
+                    UI.println(`  ${panel.label}: http://localhost:${args.port}/plugin/${encodeURIComponent(manifest.name)}/sandbox/${encodeURIComponent(panel.id)}`);
+                }
+            }
+            for (const panel of manifest.contributes?.ui?.globalPanels ?? []) {
+                if (panel.sandbox) {
+                    UI.println(`  ${panel.label}: http://localhost:${args.port}/plugin/${encodeURIComponent(manifest.name)}/sandbox/${encodeURIComponent(panel.id)}`);
+                }
+            }
+        }
+        const srcDir = path.join(pluginDir, "src");
+        if (!fs.existsSync(srcDir)) {
+            UI.println(`${UI.Style.TEXT_WARNING}⚠${UI.Style.TEXT_NORMAL} No src/ directory found at ${srcDir}`);
+            return;
+        }
+        UI.println();
+        UI.println(`Watching ${srcDir} for changes...`);
+        UI.println(`${UI.Style.TEXT_DIM}Run synergy plugin add file://${pluginDir} in a Synergy runtime when you need live installation/reload.${UI.Style.TEXT_NORMAL}`);
+        UI.println();
+        const onReload = debounce(300);
+        const watcher = fs.watch(srcDir, { recursive: true }, (_event, filename) => {
+            if (!filename)
+                return;
+            onReload(() => {
+                UI.println(`${timestamp()} [${manifest.name}] File changed: ${filename}`);
+                try {
+                    manifest = readManifest(manifestPath);
+                    UI.println(`${UI.Style.TEXT_SUCCESS}✓${UI.Style.TEXT_NORMAL} manifest valid`);
+                    printPermissionPreview(manifest);
+                    UI.println();
+                }
+                catch (error) {
+                    UI.error(`Manifest read error: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            });
+        });
+        const shutdown = () => {
+            UI.println();
+            UI.println("Shutting down...");
+            watcher.close();
+            process.exit(0);
+        };
+        process.on("SIGINT", shutdown);
+        process.on("SIGTERM", shutdown);
+    },
+});

package/dist/commands/entry.d.ts

@@ -0,0 +1,19 @@
+export declare const PluginEntryCommand: import("yargs").CommandModule<{}, {
+    tarball: string;
+} & {
+    repo: string | undefined;
+} & {
+    "download-url": string | undefined;
+} & {
+    "signature-url": string | undefined;
+} & {
+    "write-entry": string | undefined;
+} & {
+    verified: boolean;
+} & {
+    official: boolean;
+} & {
+    changelog: string | undefined;
+} & {
+    "--"?: string[];
+}>;

package/dist/commands/entry.js

@@ -0,0 +1,71 @@
+import path from "path";
+import { cmd } from "../cmd";
+import { UI } from "../ui";
+import { githubEntry, writeGithubEntry } from "../lib/market-entry";
+export const PluginEntryCommand = cmd({
+    command: "entry <tarball>",
+    describe: "generate a SII-Holos/synergy-plugins registry entry JSON",
+    builder: (yargs) => yargs
+        .positional("tarball", {
+        type: "string",
+        describe: "path to the plugin .synergy-plugin.tgz tarball",
+        demandOption: true,
+    })
+        .option("repo", {
+        type: "string",
+        describe: "plugin GitHub repository URL",
+    })
+        .option("download-url", {
+        type: "string",
+        describe: "release asset URL for the .synergy-plugin.tgz",
+    })
+        .option("signature-url", {
+        type: "string",
+        describe: "release asset URL for the .sig file",
+    })
+        .option("write-entry", {
+        type: "string",
+        describe: "write or update a synergy-plugins plugins/<id>.json entry",
+    })
+        .option("verified", {
+        type: "boolean",
+        default: false,
+        describe: "mark the entry as verified",
+    })
+        .option("official", {
+        type: "boolean",
+        default: false,
+        describe: "mark the entry as official",
+    })
+        .option("changelog", {
+        type: "string",
+        describe: "version changelog",
+    }),
+    async handler(args) {
+        try {
+            const tarballPath = path.resolve(args.tarball);
+            const entry = githubEntry({
+                tarballPath,
+                repo: args.repo,
+                downloadUrl: args.downloadUrl,
+                signatureUrl: args.signatureUrl,
+                verified: Boolean(args.verified),
+                official: Boolean(args.official),
+                changelog: args.changelog,
+            });
+            const writeEntry = args.writeEntry;
+            if (writeEntry) {
+                const outputPath = path.resolve(writeEntry);
+                writeGithubEntry(outputPath, entry);
+                UI.println(`${UI.Style.TEXT_SUCCESS}✔${UI.Style.TEXT_NORMAL} Wrote GitHub registry entry ${outputPath}`);
+            }
+            else {
+                UI.println(JSON.stringify(entry, null, 2));
+            }
+        }
+        catch (error) {
+            UI.error(error instanceof Error ? error.message : String(error));
+            process.exitCode = 1;
+        }
+    },
+});

package/dist/commands/index.d.ts

@@ -0,0 +1,9 @@
+export { PluginBuildCommand, buildPluginProject } from "./build";
+export { PluginCreateCommand } from "./create";
+export { PluginDevCommand } from "./dev";
+export { PluginEntryCommand } from "./entry";
+export { PluginPackCommand, packPluginProject } from "./pack";
+export { PluginPublishMarketCommand } from "./publish-market";
+export { PluginSignCommand, signPluginTarball } from "./sign";
+export { PluginTestCommand } from "./test";
+export { PluginValidateCommand, validatePluginProject } from "./validate";

package/dist/commands/index.js

@@ -0,0 +1,9 @@
+export { PluginBuildCommand, buildPluginProject } from "./build";
+export { PluginCreateCommand } from "./create";
+export { PluginDevCommand } from "./dev";
+export { PluginEntryCommand } from "./entry";
+export { PluginPackCommand, packPluginProject } from "./pack";
+export { PluginPublishMarketCommand } from "./publish-market";
+export { PluginSignCommand, signPluginTarball } from "./sign";
+export { PluginTestCommand } from "./test";
+export { PluginValidateCommand, validatePluginProject } from "./validate";

package/dist/commands/pack.d.ts

@@ -0,0 +1,8 @@
+import { type PluginManifest as PluginManifestType } from "@ericsanchezok/synergy-plugin";
+export declare function readSourceManifest(pluginDir: string): PluginManifestType;
+export declare function packPluginProject(pluginDir: string): string;
+export declare const PluginPackCommand: import("yargs").CommandModule<{}, {
+    path: string | undefined;
+} & {
+    "--"?: string[];
+}>;

package/dist/commands/pack.js

@@ -0,0 +1,64 @@
+import path from "path";
+import fs from "fs";
+import { PluginManifest } from "@ericsanchezok/synergy-plugin";
+import { cmd } from "../cmd";
+import { UI } from "../ui";
+import { sha256File } from "../lib/crypto";
+function formatSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function safePackageName(name) {
+    return name.replace(/[^a-zA-Z0-9_.-]/g, "-");
+}
+export function readSourceManifest(pluginDir) {
+    const manifestPath = path.join(pluginDir, "plugin.json");
+    const raw = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+    return PluginManifest.parse(raw);
+}
+export function packPluginProject(pluginDir) {
+    const manifestPath = path.join(pluginDir, "plugin.json");
+    if (!fs.existsSync(manifestPath))
+        throw new Error(`No plugin.json found at ${manifestPath}`);
+    const manifest = readSourceManifest(pluginDir);
+    UI.println(`${UI.Style.TEXT_NORMAL_BOLD}Packing${UI.Style.TEXT_NORMAL} ${manifest.name} v${manifest.version}`);
+    const distDir = path.join(pluginDir, "dist");
+    if (!fs.existsSync(distDir))
+        throw new Error(`dist/ directory not found at ${distDir}. Run "synergy-plugin build" first.`);
+    if (!fs.existsSync(path.join(distDir, "plugin.json"))) {
+        throw new Error(`dist/plugin.json not found at ${distDir}. Run "synergy-plugin build" first.`);
+    }
+    const tgzName = `${safePackageName(manifest.name)}-${manifest.version}.synergy-plugin.tgz`;
+    const result = Bun.spawnSync(["tar", "-czf", tgzName, "-C", distDir, "."], { cwd: pluginDir });
+    if (result.exitCode !== 0) {
+        const stderr = new TextDecoder().decode(result.stderr);
+        throw new Error(`Failed to create tarball${stderr ? `: ${stderr}` : ""}`);
+    }
+    const tgzPath = path.join(pluginDir, tgzName);
+    const st = fs.statSync(tgzPath);
+    const integrity = sha256File(tgzPath);
+    UI.println(`${UI.Style.TEXT_SUCCESS}✔${UI.Style.TEXT_NORMAL} Packed: ${UI.Style.TEXT_HIGHLIGHT}${tgzName}${UI.Style.TEXT_NORMAL}`);
+    UI.println(`  ${UI.Style.TEXT_DIM}Size:${UI.Style.TEXT_NORMAL} ${formatSize(st.size)}`);
+    UI.println(`  ${UI.Style.TEXT_DIM}Integrity:${UI.Style.TEXT_NORMAL} sha256-${integrity}`);
+    return tgzPath;
+}
+export const PluginPackCommand = cmd({
+    command: "pack [path]",
+    describe: "package a built plugin into a .synergy-plugin.tgz",
+    builder: (yargs) => yargs.positional("path", {
+        type: "string",
+        describe: "path to plugin directory (defaults to cwd)",
+    }),
+    async handler(args) {
+        try {
+            packPluginProject(path.resolve(args.path ?? process.cwd()));
+        }
+        catch (error) {
+            UI.error(error instanceof Error ? error.message : String(error));
+            process.exitCode = 1;
+        }
+    },
+});

package/dist/commands/publish-market.d.ts

@@ -0,0 +1,23 @@
+export declare const PluginPublishMarketCommand: import("yargs").CommandModule<{}, {
+    tarball: string | undefined;
+} & {
+    path: string | undefined;
+} & {
+    repo: string | undefined;
+} & {
+    "registry-dir": string | undefined;
+} & {
+    "registry-repo": string;
+} & {
+    "download-url": string | undefined;
+} & {
+    "signature-url": string | undefined;
+} & {
+    "skip-release-upload": boolean;
+} & {
+    "no-pr": boolean;
+} & {
+    changelog: string | undefined;
+} & {
+    "--"?: string[];
+}>;

package/dist/commands/publish-market.js

@@ -0,0 +1,224 @@
+import { $ } from "bun";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { cmd } from "../cmd";
+import { UI } from "../ui";
+import { buildPluginProject } from "./build";
+import { packPluginProject } from "./pack";
+import { signPluginTarball } from "./sign";
+import { validatePluginProject } from "./validate";
+import { githubEntry, githubRepoSlug, normalizeRepoUrl, releaseAssetUrl, readTarballManifest, writeGithubEntry, } from "../lib/market-entry";
+const DEFAULT_REGISTRY_REPO = "https://github.com/SII-Holos/synergy-plugins.git";
+async function commandExists(name) {
+    const result = await $ `which ${name}`.quiet().nothrow();
+    return result.exitCode === 0;
+}
+async function ghReady() {
+    if (!(await commandExists("gh")))
+        return false;
+    const result = await $ `gh auth status`.quiet().nothrow();
+    return result.exitCode === 0;
+}
+async function currentRepoUrl(cwd) {
+    const result = await $ `git remote get-url origin`.cwd(cwd).quiet().nothrow();
+    if (result.exitCode !== 0)
+        return undefined;
+    return normalizeRepoUrl(result.text().trim());
+}
+function defaultRegistryDir(pluginDir) {
+    const sibling = path.resolve(pluginDir, "..", "synergy-plugins");
+    if (fs.existsSync(sibling))
+        return sibling;
+    return path.join(os.homedir(), "projects", "synergy-plugins");
+}
+function safeArtifactName(name) {
+    return name.replace(/[^a-zA-Z0-9_.-]/g, "-");
+}
+function readTarballPackageName(tarballPath) {
+    const result = Bun.spawnSync(["tar", "-xOf", tarballPath, "package.json"], { stdout: "pipe", stderr: "pipe" });
+    if (result.exitCode !== 0)
+        return undefined;
+    const pkg = JSON.parse(new TextDecoder().decode(result.stdout));
+    return typeof pkg.name === "string" ? pkg.name : undefined;
+}
+function assertMarketplaceNaming(input) {
+    const packageName = readTarballPackageName(input.tarballPath);
+    if (!packageName) {
+        throw new Error("Marketplace publishing requires package.json inside the plugin tarball. Run `synergy-plugin build` and `synergy-plugin pack`.");
+    }
+    if (packageName !== input.manifest.name) {
+        throw new Error(`Marketplace publishing requires package.json name "${packageName}" to match plugin.json name "${input.manifest.name}".`);
+    }
+    const expectedArtifact = `${safeArtifactName(input.manifest.name)}-${input.manifest.version}.synergy-plugin.tgz`;
+    if (path.basename(input.tarballPath) !== expectedArtifact) {
+        throw new Error(`Marketplace publishing requires artifact name "${expectedArtifact}", got "${path.basename(input.tarballPath)}".`);
+    }
+}
+async function ensureRegistryCheckout(registryDir, registryRepo) {
+    if (fs.existsSync(path.join(registryDir, ".git")))
+        return;
+    fs.mkdirSync(path.dirname(registryDir), { recursive: true });
+    UI.println(`Cloning official plugin registry to ${registryDir}`);
+    const result = await $ `git clone ${registryRepo} ${registryDir}`.nothrow();
+    if (result.exitCode !== 0) {
+        throw new Error(`Failed to clone ${registryRepo}. Clone it manually or pass --registry-dir.`);
+    }
+}
+async function ensureGitHubReleaseAssets(input) {
+    if (input.skipUpload)
+        return;
+    if (!(await ghReady())) {
+        UI.println(`${UI.Style.TEXT_WARNING}gh is not authenticated; skipping GitHub Release upload.${UI.Style.TEXT_NORMAL}`);
+        return;
+    }
+    const repoSlug = githubRepoSlug(input.repo);
+    if (!repoSlug) {
+        UI.println(`${UI.Style.TEXT_WARNING}Could not derive GitHub owner/repo from ${input.repo}; skipping release upload.${UI.Style.TEXT_NORMAL}`);
+        return;
+    }
+    const tag = `v${input.version}`;
+    const view = await $ `gh release view ${tag} --repo ${repoSlug}`.quiet().nothrow();
+    if (view.exitCode === 0) {
+        await $ `gh release upload ${tag} ${input.tarballPath} ${input.signaturePath} --repo ${repoSlug} --clobber`;
+        return;
+    }
+    await $ `gh release create ${tag} ${input.tarballPath} ${input.signaturePath} --repo ${repoSlug} --title ${tag} --notes ${`Synergy plugin release ${tag}`}`;
+}
+async function runRegistryValidation(registryDir) {
+    await $ `bun install`.cwd(registryDir);
+    await $ `bun run validate`.cwd(registryDir);
+    await $ `bun run build-registry --check`.cwd(registryDir);
+}
+async function openRegistryPr(input) {
+    const branch = `publish/${input.pluginId}-${input.version}`;
+    await $ `git checkout -B ${branch}`.cwd(input.registryDir);
+    await $ `git add plugins/${input.pluginId}.json registry.json`.cwd(input.registryDir).nothrow();
+    const diff = await $ `git diff --cached --quiet`.cwd(input.registryDir).nothrow();
+    if (diff.exitCode === 0) {
+        UI.println(`${UI.Style.TEXT_DIM}No registry changes to commit.${UI.Style.TEXT_NORMAL}`);
+        return;
+    }
+    await $ `git commit -m ${`Add ${input.pluginId} ${input.version}`}`.cwd(input.registryDir);
+    if (input.noPr || !(await ghReady())) {
+        UI.println();
+        UI.println(`${UI.Style.TEXT_WARNING}Registry entry is ready, but PR was not opened automatically.${UI.Style.TEXT_NORMAL}`);
+        UI.println(`  cd ${input.registryDir}`);
+        UI.println(`  git push origin ${branch}`);
+        UI.println(`  Open a PR against SII-Holos/synergy-plugins:main`);
+        return;
+    }
+    try {
+        await $ `git push -u origin ${branch}`.cwd(input.registryDir);
+        await $ `gh pr create --repo SII-Holos/synergy-plugins --base main --head ${branch} --title ${`Add ${input.pluginId} ${input.version}`} --body ${`Adds ${input.pluginId} ${input.version} to the official Synergy Plugin Marketplace.`}`.cwd(input.registryDir);
+    }
+    catch {
+        UI.println();
+        UI.println(`${UI.Style.TEXT_WARNING}Registry entry is committed, but the PR could not be opened automatically.${UI.Style.TEXT_NORMAL}`);
+        UI.println(`  cd ${input.registryDir}`);
+        UI.println(`  git push origin ${branch}`);
+        UI.println(`  Open a PR against SII-Holos/synergy-plugins:main`);
+    }
+}
+export const PluginPublishMarketCommand = cmd({
+    command: "publish-market [tarball]",
+    describe: "prepare and open an official Synergy Plugin Marketplace PR",
+    builder: (yargs) => yargs
+        .positional("tarball", {
+        type: "string",
+        describe: "optional prebuilt .synergy-plugin.tgz tarball",
+    })
+        .option("path", {
+        type: "string",
+        describe: "plugin directory (defaults to cwd)",
+    })
+        .option("repo", {
+        type: "string",
+        describe: "plugin GitHub repository URL",
+    })
+        .option("registry-dir", {
+        type: "string",
+        describe: "local checkout path for SII-Holos/synergy-plugins",
+    })
+        .option("registry-repo", {
+        type: "string",
+        default: DEFAULT_REGISTRY_REPO,
+        describe: "registry repository to clone when --registry-dir does not exist",
+    })
+        .option("download-url", {
+        type: "string",
+        describe: "release asset URL for the .synergy-plugin.tgz",
+    })
+        .option("signature-url", {
+        type: "string",
+        describe: "release asset URL for the .sig file",
+    })
+        .option("skip-release-upload", {
+        type: "boolean",
+        default: false,
+        describe: "do not create/upload GitHub Release assets",
+    })
+        .option("no-pr", {
+        type: "boolean",
+        default: false,
+        describe: "prepare registry changes but do not open a PR",
+    })
+        .option("changelog", {
+        type: "string",
+        describe: "version changelog for the registry entry",
+    }),
+    async handler(args) {
+        try {
+            const pluginDir = path.resolve(args.path ?? process.cwd());
+            let tarballPath = args.tarball ? path.resolve(args.tarball) : undefined;
+            if (!tarballPath) {
+                await validatePluginProject(pluginDir, { runtimeDiscovery: true });
+                if (process.exitCode && process.exitCode !== 0)
+                    throw new Error("Validation failed");
+                const built = await buildPluginProject(pluginDir);
+                if (!built)
+                    throw new Error("Build failed");
+                tarballPath = packPluginProject(pluginDir);
+            }
+            const manifest = readTarballManifest(tarballPath);
+            assertMarketplaceNaming({ tarballPath, manifest });
+            await signPluginTarball(tarballPath);
+            const repo = normalizeRepoUrl(args.repo ?? (await currentRepoUrl(pluginDir)) ?? manifest.repository);
+            if (!repo)
+                throw new Error("Could not determine plugin GitHub repo. Pass --repo https://github.com/owner/repo.");
+            const signaturePath = `${tarballPath}.sig`;
+            await ensureGitHubReleaseAssets({
+                repo,
+                version: manifest.version,
+                tarballPath,
+                signaturePath,
+                skipUpload: Boolean(args["skip-release-upload"]),
+            });
+            const downloadUrl = args.downloadUrl ?? releaseAssetUrl(repo, manifest.version, path.basename(tarballPath));
+            const signatureUrl = args.signatureUrl ?? (downloadUrl ? `${downloadUrl}.sig` : undefined);
+            const entry = githubEntry({
+                tarballPath,
+                repo,
+                downloadUrl,
+                signatureUrl,
+                changelog: args.changelog,
+            });
+            const registryDir = path.resolve(args["registry-dir"] ?? defaultRegistryDir(pluginDir));
+            await ensureRegistryCheckout(registryDir, args["registry-repo"] ?? DEFAULT_REGISTRY_REPO);
+            const entryPath = path.join(registryDir, "plugins", `${entry.id}.json`);
+            writeGithubEntry(entryPath, entry);
+            await runRegistryValidation(registryDir);
+            await openRegistryPr({
+                registryDir,
+                pluginId: entry.id,
+                version: manifest.version,
+                noPr: Boolean(args["no-pr"]),
+            });
+            UI.println(`${UI.Style.TEXT_SUCCESS}✔${UI.Style.TEXT_NORMAL} Marketplace publishing request prepared for ${entry.id} v${manifest.version}`);
+        }
+        catch (error) {
+            UI.error(error instanceof Error ? error.message : String(error));
+            process.exitCode = 1;
+        }
+    },
+});

package/dist/commands/sign.d.ts

@@ -0,0 +1,10 @@
+export declare function signPluginTarball(tarballPath: string, options?: {
+    stdout?: boolean;
+}): Promise<string>;
+export declare const PluginSignCommand: import("yargs").CommandModule<{}, {
+    tarball: string;
+} & {
+    stdout: boolean;
+} & {
+    "--"?: string[];
+}>;