@ryuhq/sdk 0.1.13 → 0.2.0

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,30 @@ 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
@@ -658,6 +726,11 @@ 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([]),
   /** App widgets (Ryu Apps). Each binds a render tool id to its
@@ -665,6 +738,8 @@ var ContributesSchema = import_zod.z.object({
    *  `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 +752,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 +796,10 @@ 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([])
 });
 var SetupStepSchema = import_zod.z.object({
   /** Card heading (e.g. the companion app name). */
@@ -795,6 +880,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"),
@@ -826,6 +966,8 @@ 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([]),
+  /** Remote or stdio MCP servers registered by this plugin. */
+  mcp_servers: import_zod.z.record(import_zod.z.string(), McpServerDeclSchema).optional(),
   /**
    * Optional Companion surface (an in-desktop overlay or sidebar panel).
    * Absent when the plugin has no Companion surface.
@@ -919,10 +1061,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 +1084,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 +1117,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()
+}).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 +1146,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)",
@@ -999,16 +1167,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);
@@ -1271,8 +1443,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 +1508,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 +1575,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) {

package/dist/cli.js

@@ -1,17 +1,19 @@
 #!/usr/bin/env bun
 import {
   PluginManifestSchema
-} from "./chunk-AO2KJRDD.js";
+} from "./chunk-IEUQ3CDG.js";
 import {
   AGENT_PLUGIN_MANIFEST_FILE,
   AGENT_PLUGIN_MCP_FILE,
   isAgentPluginManifest,
   toAgentPlugin
-} from "./chunk-G6FLVEC4.js";
+} from "./chunk-JX6DDRXV.js";
+import {
+  ModelClient
+} from "./chunk-HACAGK65.js";
 import {
-  ModelClient,
   resolveGatewayUrl
-} from "./chunk-ODFEUVPW.js";
+} from "./chunk-IKEDLLFY.js";
 
 // src/cli.ts
 import { createHash } from "crypto";
@@ -27,9 +29,9 @@ import { join, resolve } from "path";
 // src/cli/dev.ts
 import { createInterface } from "readline";
 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)
     });
@@ -228,7 +230,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)",
@@ -247,16 +251,20 @@ var MANIFEST_FILE_NAMES = [
   "ryu.json"
 ];
 function resolveNativeManifestPath(dir) {
-  return MANIFEST_FILE_NAMES.map((name) => join(dir, name)).find((candidate) => {
-    if (!existsSync(candidate)) {
-      return false;
-    }
-    try {
-      return !isAgentPluginManifest(JSON.parse(readFileSync(candidate, "utf8")));
-    } catch {
-      return true;
+  return MANIFEST_FILE_NAMES.map((name) => join(dir, name)).find(
+    (candidate) => {
+      if (!existsSync(candidate)) {
+        return false;
+      }
+      try {
+        return !isAgentPluginManifest(
+          JSON.parse(readFileSync(candidate, "utf8"))
+        );
+      } catch {
+        return true;
+      }
     }
-  });
+  );
 }
 function loadManifest(dir) {
   const manifestPath = resolveNativeManifestPath(dir);
@@ -519,8 +527,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 } : {},
@@ -576,6 +592,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();
@@ -594,9 +659,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) {

package/dist/client-D5U6ssPc.d.cts

@@ -0,0 +1,84 @@
+/**
+ * Gateway-mandatory model client for the Ryu SDK.
+ *
+ * Rust-cored: this is a thin TypeScript wrapper over the `@ryuhq/sdk-native`
+ * addon's `ModelClient`, which is the `crates/ryu-sdk` Rust core. Every model
+ * call is routed by the Rust core to the Ryu gateway's OpenAI-compatible
+ * `/v1/chat/completions` endpoint; direct-provider base URLs are rejected at
+ * construction. No provider SDK or base URL is ever imported here.
+ *
+ * Usage:
+ *
+ *   const model = defineModel("gpt-4o");
+ *   const reply = await model.chat([{ role: "user", content: "hello" }]);
+ *   for await (const delta of model.stream([{ role: "user", content: "hi" }])) {
+ *     process.stdout.write(delta.content);
+ *   }
+ */
+/** A single message in a chat conversation. */
+interface ChatMessage {
+    /** The message text. */
+    content: string;
+    /** The speaker: "system", "user", or "assistant". */
+    role: "system" | "user" | "assistant";
+}
+/** A streaming chat completion delta. */
+interface ChatDelta {
+    /** Incremental text fragment from the model. */
+    content: string | null;
+    /** Non-null on the final chunk when `finish_reason` is set. */
+    finishReason: string | null;
+}
+/** Non-streaming chat completion result. */
+interface ChatResult {
+    /** The full assistant reply text. */
+    content: string;
+    /** The gateway/model-reported finish reason. */
+    finishReason: string | null;
+    /** Usage stats as reported by the gateway (optional — gateway may omit). */
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+}
+/** Options accepted by `defineModel`. */
+interface ModelClientOptions {
+    /**
+     * Gateway base URL (no trailing `/v1`). Defaults to `RYU_GATEWAY_URL` then
+     * the Rust core's default. Direct provider URLs are rejected at construction.
+     */
+    baseUrl?: string;
+    /**
+     * Bearer token forwarded to the gateway. Defaults to `RYU_GATEWAY_TOKEN`.
+     * This is the gateway token, never a provider API key.
+     */
+    token?: string;
+}
+/**
+ * A gateway-mandatory model client backed by the Rust core.
+ *
+ * All calls go through the native `ModelClient`; if the configured base URL is a
+ * direct provider, construction throws.
+ */
+declare class ModelClient {
+    readonly model: string;
+    readonly baseUrl: string;
+    private readonly native;
+    constructor(model: string, options?: ModelClientOptions);
+    /** Send a non-streaming chat completion request to the gateway. */
+    chat(messages: ChatMessage[]): Promise<ChatResult>;
+    /** Send a streaming chat completion request, yielding deltas as they arrive. */
+    stream(messages: ChatMessage[]): AsyncGenerator<ChatDelta>;
+}
+/**
+ * Create a gateway-mandatory model client for `modelId`.
+ *
+ *   const model = defineModel("gpt-4o");
+ *   const model = defineModel("claude-3-5-sonnet", { baseUrl: "http://my-gateway:7981" });
+ *
+ * A direct provider URL throws immediately (egress enforcement in the Rust core).
+ */
+declare function defineModel(modelId: string, options?: ModelClientOptions): ModelClient;
+
+export { type ChatDelta as C, ModelClient as M, type ChatMessage as a, type ChatResult as b, type ModelClientOptions as c, defineModel as d };