pinomad 0.3.0 → 0.5.0

package/README.md

@@ -1,6 +1,6 @@
 # PiNomad
 
-English · [中文](README.zh-CN.md)
+English · [中文](README.zh-CN.md) · [pinomad.si](https://pinomad.si)
 
 A self-hosted coding agent built on [Pi Durable](https://www.npmjs.com/package/@earendil-works/pi-durable). The agent runs on your own machine; the Mac app, the web client, and the iPhone app all attach to the same runs.
 
@@ -87,8 +87,10 @@ These docs are written in Chinese.
 | [Usage](docs/usage.md) | Projects, worktrees, tools, MCP configuration |
 | [Remote access](docs/remote-access.md) | Pairing, tunnels, self-hosted relay (VPS or container platforms) |
 | [Running as a service](docs/service.md) | `service` and `upgrade` commands, platform notes |
+| [Website](docs/website.md) | The pinomad.si landing page and the hosted app.pinomad.si instance |
+| [Architecture overview](docs/architecture.md) | How the parts and languages fit together, with send/receive diagrams |
 | [Architecture decisions](docs/adr/README.md) | Why things are the way they are |
-| [Roadmap](docs/roadmap.md) | What's done and what's next |
+| [Roadmap](docs/roadmap.md) | Direction and order; items live in GitHub Issues |
 | [Glossary](GLOSSARY.md) | Domain terms |
 
 ## Contributing

package/dist/{chunk-3tf23vjq.js → chunk-1d9sppj0.js}

@@ -1,6 +1,6 @@
 // apps/host/src/distribution.ts
 import { fileURLToPath } from "node:url";
-var packagedVersion = "0.3.0";
+var packagedVersion = "0.5.0";
 var webRoot = fileURLToPath(new URL(packagedVersion === undefined ? "../../web/dist" : "../web/", import.meta.url));
 var hostEntry = packagedVersion === undefined ? { script: fileURLToPath(new URL("./main.ts", import.meta.url)), args: [] } : { script: fileURLToPath(new URL("./pinomad.js", import.meta.url)), args: ["host"] };
 var commandHint = (name) => packagedVersion === undefined ? `bun run ${name}` : `pinomad ${name}`;

package/dist/chunk-26d04z02.js

@@ -0,0 +1,126 @@
+import {
+  RELAY_CLOSE,
+  decodeRelayToHost,
+  encodeRelayFrame,
+  relayHostId,
+  relayWsBase,
+  signRelayChallenge,
+  signRelayChallengeV2,
+  toBase64Url
+} from "./chunk-kmbh44dt.js";
+
+// apps/host/src/cli/server-ops.ts
+import { WebSocket } from "ws";
+
+// packages/client/src/account.ts
+var fallbackFetch = (url, init) => fetch(url, init);
+async function probeAccounts(origin, fetchImpl = fallbackFetch) {
+  const timeout = new AbortController;
+  const timer = setTimeout(() => timeout.abort(), 5000);
+  try {
+    const response = await fetchImpl(`${origin.replace(/\/+$/, "")}/api/me`, { signal: timeout.signal });
+    if (response.status === 401)
+      return "enabled";
+    if (response.status === 200) {
+      const text = await response.text();
+      let body;
+      try {
+        body = JSON.parse(text);
+      } catch {
+        return "disabled";
+      }
+      return typeof body?.user === "object" && body.user !== null ? "enabled" : "disabled";
+    }
+    return response.status === 404 ? "disabled" : "unreachable";
+  } catch {
+    return "unreachable";
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function isSecureServerOrigin(origin) {
+  let url;
+  try {
+    url = new URL(origin);
+  } catch {
+    return false;
+  }
+  const host = url.hostname;
+  const loopback = host === "localhost" || host.endsWith(".localhost") || host.startsWith("127.") || host === "::1" || host === "[::1]";
+  return url.protocol === "https:" || url.protocol === "http:" && loopback;
+}
+
+// apps/host/src/cli/server-ops.ts
+function assertSecureServerOrigin(origin) {
+  try {
+    new URL(origin);
+  } catch {
+    throw new Error(`not a URL: ${origin}`);
+  }
+  if (isSecureServerOrigin(origin))
+    return;
+  throw new Error(`account operations need an https origin (loopback http allowed for development) — got ${origin}`);
+}
+var probeServerAccounts = (origin, fetchImpl = fetch) => probeAccounts(origin, fetchImpl);
+var closeReason = (code, origin) => {
+  switch (code) {
+    case RELAY_CLOSE.badSignature:
+      return `the server rejected this host's registration signature (${code})`;
+    case RELAY_CLOSE.hostNotAllowed:
+      return `the server does not know this host (${code}) — a pre-accounts server can't do join/leave; upgrade it first`;
+    default:
+      return `the connection to ${origin} closed (${code})`;
+  }
+};
+async function runServerOperation(options) {
+  const origin = options.origin.replace(/\/+$/, "");
+  assertSecureServerOrigin(origin);
+  const hostId = relayHostId(options.signingKey.publicKey);
+  const timeoutMs = options.timeoutMs ?? 1e4;
+  const socket = new WebSocket(`${relayWsBase(origin)}/host`, { handshakeTimeout: timeoutMs });
+  return await new Promise((resolve, reject) => {
+    const finish = (done) => {
+      clearTimeout(timer);
+      socket.close();
+      done();
+    };
+    const timer = setTimeout(() => finish(() => reject(new Error(`no answer from ${origin} within ${timeoutMs / 1000}s`))), timeoutMs);
+    socket.once("error", () => {});
+    socket.once("close", (code) => finish(() => reject(new Error(closeReason(code, origin)))));
+    socket.on("message", (data, isBinary) => {
+      let frame;
+      try {
+        if (isBinary)
+          throw new Error("binary frame");
+        frame = decodeRelayToHost(data.toString());
+      } catch {
+        finish(() => reject(new Error(`${origin} is not speaking the pinomad relay protocol`)));
+        return;
+      }
+      if (frame.t === "challenge") {
+        const noisePublicKey = toBase64Url(options.noisePublicKey);
+        const challenge = { relayOrigin: origin, hostId, nonce: frame.nonce };
+        socket.send(encodeRelayFrame({
+          t: "register",
+          hostId,
+          signature: signRelayChallenge(options.signingKey.secretKey, challenge),
+          signatureV2: signRelayChallengeV2(options.signingKey.secretKey, { ...challenge, noisePublicKey }),
+          noisePublicKey,
+          op: options.op,
+          ...options.joinToken === undefined ? {} : { joinToken: options.joinToken },
+          ...options.name === undefined ? {} : { name: options.name }
+        }));
+        return;
+      }
+      if (frame.t === "registered") {
+        finish(() => reject(new Error(`${origin} ignored the operation — the server is too old for accounts; upgrade it first`)));
+        return;
+      }
+      if (frame.t === "incoming" || frame.t === "pairing-request" || frame.t === "push-result")
+        return;
+      finish(() => resolve(frame));
+    });
+  });
+}
+
+export { assertSecureServerOrigin, probeServerAccounts, runServerOperation };