clawvault 3.1.0 → 3.2.0

package/dist/{chunk-33UGEQRT.js → chunk-X3SPPUFG.js}

@@ -4,6 +4,8 @@ import * as path from "path";
 import matter from "gray-matter";
 import { spawnSync } from "child_process";
 import { fileURLToPath } from "url";
+var REQUIRED_HOOK_EVENTS = ["gateway:startup", "command:new", "session:start"];
+var REQUIRED_HOOK_BIN = "clawvault";
 function readOptionalFile(filePath) {
   try {
     if (!fs.existsSync(filePath)) return null;
@@ -39,7 +41,7 @@ function checkOpenClawCli() {
       label: "openclaw CLI available",
       status: "warn",
       detail: "openclaw binary not found",
-      hint: "Install OpenClaw CLI to enable plugin runtime validation."
+      hint: "Install OpenClaw CLI to enable hook runtime validation."
     };
   }
   if (typeof result.status === "number" && result.status !== 0) {
@@ -60,106 +62,190 @@ function checkOpenClawCli() {
   }
   return { label: "openclaw CLI available", status: "ok" };
 }
-function checkPluginManifest(options) {
-  const manifestRaw = readOptionalFile(
-    resolveProjectFile("openclaw.plugin.json", options.baseDir)
-  );
-  if (!manifestRaw) {
+function checkPackageHookRegistration(options) {
+  const packageRaw = readOptionalFile(resolveProjectFile("package.json", options.baseDir));
+  if (!packageRaw) {
     return {
-      label: "plugin manifest",
+      label: "package hook registration",
       status: "error",
-      detail: "openclaw.plugin.json not found",
-      hint: "Create openclaw.plugin.json with id, kind, and configSchema fields."
+      detail: "package.json not found"
     };
   }
   try {
-    const manifest = JSON.parse(manifestRaw);
-    const issues = [];
-    if (!manifest.id) issues.push("missing id");
-    if (!manifest.kind) issues.push("missing kind");
-    if (!manifest.configSchema) issues.push("missing configSchema");
-    if (issues.length > 0) {
+    const parsed = JSON.parse(packageRaw);
+    const registeredHooks = parsed.openclaw?.hooks ?? [];
+    if (registeredHooks.includes("./hooks/clawvault")) {
       return {
-        label: "plugin manifest",
-        status: "error",
-        detail: issues.join(", ")
+        label: "package hook registration",
+        status: "ok",
+        detail: "./hooks/clawvault"
       };
     }
     return {
-      label: "plugin manifest",
-      status: "ok",
-      detail: `id=${manifest.id} kind=${manifest.kind}`
+      label: "package hook registration",
+      status: "error",
+      detail: "Missing ./hooks/clawvault in package openclaw.hooks"
     };
   } catch (err) {
     return {
-      label: "plugin manifest",
+      label: "package hook registration",
       status: "error",
-      detail: err?.message || "Unable to parse openclaw.plugin.json"
+      detail: err?.message || "Unable to parse package.json"
     };
   }
 }
-function checkPluginExtensions(options) {
-  let packageRaw = readOptionalFile(
-    resolveProjectFile("package.json", options.baseDir)
-  );
-  if (packageRaw && !options.baseDir) {
-    try {
-      const parsed = JSON.parse(packageRaw);
-      if (!parsed.openclaw?.extensions) {
-        const fallbackPath = path.resolve(findPackageRoot(), "package.json");
-        const fallbackRaw = readOptionalFile(fallbackPath);
-        if (fallbackRaw) packageRaw = fallbackRaw;
-      }
-    } catch {
+function checkHookManifest(options) {
+  const hookRaw = readOptionalFile(resolveProjectFile("hooks/clawvault/HOOK.md", options.baseDir));
+  if (!hookRaw) {
+    return {
+      label: "hook manifest",
+      status: "error",
+      detail: "HOOK.md not found"
+    };
+  }
+  try {
+    const parsed = matter(hookRaw);
+    const openclaw = parsed.data?.metadata?.openclaw;
+    const events = Array.isArray(openclaw?.events) ? openclaw?.events ?? [] : [];
+    const missingEvents = REQUIRED_HOOK_EVENTS.filter((event) => !events.includes(event));
+    if (missingEvents.length === 0) {
+      return {
+        label: "hook manifest events",
+        status: "ok",
+        detail: events.join(", ")
+      };
     }
+    return {
+      label: "hook manifest events",
+      status: "error",
+      detail: `Missing events: ${missingEvents.join(", ")}`
+    };
+  } catch (err) {
+    return {
+      label: "hook manifest events",
+      status: "error",
+      detail: err?.message || "Unable to parse HOOK.md frontmatter"
+    };
   }
-  if (!packageRaw) {
+}
+function checkHookManifestRequirements(options) {
+  const hookRaw = readOptionalFile(resolveProjectFile("hooks/clawvault/HOOK.md", options.baseDir));
+  if (!hookRaw) {
     return {
-      label: "plugin extensions registration",
+      label: "hook manifest requirements",
       status: "error",
-      detail: "package.json not found"
+      detail: "HOOK.md not found"
     };
   }
   try {
-    const parsed = JSON.parse(packageRaw);
-    const extensions = parsed.openclaw?.extensions ?? [];
-    if (extensions.length === 0) {
+    const parsed = matter(hookRaw);
+    const requiresBins = parsed.data?.metadata?.openclaw?.requires?.bins;
+    const bins = Array.isArray(requiresBins) ? requiresBins : [];
+    if (bins.includes(REQUIRED_HOOK_BIN)) {
+      return {
+        label: "hook manifest requirements",
+        status: "ok",
+        detail: `bins: ${bins.join(", ")}`
+      };
+    }
+    return {
+      label: "hook manifest requirements",
+      status: "warn",
+      detail: `Missing required hook bin "${REQUIRED_HOOK_BIN}"`,
+      hint: 'Add metadata.openclaw.requires.bins: ["clawvault"] to hooks/clawvault/HOOK.md.'
+    };
+  } catch (err) {
+    return {
+      label: "hook manifest requirements",
+      status: "error",
+      detail: err?.message || "Unable to parse HOOK.md frontmatter"
+    };
+  }
+}
+function checkHookHandlerSafety(options) {
+  const handlerRaw = readOptionalFile(resolveProjectFile("hooks/clawvault/handler.js", options.baseDir));
+  if (!handlerRaw) {
+    return {
+      label: "hook handler script",
+      status: "error",
+      detail: "handler.js not found"
+    };
+  }
+  const usesExecFileSync = handlerRaw.includes("execFileSync");
+  const usesExecSync = /\bexecSync\b/.test(handlerRaw);
+  const enablesShell = /\bshell\s*:\s*true\b/.test(handlerRaw);
+  const delegatesAutoProfile = /['"]--profile['"]\s*,\s*['"]auto['"]/.test(handlerRaw);
+  const violations = [];
+  if (!usesExecFileSync || usesExecSync) {
+    violations.push("execFileSync-only execution path");
+  }
+  if (enablesShell) {
+    violations.push("shell:false execution option");
+  }
+  if (!delegatesAutoProfile) {
+    violations.push("shared context profile delegation (--profile auto)");
+  }
+  if (violations.length > 0) {
+    return {
+      label: "hook handler safety",
+      status: "warn",
+      detail: `Missing conventions: ${violations.join(", ")}`,
+      hint: "Use execFileSync (no shell), avoid execSync, and delegate profile inference via --profile auto."
+    };
+  }
+  return { label: "hook handler safety", status: "ok" };
+}
+function checkPluginManifest(options) {
+  const manifestRaw = readOptionalFile(resolveProjectFile("hooks/clawvault/openclaw.plugin.json", options.baseDir));
+  if (!manifestRaw) {
+    return {
+      label: "plugin manifest",
+      status: "error",
+      detail: "hooks/clawvault/openclaw.plugin.json not found",
+      hint: "Add openclaw.plugin.json to hooks/clawvault/ for config schema registration."
+    };
+  }
+  try {
+    const parsed = JSON.parse(manifestRaw);
+    if (!parsed.id || parsed.id !== "clawvault") {
       return {
-        label: "plugin extensions registration",
+        label: "plugin manifest",
         status: "error",
-        detail: "Missing openclaw.extensions in package.json",
-        hint: 'Add openclaw.extensions: ["./dist/plugin/index.js"] to package.json.'
+        detail: `Invalid plugin id: expected "clawvault", got "${parsed.id || "(missing)"}"`
       };
     }
-    const baseDir = options.baseDir || findPackageRoot();
-    const missing = extensions.filter(
-      (ext) => !fs.existsSync(path.resolve(baseDir, ext))
-    );
-    if (missing.length > 0) {
+    if (!parsed.configSchema || typeof parsed.configSchema !== "object") {
       return {
-        label: "plugin extensions registration",
+        label: "plugin manifest",
         status: "error",
-        detail: `Entry file(s) not found: ${missing.join(", ")}`,
-        hint: "Run npm run build to generate dist files."
+        detail: "Missing configSchema in plugin manifest",
+        hint: "Add configSchema to openclaw.plugin.json for config validation."
+      };
+    }
+    const hasVaultPath = Boolean(parsed.configSchema.properties?.vaultPath);
+    if (!hasVaultPath) {
+      return {
+        label: "plugin manifest",
+        status: "warn",
+        detail: "configSchema missing vaultPath property",
+        hint: "Add vaultPath to configSchema.properties for vault path configuration."
       };
     }
     return {
-      label: "plugin extensions registration",
+      label: "plugin manifest",
       status: "ok",
-      detail: extensions.join(", ")
+      detail: `id: ${parsed.id}, configSchema defined`
     };
   } catch (err) {
     return {
-      label: "plugin extensions registration",
+      label: "plugin manifest",
       status: "error",
-      detail: err?.message || "Unable to parse package.json"
+      detail: err?.message || "Unable to parse openclaw.plugin.json"
     };
   }
 }
 function checkSkillMetadata(options) {
-  const skillRaw = readOptionalFile(
-    resolveProjectFile("SKILL.md", options.baseDir)
-  );
+  const skillRaw = readOptionalFile(resolveProjectFile("SKILL.md", options.baseDir));
   if (!skillRaw) {
     return {
       label: "skill metadata",
@@ -198,8 +284,11 @@ function checkSkillMetadata(options) {
 function checkOpenClawCompatibility(options = {}) {
   const checks = [
     checkOpenClawCli(),
+    checkPackageHookRegistration(options),
     checkPluginManifest(options),
-    checkPluginExtensions(options),
+    checkHookManifest(options),
+    checkHookManifestRequirements(options),
+    checkHookHandlerSafety(options),
     checkSkillMetadata(options)
   ];
   const warnings = checks.filter((check) => check.status === "warn").length;
@@ -219,9 +308,7 @@ function formatCompatibilityReport(report) {
   lines.push("");
   for (const check of report.checks) {
     const prefix = check.status === "ok" ? "\u2713" : check.status === "warn" ? "\u26A0" : "\u2717";
-    lines.push(
-      `${prefix} ${check.label}${check.detail ? ` \u2014 ${check.detail}` : ""}`
-    );
+    lines.push(`${prefix} ${check.label}${check.detail ? ` \u2014 ${check.detail}` : ""}`);
     if (check.hint) {
       lines.push(`  ${check.hint}`);
     }

package/dist/chunk-Y6VJKXGL.js

@@ -0,0 +1,373 @@
+import {
+  DEFAULT_SERVE_PORT,
+  configureTailscaleServe,
+  discoverClawVaultPeers,
+  findPeer,
+  getOnlinePeers,
+  getTailscaleStatus,
+  getTailscaleVersion,
+  serveVault,
+  stopTailscaleServe,
+  syncWithPeer
+} from "./chunk-TIGW564L.js";
+import {
+  resolveVaultPath
+} from "./chunk-GNJL4YGR.js";
+
+// src/commands/tailscale.ts
+import * as path from "path";
+async function tailscaleStatusCommand(options = {}) {
+  const status = getTailscaleStatus();
+  if (options.json) {
+    console.log(JSON.stringify(status, null, 2));
+    return status;
+  }
+  if (!status.installed) {
+    console.log("Tailscale: Not installed");
+    console.log("  Install from: https://tailscale.com/download");
+    return status;
+  }
+  const version = getTailscaleVersion();
+  console.log(`Tailscale: ${version || "installed"}`);
+  if (!status.running) {
+    console.log("  Status: Daemon not running");
+    if (status.error) {
+      console.log(`  Error: ${status.error}`);
+    }
+    return status;
+  }
+  console.log(`  Status: ${status.backendState}`);
+  if (status.connected) {
+    console.log(`  Tailnet: ${status.tailnetName || "unknown"}`);
+    console.log(`  Self IP: ${status.selfIP || "unknown"}`);
+    console.log(`  Hostname: ${status.selfHostname || "unknown"}`);
+    if (status.selfDNSName) {
+      console.log(`  DNS Name: ${status.selfDNSName}`);
+    }
+    if (options.peers || status.peers.length > 0) {
+      const onlinePeers = status.peers.filter((p) => p.online);
+      const offlinePeers = status.peers.filter((p) => !p.online);
+      console.log(`
+Peers (${onlinePeers.length} online, ${offlinePeers.length} offline):`);
+      for (const peer of onlinePeers) {
+        const ip = peer.tailscaleIPs[0] || "no-ip";
+        const os = peer.os ? ` (${peer.os})` : "";
+        const clawvault = peer.clawvaultServing ? " [ClawVault]" : "";
+        console.log(`  \u25CF ${peer.hostname}${os} - ${ip}${clawvault}`);
+      }
+      if (options.peers) {
+        for (const peer of offlinePeers) {
+          const ip = peer.tailscaleIPs[0] || "no-ip";
+          const os = peer.os ? ` (${peer.os})` : "";
+          console.log(`  \u25CB ${peer.hostname}${os} - ${ip} [offline]`);
+        }
+      }
+    }
+  } else {
+    console.log("  Status: Not connected to tailnet");
+    if (status.error) {
+      console.log(`  Error: ${status.error}`);
+    }
+  }
+  return status;
+}
+function registerTailscaleStatusCommand(program) {
+  program.command("tailscale-status").alias("ts-status").description("Show Tailscale connection status and peers").option("--json", "Output as JSON").option("--peers", "Show all peers including offline").action(async (rawOptions) => {
+    await tailscaleStatusCommand({
+      json: rawOptions.json,
+      peers: rawOptions.peers
+    });
+  });
+}
+async function tailscaleSyncCommand(options) {
+  const vaultPath = resolveVaultPath({ explicitPath: options.vaultPath });
+  const status = getTailscaleStatus();
+  if (!status.installed) {
+    const error = {
+      pushed: [],
+      pulled: [],
+      deleted: [],
+      unchanged: [],
+      errors: ["Tailscale not installed. Install from https://tailscale.com/download"],
+      stats: { bytesTransferred: 0, filesProcessed: 0, duration: 0 }
+    };
+    if (options.json) {
+      console.log(JSON.stringify(error, null, 2));
+    } else {
+      console.error("Error: Tailscale not installed");
+    }
+    return error;
+  }
+  if (!status.connected) {
+    const error = {
+      pushed: [],
+      pulled: [],
+      deleted: [],
+      unchanged: [],
+      errors: ["Not connected to Tailscale. Run `tailscale up` to connect."],
+      stats: { bytesTransferred: 0, filesProcessed: 0, duration: 0 }
+    };
+    if (options.json) {
+      console.log(JSON.stringify(error, null, 2));
+    } else {
+      console.error("Error: Not connected to Tailscale");
+    }
+    return error;
+  }
+  const peer = findPeer(options.peer);
+  if (!peer) {
+    const error = {
+      pushed: [],
+      pulled: [],
+      deleted: [],
+      unchanged: [],
+      errors: [`Peer not found: ${options.peer}`],
+      stats: { bytesTransferred: 0, filesProcessed: 0, duration: 0 }
+    };
+    if (options.json) {
+      console.log(JSON.stringify(error, null, 2));
+    } else {
+      console.error(`Error: Peer not found: ${options.peer}`);
+      console.log("\nAvailable online peers:");
+      for (const p of getOnlinePeers()) {
+        console.log(`  - ${p.hostname} (${p.tailscaleIPs[0]})`);
+      }
+    }
+    return error;
+  }
+  if (!peer.online) {
+    const error = {
+      pushed: [],
+      pulled: [],
+      deleted: [],
+      unchanged: [],
+      errors: [`Peer is offline: ${peer.hostname}`],
+      stats: { bytesTransferred: 0, filesProcessed: 0, duration: 0 }
+    };
+    if (options.json) {
+      console.log(JSON.stringify(error, null, 2));
+    } else {
+      console.error(`Error: Peer is offline: ${peer.hostname}`);
+    }
+    return error;
+  }
+  const syncOptions = {
+    peer: peer.tailscaleIPs[0],
+    port: options.port || DEFAULT_SERVE_PORT,
+    direction: options.direction || "bidirectional",
+    dryRun: options.dryRun,
+    deleteOrphans: options.deleteOrphans,
+    categories: options.categories,
+    https: options.https
+  };
+  if (!options.json && !options.dryRun) {
+    console.log(`Syncing with ${peer.hostname} (${peer.tailscaleIPs[0]})...`);
+  }
+  const result = await syncWithPeer(vaultPath, syncOptions);
+  if (options.json) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    const prefix = options.dryRun ? "[dry-run] " : "";
+    if (result.pushed.length > 0) {
+      console.log(`
+${prefix}Pushed ${result.pushed.length} file(s):`);
+      for (const file of result.pushed.slice(0, 10)) {
+        console.log(`  \u2192 ${file}`);
+      }
+      if (result.pushed.length > 10) {
+        console.log(`  ... and ${result.pushed.length - 10} more`);
+      }
+    }
+    if (result.pulled.length > 0) {
+      console.log(`
+${prefix}Pulled ${result.pulled.length} file(s):`);
+      for (const file of result.pulled.slice(0, 10)) {
+        console.log(`  \u2190 ${file}`);
+      }
+      if (result.pulled.length > 10) {
+        console.log(`  ... and ${result.pulled.length - 10} more`);
+      }
+    }
+    if (result.deleted.length > 0) {
+      console.log(`
+${prefix}Deleted ${result.deleted.length} file(s):`);
+      for (const file of result.deleted.slice(0, 10)) {
+        console.log(`  \u2717 ${file}`);
+      }
+      if (result.deleted.length > 10) {
+        console.log(`  ... and ${result.deleted.length - 10} more`);
+      }
+    }
+    if (result.errors.length > 0) {
+      console.log(`
+Errors (${result.errors.length}):`);
+      for (const error of result.errors) {
+        console.log(`  ! ${error}`);
+      }
+    }
+    console.log(`
+Summary:`);
+    console.log(`  Pushed: ${result.pushed.length}`);
+    console.log(`  Pulled: ${result.pulled.length}`);
+    console.log(`  Deleted: ${result.deleted.length}`);
+    console.log(`  Unchanged: ${result.unchanged.length}`);
+    console.log(`  Errors: ${result.errors.length}`);
+    console.log(`  Duration: ${result.stats.duration}ms`);
+    console.log(`  Transferred: ${formatBytes(result.stats.bytesTransferred)}`);
+  }
+  return result;
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}
+function registerTailscaleSyncCommand(program) {
+  program.command("tailscale-sync").alias("ts-sync").description("Sync vault with a peer on the Tailscale network").requiredOption("--peer <hostname>", "Peer hostname or IP to sync with").option("-v, --vault <path>", "Vault path").option("--port <number>", "Port on the peer", parseInt).option("--direction <dir>", "Sync direction: push, pull, or bidirectional", "bidirectional").option("--dry-run", "Show what would be synced without making changes").option("--delete-orphans", "Delete files that exist locally but not on peer (pull only)").option("--categories <list>", "Comma-separated list of categories to sync").option("--https", "Use HTTPS for connection").option("--json", "Output as JSON").action(async (rawOptions) => {
+    await tailscaleSyncCommand({
+      peer: rawOptions.peer,
+      vaultPath: rawOptions.vault,
+      port: rawOptions.port,
+      direction: rawOptions.direction,
+      dryRun: rawOptions.dryRun,
+      deleteOrphans: rawOptions.deleteOrphans,
+      categories: rawOptions.categories?.split(",").map((c) => c.trim()),
+      https: rawOptions.https,
+      json: rawOptions.json
+    });
+  });
+}
+var activeServeInstance = null;
+async function tailscaleServeCommand(options) {
+  if (options.stop) {
+    if (activeServeInstance) {
+      await activeServeInstance.stop();
+      activeServeInstance = null;
+      console.log("ClawVault serve stopped.");
+    }
+    stopTailscaleServe();
+    return;
+  }
+  const vaultPath = resolveVaultPath({ explicitPath: options.vaultPath });
+  const port = options.port || DEFAULT_SERVE_PORT;
+  const status = getTailscaleStatus();
+  console.log(`Starting ClawVault serve...`);
+  console.log(`  Vault: ${path.basename(vaultPath)}`);
+  console.log(`  Port: ${port}`);
+  activeServeInstance = serveVault(vaultPath, { port });
+  console.log(`  Local URL: http://localhost:${port}/.clawvault`);
+  if (status.connected) {
+    console.log(`  Tailscale URL: http://${status.selfIP}:${port}/.clawvault`);
+    if (status.selfDNSName) {
+      const dnsHost = status.selfDNSName.replace(/\.$/, "");
+      console.log(`  MagicDNS URL: http://${dnsHost}:${port}/.clawvault`);
+    }
+    if (options.funnel || options.background) {
+      console.log("\nConfiguring Tailscale serve...");
+      configureTailscaleServe(port, {
+        funnel: options.funnel,
+        background: options.background
+      });
+      if (options.funnel) {
+        console.log("  Funnel enabled - vault is accessible from the public internet");
+      }
+    }
+  } else {
+    console.log("\n  Note: Not connected to Tailscale. Only local access available.");
+  }
+  console.log("\nEndpoints:");
+  console.log(`  Health: /.clawvault/health`);
+  console.log(`  Manifest: /.clawvault/manifest`);
+  console.log(`  Files: /.clawvault/files/<path>`);
+  if (!options.background) {
+    console.log("\nPress Ctrl+C to stop serving.");
+    process.on("SIGINT", async () => {
+      console.log("\nStopping ClawVault serve...");
+      if (activeServeInstance) {
+        await activeServeInstance.stop();
+        activeServeInstance = null;
+      }
+      stopTailscaleServe();
+      process.exit(0);
+    });
+    await new Promise(() => {
+    });
+  }
+}
+function registerTailscaleServeCommand(program) {
+  program.command("tailscale-serve").alias("ts-serve").description("Serve vault for sync over Tailscale").option("-v, --vault <path>", "Vault path").option("--port <number>", `Port to serve on (default: ${DEFAULT_SERVE_PORT})`, parseInt).option("--funnel", "Expose via Tailscale Funnel (public internet)").option("--background", "Run in background").option("--stop", "Stop serving").action(async (rawOptions) => {
+    await tailscaleServeCommand({
+      vaultPath: rawOptions.vault,
+      port: rawOptions.port,
+      funnel: rawOptions.funnel,
+      background: rawOptions.background,
+      stop: rawOptions.stop
+    });
+  });
+}
+async function tailscaleDiscoverCommand(options = {}) {
+  const port = options.port || DEFAULT_SERVE_PORT;
+  const status = getTailscaleStatus();
+  if (!status.connected) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: "Not connected to Tailscale", peers: [] }));
+    } else {
+      console.error("Error: Not connected to Tailscale");
+    }
+    return [];
+  }
+  if (!options.json) {
+    console.log("Discovering ClawVault peers on tailnet...");
+  }
+  const peers = await discoverClawVaultPeers(port);
+  if (options.json) {
+    console.log(JSON.stringify({ peers }, null, 2));
+  } else {
+    if (peers.length === 0) {
+      console.log("\nNo ClawVault peers found.");
+      console.log("  Run `clawvault tailscale-serve` on other devices to enable sync.");
+    } else {
+      console.log(`
+Found ${peers.length} ClawVault peer(s):`);
+      for (const peer of peers) {
+        const ip = peer.tailscaleIPs[0] || "no-ip";
+        const os = peer.os ? ` (${peer.os})` : "";
+        console.log(`  \u25CF ${peer.hostname}${os}`);
+        console.log(`    IP: ${ip}`);
+        console.log(`    Port: ${peer.clawvaultPort}`);
+        if (peer.dnsName) {
+          console.log(`    DNS: ${peer.dnsName.replace(/\.$/, "")}`);
+        }
+      }
+    }
+  }
+  return peers;
+}
+function registerTailscaleDiscoverCommand(program) {
+  program.command("tailscale-discover").alias("ts-discover").description("Discover ClawVault peers on the Tailscale network").option("--port <number>", `Port to check (default: ${DEFAULT_SERVE_PORT})`, parseInt).option("--json", "Output as JSON").action(async (rawOptions) => {
+    await tailscaleDiscoverCommand({
+      port: rawOptions.port,
+      json: rawOptions.json
+    });
+  });
+}
+function registerTailscaleCommands(program) {
+  registerTailscaleStatusCommand(program);
+  registerTailscaleSyncCommand(program);
+  registerTailscaleServeCommand(program);
+  registerTailscaleDiscoverCommand(program);
+}
+
+export {
+  tailscaleStatusCommand,
+  registerTailscaleStatusCommand,
+  tailscaleSyncCommand,
+  registerTailscaleSyncCommand,
+  tailscaleServeCommand,
+  registerTailscaleServeCommand,
+  tailscaleDiscoverCommand,
+  registerTailscaleDiscoverCommand,
+  registerTailscaleCommands
+};