@ryuhq/sdk 0.1.14 → 0.2.2

package/dist/cli.js

@@ -1,17 +1,19 @@
 #!/usr/bin/env bun
-import {
-  PluginManifestSchema
-} from "./chunk-AO2KJRDD.js";
 import {
   AGENT_PLUGIN_MANIFEST_FILE,
   AGENT_PLUGIN_MCP_FILE,
   isAgentPluginManifest,
   toAgentPlugin
-} from "./chunk-G6FLVEC4.js";
+} from "./chunk-JX6DDRXV.js";
+import {
+  PluginManifestSchema
+} from "./chunk-NZKVOSC2.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";
@@ -19,17 +21,19 @@ import {
   existsSync,
   mkdirSync,
   readFileSync,
+  realpathSync,
   rmSync,
-  writeFileSync
+  writeFileSync,
+  writeSync
 } from "fs";
-import { join, resolve } from "path";
+import { isAbsolute, join, relative, resolve, sep } 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 +232,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)",
@@ -237,7 +243,7 @@ function printUsage() {
   );
 }
 function exitError(message) {
-  process.stderr.write(`error: ${message}
+  writeSync(process.stderr.fd, `error: ${message}
 `);
   process.exit(1);
 }
@@ -247,16 +253,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);
@@ -286,13 +296,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 = realpathSync(dir);
+    realTarget = realpathSync(join(dir, rel));
+  } catch (error) {
+    exitError(`${label}: could not resolve '${rel}': ${String(error)}`);
+  }
+  const fromRoot = relative(realRoot, realTarget);
+  if (fromRoot === ".." || fromRoot.startsWith(`..${sep}`) || 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 = join(dir, rel);
+  const path = containedPackageFile(dir, rel, label);
   let body;
   try {
     body = readFileSync(path, "utf8");
@@ -342,7 +369,7 @@ function inlineOutputStyleFiles(manifest, dir) {
     }
     let body;
     try {
-      body = readFileSync(join(dir, rel), "utf8");
+      body = readFileSync(containedPackageFile(dir, rel, label), "utf8");
     } catch (err) {
       exitError(`${label}: could not read file '${rel}': ${String(err)}`);
     }
@@ -388,6 +415,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) {
@@ -519,8 +552,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 +617,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 +684,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 };

package/dist/client-D5U6ssPc.d.ts

@@ -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 };