shadow-claw 1.27.0 → 1.28.0

package/bin/utils/control-client.mjs

@@ -271,4 +271,21 @@ export class CliControlClient {
     });
     return data;
   }
+
+  async broadcastNotification({ title = "ShadowClaw", body, clientId } = {}) {
+    const data = await this._request({
+      path: "/push/broadcast",
+      method: "POST",
+      body: {
+        title,
+        body,
+        ...(clientId ? { clientId } : {}),
+      },
+    });
+    return data;
+  }
+
+  async sendNotification(options) {
+    return this.broadcastNotification(options);
+  }
 }

package/bin/utils/control-client.test.mjs

@@ -35,6 +35,10 @@ describe("CliControlClient", () => {
       token,
     });
 
+    app.post("/push/broadcast", (req, res) => {
+      res.json({ sent: 1, failed: 0, received: req.body });
+    });
+
     await new Promise((resolve) => {
       server.listen(0, "127.0.0.1", () => {
         port = server.address().port;
@@ -90,4 +94,46 @@ describe("CliControlClient", () => {
     expect(client2.protocol).toBe("https");
     delete process.env.SHADOWCLAW_HTTPS;
   });
+
+  it("broadcasts push notifications via broadcastNotification", async () => {
+    const client = new CliControlClient({
+      host: "127.0.0.1",
+      port,
+      token,
+    });
+
+    const result = await client.broadcastNotification({
+      title: "Test Title",
+      body: "Test Body",
+    });
+
+    expect(result).toBeDefined();
+    expect(result.sent).toBe(1);
+    expect(result.received).toEqual({
+      title: "Test Title",
+      body: "Test Body",
+    });
+  });
+
+  it("sends targeted push notification with clientId via sendNotification", async () => {
+    const client = new CliControlClient({
+      host: "127.0.0.1",
+      port,
+      token,
+    });
+
+    const result = await client.sendNotification({
+      title: "Targeted Alert",
+      body: "Hello specific client",
+      clientId: "client-target-42",
+    });
+
+    expect(result).toBeDefined();
+    expect(result.sent).toBe(1);
+    expect(result.received).toEqual({
+      title: "Targeted Alert",
+      body: "Hello specific client",
+      clientId: "client-target-42",
+    });
+  });
 });

package/bin/version.mjs

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+
+import { execSync } from "node:child_process";
+import { readFile, writeFile, stat } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const rootDir = path.resolve(__dirname, "..");
+
+export const DISALLOWED_KEYWORDS = new Set([
+  "major",
+  "minor",
+  "patch",
+  "premajor",
+  "preminor",
+  "prepatch",
+  "prerelease",
+  "from-git",
+]);
+
+export const USAGE_NOTICE = `
+Usage: npm run version [<newversion>]
+
+Note: Only explicit semantic version strings (e.g. 1.28.0) are supported.
+Keyword commands (major, minor, patch, premajor, preminor, prepatch, prerelease, from-git) are not supported.
+
+Standard npm version syntax for reference:
+  npm version [<newversion> | major | minor | patch | premajor | preminor | prepatch | prerelease | from-git]
+`.trim();
+
+export async function pathExists(p) {
+  try {
+    await stat(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function parseSemverString(v) {
+  const clean = String(v || "")
+    .trim()
+    .replace(/^v/, "");
+  const match = clean.match(
+    /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+([0-9A-Za-z.-]+))?$/,
+  );
+  if (!match) return null;
+  return clean;
+}
+
+export function validateVersionArg(arg) {
+  if (!arg) return null;
+  const lower = arg.toLowerCase().trim();
+  if (lower === "--help" || lower === "-h") {
+    return { isHelp: true };
+  }
+  if (DISALLOWED_KEYWORDS.has(lower)) {
+    return {
+      error: `Error: Keyword command "${arg}" is not supported by npm run version.\n\n${USAGE_NOTICE}`,
+    };
+  }
+  const clean = parseSemverString(arg);
+  if (!clean) {
+    return {
+      error: `Error: Invalid version string "${arg}". Expected a valid semantic version (e.g. 1.28.0).\n\n${USAGE_NOTICE}`,
+    };
+  }
+  return { version: clean };
+}
+
+export async function getVersionMap(targetRoot = rootDir) {
+  const pkg = JSON.parse(
+    await readFile(path.join(targetRoot, "package.json"), "utf8"),
+  );
+  let npmVer = "";
+  try {
+    npmVer = execSync("npm -v", { encoding: "utf8" }).trim();
+  } catch {}
+
+  return {
+    [pkg.name]: pkg.version,
+    ...(npmVer ? { npm: npmVer } : {}),
+    ...process.versions,
+  };
+}
+
+export async function syncWellKnownVersions(newVersion, targetRoot = rootDir) {
+  const filesToSync = [
+    path.join(targetRoot, ".well-known/mcp.json"),
+    path.join(targetRoot, ".well-known/mcp/server-card.json"),
+    path.join(targetRoot, "dist/public/.well-known/mcp.json"),
+    path.join(targetRoot, "dist/public/.well-known/mcp/server-card.json"),
+  ];
+
+  const updatedFiles = [];
+  for (const filePath of filesToSync) {
+    if (await pathExists(filePath)) {
+      try {
+        const content = await readFile(filePath, "utf8");
+        const json = JSON.parse(content);
+        if (json.version !== newVersion) {
+          json.version = newVersion;
+          await writeFile(
+            filePath,
+            JSON.stringify(json, null, 2) + "\n",
+            "utf8",
+          );
+          updatedFiles.push(path.relative(targetRoot, filePath));
+        }
+      } catch (err) {
+        console.warn(`Warning: Could not update version in ${filePath}:`, err);
+      }
+    }
+  }
+  return updatedFiles;
+}
+
+export async function runVersion(args = process.argv.slice(2), options = {}) {
+  const isLifecycle =
+    options.isLifecycle ??
+    (process.env.npm_command === "version" &&
+      process.env.npm_lifecycle_event === "version");
+  const targetRoot = options.rootDir || rootDir;
+  const execOptions = options.execOptions || {
+    cwd: targetRoot,
+    stdio: options.stdio || "inherit",
+  };
+
+  // 1. If running under npm's lifecycle hook (npm version <newver> triggered this script)
+  if (isLifecycle) {
+    const pkg = JSON.parse(
+      await readFile(path.join(targetRoot, "package.json"), "utf8"),
+    );
+    const newVersion = pkg.version;
+    const updated = await syncWellKnownVersions(newVersion, targetRoot);
+    if (
+      updated.length > 0 &&
+      (await pathExists(path.join(targetRoot, ".git")))
+    ) {
+      try {
+        execSync(
+          `git add .well-known/mcp.json .well-known/mcp/server-card.json`,
+          { cwd: targetRoot, stdio: "pipe" },
+        );
+      } catch {}
+    }
+    return { version: newVersion, updated };
+  }
+
+  // 2. Direct CLI invocation
+  const targetArg = args.find((a) => !a.startsWith("--")) || args[0];
+
+  // No arguments passed -> list versions mimicking `npm version`
+  if (!targetArg) {
+    const versionMap = await getVersionMap(targetRoot);
+    if (execOptions.stdio === "inherit") {
+      console.log(versionMap);
+    }
+    return { action: "list", versions: versionMap };
+  }
+
+  const validation = validateVersionArg(targetArg);
+  if (validation.isHelp) {
+    if (execOptions.stdio === "inherit") {
+      console.log(USAGE_NOTICE);
+    }
+    return { action: "help", message: USAGE_NOTICE };
+  }
+
+  if (validation.error) {
+    throw new Error(validation.error);
+  }
+
+  const cleanVersion = validation.version;
+
+  // Run npm version --no-git-tag-version --allow-same-version --ignore-scripts
+  execSync(
+    `npm version ${cleanVersion} --no-git-tag-version --allow-same-version --ignore-scripts`,
+    execOptions,
+  );
+
+  // Sync .well-known JSON discovery files
+  const updated = await syncWellKnownVersions(cleanVersion, targetRoot);
+
+  if (execOptions.stdio === "inherit") {
+    console.log(`v${cleanVersion}`);
+    if (updated.length > 0) {
+      console.log(
+        `Updated .well-known discovery versions: ${updated.join(", ")}`,
+      );
+    }
+  }
+
+  return { version: cleanVersion, updated };
+}
+
+const isMainModule =
+  process.argv[1] &&
+  import.meta.url === pathToFileURL(path.resolve(process.argv[1])).href;
+
+if (isMainModule) {
+  runVersion().catch((err) => {
+    console.error(`\n${err.message}\n`);
+    process.exit(1);
+  });
+}

package/bin/version.test.mjs

@@ -0,0 +1,138 @@
+import { describe, it, expect } from "@jest/globals";
+import { cp, mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import {
+  DISALLOWED_KEYWORDS,
+  USAGE_NOTICE,
+  getVersionMap,
+  parseSemverString,
+  runVersion,
+  syncWellKnownVersions,
+  validateVersionArg,
+} from "./version.mjs";
+
+describe("bin/version.mjs", () => {
+  describe("parseSemverString", () => {
+    it("parses valid semver versions with or without leading v", () => {
+      expect(parseSemverString("1.28.0")).toBe("1.28.0");
+      expect(parseSemverString("v1.28.0")).toBe("1.28.0");
+      expect(parseSemverString("2.0.0-rc.1")).toBe("2.0.0-rc.1");
+      expect(parseSemverString("v0.1.0+build.123")).toBe("0.1.0+build.123");
+    });
+
+    it("returns null for non-semver strings", () => {
+      expect(parseSemverString("minor")).toBeNull();
+      expect(parseSemverString("latest")).toBeNull();
+      expect(parseSemverString("1.2")).toBeNull();
+      expect(parseSemverString("")).toBeNull();
+    });
+  });
+
+  describe("validateVersionArg", () => {
+    it("returns isHelp for help flags", () => {
+      expect(validateVersionArg("--help")).toEqual({ isHelp: true });
+      expect(validateVersionArg("-h")).toEqual({ isHelp: true });
+    });
+
+    it("rejects all disallowed npm version keyword commands", () => {
+      for (const keyword of DISALLOWED_KEYWORDS) {
+        const result = validateVersionArg(keyword);
+        expect(result.error).toBeDefined();
+        expect(result.error).toContain(keyword);
+        expect(result.error).toContain(USAGE_NOTICE);
+      }
+    });
+
+    it("rejects invalid semver strings", () => {
+      const result = validateVersionArg("invalid-version");
+      expect(result.error).toBeDefined();
+      expect(result.error).toContain("Invalid version string");
+      expect(result.error).toContain(USAGE_NOTICE);
+    });
+
+    it("accepts valid semver string", () => {
+      expect(validateVersionArg("1.28.0")).toEqual({ version: "1.28.0" });
+      expect(validateVersionArg("v1.28.0")).toEqual({ version: "1.28.0" });
+    });
+  });
+
+  describe("getVersionMap", () => {
+    it("returns version mapping object containing package name and node versions", async () => {
+      const map = await getVersionMap();
+      expect(map["shadow-claw"]).toBeDefined();
+      expect(map.node).toBeDefined();
+    });
+  });
+
+  describe("syncWellKnownVersions", () => {
+    let tempDir;
+
+    beforeEach(async () => {
+      tempDir = await mkdtemp(path.join(os.tmpdir(), "sync-well-known-"));
+      await mkdir(path.join(tempDir, ".well-known/mcp"), { recursive: true });
+      await writeFile(
+        path.join(tempDir, ".well-known/mcp.json"),
+        JSON.stringify({ name: "shadow-claw", version: "1.27.1" }, null, 2),
+        "utf8",
+      );
+      await writeFile(
+        path.join(tempDir, ".well-known/mcp/server-card.json"),
+        JSON.stringify({ name: "shadow-claw", version: "1.27.1" }, null, 2),
+        "utf8",
+      );
+    });
+
+    afterEach(async () => {
+      await rm(tempDir, { recursive: true, force: true });
+    });
+
+    it("updates version in .well-known/mcp.json and .well-known/mcp/server-card.json", async () => {
+      const updated = await syncWellKnownVersions("1.28.0", tempDir);
+      expect(updated).toEqual(
+        expect.arrayContaining([
+          ".well-known/mcp.json",
+          ".well-known/mcp/server-card.json",
+        ]),
+      );
+
+      const mcpJson = JSON.parse(
+        await readFile(path.join(tempDir, ".well-known/mcp.json"), "utf8"),
+      );
+      const serverCard = JSON.parse(
+        await readFile(
+          path.join(tempDir, ".well-known/mcp/server-card.json"),
+          "utf8",
+        ),
+      );
+      expect(mcpJson.version).toBe("1.28.0");
+      expect(serverCard.version).toBe("1.28.0");
+    });
+
+    it("skips updating files that already have the matching version", async () => {
+      await syncWellKnownVersions("1.28.0", tempDir);
+      const secondUpdate = await syncWellKnownVersions("1.28.0", tempDir);
+      expect(secondUpdate).toEqual([]);
+    });
+  });
+
+  describe("runVersion CLI execution", () => {
+    it("returns list action when no arguments are provided", async () => {
+      const result = await runVersion([], { stdio: "pipe" });
+      expect(result.action).toBe("list");
+      expect(result.versions["shadow-claw"]).toBeDefined();
+    });
+
+    it("returns help action when --help flag is provided", async () => {
+      const result = await runVersion(["--help"], { stdio: "pipe" });
+      expect(result.action).toBe("help");
+      expect(result.message).toContain(USAGE_NOTICE);
+    });
+
+    it("throws error when disallowed keyword is provided", async () => {
+      await expect(runVersion(["minor"], { stdio: "pipe" })).rejects.toThrow(
+        'Keyword command "minor" is not supported',
+      );
+    });
+  });
+});