@ryuhq/sdk 0.0.5 → 0.0.17

package/src/cli.ts

@@ -7,10 +7,10 @@
  *   bunx ryu publish <dir>
  *
  * Commands:
- *   pack <dir>      Validate the plugin.json in <dir> and emit a publish-ready
+ *   pack <dir>      Validate the manifest.json in <dir> and emit a publish-ready
  *                   Plugin bundle at <dir>/dist/plugin.bundle.json.
  *                   Exits 0 on success; exits 1 with the failing field on error.
- *   publish <dir>   Validate the plugin.json and POST it to the Ryu Marketplace
+ *   publish <dir>   Validate the manifest.json and POST it to the Ryu Marketplace
  *                   publish endpoint with the author's auth token. The item is
  *                   stored as `pending` until a moderator approves it.
  */
@@ -38,8 +38,8 @@ function printUsage(): void {
 			"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 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 dev <entry>     Run a Runnable locally with an interactive chat loop",
 			"",
 		].join("\n")
@@ -55,12 +55,24 @@ function exitError(message: string): never {
 
 type LoadedManifest = ReturnType<typeof PluginManifestSchema.parse>;
 
-// Read + parse + validate the plugin.json in `dir`. Exits with the failing
+// Manifest file names, in preference order — mirrors Core's resolver
+// (`plugin_manifest::MANIFEST_FILE_NAMES`). `manifest.json` is canonical; the
+// legacy `plugin.json` / `ryu.json` are still accepted so an author's existing
+// project directory keeps packing without a rename.
+const MANIFEST_FILE_NAMES = [
+	"manifest.json",
+	"plugin.json",
+	"ryu.json",
+] as const;
+
+// Read + parse + validate the manifest in `dir`. Exits with the failing
 // field on any error. Shared by pack and publish so both validate identically.
 function loadManifest(dir: string): LoadedManifest {
-	const manifestPath = join(dir, "plugin.json");
-	if (!existsSync(manifestPath)) {
-		exitError(`plugin.json not found in: ${dir}`);
+	const manifestPath = MANIFEST_FILE_NAMES.map((name) => join(dir, name)).find(
+		(candidate) => existsSync(candidate)
+	);
+	if (!manifestPath) {
+		exitError(`manifest.json not found in: ${dir}`);
 	}
 
 	let raw: string;
@@ -74,7 +86,7 @@ function loadManifest(dir: string): LoadedManifest {
 	try {
 		parsed = JSON.parse(raw);
 	} catch {
-		exitError(`plugin.json is not valid JSON: ${manifestPath}`);
+		exitError(`manifest.json is not valid JSON: ${manifestPath}`);
 	}
 
 	const result = PluginManifestSchema.safeParse(parsed);
@@ -82,9 +94,82 @@ function loadManifest(dir: string): LoadedManifest {
 		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}`);
+		exitError(`manifest.json validation failed at '${field}': ${message}`);
+	}
+	return inlineCodeFiles(result.data, dir);
+}
+
+/** Directories a `code_file` may name — mirrors Rust's `CODE_FILE_DIRS`. */
+const CODE_FILE_DIRS = ["hooks", "adapters"];
+const CODE_FILE_PATH = /^(hooks|adapters)\/[A-Za-z0-9_][A-Za-z0-9._-]*\.m?js$/;
+
+/**
+ * Read one `code_file` and return its contents, or exit with a clear error.
+ *
+ * The path is joined onto the plugin directory, so it is validated against the
+ * same flat allowlist Core enforces (`<hooks|adapters>/<name>.js`, no traversal)
+ * rather than trusted.
+ */
+function readCodeFile(dir: string, rel: string, label: string): string {
+	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);
+	let body: string;
+	try {
+		body = readFileSync(path, "utf8");
+	} catch (err) {
+		exitError(`${label}: could not read code_file '${rel}': ${String(err)}`);
+	}
+	if (!body.trim()) {
+		exitError(`${label}: code_file '${rel}' is empty`);
 	}
-	return result.data;
+	return body;
+}
+
+/**
+ * Replace every `code_file` reference with the file's contents — the source form
+ * becoming the wire form.
+ *
+ * `code_file` exists so a plugin's sandboxed JS lives in real, reviewable `.js`
+ * files instead of a one-line escaped JSON string. But the BUNDLE must stay
+ * self-contained and, for a marketplace plugin, the Gateway signs the manifest
+ * verbatim — so inlining here is what keeps the entire hook/adapter body inside the
+ * signed surface. A published bundle that still carried `code_file` would be a new
+ * unsigned-code carriage channel, which is exactly what this must not become.
+ */
+function inlineCodeFiles(
+	manifest: LoadedManifest,
+	dir: string
+): LoadedManifest {
+	const out = manifest as LoadedManifest & {
+		contributes?: { turn_hooks?: Record<string, unknown>[] };
+		provides?: {
+			tools?: Record<string, { adapter?: Record<string, unknown> }>;
+		}[];
+	};
+
+	for (const hook of out.contributes?.turn_hooks ?? []) {
+		const rel = hook.code_file;
+		if (typeof rel === "string") {
+			hook.code = readCodeFile(dir, rel, `turn hook '${String(hook.id)}'`);
+			hook.code_file = undefined;
+		}
+	}
+
+	for (const entry of out.provides ?? []) {
+		for (const [verb, binding] of Object.entries(entry.tools ?? {})) {
+			const rel = binding.adapter?.code_file;
+			if (binding.adapter && typeof rel === "string") {
+				binding.adapter.code = readCodeFile(dir, rel, `adapter '${verb}'`);
+				binding.adapter.code_file = undefined;
+			}
+		}
+	}
+
+	return out;
 }
 
 // ── pack command ──────────────────────────────────────────────────────────────
@@ -236,10 +321,10 @@ function authToken(): string {
 	return token;
 }
 
-// An SDK-authored Plugin always publishes as a `plugin` (a plugin.json bundle of
+// An SDK-authored Plugin always publishes as a `plugin` (a manifest.json bundle of
 // runnables). It is deliberately NOT published as `skill`: Core's skill install
 // path needs a `descriptor.raw.install_source` (a from-source owner/repo), which
-// a plugin.json manifest does not carry, so a skill-kind publish would be
+// a manifest.json manifest does not carry, so a skill-kind publish would be
 // uninstallable. Model / mcp items are published through their own tools.
 const SDK_PUBLISH_KIND = "plugin" as const;
 

package/src/contracts-lockstep.test.ts

@@ -8,7 +8,7 @@
  * that the SDK's deliberately simpler zod authoring schema, the blessed JSON
  * Schema, and the generated types stay describing the same manifest:
  *
- * 1. a known-good repo manifest (apps-store/mail/ui/plugin.json — the first
+ * 1. a known-good repo manifest (apps-store/mail/manifest.json — the first
  *    fully manifest-driven app) parses with the zod `PluginManifestSchema`;
  * 2. every key the schema marks required exists in the schema, the generated
  *    TS, and the fixture;
@@ -24,7 +24,7 @@ import { PluginManifestSchema } from "./manifest";
 
 const FIXTURE_PATH = join(
 	import.meta.dir,
-	"../../../apps-store/mail/ui/plugin.json"
+	"../../../apps-store/mail/manifest.json"
 );
 const SCHEMA_PATH = join(
 	import.meta.dir,
@@ -44,9 +44,9 @@ const schema = JSON.parse(readFileSync(SCHEMA_PATH, "utf8")) as {
 const generatedSource = readFileSync(GENERATED_PATH, "utf8");
 
 describe("contracts lockstep (zod ↔ blessed JSON Schema ↔ generated TS)", () => {
-	test("the known-good mail plugin.json parses with the zod authoring schema", () => {
+	test("the known-good mail manifest.json parses with the zod authoring schema", () => {
 		const parsed = PluginManifestSchema.parse(fixture);
-		expect(parsed.id).toBe("com.ryu.mail");
+		expect(parsed.id).toBe("@ryu/mail");
 		expect(parsed.runnables.length).toBeGreaterThan(0);
 	});