@openvcs/sdk 0.4.0 → 0.4.1-beta.128

package/test/build.test.js

@@ -4,14 +4,32 @@ const path = require("node:path");
 const test = require("node:test");
 
 const {
+  authoredPluginModulePath,
   buildPluginAssets,
+  generateModuleBootstrap,
+  hasPackageJson,
   parseBuildArgs,
   readManifest,
+  runCommand,
   validateDeclaredModuleExec,
   validateGeneratedBootstrapTargets,
 } = require("../lib/build");
 const { cleanupTempDir, makeTempDir, writeJson, writeText } = require("./helpers");
 
+function captureStderr(fn) {
+  const chunks = [];
+  const originalWrite = process.stderr.write;
+  process.stderr.write = (chunk) => {
+    chunks.push(String(chunk));
+    return true;
+  };
+  try {
+    return { result: fn(), stderr: chunks.join("") };
+  } finally {
+    process.stderr.write = originalWrite;
+  }
+}
+
 test("renderGeneratedBootstrap creates ESM code", () => {
   const output = require("../lib/build").renderGeneratedBootstrap("./plugin.js", true);
   assert.match(output, /^#!/);
@@ -48,6 +66,10 @@ test("parseBuildArgs help returns usage error", () => {
   assert.throws(() => parseBuildArgs(["--help"]), /openvcs build \[args\]/);
 });
 
+test("parseBuildArgs rejects unknown flags", () => {
+  assert.throws(() => parseBuildArgs(["--wat"]), /unknown flag: --wat/);
+});
+
 test("buildPluginAssets no-ops for theme-only plugins", () => {
   const root = makeTempDir("openvcs-sdk-test");
   const pluginDir = path.join(root, "plugin");
@@ -56,9 +78,11 @@ test("buildPluginAssets no-ops for theme-only plugins", () => {
     name: "theme-only",
     openvcs: { id: "theme-only" },
   });
-  const manifest = buildPluginAssets({ pluginDir, verbose: false });
+  const { result: manifest, stderr } = captureStderr(() => buildPluginAssets({ pluginDir, verbose: false }));
 
   assert.equal(manifest.pluginId, "theme-only");
+  assert.match(stderr, /openvcs build: reading plugin manifest/);
+  assert.match(stderr, /openvcs build: theme-only plugin theme-only; nothing to build/);
   cleanupTempDir(root);
 });
 
@@ -102,7 +126,7 @@ test("buildPluginAssets runs build:plugin and validates output", () => {
     "const fs = require('node:fs');\nconst path = require('node:path');\nconst out = path.join(process.cwd(), 'bin', 'plugin.js');\nfs.mkdirSync(path.dirname(out), { recursive: true });\nfs.writeFileSync(out, 'export {};\\n', 'utf8');\n"
   );
 
-  const manifest = buildPluginAssets({ pluginDir, verbose: false });
+  const { result: manifest, stderr } = captureStderr(() => buildPluginAssets({ pluginDir, verbose: false }));
 
   assert.equal(manifest.pluginId, "builder");
   assert.equal(fs.existsSync(path.join(pluginDir, "bin", "plugin.js")), true);
@@ -111,6 +135,42 @@ test("buildPluginAssets runs build:plugin and validates output", () => {
     fs.readFileSync(path.join(pluginDir, "bin", "openvcs-plugin.js"), "utf8"),
     /bootstrapPluginModule/
   );
+  assert.match(stderr, /openvcs build: reading plugin manifest/);
+  assert.match(stderr, /openvcs build: running build:plugin/);
+  assert.match(stderr, /openvcs build: generating bootstrap openvcs-plugin.js/);
+  assert.match(stderr, /openvcs build: validating bootstrap openvcs-plugin.js/);
+  assert.match(stderr, /openvcs build: build complete for builder/);
+  cleanupTempDir(root);
+});
+
+test("buildPluginAssets verbose mode adds detailed progress output", () => {
+  const root = makeTempDir("openvcs-sdk-test");
+  const pluginDir = path.join(root, "plugin");
+
+  writeJson(path.join(pluginDir, "package.json"), {
+    name: "verbose-builder",
+    private: true,
+    type: "module",
+    openvcs: {
+      id: "verbose-builder",
+      module: { exec: "openvcs-plugin.mjs" },
+    },
+    scripts: {
+      "build:plugin": "node ./scripts/build-plugin.cjs",
+    },
+  });
+  writeText(
+    path.join(pluginDir, "scripts", "build-plugin.cjs"),
+    "const fs = require('node:fs');\nconst path = require('node:path');\nconst out = path.join(process.cwd(), 'bin', 'plugin.js');\nfs.mkdirSync(path.dirname(out), { recursive: true });\nfs.writeFileSync(out, 'export {};\\n', 'utf8');\n"
+  );
+
+  const { result: manifest, stderr } = captureStderr(() => buildPluginAssets({ pluginDir, verbose: true }));
+
+  assert.equal(manifest.pluginId, "verbose-builder");
+  assert.match(stderr, /openvcs build: reading manifest at .*package\.json/);
+  assert.match(stderr, /openvcs build: manifest loaded for verbose-builder \(module\.exec: openvcs-plugin\.mjs\)/);
+  assert.match(stderr, /Running command in .*: .* run build:plugin/);
+  assert.match(stderr, /openvcs build: writing bootstrap .*openvcs-plugin\.mjs -> .*plugin\.js \(esm\)/);
   cleanupTempDir(root);
 });
 
@@ -136,6 +196,73 @@ test("readManifest and validateDeclaredModuleExec stay reusable", () => {
   cleanupTempDir(root);
 });
 
+test("readManifest reports missing and invalid package manifests", () => {
+  const root = makeTempDir("openvcs-sdk-test");
+  const missingDir = path.join(root, "missing");
+  fs.mkdirSync(missingDir, { recursive: true });
+  assert.throws(() => readManifest(missingDir), /missing package\.json/);
+
+  const invalidDir = path.join(root, "invalid");
+  writeText(path.join(invalidDir, "package.json"), "{");
+  assert.throws(() => readManifest(invalidDir), /parse .*package\.json/);
+
+  const noOpenVcs = path.join(root, "no-openvcs");
+  writeJson(path.join(noOpenVcs, "package.json"), { name: "x" });
+  assert.throws(() => readManifest(noOpenVcs), /missing an 'openvcs' object/);
+
+  const badId = path.join(root, "bad-id");
+  writeJson(path.join(badId, "package.json"), { openvcs: { id: "bad/id" } });
+  assert.throws(() => readManifest(badId), /must not contain path separators/);
+
+  const missingId = path.join(root, "missing-id");
+  writeJson(path.join(missingId, "package.json"), { openvcs: {} });
+  assert.throws(() => readManifest(missingId), /missing openvcs\.id/);
+
+  cleanupTempDir(root);
+});
+
+test("validateDeclaredModuleExec rejects invalid module paths", () => {
+  const root = makeTempDir("openvcs-sdk-test");
+  const pluginDir = path.join(root, "plugin");
+  fs.mkdirSync(path.join(pluginDir, "bin"), { recursive: true });
+
+  assert.doesNotThrow(() => validateDeclaredModuleExec(pluginDir, undefined));
+  assert.throws(() => validateDeclaredModuleExec(pluginDir, "native.node"), /must end with/);
+  assert.throws(() => validateDeclaredModuleExec(pluginDir, path.join(pluginDir, "bin", "x.js")), /must be a relative path/);
+  assert.throws(() => validateDeclaredModuleExec(pluginDir, "../escape.js"), /must point to a file under bin/);
+  assert.throws(() => validateDeclaredModuleExec(pluginDir, "missing.js"), /module entrypoint not found/);
+
+  cleanupTempDir(root);
+});
+
+test("renderGeneratedBootstrap rejects unsafe import paths", () => {
+  assert.throws(() => require("../lib/build").renderGeneratedBootstrap("./bad path.js", true), /unsafe module import path/);
+});
+
+test("build helpers handle no-op and package existence paths", () => {
+  const root = makeTempDir("openvcs-sdk-test");
+  const pluginDir = path.join(root, "plugin");
+  fs.mkdirSync(pluginDir, { recursive: true });
+
+  assert.equal(hasPackageJson(pluginDir), false);
+  writeJson(path.join(pluginDir, "package.json"), { openvcs: { id: "x" } });
+  assert.equal(hasPackageJson(pluginDir), true);
+  assert.equal(authoredPluginModulePath(pluginDir), path.join(pluginDir, "bin", "plugin.js"));
+  assert.doesNotThrow(() => generateModuleBootstrap(pluginDir, undefined));
+
+  cleanupTempDir(root);
+});
+
+test("runCommand reports spawn failures and non-zero exits", () => {
+  const root = makeTempDir("openvcs-sdk-test");
+
+  assert.doesNotThrow(() => runCommand(process.execPath, ["-e", "process.exit(0)"], root, true));
+  assert.throws(() => runCommand(process.execPath, ["-e", "process.exit(7)"], root, false), /exit code 7/);
+  assert.throws(() => runCommand(path.join(root, "missing-binary"), [], root, false), /failed to spawn/);
+
+  cleanupTempDir(root);
+});
+
 test("validateGeneratedBootstrapTargets rejects module.exec collisions", () => {
   const root = makeTempDir("openvcs-sdk-test");
   const pluginDir = path.join(root, "plugin");
@@ -168,6 +295,30 @@ test("validateGeneratedBootstrapTargets rejects case-insensitive collisions", ()
   cleanupTempDir(root);
 });
 
+test("validateGeneratedBootstrapTargets no-ops without module exec and rejects missing compiled module", () => {
+  const root = makeTempDir("openvcs-sdk-test");
+  const pluginDir = path.join(root, "plugin");
+  fs.mkdirSync(path.join(pluginDir, "bin"), { recursive: true });
+
+  assert.doesNotThrow(() => validateGeneratedBootstrapTargets(pluginDir, undefined));
+  assert.throws(() => validateGeneratedBootstrapTargets(pluginDir, "openvcs-plugin.js"), /compiled plugin module not found/);
+
+  cleanupTempDir(root);
+});
+
+test("generateModuleBootstrap tolerates invalid package json and uses extension for ESM", () => {
+  const root = makeTempDir("openvcs-sdk-test");
+  const pluginDir = path.join(root, "plugin");
+  writeText(path.join(pluginDir, "package.json"), "{");
+  writeText(path.join(pluginDir, "bin", "plugin.js"), "export {};\n");
+  writeText(path.join(pluginDir, "bin", "bootstrap.mjs"), "");
+
+  generateModuleBootstrap(pluginDir, "bootstrap.mjs");
+
+  assert.match(fs.readFileSync(path.join(pluginDir, "bin", "bootstrap.mjs"), "utf8"), /^import/m);
+  cleanupTempDir(root);
+});
+
 test("generateModuleBootstrap handles subdirectory module.exec paths", () => {
   const root = makeTempDir("openvcs-sdk-test");
   const pluginDir = path.join(root, "plugin");

package/test/cli-direct.test.js

@@ -0,0 +1,57 @@
+const assert = require("node:assert/strict");
+const test = require("node:test");
+
+const { runCli } = require("../lib/cli");
+
+async function captureCli(args) {
+  const stdout = [];
+  const stderr = [];
+  const originalStdoutWrite = process.stdout.write;
+  const originalStderrWrite = process.stderr.write;
+  const originalExitCode = process.exitCode;
+  process.exitCode = undefined;
+  process.stdout.write = (chunk) => { stdout.push(String(chunk)); return true; };
+  process.stderr.write = (chunk) => { stderr.push(String(chunk)); return true; };
+  try {
+    await runCli(args);
+    return { stdout: stdout.join(""), stderr: stderr.join(""), exitCode: process.exitCode };
+  } finally {
+    process.stdout.write = originalStdoutWrite;
+    process.stderr.write = originalStderrWrite;
+    process.exitCode = originalExitCode;
+  }
+}
+
+test("runCli writes usage to stderr for empty args", async () => {
+  const result = await captureCli([]);
+
+  assert.match(result.stderr, /Usage: openvcs/);
+  assert.equal(result.exitCode, 1);
+});
+
+test("runCli writes root help to stdout", async () => {
+  const result = await captureCli(["help"]);
+
+  assert.match(result.stdout, /Commands:/);
+  assert.equal(result.exitCode, undefined);
+});
+
+test("runCli passes through build parser errors", async () => {
+  await assert.rejects(() => runCli(["build", "--plugin-dir"]), /missing value for --plugin-dir/);
+});
+
+test("runCli rejects invalid init arguments", async () => {
+  await assert.rejects(() => runCli(["init", "--bad"]), /unknown argument for init/);
+});
+
+test("runCli direct help branches write subcommand usage", async () => {
+  const buildHelp = await captureCli(["build", "--help"]);
+  const initHelp = await captureCli(["init", "--help"]);
+
+  assert.match(buildHelp.stdout, /openvcs build \[args\]/);
+  assert.match(initHelp.stdout, /Usage: openvcs init/);
+});
+
+test("runCli direct unknown command branch rejects", async () => {
+  await assert.rejects(() => runCli(["wat"]), /unknown command: wat/);
+});

package/test/dispatcher.test.js

@@ -0,0 +1,104 @@
+const assert = require("node:assert/strict");
+const test = require("node:test");
+
+const { createDefaultPluginDelegates, createHost, createRuntimeDispatcher, isPluginFailure, pluginError } = require("../lib/runtime");
+const { PROTOCOL_VERSION } = require("../lib/types");
+
+function writer() {
+  const messages = [];
+  return {
+    messages,
+    sendResult(id, result) {
+      messages.push({ id, result });
+    },
+    sendError(id, code, message, data) {
+      messages.push({ id, error: { code, message, data } });
+    },
+  };
+}
+
+test("default plugin delegates return protocol-safe defaults", async () => {
+  const delegates = createDefaultPluginDelegates();
+
+  assert.equal(await delegates["plugin.init"]({}, {}), null);
+  assert.equal(await delegates["plugin.deinit"]({}, {}), null);
+  assert.deepEqual(await delegates["plugin.get_menus"]({}, {}), []);
+  assert.equal(await delegates["plugin.handle_action"]({}, {}), null);
+  assert.deepEqual(await delegates["plugin.settings.defaults"]({}, {}), []);
+  assert.deepEqual(await delegates["plugin.settings.on_load"]({ values: [1] }, {}), [1]);
+  assert.deepEqual(await delegates["plugin.settings.on_load"]({}, {}), []);
+  assert.equal(await delegates["plugin.settings.on_apply"]({}, {}), null);
+  assert.deepEqual(await delegates["plugin.settings.on_save"]({ values: [2] }, {}), [2]);
+  assert.deepEqual(await delegates["plugin.settings.on_save"]({}, {}), []);
+  assert.equal(await delegates["plugin.settings.on_reset"]({}, {}), null);
+});
+
+test("dispatcher rejects protocol version mismatch", async () => {
+  const out = writer();
+  const dispatcher = createRuntimeDispatcher({}, createHost(() => {}), out);
+
+  await dispatcher(1, "plugin.initialize", { expected_protocol_version: PROTOCOL_VERSION + 1 });
+
+  assert.equal(out.messages[0].id, 1);
+  assert.equal(out.messages[0].error.data.code, "protocol-version-mismatch");
+});
+
+test("dispatcher merges initialize override with inferred implements", async () => {
+  const out = writer();
+  const dispatcher = createRuntimeDispatcher(
+    {
+      implements: { plugin: { menus: true } },
+      vcs: { "vcs.status": async () => ({ files: [] }) },
+      plugin: {
+        "plugin.initialize": async () => ({ implements: { custom: true } }),
+      },
+    },
+    createHost(() => {}),
+    out,
+  );
+
+  await dispatcher("init", "plugin.initialize", { expected_protocol_version: PROTOCOL_VERSION });
+
+  assert.equal(out.messages[0].result.protocol_version, PROTOCOL_VERSION);
+  assert.equal(out.messages[0].result.implements.custom, true);
+  assert.equal(out.messages[0].result.implements.vcs, true);
+});
+
+test("dispatcher reports plugin failures separately from generic failures", async () => {
+  const pluginOut = writer();
+  await createRuntimeDispatcher(
+    { plugin: { "plugin.init": async () => { throw pluginError("bad-input", "Bad input", { field: "x" }); } } },
+    createHost(() => {}),
+    pluginOut,
+  )(2, "plugin.init", {});
+
+  const genericOut = writer();
+  await createRuntimeDispatcher(
+    { plugin: { "plugin.init": async () => { throw new Error("Boom"); } } },
+    createHost(() => {}),
+    genericOut,
+  )(3, "plugin.init", {});
+
+  assert.equal(pluginOut.messages[0].error.data.code, "bad-input");
+  assert.equal(genericOut.messages[0].error.data.code, "plugin-internal-error");
+});
+
+test("isPluginFailure rejects non-objects", () => {
+  assert.equal(isPluginFailure(null), false);
+  assert.equal(isPluginFailure("bad"), false);
+  assert.equal(isPluginFailure({ code: "x", message: "y" }), false);
+});
+
+test("dispatcher times out slow handlers", async () => {
+  const out = writer();
+  const dispatcher = createRuntimeDispatcher(
+    { timeout: 1, plugin: { "plugin.init": async () => new Promise(() => {}) } },
+    createHost(() => {}),
+    out,
+  );
+
+  await dispatcher(4, "plugin.init", {});
+
+  assert.equal(out.messages[0].error.data.code, "request-timeout");
+  assert.match(out.messages[0].error.message, /timed out/);
+});

package/test/fs-utils.test.js

@@ -55,6 +55,20 @@ test("copyFileStrict rejects non-files", () => {
   cleanupTempDir(root);
 });
 
+test("copyFileStrict rejects file symlinks", () => {
+  if (process.platform === "win32") {
+    return;
+  }
+  const root = makeTempDir("openvcs-sdk-test");
+  const target = path.join(root, "target.txt");
+  const link = path.join(root, "link.txt");
+  writeText(target, "target");
+  fs.symlinkSync(target, link);
+
+  assert.throws(() => copyFileStrict(link, path.join(root, "out.txt")), /symlink/);
+  cleanupTempDir(root);
+});
+
 test("copyDirectoryRecursiveStrict copies nested trees", () => {
   const root = makeTempDir("openvcs-sdk-test");
   const src = path.join(root, "src");
@@ -87,6 +101,49 @@ test("copyDirectoryRecursiveStrict errors when source is file", () => {
   cleanupTempDir(root);
 });
 
+test("copyDirectoryRecursiveStrict rejects source directory symlink", () => {
+  if (process.platform === "win32") {
+    return;
+  }
+  const root = makeTempDir("openvcs-sdk-test");
+  const targetDir = path.join(root, "target");
+  const link = path.join(root, "link");
+  fs.mkdirSync(targetDir, { recursive: true });
+  fs.symlinkSync(targetDir, link);
+
+  assert.throws(() => copyDirectoryRecursiveStrict(link, path.join(root, "dst")), /symlink/);
+  cleanupTempDir(root);
+});
+
+test("copyDirectoryRecursiveStrict skips special non-file entries", () => {
+  const root = makeTempDir("openvcs-sdk-test");
+  const src = path.join(root, "src");
+  const dst = path.join(root, "dst");
+  fs.mkdirSync(path.join(src, "fifo-like"), { recursive: true });
+  writeText(path.join(src, "file.txt"), "ok");
+
+  copyDirectoryRecursiveStrict(src, dst);
+
+  assert.equal(fs.readFileSync(path.join(dst, "file.txt"), "utf8"), "ok");
+  cleanupTempDir(root);
+});
+
+test("copyDirectoryRecursiveStrict rejects symlink entries inside trees", () => {
+  if (process.platform === "win32") {
+    return;
+  }
+  const root = makeTempDir("openvcs-sdk-test");
+  const src = path.join(root, "src");
+  const dst = path.join(root, "dst");
+  const target = path.join(root, "target.txt");
+  writeText(target, "target");
+  fs.mkdirSync(src, { recursive: true });
+  fs.symlinkSync(target, path.join(src, "linked.txt"));
+
+  assert.throws(() => copyDirectoryRecursiveStrict(src, dst), /symlink/);
+  cleanupTempDir(root);
+});
+
 test("rejectSymlinksRecursive allows regular trees", () => {
   const root = makeTempDir("openvcs-sdk-test");
   writeText(path.join(root, "a.txt"), "a");

package/test/host.test.js

@@ -0,0 +1,39 @@
+const assert = require("node:assert/strict");
+const test = require("node:test");
+
+const { createHost } = require("../lib/runtime");
+
+test("createHost maps log helpers to host.log notifications", () => {
+  const sent = [];
+  const host = createHost((method, params) => sent.push({ method, params }), { logTarget: "test.plugin" });
+
+  host.log("warn", "careful");
+  host.info("ready");
+  host.error("failed");
+
+  assert.deepEqual(sent, [
+    { method: "host.log", params: { level: "warn", target: "test.plugin", message: "careful" } },
+    { method: "host.log", params: { level: "info", target: "test.plugin", message: "ready" } },
+    { method: "host.log", params: { level: "error", target: "test.plugin", message: "failed" } },
+  ]);
+});
+
+test("createHost maps UI/status/event helpers to protocol notifications", () => {
+  const sent = [];
+  const host = createHost((method, params) => sent.push({ method, params }));
+
+  host.uiNotify({ level: "info", message: "Saved" });
+  host.statusSet({ message: "Working" });
+  host.emitEvent({ name: "custom", payload: { value: 1 } });
+  host.emitVcsEvent("session-1", 42, { type: "progress", message: "Fetch" });
+
+  assert.deepEqual(sent, [
+    { method: "host.ui_notify", params: { level: "info", message: "Saved" } },
+    { method: "host.status_set", params: { message: "Working" } },
+    { method: "host.event_emit", params: { name: "custom", payload: { value: 1 } } },
+    {
+      method: "vcs.event",
+      params: { session_id: "session-1", request_id: 42, event: { type: "progress", message: "Fetch" } },
+    },
+  ]);
+});