@ryuhq/sdk 0.0.5

package/dist/cli.d.cts

@@ -0,0 +1 @@
+#!/usr/bin/env bun

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env bun

package/dist/cli.js

@@ -0,0 +1,454 @@
+#!/usr/bin/env bun
+import {
+  PluginManifestSchema
+} from "./chunk-GXHL5CO7.js";
+import {
+  ModelClient,
+  resolveGatewayUrl
+} from "./chunk-ODFEUVPW.js";
+
+// src/cli.ts
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join, resolve } from "path";
+
+// src/cli/dev.ts
+import { createInterface } from "readline";
+var RE_ABSOLUTE_PATH = /^[A-Za-z]:[\\/]/;
+async function probeGateway(baseUrl) {
+  try {
+    await fetch(`${baseUrl}/health`, {
+      method: "HEAD",
+      signal: AbortSignal.timeout(3e3)
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadRunnable(entryPath) {
+  const abs = entryPath.startsWith("/") || RE_ABSOLUTE_PATH.test(entryPath) ? entryPath : `${process.cwd()}/${entryPath}`;
+  const mod = await import(abs);
+  const candidate = mod.default ?? mod.runnable;
+  if (!candidate || typeof candidate.run !== "function") {
+    throw new Error(
+      `[ryu dev] Module at "${entryPath}" must export a Runnable as "default" or "runnable". A Runnable has a "run(messages, model)" generator method.`
+    );
+  }
+  return candidate;
+}
+var ANSI = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  cyan: "\x1B[36m",
+  yellow: "\x1B[33m",
+  green: "\x1B[32m",
+  red: "\x1B[31m",
+  dim: "\x1B[2m"
+};
+function printBanner(runnableName, gatewayUrl) {
+  process.stdout.write(
+    [
+      "",
+      `${ANSI.bold}${ANSI.cyan}ryu dev${ANSI.reset} \u2014 local Runnable playground`,
+      `${ANSI.dim}runnable : ${runnableName}${ANSI.reset}`,
+      `${ANSI.dim}gateway  : ${gatewayUrl}${ANSI.reset}`,
+      `${ANSI.dim}type "/quit" or Ctrl+C to exit${ANSI.reset}`,
+      ""
+    ].join("\n")
+  );
+}
+function printPrompt() {
+  process.stdout.write(`${ANSI.bold}> ${ANSI.reset}`);
+}
+function printAssistantStart() {
+  process.stdout.write(`
+${ANSI.green}assistant:${ANSI.reset} `);
+}
+function printAssistantEnd() {
+  process.stdout.write("\n");
+}
+function printToolCall(event) {
+  process.stdout.write(
+    `
+${ANSI.yellow}tool-call${ANSI.reset} [${event.id}] ${event.title} (${event.kind})`
+  );
+  if (event.input !== null && event.input !== void 0) {
+    process.stdout.write(
+      ` ${ANSI.dim}${JSON.stringify(event.input)}${ANSI.reset}`
+    );
+  }
+  process.stdout.write("\n");
+}
+function statusAnsiColor(status) {
+  if (status === "completed") {
+    return ANSI.green;
+  }
+  if (status === "failed") {
+    return ANSI.red;
+  }
+  return ANSI.dim;
+}
+function printToolResult(event) {
+  const statusColor = statusAnsiColor(event.status);
+  process.stdout.write(
+    `${ANSI.dim}tool-result${ANSI.reset} [${event.id}] ${statusColor}${event.status}${ANSI.reset}`
+  );
+  if (event.output !== null && event.output !== void 0) {
+    process.stdout.write(
+      ` ${ANSI.dim}${JSON.stringify(event.output)}${ANSI.reset}`
+    );
+  }
+  process.stdout.write("\n");
+}
+function printError(message) {
+  process.stderr.write(`
+${ANSI.red}error:${ANSI.reset} ${message}
+`);
+}
+async function runDevLoop(runnable, model) {
+  const history = [];
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: false
+  });
+  const linePromise = () => new Promise((resolve2) => {
+    rl.once("line", resolve2);
+    rl.once("close", () => resolve2(null));
+  });
+  printPrompt();
+  while (true) {
+    const line = await linePromise();
+    if (line === null) {
+      process.stdout.write("\n");
+      break;
+    }
+    const trimmed = line.trim();
+    if (trimmed === "") {
+      printPrompt();
+      continue;
+    }
+    if (trimmed === "/quit" || trimmed === "/exit") {
+      process.stdout.write("bye\n");
+      break;
+    }
+    history.push({ role: "user", content: trimmed });
+    let assistantReply = "";
+    printAssistantStart();
+    const gen = runnable.run([...history], model);
+    for await (const event of gen) {
+      switch (event.type) {
+        case "text": {
+          process.stdout.write(event.content);
+          assistantReply += event.content;
+          break;
+        }
+        case "tool_call": {
+          printToolCall(event);
+          break;
+        }
+        case "tool_result": {
+          printToolResult(event);
+          break;
+        }
+        case "error": {
+          printAssistantEnd();
+          printError(event.message);
+          history.pop();
+          assistantReply = "";
+          break;
+        }
+        default:
+          break;
+      }
+    }
+    printAssistantEnd();
+    if (assistantReply) {
+      history.push({ role: "assistant", content: assistantReply });
+    }
+    printPrompt();
+  }
+  rl.close();
+}
+async function commandDev(entryPath) {
+  const gatewayUrl = resolveGatewayUrl();
+  process.stdout.write(`checking gateway at ${gatewayUrl} ...
+`);
+  const reachable = await probeGateway(gatewayUrl);
+  if (!reachable) {
+    process.stderr.write(
+      [
+        "",
+        `${ANSI.red}error:${ANSI.reset} gateway not reachable at ${gatewayUrl}`,
+        "",
+        "The ryu dev playground requires a running Ryu gateway.",
+        "Start the gateway with: ryu gateway start",
+        "Or set RYU_GATEWAY_URL to point at a remote gateway.",
+        "",
+        "No provider fallback is attempted. Fix the gateway connection and retry.",
+        ""
+      ].join("\n")
+    );
+    process.exit(1);
+  }
+  let runnable;
+  try {
+    runnable = await loadRunnable(entryPath);
+  } catch (err) {
+    process.stderr.write(`error: ${String(err)}
+`);
+    process.exit(1);
+  }
+  const model = new ModelClient("default", { baseUrl: gatewayUrl });
+  printBanner(runnable.name, gatewayUrl);
+  await runDevLoop(runnable, model);
+}
+
+// src/cli.ts
+function uiCodeSha256(code) {
+  return createHash("sha256").update(code, "utf8").digest("hex");
+}
+function printUsage() {
+  process.stderr.write(
+    [
+      "Ryu dev SDK",
+      "",
+      "Usage:",
+      "  bunx ryu pack <dir>      Validate and bundle a plugin.json Plugin",
+      "  bunx ryu publish <dir>   Validate and publish a plugin.json Plugin to the Ryu Marketplace",
+      "  bunx ryu dev <entry>     Run a Runnable locally with an interactive chat loop",
+      ""
+    ].join("\n")
+  );
+}
+function exitError(message) {
+  process.stderr.write(`error: ${message}
+`);
+  process.exit(1);
+}
+function loadManifest(dir) {
+  const manifestPath = join(dir, "plugin.json");
+  if (!existsSync(manifestPath)) {
+    exitError(`plugin.json not found in: ${dir}`);
+  }
+  let raw;
+  try {
+    raw = readFileSync(manifestPath, "utf8");
+  } catch (err) {
+    exitError(`could not read ${manifestPath}: ${String(err)}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    exitError(`plugin.json is not valid JSON: ${manifestPath}`);
+  }
+  const result = PluginManifestSchema.safeParse(parsed);
+  if (!result.success) {
+    const first = result.error.issues[0];
+    const field = first?.path.join(".") ?? "unknown";
+    const message = first?.message ?? "validation failed";
+    exitError(`plugin.json validation failed at '${field}': ${message}`);
+  }
+  return result.data;
+}
+function resolveUiEntry(manifest) {
+  for (const runnable of manifest.runnables) {
+    if (runnable.kind !== "companion") {
+      continue;
+    }
+    const entry = runnable.config?.ui_entry;
+    if (typeof entry === "string" && entry.trim().length > 0) {
+      return entry;
+    }
+  }
+  for (const widget of manifest.contributes?.widgets ?? []) {
+    const entry = widget.ui_entry;
+    if (typeof entry === "string" && entry.trim().length > 0) {
+      return entry;
+    }
+  }
+  return null;
+}
+function resolveUiFormat(manifest) {
+  for (const runnable of manifest.runnables) {
+    if (runnable.kind !== "companion") {
+      continue;
+    }
+    const fmt = runnable.config?.ui_format;
+    if (typeof fmt === "string" && fmt.trim().toLowerCase() === "html") {
+      return "html";
+    }
+  }
+  return "js";
+}
+function readUiEntryHtml(dir, uiEntry) {
+  const entryPath = resolve(dir, uiEntry);
+  if (!existsSync(entryPath)) {
+    exitError(`companion ui_entry (html) not found: ${entryPath}`);
+  }
+  return readFileSync(entryPath, "utf8");
+}
+async function bundleUiEntry(dir, uiEntry) {
+  const entryPath = resolve(dir, uiEntry);
+  if (!existsSync(entryPath)) {
+    exitError(`companion ui_entry not found: ${entryPath}`);
+  }
+  const result = await Bun.build({
+    entrypoints: [entryPath],
+    target: "browser",
+    format: "esm",
+    minify: false
+  });
+  if (!result.success) {
+    const messages = result.logs.map((l) => String(l.message)).join("; ");
+    exitError(`failed to bundle ui_entry '${uiEntry}': ${messages}`);
+  }
+  const output = result.outputs[0];
+  if (!output) {
+    exitError(`bundling ui_entry '${uiEntry}' produced no output`);
+  }
+  return await output.text();
+}
+async function commandPack(rawDir) {
+  const dir = resolve(rawDir);
+  const manifest = loadManifest(dir);
+  const uiEntry = resolveUiEntry(manifest);
+  const uiCode = uiEntry ? resolveUiFormat(manifest) === "html" ? readUiEntryHtml(dir, uiEntry) : await bundleUiEntry(dir, uiEntry) : null;
+  const manifestWithHash = uiCode ? { ...manifest, ui_code_sha256: uiCodeSha256(uiCode) } : manifest;
+  const outDir = join(dir, "dist");
+  if (!existsSync(outDir)) {
+    mkdirSync(outDir, { recursive: true });
+  }
+  const outPath = join(outDir, "plugin.bundle.json");
+  const bundle = uiCode ? { ...manifestWithHash, ui_code: uiCode } : manifestWithHash;
+  writeFileSync(outPath, JSON.stringify(bundle, null, 2), "utf8");
+  const codeNote = uiCode ? ` (+${uiCode.length}B ui_code)` : "";
+  process.stdout.write(
+    `packed ${manifest.id}@${manifest.version}${codeNote} \u2192 ${outPath}
+`
+  );
+}
+var TRAILING_SLASHES = /\/+$/;
+function publishBaseUrl() {
+  const raw = (process.env.RYU_MARKETPLACE_API_URL ?? "").trim();
+  return (raw || "http://localhost:3000").replace(TRAILING_SLASHES, "");
+}
+function authToken() {
+  const token = (process.env.RYU_AUTH_TOKEN ?? "").trim();
+  if (!token) {
+    exitError(
+      "publish requires an auth token: set RYU_AUTH_TOKEN to your Ryu access token"
+    );
+  }
+  return token;
+}
+var SDK_PUBLISH_KIND = "plugin";
+async function commandPublish(rawDir) {
+  const dir = resolve(rawDir);
+  const manifest = loadManifest(dir);
+  const token = authToken();
+  const kind = SDK_PUBLISH_KIND;
+  const uiEntry = resolveUiEntry(manifest);
+  const uiCode = uiEntry ? resolveUiFormat(manifest) === "html" ? readUiEntryHtml(dir, uiEntry) : await bundleUiEntry(dir, uiEntry) : null;
+  const manifestWithHash = uiCode ? { ...manifest, ui_code_sha256: uiCodeSha256(uiCode) } : manifest;
+  const developer = typeof manifest.author === "string" ? manifest.author : manifest.author?.name;
+  const runnablesForDisplay = manifest.runnables.map((r) => ({
+    id: r.id,
+    kind: r.kind,
+    name: r.name,
+    enabled: true
+  }));
+  const listingMetadata = {
+    ...manifest.description ? { description: manifest.description } : {},
+    ...manifest.tagline ? { tagline: manifest.tagline } : {},
+    ...developer ? { developer } : {},
+    ...manifest.category ? { category: manifest.category } : {},
+    ...manifest.iconUrl ? { iconUrl: manifest.iconUrl } : {},
+    ...manifest.screenshots?.length ? { screenshots: manifest.screenshots } : {},
+    ...manifest.homepage ? { website: manifest.homepage } : {},
+    ...manifest.privacyPolicyUrl ? { privacyPolicyUrl: manifest.privacyPolicyUrl } : {},
+    ...manifest.termsOfServiceUrl ? { termsOfServiceUrl: manifest.termsOfServiceUrl } : {},
+    ...manifest.capabilities?.length ? { capabilities: manifest.capabilities } : {},
+    ...manifest.examplePrompts?.length ? { examplePrompts: manifest.examplePrompts } : {},
+    ...manifest.setup ? { setup: manifest.setup } : {},
+    ...runnablesForDisplay.length ? { runnables: runnablesForDisplay } : {}
+  };
+  const url = `${publishBaseUrl()}/api/marketplace/publish`;
+  const body = {
+    id: manifest.id,
+    kind,
+    name: manifest.name,
+    version: manifest.version,
+    manifest: manifestWithHash,
+    // The descriptor is the manifest itself for a plugin/skill Plugin; Core maps
+    // it on install. Grants are read from the manifest server-side too.
+    descriptor: manifestWithHash,
+    grants: manifest.permission_grants ?? [],
+    // Rich listing metadata (Phase 1.5) forwarded flat; see above.
+    ...listingMetadata,
+    // Per-item affiliate terms (optional): the commission a referrer earns when
+    // a referred user buys this paid item. The server re-validates the rule and
+    // stores it as the item's override (else the seller default applies).
+    ...manifest.affiliate?.enabled ? { affiliate: manifest.affiliate } : {},
+    // The bundled UI code rides OUTSIDE the signed manifest as payload; the
+    // server stores it and serves it on detail. Omitted for manifest-only.
+    ...uiCode ? { ui_code: uiCode } : {}
+  };
+  let resp;
+  try {
+    resp = await fetch(url, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${token}`
+      },
+      body: JSON.stringify(body)
+    });
+  } catch (err) {
+    exitError(`could not reach ${url}: ${String(err)}`);
+  }
+  const text = await resp.text();
+  if (!resp.ok) {
+    exitError(`publish failed (${resp.status}): ${text}`);
+  }
+  process.stdout.write(
+    `published ${manifest.id}@${manifest.version} (${kind}) \u2192 pending moderation
+${text}
+`
+  );
+}
+var [, , command, ...args] = process.argv;
+if (!command) {
+  printUsage();
+  process.exit(1);
+}
+if (command === "pack") {
+  const dir = args[0];
+  if (!dir) {
+    exitError("pack requires a directory argument: bunx ryu pack <dir>");
+  }
+  commandPack(dir).catch((err) => {
+    exitError(String(err));
+  });
+} else if (command === "publish") {
+  const dir = args[0];
+  if (!dir) {
+    exitError("publish requires a directory argument: bunx ryu publish <dir>");
+  }
+  commandPublish(dir).catch((err) => {
+    exitError(String(err));
+  });
+} else if (command === "dev") {
+  const entry = args[0];
+  if (!entry) {
+    exitError("dev requires an entry argument: bunx ryu dev <entry>");
+  }
+  commandDev(entry).catch((err) => {
+    exitError(String(err));
+  });
+} else {
+  printUsage();
+  exitError(`unknown command: ${command}`);
+}