pinomad 0.4.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-fgx2sh7d.js → chunk-1d9sppj0.js}

@@ -1,6 +1,6 @@
 // apps/host/src/distribution.ts
 import { fileURLToPath } from "node:url";
-var packagedVersion = "0.4.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-5785kwej.js → chunk-26d04z02.js}

@@ -1,15 +1,13 @@
-import {
-  relayWsBase
-} from "./chunk-knaw1a9g.js";
 import {
   RELAY_CLOSE,
   decodeRelayToHost,
   encodeRelayFrame,
   relayHostId,
+  relayWsBase,
   signRelayChallenge,
   signRelayChallengeV2,
   toBase64Url
-} from "./chunk-7gmkgyaz.js";
+} from "./chunk-kmbh44dt.js";
 
 // apps/host/src/cli/server-ops.ts
 import { WebSocket } from "ws";
@@ -118,7 +116,7 @@ async function runServerOperation(options) {
         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")
+      if (frame.t === "incoming" || frame.t === "pairing-request" || frame.t === "push-result")
         return;
       finish(() => resolve(frame));
     });

package/dist/{chunk-vw5yb5pd.js → chunk-4by4x5c4.js}

@@ -2,35 +2,33 @@
 import {
   serveWebClient
 } from "./chunk-r6w5aqkw.js";
-import {
-  relayWsBase
-} from "./chunk-knaw1a9g.js";
-import {
-  commandHint,
-  webRoot
-} from "./chunk-fgx2sh7d.js";
 import {
   RELAY_CLOSE,
   decodeHostToRelay,
   encodeRelayFrame,
+  relayWsBase,
   verifyRelayChallenge,
   verifyRelayChallengeV2
-} from "./chunk-7gmkgyaz.js";
+} from "./chunk-kmbh44dt.js";
+import {
+  commandHint,
+  webRoot
+} from "./chunk-1d9sppj0.js";
 import"./chunk-df32avw6.js";
 
-// apps/relay/src/main.ts
+// apps/server/src/main.ts
 import { homedir } from "node:os";
 import { join as join2, resolve } from "node:path";
 import { parseArgs } from "node:util";
 
-// apps/relay/src/accounts.ts
+// apps/server/src/accounts.ts
 import { createHash, randomBytes, scrypt, timingSafeEqual } from "node:crypto";
 import { mkdir } from "node:fs/promises";
 import { join } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import { promisify } from "node:util";
 
-// apps/relay/src/lock.ts
+// apps/server/src/lock.ts
 import lockfile from "proper-lockfile";
 async function lockDataDir(dir, options) {
   const stale = Math.max(2000, options?.staleMs ?? 1e4);
@@ -44,6 +42,8 @@ async function lockDataDir(dir, options) {
         throw error;
     }
   }).catch((error) => {
+    if (error.code !== "ELOCKED")
+      throw error;
     throw new Error(`Data directory is already in use by a running process: ${dir}`, { cause: error });
   });
   return async () => {
@@ -52,7 +52,7 @@ async function lockDataDir(dir, options) {
   };
 }
 
-// apps/relay/src/accounts.ts
+// apps/server/src/accounts.ts
 var DB_FILE = "server.sqlite";
 var SCHEMA_VERSION = 1;
 var SESSION_TTL_MS = 30 * 24 * 60 * 60 * 1000;
@@ -394,13 +394,220 @@ async function changePassword(options) {
   }
 }
 
-// apps/relay/src/relay.ts
+// apps/server/src/apns.ts
+import { createPrivateKey, sign } from "node:crypto";
+import { connect } from "node:http2";
+var AUTHORITIES = {
+  production: "https://api.push.apple.com",
+  development: "https://api.sandbox.push.apple.com"
+};
+var PAYLOAD_MAX_BYTES = 4096;
+var EXPIRATION_SECONDS = 3600;
+var TOKEN_REFRESH_MS = 45 * 60 * 1000;
+var REQUEST_TIMEOUT_MS = 8000;
+var SERVER_ERROR_RETRY_MS = 15 * 60 * 1000;
+var base64url = (text) => Buffer.from(text, "utf8").toString("base64url");
+function loadApnsConfig(env = process.env) {
+  const teamId = env.PINOMAD_SERVER_APNS_TEAM_ID?.trim();
+  const topic = env.PINOMAD_SERVER_APNS_TOPIC?.trim();
+  if (teamId === undefined || teamId === "" || topic === undefined || topic === "")
+    return;
+  const loadEnv = (name) => {
+    const keyId = env[`PINOMAD_SERVER_APNS_${name}_KEY_ID`]?.trim();
+    const keyPem = env[`PINOMAD_SERVER_APNS_${name}_KEY`]?.replace(/\\n/g, `
+`).trim();
+    if (keyId === undefined && keyPem === undefined)
+      return;
+    if (keyId === undefined || keyId === "" || keyPem === undefined || keyPem === "") {
+      console.error(`apns: PINOMAD_SERVER_APNS_${name}_KEY and _KEY_ID must both be set — environment disabled`);
+      return;
+    }
+    return { keyId, keyPem };
+  };
+  const production = loadEnv("PRODUCTION");
+  const development = loadEnv("DEVELOPMENT");
+  return {
+    teamId,
+    topic,
+    environments: {
+      ...production === undefined ? {} : { production },
+      ...development === undefined ? {} : { development }
+    }
+  };
+}
+function providerToken(key, keyId, teamId, iatSeconds) {
+  const signingInput = `${base64url(JSON.stringify({ alg: "ES256", kid: keyId }))}.${base64url(JSON.stringify({ iss: teamId, iat: iatSeconds }))}`;
+  const signature = sign("sha256", Buffer.from(signingInput, "utf8"), { key, dsaEncoding: "ieee-p1363" });
+  return `${signingInput}.${signature.toString("base64url")}`;
+}
+function openApns(config) {
+  const states = new Map;
+  for (const environment of ["production", "development"]) {
+    const env = config.environments[environment];
+    if (env === undefined)
+      continue;
+    try {
+      states.set(environment, {
+        key: createPrivateKey(env.keyPem),
+        keyId: env.keyId,
+        authority: env.authority ?? AUTHORITIES[environment]
+      });
+    } catch {
+      console.error(`apns: the ${environment} key is not a valid EC private key — environment disabled`);
+    }
+  }
+  const environments = [...states.keys()];
+  const bearerFor = (state) => {
+    const now = Date.now();
+    if (state.token !== undefined && now - state.token.issuedAt < TOKEN_REFRESH_MS)
+      return state.token.jwt;
+    const jwt = providerToken(state.key, state.keyId, config.teamId, Math.floor(now / 1000));
+    state.token = { jwt, issuedAt: now };
+    return jwt;
+  };
+  const sessionFor = (environment, state) => {
+    const existing = state.session;
+    if (existing !== undefined && !existing.destroyed && !existing.closed)
+      return existing;
+    const session = connect(state.authority);
+    const drop = () => {
+      if (state.session === session)
+        state.session = undefined;
+      if (!session.destroyed)
+        session.destroy();
+    };
+    session.once("goaway", drop);
+    session.once("error", drop);
+    session.once("close", () => {
+      if (state.session === session)
+        state.session = undefined;
+    });
+    state.session = session;
+    return session;
+  };
+  const payloadFor = (notification) => JSON.stringify({
+    aps: {
+      alert: { title: notification.title, body: notification.body },
+      sound: "default",
+      "thread-id": notification.collapseId
+    },
+    hostKey: notification.hostKey,
+    conversationId: notification.conversationId
+  });
+  const classify = (environment, status, headers, body, state) => {
+    const reason = typeof body?.reason === "string" ? body.reason : `HTTP ${status}`;
+    const timestamp = body?.timestamp;
+    if (status === 200)
+      return { result: "accepted", reason: "ok" };
+    if (status === 410) {
+      return {
+        result: "unregistered",
+        reason,
+        unregisteredAt: typeof timestamp === "number" ? timestamp : Date.now()
+      };
+    }
+    if (status === 403 && reason === "ExpiredProviderToken") {
+      state.token = undefined;
+      return { result: "retry", reason };
+    }
+    if (reason === "InvalidProviderToken" || reason === "TooManyProviderTokenUpdates") {
+      console.error(`apns: provider token problem for ${environment}: ${reason}`);
+      return { result: "rejected", reason };
+    }
+    if (status === 429) {
+      const retryAfter = Number(headers["retry-after"]);
+      return {
+        result: "retry",
+        reason,
+        ...Number.isFinite(retryAfter) && retryAfter > 0 ? { retryAfterMs: retryAfter * 1000 } : {}
+      };
+    }
+    if (status >= 500)
+      return { result: "retry", reason, retryAfterMs: SERVER_ERROR_RETRY_MS };
+    return { result: "rejected", reason };
+  };
+  return {
+    environments,
+    async send(request) {
+      const state = states.get(request.environment);
+      if (state === undefined)
+        return { result: "unavailable", reason: "environment not configured" };
+      const body = payloadFor(request.notification);
+      if (Buffer.byteLength(body, "utf8") > PAYLOAD_MAX_BYTES) {
+        return { result: "rejected", reason: "PayloadTooLarge" };
+      }
+      return await new Promise((resolve) => {
+        let session;
+        try {
+          session = sessionFor(request.environment, state);
+        } catch {
+          resolve({ result: "retry", reason: "session unavailable" });
+          return;
+        }
+        let stream;
+        try {
+          stream = session.request({
+            ":method": "POST",
+            ":path": `/3/device/${request.token}`,
+            authorization: `bearer ${bearerFor(state)}`,
+            "apns-push-type": "alert",
+            "apns-topic": config.topic,
+            "apns-expiration": String(Math.floor(Date.now() / 1000) + EXPIRATION_SECONDS),
+            "apns-collapse-id": request.notification.collapseId,
+            "content-type": "application/json"
+          });
+        } catch {
+          resolve({ result: "retry", reason: "session unavailable" });
+          return;
+        }
+        let status = 0;
+        let responseHeaders = {};
+        const chunks = [];
+        let settled = false;
+        const finish = (verdict) => {
+          if (settled)
+            return;
+          settled = true;
+          clearTimeout(timer);
+          stream.destroy();
+          resolve(verdict);
+        };
+        const timer = setTimeout(() => finish({ result: "retry", reason: "apns timeout" }), REQUEST_TIMEOUT_MS);
+        stream.on("response", (headers) => {
+          status = Number(headers[":status"] ?? 0);
+          responseHeaders = headers;
+        });
+        stream.on("data", (chunk) => chunks.push(chunk));
+        stream.on("end", () => {
+          let body2;
+          try {
+            body2 = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+          } catch {
+            body2 = undefined;
+          }
+          finish(classify(request.environment, status, responseHeaders, body2, state));
+        });
+        stream.on("error", () => finish({ result: "retry", reason: "connection error" }));
+        stream.on("aborted", () => finish({ result: "retry", reason: "connection aborted" }));
+        stream.end(body);
+      });
+    },
+    close() {
+      for (const state of states.values())
+        state.session?.destroy();
+      states.clear();
+      return Promise.resolve();
+    }
+  };
+}
+
+// apps/server/src/relay.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
 import { once } from "node:events";
 import { createServer } from "node:http";
 import { WebSocket, WebSocketServer } from "ws";
 
-// apps/relay/src/api.ts
+// apps/server/src/api.ts
 var SESSION_COOKIE = "__Host-pinomad-session";
 var MAX_BODY = 8 * 1024;
 var MUTATING = new Set(["POST", "PUT", "PATCH", "DELETE"]);
@@ -635,7 +842,7 @@ async function handleApiRequest(request, response, ctx) {
   deny(404, "not_found");
 }
 
-// apps/relay/src/relay.ts
+// apps/server/src/relay.ts
 var MAX_PAYLOAD = 128 * 1024;
 var MAX_BUFFERED = 64 * 1024;
 var HIGH_WATER = 1024 * 1024;
@@ -647,11 +854,12 @@ var isSendableCloseCode = (code) => code >= 1000 && code <= 1003 || code >= 1007
 var rawLength = (data) => Array.isArray(data) ? data.reduce((sum, part) => sum + part.length, 0) : data.byteLength;
 var MAX_PAIRING_PER_HOST = 4;
 var MAX_PAIRING_PER_SESSION = 2;
+var MAX_PUSH_PER_HOST = 4;
+var MAX_PUSH_TOTAL = 32;
 async function startRelay(options) {
   const publicOrigin = options.publicOrigin.replace(/\/+$/, "");
   if (publicOrigin === "")
     throw new Error("publicOrigin is required");
-  const allowedHosts = new Set(options.allowedHosts);
   const acceptTimeoutMs = options.acceptTimeoutMs ?? 1e4;
   const registerTimeoutMs = options.registerTimeoutMs ?? 1e4;
   const pingIntervalMs = options.pingIntervalMs ?? 30000;
@@ -659,6 +867,12 @@ async function startRelay(options) {
   const accounts = options.accounts;
   const trustProxy = options.trustProxy ?? false;
   const pairingTimeoutMs = options.pairingTimeoutMs ?? 1e4;
+  const apns = options.push;
+  const pushEnvironments = apns?.environments ?? [];
+  const pushPerHost = options.pushLimits?.perHost ?? MAX_PUSH_PER_HOST;
+  const pushTotal = options.pushLimits?.total ?? MAX_PUSH_TOTAL;
+  let pushInflightTotal = 0;
+  const pushInflightHosts = new Map;
   const controls = new Map;
   const pending = new Map;
   const pairingRequests = new Map;
@@ -732,6 +946,45 @@ async function startRelay(options) {
     });
   }
   const pairing = { status: pairingStatus, request: requestPairing };
+  function handlePush(socket, hostId, frame) {
+    const startedAt = Date.now();
+    const finish = (verdict) => {
+      console.log(JSON.stringify({
+        event: "push",
+        hostId,
+        environment: frame.environment,
+        result: verdict.result,
+        reason: verdict.reason,
+        ms: Date.now() - startedAt
+      }));
+      if (socket.readyState === WebSocket.OPEN) {
+        socket.send(encodeRelayFrame({ t: "push-result", requestId: frame.requestId, ...verdict }));
+      }
+    };
+    if (accounts?.hasHost(hostId) !== true) {
+      finish({ result: "rejected", reason: "unauthorized" });
+      return;
+    }
+    if (apns === undefined || !pushEnvironments.includes(frame.environment)) {
+      finish({ result: "unavailable", reason: "environment not configured" });
+      return;
+    }
+    const perHost = pushInflightHosts.get(hostId) ?? 0;
+    if (perHost >= pushPerHost || pushInflightTotal >= pushTotal) {
+      finish({ result: "retry", reason: "rate_limited" });
+      return;
+    }
+    pushInflightTotal += 1;
+    pushInflightHosts.set(hostId, perHost + 1);
+    apns.send({ token: frame.token, environment: frame.environment, notification: frame.notification }).then(finish, () => finish({ result: "retry", reason: "server error" })).finally(() => {
+      pushInflightTotal -= 1;
+      const left = (pushInflightHosts.get(hostId) ?? 1) - 1;
+      if (left <= 0)
+        pushInflightHosts.delete(hostId);
+      else
+        pushInflightHosts.set(hostId, left);
+    });
+  }
   function runOp(socket, frame, noisePublicKey) {
     const answer = (reply) => socket.send(encodeRelayFrame(reply), () => socket.close(1000));
     if (accounts === undefined) {
@@ -763,8 +1016,7 @@ async function startRelay(options) {
       return;
     }
     answer({ t: "left" });
-    if (!allowedHosts.has(frame.hostId))
-      controls.get(frame.hostId)?.socket.close(RELAY_CLOSE.hostNotAllowed);
+    controls.get(frame.hostId)?.socket.close(RELAY_CLOSE.hostNotAllowed);
   }
   function onControl(socket) {
     track(socket);
@@ -785,6 +1037,10 @@ async function startRelay(options) {
           socket.close(1008, "malformed frame");
           return;
         }
+        if (answer.t === "push") {
+          handlePush(socket, hostId, answer);
+          return;
+        }
         if (answer.t === "pairing" || answer.t === "pairing-refused") {
           const request = pairingRequests.get(answer.requestId);
           if (request === undefined || request.control !== socket)
@@ -826,7 +1082,7 @@ async function startRelay(options) {
         runOp(socket, frame, noisePublicKey);
         return;
       }
-      if (!allowedHosts.has(frame.hostId) && accounts?.hasHost(frame.hostId) !== true) {
+      if (accounts?.hasHost(frame.hostId) !== true) {
         socket.close(RELAY_CLOSE.hostNotAllowed);
         return;
       }
@@ -841,7 +1097,7 @@ async function startRelay(options) {
         ...frame.features === undefined ? {} : { features: frame.features }
       });
       accounts?.markHostSeen(hostId);
-      socket.send(encodeRelayFrame({ t: "registered" }));
+      socket.send(encodeRelayFrame({ t: "registered", push: pushEnvironments }));
     });
     socket.once("close", () => {
       clearTimeout(deadline);
@@ -1016,11 +1272,12 @@ async function startRelay(options) {
       await closing;
       await new Promise((resolve) => httpServer.close(() => resolve()));
       await accounts?.close();
+      await apns?.close();
     }
   };
 }
 
-// apps/relay/src/main.ts
+// apps/server/src/main.ts
 function resolveDataDir(flag) {
   return resolve(flag ?? process.env.PINOMAD_SERVER_DATA_DIR ?? join2(homedir(), ".pinomad-server"));
 }
@@ -1045,7 +1302,7 @@ async function passwdMain(argv) {
     strict: true
   });
   if (process.stdin.isTTY) {
-    console.error("pipe the new password on stdin, e.g. `printenv NEW_PINOMAD_SERVER_PASSWORD | " + commandHint("relay") + " passwd`");
+    console.error("pipe the new password on stdin, e.g. `printenv NEW_PINOMAD_SERVER_PASSWORD | " + commandHint("server") + " passwd`");
     process.exit(1);
   }
   const dataDir = resolveDataDir(values["data-dir"]);
@@ -1067,44 +1324,40 @@ async function main(argv) {
       port: { type: "string", default: "7430" },
       listen: { type: "string", default: "127.0.0.1" },
       "public-origin": { type: "string" },
-      "allow-host": { type: "string", multiple: true },
       "data-dir": { type: "string" },
       "trust-proxy": { type: "boolean", default: false }
     }
   });
-  const allowedHosts = values["allow-host"] ?? [];
-  const bootstrapUser = process.env.PINOMAD_SERVER_USER;
-  const bootstrapPassword = process.env.PINOMAD_SERVER_PASSWORD;
-  const accountMode = allowedHosts.length === 0 || values["data-dir"] !== undefined || process.env.PINOMAD_SERVER_DATA_DIR !== undefined || bootstrapUser !== undefined || bootstrapPassword !== undefined;
   if (values["public-origin"] === undefined) {
-    console.error(`usage: ${commandHint("relay")} --public-origin ORIGIN [--allow-host HOST_ID ...] [--data-dir DIR] [--trust-proxy] [--port 7430] [--listen 127.0.0.1]
-` + `       ${commandHint("relay")} passwd [--data-dir DIR] [--user NAME]   (server stopped; new password on stdin)
+    console.error(`usage: ${commandHint("server")} --public-origin ORIGIN [--data-dir DIR] [--trust-proxy] [--port 7430] [--listen 127.0.0.1]
+` + `       ${commandHint("server")} passwd [--data-dir DIR] [--user NAME]   (server stopped; new password on stdin)
 ` + "       env: PINOMAD_SERVER_USER, PINOMAD_SERVER_PASSWORD, PINOMAD_SERVER_DATA_DIR");
     process.exit(1);
   }
-  const accounts = accountMode ? await openAccounts({
+  const accounts = await openAccounts({
     dataDir: resolveDataDir(values["data-dir"]),
-    bootstrapUser,
-    bootstrapPassword
+    bootstrapUser: process.env.PINOMAD_SERVER_USER,
+    bootstrapPassword: process.env.PINOMAD_SERVER_PASSWORD
   }).catch((error) => {
     console.error(error instanceof Error ? error.message : String(error));
     process.exit(1);
-  }) : undefined;
+  });
+  const apnsConfig = loadApnsConfig();
+  const apns = apnsConfig === undefined ? undefined : openApns(apnsConfig);
   const relay = await startRelay({
     port: Number(values.port),
     listenHost: values.listen,
     publicOrigin: values["public-origin"],
-    allowedHosts,
     webRoot,
     accounts,
-    trustProxy: values["trust-proxy"]
+    trustProxy: values["trust-proxy"],
+    ...apns === undefined ? {} : { push: apns }
   });
   console.log(JSON.stringify({
     event: "ready",
     url: relay.url,
     publicOrigin: values["public-origin"],
-    allowedHosts: allowedHosts.length,
-    accounts: accounts !== undefined
+    push: apns?.environments ?? []
   }));
   let stopping = false;
   const stop = () => {

package/dist/{chunk-prhvksh3.js → chunk-5ng86fmy.js}

@@ -2,10 +2,10 @@
 import {
   main,
   restartService
-} from "./chunk-akgxwg8f.js";
-import"./chunk-fgx2sh7d.js";
-import"./chunk-374zqx5h.js";
-import"./chunk-myjp910s.js";
+} from "./chunk-aqj4wg33.js";
+import"./chunk-1d9sppj0.js";
+import"./chunk-m4q9wafw.js";
+import"./chunk-hsp12cjt.js";
 import"./chunk-cjfmfyjb.js";
 import"./chunk-df32avw6.js";
 export {

package/dist/{chunk-b3f0ced1.js → chunk-9d59jjmt.js}

@@ -3,31 +3,28 @@ import {
   assertSecureServerOrigin,
   probeServerAccounts,
   runServerOperation
-} from "./chunk-5785kwej.js";
+} from "./chunk-26d04z02.js";
 import {
+  loadHostKey,
+  loadRelayKey,
   writeServerConfig
-} from "./chunk-302y6by9.js";
-import"./chunk-knaw1a9g.js";
+} from "./chunk-ebfaf3k2.js";
+import {
+  relayHostId
+} from "./chunk-kmbh44dt.js";
 import {
   argValue,
   installSpec,
   restartService,
   serviceManager,
   withoutRelayArgs
-} from "./chunk-akgxwg8f.js";
+} from "./chunk-aqj4wg33.js";
 import {
   commandHint,
   hostEntry
-} from "./chunk-fgx2sh7d.js";
-import"./chunk-374zqx5h.js";
-import"./chunk-myjp910s.js";
-import {
-  loadHostKey,
-  loadRelayKey
-} from "./chunk-837gh8nr.js";
-import {
-  relayHostId
-} from "./chunk-7gmkgyaz.js";
+} from "./chunk-1d9sppj0.js";
+import"./chunk-m4q9wafw.js";
+import"./chunk-hsp12cjt.js";
 import {
   DEFAULT_DATA_DIR
 } from "./chunk-cjfmfyjb.js";

package/dist/{chunk-akgxwg8f.js → chunk-aqj4wg33.js}

@@ -2,10 +2,10 @@ import {
   commandHint,
   hostEntry,
   packagedVersion
-} from "./chunk-fgx2sh7d.js";
+} from "./chunk-1d9sppj0.js";
 import {
   connectRemoteDurable
-} from "./chunk-374zqx5h.js";
+} from "./chunk-m4q9wafw.js";
 import {
   DEFAULT_DATA_DIR,
   hostAddress

package/dist/{chunk-17p6bfvy.js → chunk-crv3dqzp.js}

@@ -2,14 +2,14 @@
 import {
   restartService,
   serviceManager
-} from "./chunk-akgxwg8f.js";
+} from "./chunk-aqj4wg33.js";
 import {
   globalPrefixOf,
   packageDir,
   packagedVersion
-} from "./chunk-fgx2sh7d.js";
-import"./chunk-374zqx5h.js";
-import"./chunk-myjp910s.js";
+} from "./chunk-1d9sppj0.js";
+import"./chunk-m4q9wafw.js";
+import"./chunk-hsp12cjt.js";
 import"./chunk-cjfmfyjb.js";
 import"./chunk-df32avw6.js";