@openvcs/sdk 0.4.0 → 0.4.1-beta.128

package/test/init.test.js

@@ -1,11 +1,42 @@
 const assert = require("node:assert/strict");
+const childProcess = require("node:child_process");
 const fs = require("node:fs");
+const readline = require("node:readline/promises");
 const test = require("node:test");
 const path = require("node:path");
 
-const { __private } = require("../lib/init");
+const { __private, initUsage, isUsageError, runInitCommand } = require("../lib/init");
 const { cleanupTempDir, makeTempDir } = require("./helpers");
 
+async function withMockReadline(answers, run) {
+  const originalCreateInterface = readline.createInterface;
+  const prompts = [];
+  readline.createInterface = () => ({
+    async question(prompt) {
+      prompts.push(prompt);
+      return answers.shift() ?? "";
+    },
+    close() {},
+  });
+
+  try {
+    return await run(prompts);
+  } finally {
+    readline.createInterface = originalCreateInterface;
+  }
+}
+
+async function withMockSpawnSync(result, run) {
+  const originalSpawnSync = childProcess.spawnSync;
+  childProcess.spawnSync = () => result;
+
+  try {
+    return await run();
+  } finally {
+    childProcess.spawnSync = originalSpawnSync;
+  }
+}
+
 test("validatePluginId accepts regular ids", () => {
   assert.equal(__private.validatePluginId("my.plugin"), undefined);
   assert.equal(__private.validatePluginId("my-plugin_1"), undefined);
@@ -25,6 +56,97 @@ test("validatePluginId rejects path separators", () => {
   assert.match(__private.validatePluginId("bad\\id"), /path separators/);
 });
 
+test("init helpers derive stable defaults", () => {
+  assert.equal(__private.sanitizeIdToken(" My Plugin!! "), "my-plugin");
+  assert.equal(__private.defaultPluginIdFromDir(path.join("tmp", "My Plugin")), "my-plugin");
+  assert.equal(__private.defaultPluginIdFromDir(path.join("tmp", "!!!")), "openvcs.plugin");
+  assert.equal(__private.defaultPluginNameFromId("my-plugin.name"), "My Plugin Name");
+  assert.equal(__private.defaultPluginNameFromId("---"), "OpenVCS Plugin");
+  assert.match(initUsage("sdk"), /sdk init/);
+});
+
+test("runInitCommand validates args before prompting", async () => {
+  await assert.rejects(() => runInitCommand(["--bad"]), /unknown argument for init/);
+  await assert.rejects(() => runInitCommand(["one", "two"]), /at most one target directory/);
+
+  let usageError;
+  try {
+    await runInitCommand(["--help"]);
+  } catch (error) {
+    usageError = error;
+  }
+  assert.equal(isUsageError(usageError), true);
+});
+
+test("runInitCommand rejects when target path is a file", async () => {
+  const root = makeTempDir("openvcs-sdk-test");
+  const targetPath = path.join(root, "plugin");
+  fs.writeFileSync(targetPath, "not a directory", "utf8");
+
+  await assert.rejects(
+    () =>
+      withMockReadline([
+        "",
+        "module",
+        "",
+        "",
+        "",
+        "",
+        "n",
+      ], () => runInitCommand([targetPath])),
+    /target path exists but is not a directory/
+  );
+
+  cleanupTempDir(root);
+});
+
+test("runInitCommand writes a module template after confirming overwrite", async () => {
+  const root = makeTempDir("openvcs-sdk-test");
+  const targetDir = path.join(root, "plugin");
+  fs.mkdirSync(targetDir, { recursive: true });
+  fs.writeFileSync(path.join(targetDir, "README.md"), "keep", "utf8");
+
+  const created = await withMockReadline([
+    "",
+    "module",
+    "",
+    "",
+    "",
+    "",
+    "n",
+    "y",
+  ], () => runInitCommand([targetDir]));
+
+  assert.equal(created, targetDir);
+  assert.equal(fs.existsSync(path.join(targetDir, "package.json")), true);
+  assert.equal(fs.existsSync(path.join(targetDir, "src", "plugin.ts")), true);
+  assert.equal(fs.existsSync(path.join(targetDir, ".gitignore")), true);
+
+  cleanupTempDir(root);
+});
+
+test("runInitCommand spawns npm install when requested", async () => {
+  const root = makeTempDir("openvcs-sdk-test");
+  const targetDir = path.join(root, "fresh-plugin");
+
+  await withMockSpawnSync({ status: 0 }, async () => {
+    const created = await withMockReadline([
+      targetDir,
+      "module",
+      "fresh.plugin",
+      "Fresh Plugin",
+      "0.1.0",
+      "y",
+      "y",
+    ], () => runInitCommand([]));
+
+    assert.equal(created, path.resolve(targetDir));
+    assert.equal(fs.existsSync(path.join(targetDir, "package.json")), true);
+  });
+
+  cleanupTempDir(root);
+});
+
 test("collectAnswers re-prompts invalid plugin id", async () => {
   const prompts = [
     "plugin-dir",
@@ -66,6 +188,67 @@ test("collectAnswers re-prompts invalid plugin id", async () => {
   assert.equal(messages.some((message) => message.includes("must not contain path separators")), true);
 });
 
+test("collectAnswers handles theme mode, invalid kind, blank defaults, and boolean retries", async () => {
+  const prompts = [
+    "",
+    "bad-kind",
+    "t",
+    "",
+    "",
+    "",
+  ];
+  const booleans = [false, true];
+  const messages = [];
+  const promptDriver = {
+    async promptText(_label, defaultValue) {
+      const value = prompts.shift();
+      return value === "" ? defaultValue : value;
+    },
+    async promptBoolean() {
+      return booleans.shift();
+    },
+    close() {
+      messages.push("closed");
+    },
+  };
+  const output = { write(message) { messages.push(message); } };
+
+  const answers = await __private.collectAnswers(
+    { forceTheme: false, targetHint: "theme-dir" },
+    promptDriver,
+    output,
+  );
+
+  assert.equal(answers.kind, "theme");
+  assert.equal(answers.pluginId, "theme-dir");
+  assert.equal(answers.pluginName, "Theme Dir");
+  assert.equal(answers.pluginVersion, "0.1.0");
+  assert.equal(answers.defaultEnabled, false);
+  assert.equal(answers.runNpmInstall, true);
+  assert.equal(messages.some((message) => String(message).includes("Please choose")), true);
+  assert.equal(messages.includes("closed"), true);
+});
+
+test("collectAnswers skips kind prompt when theme is forced", async () => {
+  const prompts = ["forced-dir", "forced.theme", "Forced Theme", "1.0.0"];
+  const labels = [];
+  const promptDriver = {
+    async promptText(label) {
+      labels.push(label);
+      return prompts.shift();
+    },
+    async promptBoolean() {
+      return false;
+    },
+    close() {},
+  };
+
+  const answers = await __private.collectAnswers({ forceTheme: true }, promptDriver, { write() {} });
+
+  assert.equal(answers.kind, "theme");
+  assert.equal(labels.includes("Template type (module/theme)"), false);
+});
+
 test("writeModuleTemplate scaffolds SDK runtime entrypoint", () => {
   const root = makeTempDir("openvcs-sdk-test");
   const targetDir = path.join(root, "plugin");
@@ -92,3 +275,28 @@ test("writeModuleTemplate scaffolds SDK runtime entrypoint", () => {
 
   cleanupTempDir(root);
 });
+
+test("writeThemeTemplate scaffolds theme package without module runtime", () => {
+  const root = makeTempDir("openvcs-sdk-test");
+  const targetDir = path.join(root, "theme-plugin");
+
+  __private.writeThemeTemplate({
+    targetDir,
+    kind: "theme",
+    pluginId: "example.theme",
+    pluginName: "Example Theme",
+    pluginVersion: "0.3.0",
+    defaultEnabled: false,
+    runNpmInstall: false,
+  });
+
+  const packageJson = JSON.parse(fs.readFileSync(path.join(targetDir, "package.json"), "utf8"));
+  const themeJson = JSON.parse(fs.readFileSync(path.join(targetDir, "themes", "default", "theme.json"), "utf8"));
+
+  assert.equal(packageJson.openvcs.module, undefined);
+  assert.equal(packageJson.openvcs.default_enabled, false);
+  assert.equal(themeJson.name, "Example Theme");
+  assert.equal(themeJson.tokens.accent, "#2a7fff");
+
+  cleanupTempDir(root);
+});

package/test/menu.test.js

@@ -0,0 +1,147 @@
+const assert = require("node:assert/strict");
+const test = require("node:test");
+
+const {
+  addMenuItem,
+  createMenu,
+  getMenu,
+  hasRegisteredAction,
+  hideMenu,
+  invoke,
+  notify,
+  registerAction,
+  removeMenu,
+  resetMenuRegistry,
+  runRegisteredAction,
+  showMenu,
+} = require("../lib/runtime/menu");
+const { createRegisteredPluginRuntime } = require("../lib/runtime");
+const { EventEmitter } = require("node:events");
+const { parseFramedMessages, serializeFramedMessage } = require("../lib/runtime/transport");
+
+function menuResult() {
+  const stdin = new EventEmitter();
+  const chunks = [];
+  const stdout = {
+    write(chunk) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+      return true;
+    },
+  };
+  createRegisteredPluginRuntime({}).start({ stdin, stdout });
+  stdin.emit("data", serializeFramedMessage({ jsonrpc: "2.0", id: 1, method: "plugin.get_menus", params: {} }));
+  return new Promise((resolve) => setImmediate(() => resolve(parseFramedMessages(Buffer.concat(chunks)).messages[0].result)));
+}
+
+test("menu ordering supports before and after placement", async () => {
+  resetMenuRegistry();
+  createMenu("middle", "Middle", { surface: "menubar" });
+  createMenu("after", "After", { surface: "settings", after: "middle" });
+  createMenu("before", "Before", { surface: "menubar", before: "middle" });
+
+  const menus = await menuResult();
+
+  assert.deepEqual(menus.map((menu) => menu.id), ["before", "middle", "after"]);
+  assert.deepEqual(menus.map((menu) => menu.surface), ["menubar", "menubar", "settings"]);
+});
+
+test("menu ordering falls back when requested anchors are missing", async () => {
+  resetMenuRegistry();
+  createMenu("first", "First", { surface: "menubar", after: "missing" });
+  createMenu("second", "Second", { surface: "menubar", before: "missing" });
+  createMenu("first", "First Updated", { surface: "settings" });
+
+  const menus = await menuResult();
+
+  assert.deepEqual(menus.map((menu) => menu.id), ["second", "first"]);
+  assert.equal(menus[1].label, "First Updated");
+  assert.equal(menus[1].surface, "settings");
+});
+
+test("menu item insertion supports before anchors and ignores invalid items", async () => {
+  resetMenuRegistry();
+  const menu = createMenu("insert", "Insert", { surface: "menubar" });
+  menu.addItem({ label: "Last", action: "last" });
+  menu.addItem({ label: "First", action: "first", before: "last" });
+  menu.addItem({ label: "", action: "ignored" });
+  menu.addItem({ label: "Ignored", action: "" });
+
+  const menus = await menuResult();
+
+  assert.deepEqual(menus[0].elements, [
+    { type: "button", id: "first", label: "First" },
+    { type: "button", id: "last", label: "Last" },
+  ]);
+});
+
+test("menu handle can remove, hide, and show individual items", async () => {
+  resetMenuRegistry();
+  const menu = createMenu("tools", "Tools", { surface: "menubar" });
+  menu.addItem({ label: "A", action: "a" });
+  menu.addItem({ label: "B", action: "b" });
+  menu.hideItem("a");
+
+  let menus = await menuResult();
+  assert.deepEqual(menus[0].elements, [{ type: "button", id: "b", label: "B" }]);
+
+  menu.showItem("a");
+  menu.removeItem("b");
+  menus = await menuResult();
+
+  assert.deepEqual(menus[0].elements, [{ type: "button", id: "a", label: "A" }]);
+});
+
+test("registered actions report presence and ignore blank ids", async () => {
+  resetMenuRegistry();
+  registerAction(" save ", () => "saved");
+
+  assert.equal(hasRegisteredAction("save"), true);
+  assert.equal(hasRegisteredAction(""), false);
+  assert.equal(await runRegisteredAction("save"), "saved");
+  assert.equal(await runRegisteredAction("missing"), null);
+  assert.equal(await runRegisteredAction(""), null);
+});
+
+test("removeMenu deletes menu and order entry", async () => {
+  resetMenuRegistry();
+  createMenu("gone", "Gone", { surface: "menubar" });
+  createMenu("stay", "Stay", { surface: "menubar" });
+  removeMenu("gone");
+  hideMenu("missing");
+  showMenu("missing");
+
+  assert.equal(getMenu("gone"), null);
+  assert.deepEqual((await menuResult()).map((menu) => menu.id), ["stay"]);
+});
+
+test("invoke and notify use OpenVCS host helper when available", async () => {
+  const previous = globalThis.OpenVCS;
+  const calls = [];
+  globalThis.OpenVCS = {
+    async invoke(cmd, args) {
+      calls.push({ cmd, args });
+      return "ok";
+    },
+    notify(msg) {
+      calls.push({ msg });
+    },
+  };
+  try {
+    assert.equal(await invoke("repo.open", { path: "/tmp" }), "ok");
+    notify("done");
+    assert.deepEqual(calls, [{ cmd: "repo.open", args: { path: "/tmp" } }, { msg: "done" }]);
+  } finally {
+    globalThis.OpenVCS = previous;
+  }
+});
+
+test("invoke and notify fail when OpenVCS host helper is missing", async () => {
+  const previous = globalThis.OpenVCS;
+  delete globalThis.OpenVCS;
+  try {
+    await assert.rejects(() => invoke("missing"), /host is not available/);
+    assert.throws(() => notify("missing"), /host is not available/);
+  } finally {
+    globalThis.OpenVCS = previous;
+  }
+});

package/test/modal.test.js

@@ -0,0 +1,74 @@
+const assert = require("node:assert/strict");
+const test = require("node:test");
+
+const { ModalBuilder } = require("../lib/runtime");
+
+test("ModalBuilder serializes all supported content item types", async () => {
+  const modal = new ModalBuilder("  Settings  ")
+    .text("Hello", { title: "Greeting", align: "center" })
+    .separator()
+    .button(" save ", "Save", { title: "Persist", variant: "primary", align: "end", payload: { ok: true } })
+    .input(" name ", " Name ", { kind: "text", value: "OpenVCS", placeholder: "Name", required: true, align: "start" })
+    .select("theme", "Theme", { value: "dark", align: "center", options: [{ value: "dark", label: "Dark" }] })
+    .list("files", { label: "Files", emptyText: "None", align: "start", items: [{ id: "a", label: "A" }] })
+    .build();
+
+  assert.equal(modal.title, "Settings");
+  assert.deepEqual(modal.content.map((item) => item.type), [
+    "text",
+    "separator",
+    "button",
+    "input",
+    "select",
+    "list",
+  ]);
+  assert.deepEqual(modal.content[2].payload, { ok: true });
+  assert.equal(modal.content[3].required, true);
+});
+
+test("ModalBuilder omits optional fields when not provided", () => {
+  const modal = new ModalBuilder("  ")
+    .text("Plain")
+    .button(" save ", "Save")
+    .input(" name ", " Name ")
+    .select("theme", "Theme", { options: [] })
+    .list("files", { items: [] })
+    .horizontalBox([{ type: "text", content: "child" }])
+    .verticalBox([{ type: "text", content: "child" }])
+    .grid([{ type: "text", content: "child" }], { columns: " 1fr " })
+    .build();
+
+  assert.equal(modal.title, "");
+  assert.equal(modal.content[0].title, undefined);
+  assert.equal(modal.content[1].variant, undefined);
+  assert.equal(modal.content[2].kind, undefined);
+  assert.equal(modal.content[3].value, undefined);
+  assert.equal(modal.content[4].label, undefined);
+  assert.equal(modal.content[5].gap, undefined);
+  assert.equal(modal.content[6].gap, undefined);
+  assert.equal(modal.content[7].gap, undefined);
+  assert.equal(modal.content[7].columns, "1fr");
+});
+
+test("ModalBuilder clones nested container content before returning definitions", () => {
+  const nested = [{ type: "text", content: "inside" }];
+  const builder = new ModalBuilder("Nested")
+    .horizontalBox(nested, { gap: "4px", align: "center", wrap: true })
+    .verticalBox(nested, { gap: "8px" })
+    .grid(nested, { columns: "1fr 1fr", gap: "2px" });
+
+  const first = builder.build();
+  first.content[0].content[0].content = "mutated";
+  nested[0].content = "source mutated";
+  const second = builder.build();
+
+  assert.equal(second.content[0].content[0].content, "inside");
+  assert.equal(second.content[1].content[0].content, "inside");
+  assert.equal(second.content[2].columns, "1fr 1fr");
+});
+
+test("ModalBuilder.open returns the same payload shape as build", async () => {
+  const builder = new ModalBuilder("Open").text("Body");
+
+  assert.deepEqual(await builder.open(), builder.build());
+});

package/test/npm-runner.test.js

@@ -0,0 +1,89 @@
+const assert = require("node:assert/strict");
+const path = require("node:path");
+const test = require("node:test");
+
+const { npmArgsPrefix, npmCommand, npmExecutable, resolveNpmCli } = require("../lib/npm-runner");
+
+test("npmCommand uses npm directly on non-Windows platforms", () => {
+  const command = npmCommand("linux", "/usr/bin/node");
+
+  assert.deepEqual(command, { program: "npm", argsPrefix: [] });
+});
+
+test("npmExecutable and npmArgsPrefix expose the default npm command", () => {
+  if (process.platform === "win32") {
+    assert.equal(npmExecutable(), process.execPath);
+    assert.ok(npmArgsPrefix().length > 0);
+  } else {
+    assert.equal(npmExecutable(), "npm");
+    assert.deepEqual(npmArgsPrefix(), []);
+  }
+});
+
+test("npmCommand runs npm through node.exe on Windows without cmd.exe", () => {
+  const execPath = "C:\\Program Files\\nodejs\\node.exe";
+  const localCli = path.join(path.dirname(execPath), "node_modules", "npm", "bin", "npm-cli.js");
+
+  const command = npmCommand("win32", execPath, (candidate) => candidate === localCli);
+
+  assert.equal(command.program, execPath);
+  assert.deepEqual(command.argsPrefix, [localCli]);
+  assert.notEqual(command.program.toLowerCase(), "cmd.exe");
+  assert.notEqual(path.basename(command.argsPrefix[0]).toLowerCase(), "npm.cmd");
+});
+
+test("resolveNpmCli falls back to require.resolve when local npm cli is unavailable", () => {
+  const resolved = resolveNpmCli(
+    "C:\\Program Files\\nodejs\\node.exe",
+    () => false,
+    (specifier) => `resolved:${specifier}`,
+  );
+
+  assert.equal(resolved, "resolved:npm/bin/npm-cli.js");
+});
+
+test("resolveNpmCli prefers npm cli beside node.exe before require.resolve", () => {
+  const execPath = "C:\\Tools With Spaces\\nodejs\\node.exe";
+  const localCli = path.join(path.dirname(execPath), "node_modules", "npm", "bin", "npm-cli.js");
+  let fallbackCalled = false;
+
+  const resolved = resolveNpmCli(
+    execPath,
+    (candidate) => candidate === localCli,
+    () => {
+      fallbackCalled = true;
+      return "fallback";
+    },
+  );
+
+  assert.equal(resolved, localCli);
+  assert.equal(fallbackCalled, false);
+});
+
+test("npmCommand keeps Windows paths unquoted because spawn receives argv array", () => {
+  const execPath = "C:\\Program Files\\nodejs\\node.exe";
+  const cliPath = "C:\\Program Files\\nodejs\\node_modules\\npm\\bin\\npm-cli.js";
+  const command = npmCommand("win32", execPath, () => false, () => cliPath);
+
+  assert.equal(command.program, execPath);
+  assert.equal(command.argsPrefix[0], cliPath);
+  assert.equal(command.program.startsWith('"'), false);
+  assert.equal(command.argsPrefix[0].startsWith('"'), false);
+});
+
+test("npmCommand returns a fresh argsPrefix array per Windows call", () => {
+  const execPath = "C:\\nodejs\\node.exe";
+  const cliPath = "C:\\nodejs\\node_modules\\npm\\bin\\npm-cli.js";
+  const first = npmCommand("win32", execPath, () => false, () => cliPath);
+  const second = npmCommand("win32", execPath, () => false, () => cliPath);
+
+  first.argsPrefix.push("mutated");
+
+  assert.deepEqual(second.argsPrefix, [cliPath]);
+});
+
+test("SDK build module no longer exposes shell-wrapper helper", () => {
+  const buildModule = require("../lib/build");
+
+  assert.equal(Object.hasOwn(buildModule, "shouldUseWindowsShell"), false);
+});