@relaymessenger/openclaw-plugin 0.3.3 → 0.4.0-staging.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Companion Inc.
+Copyright (c) 2026 Relay Messenger
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,145 +1,180 @@
-# Relay channel plugin for OpenClaw
+# Relay for OpenClaw
 
-Backs a Relay contact with an OpenClaw agent: install the plugin, point it at
-an owner-only Agent Token file, and your OpenClaw appears in Relay as a contact
-you text like a friend.
+`@relaymessenger/openclaw-plugin` is the native Relay channel for OpenClaw
+`2026.8.1`.
 
-Requires `openclaw >= 2026.7.1-2`, which the stable channel satisfies today.
-
-Cores from `2026.7.2-beta.5` onward tell the channel which part of a delivery
-each chunk is, and the plugin keys its idempotent sends on that. Older cores do
-not, so on those the plugin keys each chunk by a digest of the chunk's own
-text. Both keep a retry replaying the same message instead of posting a second
-one. The one thing an older core cannot do is separate two byte-identical
-chunks of a single reply, which arrive as one message.
+It connects an OpenClaw gateway to Relay with a Relay Agent Token. Relay
+delivers events over its v1 WebSocket, and the plugin sends replies through
+the Relay v1 REST Message API. The plugin imports `@relaymessenger/sdk`; it
+does not contain a copied Relay client or protocol implementation.
 
 ## Install
 
-```sh
-npm install -g @relaymessenger/cli
-relaymessenger pair
-relaymessenger install-openclaw
+```bash
+openclaw plugins install @relaymessenger/openclaw-plugin
+```
+
+Configure the default account:
+
+```json
+{
+  "channels": {
+    "relay": {
+      "enabled": true,
+      "tokenFile": "/run/secrets/relay-agent-token"
+    }
+  }
+}
 ```
 
-The installer uses the OpenClaw archive bundled in the installed `relaymessenger`
-package, persists that archive in the paired account's private Relay runtime,
-and invokes OpenClaw's managed `npm-pack:` installer on the stable copy so
-declared runtime dependencies are installed with the plugin. It surgically
-adds Relay to `~/.openclaw/openclaw.json`, preserves unrelated configuration,
-writes the token to an owner-only file, and never prints it. It refuses to
-replace a different configured Relay identity.
+For a single account, `RELAY_AGENT_TOKEN` is also supported. Use
+`RELAY_BASE_URL` only when the Agent Token belongs to a non-production Relay
+environment.
 
-For integration development from this checkout only:
+One OpenClaw gateway can back multiple Relay Contacts:
 
-```sh
-cd integrations/openclaw
-npm install
-npm pack
-openclaw plugins install npm-pack:./relaymessenger-openclaw-plugin-0.1.0.tgz --force
+```json
+{
+  "channels": {
+    "relay": {
+      "defaultAccount": "default",
+      "accounts": {
+        "default": {
+          "tokenFile": "/run/secrets/relay-default"
+        },
+        "support": {
+          "tokenFile": "/run/secrets/relay-support"
+        }
+      }
+    }
+  }
+}
 ```
 
-The installer produces the equivalent Relay-specific configuration:
+Do not reuse one Agent Token in two configured accounts. Channel-level
+`token`, `tokenFile`, and `RELAY_AGENT_TOKEN` credentials belong only to the
+default account. Every named account must set its own inline token or
+`tokenFile`; named accounts never inherit default credentials.
+
+## Relay vocabulary and scope
+
+- A **Contact** is a Relay user or agent profile.
+- Each Contact owns a public **Handle**.
+- A **Chat** is direct or group.
+- A **Message** belongs to one Chat and contains ordered parts.
+
+The plugin starts OpenClaw turns for every inbound user-authored
+`message.received` event in a direct Chat. In a group Chat, it starts a turn
+only when a text part's canonical `mention` Handle matches the canonical
+`chat.owner_handle`, or when `reply_to.message_id` resolves through Relay to a
+Message authored by this agent in the same Chat. Visible `@handle` text is not
+parsed as a mention. Unmentioned group traffic, agent-authored Messages,
+reactions, typing events, receipts, and membership events are durably accepted
+without starting a turn.
+
+Text, link, and media parts are rendered into agent-visible text. Media stays
+a labeled signed URL; the plugin does not upload or send media.
+
+Outbound support is deliberately limited to text Messages and Message reply
+references. OpenClaw splits text at Relay's current 10,000-character text-part
+limit. Reactions, edit, unsend, native threads, rich cards, and outbound media
+are not declared.
+
+`allowFrom` optionally limits inbound turns to exact Relay Contact IDs or
+Handles:
 
 ```json
 {
-  "plugins": {
-    "allow": ["relay"],
-    "entries": { "relay": { "enabled": true } }
-  },
   "channels": {
     "relay": {
-      "enabled": true,
-      "tokenFile": "~/.openclaw/secrets/relay-agent-token",
-      "baseUrl": "https://api.relayapp.im"
+      "tokenFile": "/run/secrets/relay-agent-token",
+      "allowFrom": [
+        "alice",
+        "00000000-0000-7000-8000-000000000001"
+      ]
     }
   }
 }
 ```
 
-`RELAY_AGENT_TOKEN` / `RELAY_BASE_URL` are honored for the default account
-when the config fields are absent. Multiple agents run as named accounts under
-`channels.relay.accounts.<id>`, one token each.
-
-## Sender security
-
-Relay agents can be discoverable, so adding an agent as a contact is not an
-authorization boundary. The plugin accepts inbound turns only from the
-authenticated agent's `owner_user_id` returned by `GET /v1/agents/me` and any
-Relay user ids the operator explicitly adds to `allowFrom`. Wildcards are
-ignored. If neither an API owner nor an explicit allowlist is available, the
-account fails closed and does not start polling.
-
-## One consumer per token
-
-Relay's `GET /v1/events` long poll allows **exactly one consumer per Agent
-Token**:
-
-- A newer poll takes the slot; the older consumer's request ends with
-  `409 terminated_by_other_consumer`. Running this plugin and another
-  long-poll consumer (for example `relaymessenger start`, or a second OpenClaw) on
-  the same token makes them steal the slot from each other forever. Give each
-  consumer its own agent/token.
-- Long polling is **XOR with webhooks**: while a webhook endpoint is enabled
-  for the agent, `/v1/events` returns `409 conflict` and the channel stops
-  with a terminal disconnect. Disable or delete the agent's webhooks to poll.
-
-The plugin also refuses to start a second configured account that resolves to
-the same agent id as a running one.
-
-## Config reference (per account)
-
-| Field | Meaning |
-| --- | --- |
-| `token` / `tokenFile` | Agent Token (or file containing it) |
-| `baseUrl` | Relay API origin (default `https://api.relayapp.im`). Remote origins must use HTTPS; HTTP is accepted only for loopback development. Paths, credentials, queries, and fragments are rejected. |
-| `allowFrom` | Additional Relay user ids (`usr_…`) allowed alongside the API-pinned owner. These identities may also run control commands. Wildcards are ignored. |
-| `pollTimeoutSeconds` | Long-poll hold time, 1–30 (default 30) |
-
-## Harness
-
-Run `npm run gateway:harness` from the repository root for the clean installed-
-runtime proof. It packs the plugin, installs it into an isolated `HOME`, starts
-a real OpenClaw gateway against `harness/mock-relay-server.mjs`, receives a
-Relay event, completes a mock model turn, and verifies the reply reaches
-Relay. The release workflow requires this proof.
-
-## Delivery and crash semantics
-
-- Every outbound platform send has a logical-send idempotency key. Durable
-  queue retries reuse the same key, while intentional identical messages and
-  identical chunks remain distinct.
-- Admission, route/session resolution, envelope building, and context
-  finalization run before an inbound event is marked attempted. Failures in
-  that replay-safe preflight release the claim and retry the event. The marker
-  is committed durably immediately before OpenClaw can dispatch the agent or
-  its tools; a failure after that boundary does not silently replay possible
-  tool side effects. The user can resend the message deliberately.
-- The long-poll cursor and inbound attempt keys are bound to the canonical
-  Relay API origin plus Relay agent id, not to a mutable local account label.
-  Renaming an account therefore retains its cursor. A missing identity starts
-  at cursor zero; corrupt, mismatched, unreadable, or unwritable state fails
-  closed instead of replaying retained history. The cursor namespace rejects
-  new identities at capacity rather than evicting an older cursor. Cursor
-  state is independent of the bounded 30-day attempt-dedupe horizon. Both
-  namespaces are private, lock-protected, atomically replaced Relay-owned
-  files under `$OPENCLAW_STATE_DIR/relay/state` (normally
-  `~/.openclaw/relay/state`); the plugin never requests trusted-only OpenClaw
-  host SQLite access.
-- Before polling, the plugin takes an atomic per-origin/per-agent filesystem
-  lock under `~/.openclaw/relay/consumer-locks`. A second OpenClaw process
-  fails closed; a lock whose recorded PID is dead is recovered on startup.
-  Shutdown aborts the active long poll and releases both process-local and
-  filesystem ownership before a replacement starts.
-- Every API operation has a deadline (15 seconds for ordinary calls; the
-  configured long-poll hold plus 15 seconds for event polling). Retrying a
-  message send reuses its logical delivery idempotency key.
-
-## v1 scope
-
-Direct conversations only. Inbound text renders as-is; inbound media and
-voice memos render as a labeled fetchable capability URL (the URL is itself
-the authorization, so no Agent Token is needed to fetch the bytes) rather
-than the agent seeing the file inline; reactions are observe-only; receipts
-(`message.delivered`/`message.read`) never start a turn. Final agent replies
-are delivered durably (chunked to Relay's 8 KiB per-part cap,
-idempotency-keyed, retry-safe).
+Without `allowFrom`, any user Contact whose Message Relay delivers to this
+agent can start a direct turn, while the group activation rules above still
+apply.
+
+## Durable delivery
+
+For every WebSocket event, the plugin:
+
+1. inserts `event_id` into OpenClaw's channel ingress queue, or its private
+   SQLite queue when a local/npm-pack install does not have trusted host state;
+2. returns from the SDK callback only after that transaction commits;
+3. lets the SDK send the cumulative WebSocket ACK;
+4. dispatches a stored event through OpenClaw's ingress lifecycle.
+
+A replayed `event_id` reaches the existing pending, completed, or failed row
+and does not repeat model or tool work. The SDK owns sequence validation,
+cumulative ACKs, reconnect replay, and JSON heartbeat ping/pong.
+
+When Relay requires `full_sync`, the plugin pages through every visible Chat
+and every visible Message, atomically replaces its local snapshot, and returns
+only after the snapshot commits. The SDK then sends
+`full_sync_complete`.
+
+Relay Webhooks and the WebSocket are exclusive. Startup checks that the Agent
+has no saved Webhook subscriptions. The SDK also treats WebSocket HTTP `409`
+and close code `4410` as terminal `RelayWebhookConfiguredError` failures.
+
+Final OpenClaw replies use the native durable outbound Message adapter. Each
+REST send carries a stable idempotency key derived from OpenClaw's delivery
+queue ID and part index. Unknown-send reconciliation repeats the exact text
+chunks with the same keys, so Relay returns the original Message or commits
+it once.
+
+## Development
+
+Use Node.js `22.22.3` or newer. Build and test on Linux:
+
+```bash
+npm install
+npm run validate
+npm run pack:smoke
+npm run gateway:harness
+```
+
+`npm run release:validate` runs all three commands. CI and the guarded manual
+staging workflow use that full sequence. The staging workflow accepts only an
+exact SHA selected from the `staging` branch, the matching
+`x.y.z-staging.n` package version, and the `staging` npm tag. It retains the
+validated tarball and publishes that same digest with npm provenance; its
+publish job is also bound to the `staging` GitHub environment.
+
+`gateway:harness` packs the plugin, installs the tarball with OpenClaw
+`2026.8.1`, inspects the managed installation, starts a real OpenClaw gateway,
+connects to a loopback Relay WebSocket, receives one Message, and proves the
+durable ACK and idempotent REST reply.
+
+## Contract lock
+
+`contracts/relay-v1.lock.json` records the compatibility boundary used by this
+release: Relay Server
+`9b4d5bb32cc749c6fd271969948c385300d404d6`, OpenAPI SHA-256
+`f62f431fc0daa48500926bf87753f81c3fdda25ab463b130ca97f2896367e0a5`,
+and the exact `@relaymessenger/sdk@0.3.0-staging.4` registry integrity, source
+commit `8570546ce30ab39d702409893006dbccd351f2b4`, REST operations, and WebSocket
+frames consumed by the plugin.
+
+Public CI hashes the checked-in `contracts/relay-openapi.yaml` fixture and
+requires the locked digest above. The retained private release receipt also
+sets `RELAY_SERVER_SOURCE_DIR` to an exact checkout of Server `9b4d5bb32cc7`
+and proves that the fixture bytes match that commit before packaging. The
+public repository does not require credentials for the private Server source
+and does not overstate what npm metadata can attest.
+
+`contracts/relay-sdk-0.3.0-staging.4.registry.json` records immutable npm
+publication metadata and tarball digests. Validation downloads the registry
+tarball, verifies SHA-1, SHA-256, and SHA-512 integrity, checks the installed
+SDK, and compares its package metadata with exact SDK commit `8570546`.
+The npm metadata has no `gitHead` or attestation for this version, so the
+receipt deliberately does not claim cryptographic source-to-tarball
+provenance. These are local artifact compatibility checks, not a claim of a
+hosted Relay deployment test.

package/contracts/relay-sdk-0.3.0-staging.4.registry.json

@@ -0,0 +1,58 @@
+{
+  "schema": "relay-sdk-registry-receipt/v1",
+  "source": {
+    "repository": "RelayMessenger/Relay-SDK",
+    "commit": "8570546ce30ab39d702409893006dbccd351f2b4",
+    "packageJsonPath": "packages/sdk/package.json",
+    "packageJsonSha256": "b9d0f5bba2c5ba5eea904ca4ad490795c01b0a67bd5592d7fdbea50a7ed8b29b",
+    "contractPath": "contracts/relay-v1-openapi.yaml",
+    "contractSha256": "f62f431fc0daa48500926bf87753f81c3fdda25ab463b130ca97f2896367e0a5"
+  },
+  "registry": {
+    "packumentUrl": "https://registry.npmjs.org/@relaymessenger%2fsdk",
+    "package": "@relaymessenger/sdk",
+    "version": "0.3.0-staging.4",
+    "publishedAt": "2026-09-01T03:05:27.371Z",
+    "repository": {
+      "type": "git",
+      "url": "git+https://github.com/RelayMessenger/Relay-SDK.git",
+      "directory": "packages/sdk"
+    },
+    "publishConfig": {
+      "access": "public",
+      "registry": "https://registry.npmjs.org/",
+      "tag": "staging"
+    },
+    "distTagsObserved": {
+      "latest": "0.2.0",
+      "staging": "0.3.0-staging.4",
+      "mutable": true
+    },
+    "dist": {
+      "tarball": "https://registry.npmjs.org/@relaymessenger/sdk/-/sdk-0.3.0-staging.4.tgz",
+      "integrity": "sha512-S47nMr+igXPIgLOgkKGUSOU7WpSQZZqsByZhbavUz87C3j0Zevy6jv9IT2t+ZS40TuLqjS9FTPnQ/MpMfLdngQ==",
+      "shasum": "fa1356cfb37b8d64683b0734c054c4afbacbfe1d",
+      "sha256": "73ffd16c0ed4b07d9ff4b90d7efc5e1bf1b2fb82e833089d097b6757c4e94848",
+      "bytes": 36322,
+      "fileCount": 37,
+      "unpackedSize": 167419,
+      "signatureMetadata": [
+        {
+          "keyid": "SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U",
+          "sig": "MEUCIDyZ96e+A/d85Ay57ET/5PGqltJRBpF5//j9GkhnqE2EAiEAoytprMukWmB1BlSxp5sCENpI8YC1kKwRaNzAvLHjqhY="
+        }
+      ]
+    },
+    "installedArtifact": {
+      "packageJsonSha256": "b9d0f5bba2c5ba5eea904ca4ad490795c01b0a67bd5592d7fdbea50a7ed8b29b",
+      "typesSha256": "efa163145777ad4df93263d87605794ca099dd8db6fe1b36cc71d0873377a653"
+    }
+  },
+  "provenanceBoundary": {
+    "registryGitHead": null,
+    "registryAttestations": null,
+    "attestationEndpoint": "https://registry.npmjs.org/-/npm/v1/attestations/@relaymessenger%2fsdk@0.3.0-staging.4",
+    "attestationEndpointObservedStatus": 404,
+    "claim": "The exact registry tarball integrity and publication metadata are verified, and its package.json bytes match Relay-SDK commit 8570546ce30ab39d702409893006dbccd351f2b4. npm registry metadata exposes neither gitHead nor an attestation for this version, so this receipt does not claim cryptographic source-to-tarball provenance."
+  }
+}

package/contracts/relay-v1.lock.json

@@ -0,0 +1,77 @@
+{
+  "relayServer": {
+    "repository": "RelayMessenger/Relay-Server",
+    "commit": "9b4d5bb32cc749c6fd271969948c385300d404d6",
+    "openapiPath": "contracts/developer/openapi.yaml",
+    "sha256": "f62f431fc0daa48500926bf87753f81c3fdda25ab463b130ca97f2896367e0a5"
+  },
+  "relaySdk": {
+    "package": "@relaymessenger/sdk",
+    "version": "0.3.0-staging.4",
+    "integrity": "sha512-S47nMr+igXPIgLOgkKGUSOU7WpSQZZqsByZhbavUz87C3j0Zevy6jv9IT2t+ZS40TuLqjS9FTPnQ/MpMfLdngQ==",
+    "operationsSha256": "8429a056605fa9555fcb34067bbb34f7e364ed18c17ec7786b2c1621044012f1",
+    "registryReceipt": "contracts/relay-sdk-0.3.0-staging.4.registry.json",
+    "source": {
+      "repository": "RelayMessenger/Relay-SDK",
+      "commit": "8570546ce30ab39d702409893006dbccd351f2b4",
+      "carriedOpenapiSha256": "f62f431fc0daa48500926bf87753f81c3fdda25ab463b130ca97f2896367e0a5"
+    },
+    "usedOperations": [
+      {
+        "method": "GET",
+        "path": "/v1/chats",
+        "operationId": "listChats"
+      },
+      {
+        "method": "GET",
+        "path": "/v1/chats/{chatId}/messages",
+        "operationId": "getMessages"
+      },
+      {
+        "method": "GET",
+        "path": "/v1/messages/{messageId}",
+        "operationId": "getMessage"
+      },
+      {
+        "method": "POST",
+        "path": "/v1/chats/{chatId}/messages",
+        "operationId": "sendMessageToChat"
+      },
+      {
+        "method": "POST",
+        "path": "/v1/chats/{chatId}/read",
+        "operationId": "markChatAsRead"
+      },
+      {
+        "method": "POST",
+        "path": "/v1/chats/{chatId}/typing",
+        "operationId": "startTyping"
+      },
+      {
+        "method": "DELETE",
+        "path": "/v1/chats/{chatId}/typing",
+        "operationId": "stopTyping"
+      },
+      {
+        "method": "GET",
+        "path": "/v1/webhook-subscriptions",
+        "operationId": "listWebhookSubscriptions"
+      }
+    ],
+    "usedWebSocketFrames": {
+      "serverToSdk": [
+        "ready",
+        "event",
+        "full_sync",
+        "ping",
+        "error",
+        "disconnect"
+      ],
+      "sdkToServer": [
+        "ack",
+        "full_sync_complete",
+        "pong"
+      ]
+    }
+  }
+}

package/dist/index.js

@@ -1,11 +1,11 @@
-// Relay channel plugin entrypoint registers the OpenClaw integration.
 import { defineChannelPluginEntry } from "openclaw/plugin-sdk/channel-core";
 import { relayChannelPlugin } from "./src/channel.js";
 import { setRelayRuntime } from "./src/runtime.js";
 export default defineChannelPluginEntry({
     id: "relay",
     name: "Relay",
-    description: "Relay channel plugin. Text your OpenClaw like a friend.",
+    description: "Native Relay channel plugin for OpenClaw.",
     plugin: relayChannelPlugin,
     setRuntime: setRelayRuntime,
 });
+//# sourceMappingURL=index.js.map

package/dist/setup-entry.js

@@ -1,5 +1,4 @@
-// Lightweight setup entry: loaded instead of the full entry while the channel
-// is disabled/unconfigured, so status/config surfaces avoid runtime imports.
 import { defineSetupPluginEntry } from "openclaw/plugin-sdk/channel-core";
 import { relayChannelPlugin } from "./src/channel.js";
 export default defineSetupPluginEntry(relayChannelPlugin);
+//# sourceMappingURL=setup-entry.js.map

package/dist/src/accounts.js

@@ -1,13 +1,9 @@
-// Multi-account resolution: channels.relay.accounts.<id> with a
-// default-account fallback, so one OpenClaw can back several Relay contacts
-// (one Agent Token each). Env vars cover the single-account quickstart.
 import { createAccountListHelpers, resolveMergedAccountConfig, } from "openclaw/plugin-sdk/account-helpers";
-import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId, } from "openclaw/plugin-sdk/account-id";
 import { tryReadSecretFileSync } from "openclaw/plugin-sdk/channel-core";
-import { DEFAULT_RELAY_BASE_URL, normalizeRelayBaseUrl } from "./client.js";
 export const RELAY_TOKEN_ENV_VAR = "RELAY_AGENT_TOKEN";
 export const RELAY_BASE_URL_ENV_VAR = "RELAY_BASE_URL";
-const DEFAULT_POLL_TIMEOUT_SECONDS = 30;
+export const DEFAULT_RELAY_BASE_URL = "https://api.relayapp.im";
 const { listAccountIds, resolveDefaultAccountId } = createAccountListHelpers("relay", {
     normalizeAccountId,
     implicitDefaultAccount: {
@@ -15,53 +11,86 @@ const { listAccountIds, resolveDefaultAccountId } = createAccountListHelpers("re
         envVars: [RELAY_TOKEN_ENV_VAR],
     },
 });
-export { listAccountIds as listRelayAccountIds, resolveDefaultAccountId as resolveDefaultRelayAccountId, DEFAULT_ACCOUNT_ID, };
-function resolveMergedRelayAccountConfig(cfg, accountId) {
+export { DEFAULT_ACCOUNT_ID, listAccountIds as listRelayAccountIds, resolveDefaultAccountId as resolveDefaultRelayAccountId, };
+function mergedAccountConfig(cfg, accountId) {
     return resolveMergedAccountConfig({
         channelConfig: cfg.channels?.relay,
         accounts: cfg.channels?.relay?.accounts,
         accountId,
-        omitKeys: ["defaultAccount"],
+        // A channel-level token or tokenFile belongs only to the implicit/default
+        // account. Named accounts may inherit non-credential defaults, but must
+        // opt into their own credential source.
+        omitKeys: accountId === DEFAULT_ACCOUNT_ID
+            ? ["defaultAccount"]
+            : ["defaultAccount", "token", "tokenFile"],
         normalizeAccountId,
     });
 }
 function resolveToken(params) {
-    const direct = params.merged.token?.trim();
-    if (direct) {
-        return direct;
-    }
-    const fromFile = params.merged.tokenFile
-        ? tryReadSecretFileSync(params.merged.tokenFile, "relay tokenFile")?.trim()
+    const inline = params.config.token?.trim();
+    if (inline)
+        return inline;
+    const fromFile = params.config.tokenFile
+        ? tryReadSecretFileSync(params.config.tokenFile, "relay tokenFile")?.trim()
         : undefined;
-    if (fromFile) {
+    if (fromFile)
         return fromFile;
+    return params.accountId === DEFAULT_ACCOUNT_ID
+        ? (params.env[RELAY_TOKEN_ENV_VAR]?.trim() ?? "")
+        : "";
+}
+function isLoopbackHostname(hostname) {
+    return (hostname === "localhost" ||
+        hostname === "127.0.0.1" ||
+        hostname === "::1" ||
+        hostname.endsWith(".localhost"));
+}
+export function normalizeRelayBaseUrl(value) {
+    let parsed;
+    try {
+        parsed = new URL(value?.trim() || DEFAULT_RELAY_BASE_URL);
+    }
+    catch {
+        throw new Error("relay: baseUrl must be an absolute Relay API origin");
     }
-    // Env token applies to the default account only, so named accounts cannot
-    // silently share one token.
-    if (params.accountId === DEFAULT_ACCOUNT_ID) {
-        return params.env[RELAY_TOKEN_ENV_VAR]?.trim() ?? "";
+    if (parsed.username || parsed.password || parsed.search || parsed.hash) {
+        throw new Error("relay: baseUrl must not contain credentials, query, or fragment");
     }
-    return "";
+    if (parsed.pathname !== "/" && parsed.pathname !== "") {
+        throw new Error("relay: baseUrl must be an origin without a path");
+    }
+    if (parsed.protocol !== "https:" &&
+        !(parsed.protocol === "http:" && isLoopbackHostname(parsed.hostname))) {
+        throw new Error("relay: baseUrl must use HTTPS (HTTP is allowed only for loopback tests)");
+    }
+    return parsed.origin;
+}
+function normalizeAllowFrom(values) {
+    return [
+        ...new Set((values ?? [])
+            .map((value) => value.trim())
+            .filter((value) => value.length > 0)),
+    ];
 }
 export function resolveRelayAccount(params) {
     const env = params.env ?? process.env;
     const accountId = normalizeAccountId(params.accountId);
-    const merged = resolveMergedRelayAccountConfig(params.cfg, accountId);
+    const config = mergedAccountConfig(params.cfg, accountId);
     const baseEnabled = params.cfg.channels?.relay?.enabled !== false;
-    const enabled = baseEnabled && merged.enabled !== false;
-    const token = resolveToken({ merged, accountId, env });
-    const baseUrl = normalizeRelayBaseUrl(merged.baseUrl?.trim() ||
-        (accountId === DEFAULT_ACCOUNT_ID ? env[RELAY_BASE_URL_ENV_VAR]?.trim() : undefined) ||
-        DEFAULT_RELAY_BASE_URL);
-    const pollTimeoutSeconds = Math.min(Math.max(merged.pollTimeoutSeconds ?? DEFAULT_POLL_TIMEOUT_SECONDS, 1), 30);
+    const token = resolveToken({ config, accountId, env });
+    const configuredBaseUrl = config.baseUrl?.trim() ||
+        (accountId === DEFAULT_ACCOUNT_ID
+            ? env[RELAY_BASE_URL_ENV_VAR]?.trim()
+            : undefined);
     return {
         accountId,
-        enabled,
-        configured: Boolean(token),
-        ...(merged.name?.trim() ? { name: merged.name.trim() } : {}),
+        ...(config.name?.trim() ? { name: config.name.trim() } : {}),
+        enabled: baseEnabled && config.enabled !== false,
+        configured: token.length > 0,
         token,
-        baseUrl,
-        pollTimeoutSeconds,
-        config: merged,
+        baseUrl: normalizeRelayBaseUrl(configuredBaseUrl),
+        allowFrom: normalizeAllowFrom(config.allowFrom),
+        config,
     };
 }
+//# sourceMappingURL=accounts.js.map