@ryuhq/sdk 0.1.14 → 0.2.2

package/dist/cli.cjs

@@ -103,6 +103,21 @@ function toSpecEnv(value) {
   }
   return Object.keys(env).length > 0 ? env : void 0;
 }
+function validateRemoteUrl(name, raw) {
+  let parsed;
+  try {
+    parsed = new URL(raw);
+  } catch {
+    return `mcp server '${name}' remote url ${JSON.stringify(raw)} is invalid and was omitted`;
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    return `mcp server '${name}' remote url must use http or https and was omitted`;
+  }
+  if (parsed.username || parsed.password || parsed.hash) {
+    return `mcp server '${name}' remote url must not contain credentials or a fragment and was omitted`;
+  }
+  return void 0;
+}
 function toSpecServer(name, decl) {
   const extras = {};
   const commandEnv = asString(decl.command_env);
@@ -120,6 +135,37 @@ function toSpecServer(name, decl) {
       note: `mcp server '${name}' is disabled in the native manifest and was omitted from ${AGENT_PLUGIN_MCP_FILE}`
     };
   }
+  const declaredType = asString(decl.type);
+  const remoteUrl = asString(decl.url);
+  const remoteType = declaredType === "sse" ? "sse" : declaredType === "streamable-http" || declaredType === "streamable_http" || declaredType === "http" || !declaredType && remoteUrl ? "streamable-http" : void 0;
+  if (remoteType) {
+    if (!remoteUrl) {
+      return {
+        extras,
+        note: `mcp server '${name}' has remote type '${remoteType}' but no url and was omitted`
+      };
+    }
+    const urlNote = validateRemoteUrl(name, remoteUrl);
+    if (urlNote) {
+      return { extras, note: urlNote };
+    }
+    const server2 = {
+      type: remoteType,
+      url: remoteUrl
+    };
+    const headers = toSpecEnv(decl.headers);
+    if (headers) {
+      server2.headers = headers;
+    }
+    const note = decl.auth ? `mcp server '${name}' uses Ryu OAuth metadata that is not portable; static headers were exported` : void 0;
+    return { server: server2, extras, note };
+  }
+  if (declaredType && declaredType !== "stdio") {
+    return {
+      extras,
+      note: `mcp server '${name}' has unsupported transport '${declaredType}' and was omitted`
+    };
+  }
   const command2 = asString(decl.command);
   if (!command2) {
     return {
@@ -313,9 +359,9 @@ function resolveGatewayUrl3() {
 
 // src/cli/dev.ts
 var RE_ABSOLUTE_PATH = /^[A-Za-z]:[\\/]/;
-async function probeGateway(baseUrl) {
+async function probeGateway(baseUrl, fetchImpl = fetch) {
   try {
-    await fetch(`${baseUrl}/health`, {
+    await fetchImpl(`${baseUrl}/health`, {
       method: "HEAD",
       signal: AbortSignal.timeout(3e3)
     });
@@ -630,8 +676,38 @@ var WidgetContributionSchema = import_zod.z.object({
   /** Default display mode (`inline` | `fullscreen` | `pip`). */
   default_display_mode: import_zod.z.string().default(DEFAULT_WIDGET_DISPLAY_MODE)
 });
+var ChatWidgetTemplateSchema = import_zod.z.object({
+  id: import_zod.z.string().regex(/^[a-z0-9][a-z0-9._:-]*$/),
+  title: import_zod.z.string().min(1),
+  description: import_zod.z.string().optional(),
+  triggers: import_zod.z.array(import_zod.z.string()).default([]),
+  examples: import_zod.z.array(import_zod.z.string()).default([]),
+  backing: import_zod.z.object({
+    tool_id: import_zod.z.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:/-]*$/).optional(),
+    view_id: import_zod.z.string().regex(/^[a-z0-9][a-z0-9._:-]*$/).optional()
+  }),
+  display_mode: import_zod.z.string().min(1),
+  safe_action_ids: import_zod.z.array(import_zod.z.string().regex(/^[a-z0-9][a-z0-9._-]*$/)).default([]),
+  availability: import_zod.z.string().default("available")
+}).superRefine((value, ctx) => {
+  const count = Number(Boolean(value.backing.tool_id)) + Number(Boolean(value.backing.view_id));
+  if (count !== 1 && value.availability === "available") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["backing"],
+      message: "available templates need exactly one backing tool_id or view_id"
+    });
+  }
+  if (count > 1) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["backing"],
+      message: "backing must declare at most one of tool_id or view_id"
+    });
+  }
+});
 var ToolAppConfigSchema = import_zod.z.object({
-  /** MCP tool slug this runnable wraps — the fully-qualified `<server>__<name>` id. */
+  /** MCP tool slug this runnable wraps — the fully-qualified `<server>.<name>` id. */
   slug: import_zod.z.string().min(1),
   /** The tool description the model reads when choosing it. Carried here because a
    *  packed app's manifest is the only channel (there is no `generated.rs`); Core's
@@ -650,6 +726,33 @@ var ToolAppConfigSchema = import_zod.z.object({
   /** Optional status label shown when the render tool finishes. */
   invoked: import_zod.z.string().optional()
 });
+var SlashCommandOptionSchema = import_zod.z.object({
+  description: import_zod.z.string().optional(),
+  label: import_zod.z.string().min(1),
+  value: import_zod.z.string().min(1)
+}).passthrough();
+var SlashCommandCustomOptionSchema = import_zod.z.union([
+  import_zod.z.literal(true),
+  import_zod.z.object({
+    description: import_zod.z.string().optional(),
+    label: import_zod.z.string().min(1).optional()
+  }).passthrough()
+]);
+var SlashCommandArgumentSchema = import_zod.z.object({
+  allow_custom: import_zod.z.boolean().optional(),
+  custom: SlashCommandCustomOptionSchema.optional(),
+  description: import_zod.z.string().optional(),
+  name: import_zod.z.string().min(1),
+  options: import_zod.z.array(SlashCommandOptionSchema).optional()
+}).passthrough();
+var SlashCommandContributionSchema = import_zod.z.object({
+  args: import_zod.z.array(SlashCommandArgumentSchema).optional(),
+  body: import_zod.z.string().optional(),
+  command: import_zod.z.string().min(1),
+  description: import_zod.z.string().optional(),
+  id: import_zod.z.string().optional(),
+  parameters: import_zod.z.array(SlashCommandArgumentSchema).optional()
+}).passthrough();
 var ContributesSchema = import_zod.z.object({
   turn_hooks: import_zod.z.array(TurnHookContributionSchema).default([]),
   /** App events this plugin EMITS — the provider half of the hook system, whose
@@ -658,13 +761,20 @@ var ContributesSchema = import_zod.z.object({
    *  signing, leaving an app that emits events nothing is allowed to subscribe to. */
   hook_events: import_zod.z.array(HookEventContributionSchema).default([]),
   composer_controls: import_zod.z.array(import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())).default([]),
+  /** Chat feature descriptors whose behavior is implemented by the host shell.
+   * Mirrors the Rust-side `Contributes.chat_features`; keeping this field in the
+   * authoring schema prevents `ryu pack` from silently deleting a plugin's chat
+   * feature declaration before signing. */
+  chat_features: import_zod.z.array(import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())).default([]),
   settings_tabs: import_zod.z.array(import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())).default([]),
-  slash_commands: import_zod.z.array(import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())).default([]),
+  slash_commands: import_zod.z.array(SlashCommandContributionSchema).default([]),
   /** App widgets (Ryu Apps). Each binds a render tool id to its
    *  `ui://widget/<slug>.html` template. Mirrors the Rust-side
    *  `Contributes.widgets` field, without which the CLI's zod parse would strip
    *  every widget an app authored here declares. */
   widgets: import_zod.z.array(WidgetContributionSchema).default([]),
+  /** Metadata-only chat widget templates. */
+  chat_widget_templates: import_zod.z.array(ChatWidgetTemplateSchema).optional(),
   /** App-registered sidebar sections (header + live list) and buttons (single nav
    *  rows). Loosely typed here — the shell owns the spec vocabulary — matching how
    *  `composer_controls`/`settings_tabs` are declared. Mirrors the Rust-side
@@ -677,6 +787,13 @@ var ContributesSchema = import_zod.z.object({
    *  Rust-side `Contributes.dock_panels`; without it the CLI's zod parse would
    *  strip the dock panel an app declares here. */
   dock_panels: import_zod.z.array(import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())).default([]),
+  /** App-registered live activities (the desktop "Dynamic Island" cards). Loosely
+   *  typed for the same reason as the surfaces above — the shell owns the
+   *  `spec` vocabulary. Mirrors the Rust-side `Contributes.live_activities`;
+   *  without it the CLI's zod parse would strip every live activity an app
+   *  declares here, so a packed bundle would ship a dock that silently stays
+   *  empty. */
+  live_activities: import_zod.z.array(import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())).default([]),
   /** Deletable data categories the app owns — one "Delete all X" row in Settings
    *  → Danger Zone. Mirrors the Rust-side `Contributes.data_categories`; without
    *  it the CLI's zod parse would strip the declaration before signing, and the
@@ -714,7 +831,13 @@ var ContributesSchema = import_zod.z.object({
    *  bug: the styles' `.md` files are not carried by the bundle either, so there
    *  would be no residue to notice — the plugin would install clean and contribute
    *  nothing. */
-  output_styles: import_zod.z.array(OutputStyleContributionSchema).default([])
+  output_styles: import_zod.z.array(OutputStyleContributionSchema).default([]),
+  /** Per-message actions contributed by an enabled plugin. Kept as loose records
+   *  so renderer-specific `kind`/`args` payloads survive `ryu pack` unchanged. */
+  message_actions: import_zod.z.array(import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())).default([]),
+  /** Buttons contributed to the floating text-selection toolbar. Kept as loose
+   *  records so host-owned dispatch args survive `ryu pack` unchanged. */
+  selection_actions: import_zod.z.array(import_zod.z.record(import_zod.z.string(), import_zod.z.unknown())).default([])
 });
 var SetupStepSchema = import_zod.z.object({
   /** Card heading (e.g. the companion app name). */
@@ -795,6 +918,61 @@ var EnginesReqSchema = import_zod.z.object({
   /** Floor for the Next.js web app. */
   web: import_zod.z.string().optional()
 });
+var McpServerAuthSchema = import_zod.z.object({
+  client_id: import_zod.z.string().min(1).optional(),
+  type: import_zod.z.literal("oauth")
+}).strict();
+var McpServerDeclSchema = import_zod.z.object({
+  args: import_zod.z.array(import_zod.z.string()).default([]),
+  auth: McpServerAuthSchema.optional(),
+  command: import_zod.z.string().optional(),
+  command_env: import_zod.z.string().optional(),
+  description: import_zod.z.string().optional(),
+  enabled: import_zod.z.boolean().default(true),
+  env: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).default({}),
+  headers: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).default({}),
+  type: import_zod.z.enum(["stdio", "http", "streamable-http", "streamable_http", "sse"]).optional(),
+  url: import_zod.z.url().optional()
+}).superRefine((server, context) => {
+  if (!(server.command || server.url)) {
+    context.addIssue({
+      code: "custom",
+      message: "an MCP server requires command or url"
+    });
+  }
+  if (!server.auth) {
+    return;
+  }
+  if (server.command || server.type === "stdio" || !server.url) {
+    context.addIssue({
+      code: "custom",
+      message: "OAuth is supported only for remote HTTP MCP servers"
+    });
+    return;
+  }
+  if (Object.keys(server.headers).some(
+    (name) => name.toLowerCase() === "authorization"
+  )) {
+    context.addIssue({
+      code: "custom",
+      message: "OAuth cannot be combined with a static Authorization header"
+    });
+  }
+  const url = new URL(server.url);
+  const loopback = url.hostname === "localhost" || url.hostname.startsWith("127.") || url.hostname === "[::1]" || url.hostname === "::1";
+  if (url.username || url.password || url.hash) {
+    context.addIssue({
+      code: "custom",
+      message: "OAuth MCP URLs cannot contain credentials or fragments"
+    });
+  }
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && loopback)) {
+    context.addIssue({
+      code: "custom",
+      message: "OAuth MCP URLs must use HTTPS except on loopback"
+    });
+  }
+});
 var PluginManifestSchema = import_zod.z.object({
   /** Reverse-domain unique identifier (e.g. `"com.example.my-plugin"`). */
   id: import_zod.z.string().min(1, "id is required"),
@@ -809,6 +987,9 @@ var PluginManifestSchema = import_zod.z.object({
     /^\d+\.\d+\.\d+(?:-[\w.]+)?(?:\+[\w.]+)?$/,
     "version must be a valid semver string (e.g. 1.0.0)"
   ),
+  /** Core-owned release maturity metadata. The Rust contract validates the
+   *  richer shape; the SDK authoring parser must preserve it for pack/publish. */
+  stability: import_zod.z.unknown().optional(),
   /**
    * Lower-case hex `sha256(utf8_bytes(ui_code))` binding the plugin's bundled
    * sandboxed-UI code to this manifest. `ryu pack` / `ryu publish` compute it and
@@ -826,6 +1007,26 @@ var PluginManifestSchema = import_zod.z.object({
    * Declarations only — grant enforcement is the Gateway's responsibility.
    */
   permission_grants: import_zod.z.array(import_zod.z.string()).default([]),
+  /** Deny-by-default sandbox permissions. Core remains authoritative; this
+   *  schema mirrors the fields so `ryu pack` cannot strip them. */
+  permissions: import_zod.z.object({
+    fs: import_zod.z.object({
+      read: import_zod.z.array(import_zod.z.string()).default([]),
+      write: import_zod.z.array(import_zod.z.string()).default([])
+    }).optional(),
+    child_process: import_zod.z.boolean().optional(),
+    run: import_zod.z.array(import_zod.z.string()).default([]),
+    network: import_zod.z.union([import_zod.z.boolean(), import_zod.z.array(import_zod.z.string())]).optional(),
+    tool: import_zod.z.array(import_zod.z.string()).default([])
+  }).optional(),
+  /** Core-owned permission presentation levels. Preserved verbatim here and
+   *  validated by Core's authoritative manifest contract. */
+  permission_levels: import_zod.z.unknown().optional(),
+  /** Remote or stdio MCP servers registered by this plugin. */
+  mcp_servers: import_zod.z.record(import_zod.z.string(), McpServerDeclSchema).optional(),
+  /** Core-owned sidecar declarations. Their full process/HTTP schema stays in
+   *  the Rust contract; this authoring layer must never strip them. */
+  sidecars: import_zod.z.unknown().optional(),
   /**
    * Optional Companion surface (an in-desktop overlay or sidebar panel).
    * Absent when the plugin has no Companion surface.
@@ -861,6 +1062,9 @@ var PluginManifestSchema = import_zod.z.object({
    * an unsupported-target plugin stays installable and inspectable.
    */
   targets: import_zod.z.array(SurfaceSchema).default([]),
+  /** Rich per-surface declarations (`support`, UI, contributed commands, …).
+   *  Core owns and validates the nested vocabulary. */
+  surfaces: import_zod.z.unknown().optional(),
   /**
    * Host version floors — the semver requirement each surface must satisfy for
    * this plugin to install. Mirrors Core's `EnginesReq`
@@ -919,10 +1123,16 @@ var PluginManifestSchema = import_zod.z.object({
       url: import_zod.z.string().optional()
     })
   ]).optional(),
+  /** Public source repository URL (Claude/Codex `repository`). */
+  repository: import_zod.z.string().url().optional(),
+  /** True when the provider operates outside the local Ryu runtime. */
+  external: import_zod.z.boolean().optional(),
   /** Project/marketing homepage — maps to the listing `website` (Claude field). */
   homepage: import_zod.z.string().optional(),
   /** Free-text search keywords (Claude field). */
   keywords: import_zod.z.array(import_zod.z.string()).optional(),
+  /** Stable Marketplace filter labels (Ryu extension). */
+  tags: import_zod.z.array(import_zod.z.string()).optional(),
   /** Taxonomy category beyond the runnable kinds (Claude field). */
   category: import_zod.z.string().optional(),
   /** SPDX-ish license identifier (Claude field). */
@@ -936,6 +1146,8 @@ var PluginManifestSchema = import_zod.z.object({
    * from `iconUrl` (a raster logo). Falls back to `iconUrl` when omitted.
    */
   icon: import_zod.z.string().optional(),
+  /** Optional detail-page hero banner metadata forwarded to the marketplace. */
+  banner: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
   /**
    * Dithered-gradient background for the card's icon square (Ryu extension),
    * mirroring dither-kit's `DitherGradient` props. `from`/`to` are a palette-colour
@@ -967,6 +1179,22 @@ var PluginManifestSchema = import_zod.z.object({
    * array of steps guiding the user through post-install configuration.
    */
   setup: import_zod.z.union([SetupStepSchema, import_zod.z.array(SetupStepSchema)]).optional()
+}).passthrough().superRefine((manifest, context) => {
+  const hasOAuthServer = Object.values(manifest.mcp_servers ?? {}).some(
+    (server) => server.auth?.type === "oauth"
+  );
+  if (!hasOAuthServer) {
+    return;
+  }
+  for (const grant of ["mcp:server", "identity.read"]) {
+    if (!manifest.permission_grants.includes(grant)) {
+      context.addIssue({
+        code: "custom",
+        message: `OAuth MCP servers require the ${grant} permission grant`,
+        path: ["permission_grants"]
+      });
+    }
+  }
 });
 
 // src/cli.ts
@@ -980,7 +1208,9 @@ function printUsage() {
       "",
       "Usage:",
       "  bunx ryu pack <dir>      Validate and bundle a manifest.json Plugin",
-      "  bunx ryu publish <dir>   Validate and publish a manifest.json Plugin to the Ryu Marketplace",
+      "  bunx ryu github-publish <url>",
+      "                           Submit a GitHub repository/package URL to the Marketplace",
+      "  bunx ryu publish <dir>   Deprecated server-artifact publishing (migration only)",
       "  bunx ryu dev <entry>     Run a Runnable locally with an interactive chat loop",
       "  bunx ryu agent-plugin <dir>",
       "                           Emit the Agent Plugins v1 interop pair (plugin.json + mcp.json)",
@@ -989,7 +1219,7 @@ function printUsage() {
   );
 }
 function exitError(message) {
-  process.stderr.write(`error: ${message}
+  (0, import_node_fs.writeSync)(process.stderr.fd, `error: ${message}
 `);
   process.exit(1);
 }
@@ -999,16 +1229,20 @@ var MANIFEST_FILE_NAMES = [
   "ryu.json"
 ];
 function resolveNativeManifestPath(dir) {
-  return MANIFEST_FILE_NAMES.map((name) => (0, import_node_path.join)(dir, name)).find((candidate) => {
-    if (!(0, import_node_fs.existsSync)(candidate)) {
-      return false;
-    }
-    try {
-      return !isAgentPluginManifest(JSON.parse((0, import_node_fs.readFileSync)(candidate, "utf8")));
-    } catch {
-      return true;
+  return MANIFEST_FILE_NAMES.map((name) => (0, import_node_path.join)(dir, name)).find(
+    (candidate) => {
+      if (!(0, import_node_fs.existsSync)(candidate)) {
+        return false;
+      }
+      try {
+        return !isAgentPluginManifest(
+          JSON.parse((0, import_node_fs.readFileSync)(candidate, "utf8"))
+        );
+      } catch {
+        return true;
+      }
     }
-  });
+  );
 }
 function loadManifest(dir) {
   const manifestPath = resolveNativeManifestPath(dir);
@@ -1038,13 +1272,30 @@ function loadManifest(dir) {
 }
 var CODE_FILE_DIRS = ["hooks", "adapters"];
 var CODE_FILE_PATH = /^(hooks|adapters)\/[A-Za-z0-9_][A-Za-z0-9._-]*\.m?js$/;
+function containedPackageFile(dir, rel, label) {
+  let realRoot;
+  let realTarget;
+  try {
+    realRoot = (0, import_node_fs.realpathSync)(dir);
+    realTarget = (0, import_node_fs.realpathSync)((0, import_node_path.join)(dir, rel));
+  } catch (error) {
+    exitError(`${label}: could not resolve '${rel}': ${String(error)}`);
+  }
+  const fromRoot = (0, import_node_path.relative)(realRoot, realTarget);
+  if (fromRoot === ".." || fromRoot.startsWith(`..${import_node_path.sep}`) || (0, import_node_path.isAbsolute)(fromRoot)) {
+    exitError(
+      `${label}: '${rel}' resolves outside the plugin package (${realTarget})`
+    );
+  }
+  return realTarget;
+}
 function readCodeFile(dir, rel, label) {
   if (!CODE_FILE_PATH.test(rel)) {
     exitError(
       `${label}: code_file '${rel}' must be exactly '<${CODE_FILE_DIRS.join("|")}>/<name>.js' with no traversal`
     );
   }
-  const path = (0, import_node_path.join)(dir, rel);
+  const path = containedPackageFile(dir, rel, label);
   let body;
   try {
     body = (0, import_node_fs.readFileSync)(path, "utf8");
@@ -1094,7 +1345,7 @@ function inlineOutputStyleFiles(manifest, dir) {
     }
     let body;
     try {
-      body = (0, import_node_fs.readFileSync)((0, import_node_path.join)(dir, rel), "utf8");
+      body = (0, import_node_fs.readFileSync)(containedPackageFile(dir, rel, label), "utf8");
     } catch (err) {
       exitError(`${label}: could not read file '${rel}': ${String(err)}`);
     }
@@ -1140,6 +1391,12 @@ function resolveUiFormat(manifest) {
       return "html";
     }
   }
+  for (const widget of manifest.contributes?.widgets ?? []) {
+    const entry = widget.ui_entry;
+    if (typeof entry === "string" && entry.trim().toLowerCase().endsWith(".html")) {
+      return "html";
+    }
+  }
   return "js";
 }
 function readUiEntryHtml(dir, uiEntry) {
@@ -1271,8 +1528,16 @@ async function commandPublish(rawDir) {
     ...manifest.description ? { description: manifest.description } : {},
     ...manifest.tagline ? { tagline: manifest.tagline } : {},
     ...developer ? { developer } : {},
+    ...manifest.author ? { author: manifest.author } : {},
+    ...manifest.repository ? { repository: manifest.repository } : {},
+    ...manifest.external ? { external: true } : {},
     ...manifest.category ? { category: manifest.category } : {},
+    ...manifest.license ? { license: manifest.license } : {},
+    ...manifest.keywords?.length ? { keywords: manifest.keywords } : {},
     ...manifest.iconUrl ? { iconUrl: manifest.iconUrl } : {},
+    ...manifest.icon ? { icon: manifest.icon } : {},
+    ...manifest.iconDither ? { iconDither: manifest.iconDither } : {},
+    ...manifest.banner ? { banner: manifest.banner } : {},
     ...manifest.screenshots?.length ? { screenshots: manifest.screenshots } : {},
     ...manifest.homepage ? { website: manifest.homepage } : {},
     ...manifest.privacyPolicyUrl ? { privacyPolicyUrl: manifest.privacyPolicyUrl } : {},
@@ -1328,6 +1593,55 @@ ${text}
 `
   );
 }
+async function commandGithubPublish(repositoryUrl) {
+  const input = repositoryUrl.trim();
+  if (!input) {
+    exitError(
+      "github-publish requires a GitHub repository or package URL, for example https://github.com/acme/my-app"
+    );
+  }
+  const token = authToken();
+  const url = `${publishBaseUrl()}/api/marketplace/github/publish`;
+  const proof = process.env.RYU_GITHUB_INSTALLATION_PROOF?.trim();
+  const body = {
+    url: input,
+    ...proof ? { installationProof: proof } : {}
+  };
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "POST",
+      headers: {
+        authorization: `Bearer ${token}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+  } catch (error) {
+    exitError(`could not reach ${url}: ${String(error)}`);
+  }
+  const text = await response.text();
+  if (!response.ok) {
+    try {
+      const error = JSON.parse(text);
+      if (error.installationUrl) {
+        exitError(
+          `${error.error ?? "GitHub App installation required"}. Open ${error.installationUrl}, then set RYU_GITHUB_INSTALLATION_PROOF to the callback proof and retry.`
+        );
+      }
+      exitError(
+        `github-publish failed (${response.status}): ${error.error ?? text}`
+      );
+    } catch {
+      exitError(`github-publish failed (${response.status}): ${text}`);
+    }
+  }
+  process.stdout.write(
+    `GitHub-backed listing submitted for moderation:
+${text}
+`
+  );
+}
 var [, , command, ...args] = process.argv;
 if (!command) {
   printUsage();
@@ -1346,9 +1660,24 @@ if (command === "pack") {
   if (!dir) {
     exitError("publish requires a directory argument: bunx ryu publish <dir>");
   }
+  if (process.env.RYU_ENABLE_LEGACY_MARKETPLACE_WRITES !== "true") {
+    exitError(
+      "ryu publish is deprecated because marketplace package contents now live in GitHub Releases; use bunx ryu github-publish <repository-or-package-url>"
+    );
+  }
   commandPublish(dir).catch((err) => {
     exitError(String(err));
   });
+} else if (command === "github-publish") {
+  const repositoryUrl = args[0];
+  if (!repositoryUrl) {
+    exitError(
+      "github-publish requires a GitHub repository or package URL, for example https://github.com/acme/my-app"
+    );
+  }
+  commandGithubPublish(repositoryUrl).catch((err) => {
+    exitError(String(err));
+  });
 } else if (command === "agent-plugin") {
   const dir = args[0];
   if (!dir) {