@xbghc/warden 0.2.0 → 0.3.0

package/README.md

@@ -134,7 +134,8 @@ branch name, plus mtime and size of the paths status reports — enough to notic
 already-modified file) and pushes a change event over `GET /api/events` (SSE). The page then re-runs
 the normal refresh: re-anchor, reload both file lists, reload the open diff. Your draft comment,
 selection, current view and current file are left alone, and the diff is scrolled back to where you
-were reading. Turn it off with the *自动刷新* checkbox; `r` still refreshes by hand.
+were reading. Turn it off with the *自动* toggle next to the refresh button; `r` still
+refreshes by hand.
 
 ## Todos
 
@@ -226,11 +227,12 @@ Only `dist/`, `README.md`, `LICENSE` and `package.json` are published.
 
 Releasing: bump `version` in `package.json`, commit, then push a matching tag —
 `git tag v0.2.0 && git push origin v0.2.0`. The `Publish to npm` workflow checks the tag against the
-version, runs build + tests through `prepublishOnly`, and publishes over OIDC trusted publishing —
-no `NPM_TOKEN` secret, and provenance is attested automatically. It relies on a trusted publisher
-configured on the package's npmjs.com settings page (user `xbghc`, repo `warden`, workflow
-`publish.yml`). CI runs typecheck, tests, build and a `publish --dry-run` on every push to `main` and
-every pull request.
+version, runs build + tests through `prepublishOnly`, and publishes over OIDC trusted publishing — no
+`NPM_TOKEN` secret to store or rotate. It relies on a trusted publisher configured on the package's
+npmjs.com settings page (user `xbghc`, repo `warden`, workflow `publish.yml`), and passes
+`--provenance` explicitly, because npm's automatic attestation does not fire through `pnpm publish`
+(0.2.0 shipped without one). CI runs typecheck, tests, build and a `publish --dry-run` on every push
+to `main` and every pull request.
 
 ## License
 

package/dist/cli.js

@@ -8,6 +8,7 @@ import { fileURLToPath } from "url";
 
 // packages/server/src/index.ts
 import net from "net";
+import { randomUUID as randomUUID2 } from "crypto";
 
 // node_modules/.pnpm/@hono+node-server@1.19.17_hono@4.13.7/node_modules/@hono/node-server/dist/index.mjs
 import { createServer as createServerHTTP } from "http";
@@ -4246,6 +4247,7 @@ function createApp(opts) {
     return c.json({ error: err instanceof Error ? err.message : String(err), code: "internal" }, 500);
   });
   const api = new Hono2();
+  api.get("/ping", (c) => c.text(opts.instanceToken ?? ""));
   api.get("/repo", async (c) => {
     const state = await store.load();
     const info = await getRepoInfo(repo, state.prefs.lastTarget ?? "working");
@@ -4800,6 +4802,37 @@ function createApp(opts) {
   return app;
 }
 
+// packages/server/src/wsl.ts
+import { execFile as execFile3 } from "child_process";
+import { readFile as readFile4 } from "fs/promises";
+var PROBE_TIMEOUT_MS = 3e3;
+async function isWsl(env = process.env, platform = process.platform) {
+  if (platform !== "linux") return false;
+  if (env.WSL_DISTRO_NAME || env.WSL_INTEROP) return true;
+  try {
+    return /microsoft/i.test(await readFile4("/proc/sys/kernel/osrelease", "utf8"));
+  } catch {
+    return false;
+  }
+}
+function reachableFromWindows(port, token, timeoutMs = PROBE_TIMEOUT_MS) {
+  return new Promise((resolve) => {
+    execFile3(
+      "curl.exe",
+      ["--silent", "--max-time", String(Math.ceil(timeoutMs / 1e3)), `http://127.0.0.1:${port}/api/ping`],
+      { timeout: timeoutMs + 1e3, encoding: "utf8", windowsHide: true },
+      (error, stdout) => {
+        const code = error?.code;
+        if (typeof code === "string") {
+          resolve(void 0);
+          return;
+        }
+        resolve(stdout.trim() === token);
+      }
+    );
+  });
+}
+
 // packages/server/src/index.ts
 var HOST = "127.0.0.1";
 var DEFAULT_PORT_START = 4100;
@@ -4818,35 +4851,56 @@ async function findFreePort(start = DEFAULT_PORT_START, host = HOST) {
   }
   throw new Error(`no free port found starting at ${start}`);
 }
+var PROBE_ATTEMPTS = 5;
 async function startServer(opts) {
   const repo = await resolveRepo(opts.repoPath);
   const stateFile = opts.stateFile ?? stateFilePath(repo.commonRoot);
   const store = new StateStore(stateFile, repo.commonRoot);
-  const app = createApp({ repo, store, nvim: new NvimService(), webDir: opts.webDir });
+  const instanceToken = randomUUID2();
+  const app = createApp({ repo, store, nvim: new NvimService(), webDir: opts.webDir, instanceToken });
+  const listen = (p) => new Promise((resolve, reject) => {
+    const s = serve({ fetch: app.fetch, hostname: HOST, port: p }, () => resolve(s));
+    s.once("error", reject);
+  });
+  const stop = (s) => new Promise((resolve, reject) => {
+    s.close((err) => err ? reject(err) : resolve());
+    if ("closeAllConnections" in s) s.closeAllConnections();
+  });
   let port;
+  let server;
+  const skippedPorts = [];
+  let windowsReachable;
   if (opts.port !== void 0) {
     if (!await isPortFree(opts.port)) throw new Error(`port ${opts.port} is already in use`);
     port = opts.port;
+    server = await listen(port);
   } else {
-    port = await findFreePort();
+    const probe = opts.probeWindows ?? (await isWsl() ? reachableFromWindows : void 0);
+    let start = DEFAULT_PORT_START;
+    for (let attempt = 1; ; attempt++) {
+      port = await findFreePort(start);
+      server = await listen(port);
+      if (!probe) break;
+      windowsReachable = await probe(port, instanceToken);
+      if (windowsReachable !== false || attempt >= PROBE_ATTEMPTS) break;
+      await stop(server);
+      skippedPorts.push(port);
+      start = port + 1;
+    }
   }
-  const server = await new Promise((resolve, reject) => {
-    const s = serve({ fetch: app.fetch, hostname: HOST, port }, () => resolve(s));
-    s.once("error", reject);
-  });
   return {
     url: `http://${HOST}:${port}/`,
     port,
     repo,
     stateFile,
-    close: () => new Promise((resolve, reject) => {
-      server.close((err) => err ? reject(err) : resolve());
-    })
+    skippedPorts,
+    windowsReachable,
+    close: () => stop(server)
   };
 }
 
 // bin/cli.ts
-var VERSION = true ? "0.2.0" : "dev";
+var VERSION = true ? "0.3.0" : "dev";
 function parseArgs(argv) {
   const args = { repoPath: process.cwd(), open: true, help: false, version: false };
   for (let i = 0; i < argv.length; i++) {
@@ -4874,7 +4928,8 @@ function usage() {
 Usage: warden [repoPath] [options]
 
 Options:
-  --port <n>, -p <n>   Listen on a fixed port (default: first free port from 4100)
+  --port <n>, -p <n>   Listen on a fixed port (default: first free port from 4100, and under WSL
+                       the first one the Windows side can reach)
   --no-open            Do not try to open the browser
   -h, --help           Show this help
   -v, --version        Print version
@@ -4951,6 +5006,14 @@ async function main() {
   console.log(`  repo:  ${server.repo.root}`);
   console.log(`  state: ${server.stateFile}`);
   console.log(`  url:   ${server.url}`);
+  if (server.skippedPorts.length > 0) {
+    const ports = server.skippedPorts.join(", ");
+    const plural = server.skippedPorts.length > 1 ? "s" : "";
+    console.log(`  note:  skipped port${plural} ${ports} \u2014 the WSL2 localhost relay does not publish ${plural ? "them" : "it"} to Windows`);
+  }
+  if (server.windowsReachable === false) {
+    console.error(`warning: Windows cannot reach ${server.url} either. Run with --port <n> to pick a port it can publish.`);
+  }
   if (args.open) {
     const opened = await openBrowser(server.url);
     if (!opened) console.log("  (could not open a browser automatically; open the URL manually)");