@wakeshift/openclaw 0.0.0-placeholder → 1.4.24

package/dist/store.js

@@ -0,0 +1,202 @@
+// What the plugin keeps on disk, under <OpenClaw state>/wakeshift: each
+// connected conversation's stream links, one per app it watches (a secret:
+// 0600 files in a 0700 directory, named by a hash of the conversation, the
+// issuer and the app, so odd IDs can't escape it), the issuer's signing
+// keys, and this install's random ID.
+import { createHash, randomBytes } from "node:crypto";
+import { chmodSync, closeSync, fchmodSync, fsyncSync, mkdirSync, openSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+/** A link's place among its conversation's: its issuer and app ("" for a link that names no app). */
+export function linkKey(l) {
+    return l.app ? `${l.issuer ?? ""}\n${l.app}` : "";
+}
+/** Store.pin's answer when the pins exist but can't be read. */
+export const PINS_UNREADABLE = "the pins can't be read";
+const hash = (s, n) => createHash("sha256").update(s).digest("hex").slice(0, n);
+/**
+ * Writes a file only this user can read: a fresh temp file of its own name
+ * (O_EXCL, 0600 before any byte, even if the umask or an old file differs),
+ * flushed to disk, then renamed over path.
+ */
+export function writeAtomic(path, body) {
+    const tmp = join(dirname(path), `.${basename(path)}.${randomBytes(6).toString("hex")}.tmp`);
+    const fd = openSync(tmp, "wx", 0o600);
+    try {
+        fchmodSync(fd, 0o600);
+        writeSync(fd, body);
+        fsyncSync(fd);
+    }
+    catch (e) {
+        closeSync(fd);
+        rmSync(tmp, { force: true });
+        throw e;
+    }
+    closeSync(fd);
+    try {
+        renameSync(tmp, path);
+    }
+    catch (e) {
+        rmSync(tmp, { force: true });
+        throw e;
+    }
+}
+function valid(s) {
+    return (!!s &&
+        typeof s.conversation === "string" &&
+        !!s.conversation &&
+        typeof s.link === "string" &&
+        !!s.link &&
+        typeof s.sessionKey === "string" &&
+        (s.issuer === undefined || typeof s.issuer === "string") &&
+        (s.app === undefined || typeof s.app === "string") &&
+        (s.stream === undefined || typeof s.stream === "string"));
+}
+export class Store {
+    dir;
+    constructor(dir) {
+        this.dir = dir;
+    }
+    ensure(sub) {
+        const d = join(this.dir, sub);
+        mkdirSync(d, { recursive: true, mode: 0o700 });
+        try {
+            chmodSync(this.dir, 0o700);
+            chmodSync(d, 0o700);
+        }
+        catch {
+            /* best effort */
+        }
+        return d;
+    }
+    write(path, body) {
+        writeAtomic(path, body);
+    }
+    /** This install's ID: random, made once. */
+    installId() {
+        const p = join(this.ensure("."), "install-id");
+        try {
+            const id = readFileSync(p, "utf8").trim();
+            if (/^[0-9a-f]{16}$/.test(id))
+                return id;
+        }
+        catch {
+            /* none yet */
+        }
+        const id = randomBytes(8).toString("hex");
+        this.write(p, id + "\n");
+        return id;
+    }
+    // links/<hash>.json: a conversation's link for one app (key: linkKey),
+    // or its one link from before links named their app (key "").
+    linkName(conversation, key) {
+        return hash(key ? `${conversation}\n${key}` : conversation, 32) + ".json";
+    }
+    linkPath(conversation, key) {
+        return join(this.dir, "links", this.linkName(conversation, key));
+    }
+    saveLink(l) {
+        this.ensure("links");
+        this.write(this.linkPath(l.conversation, linkKey(l)), JSON.stringify({ ...l, saved_at: new Date().toISOString() }));
+    }
+    /** The conversation's link for one app (key: linkKey; "" for the one saved before links named their app). */
+    loadLink(conversation, key = "") {
+        try {
+            const s = JSON.parse(readFileSync(this.linkPath(conversation, key), "utf8"));
+            return valid(s) && s.conversation === conversation && linkKey(s) === key ? s : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    forgetLink(conversation, key = "") {
+        rmSync(this.linkPath(conversation, key), { force: true });
+    }
+    /** Every saved link: only a file named for what it holds (a copy under another name isn't read). */
+    links() {
+        let names;
+        try {
+            names = readdirSync(join(this.dir, "links"));
+        }
+        catch {
+            return [];
+        }
+        const out = [];
+        for (const n of names) {
+            if (!n.endsWith(".json"))
+                continue;
+            try {
+                const s = JSON.parse(readFileSync(join(this.dir, "links", n), "utf8"));
+                if (valid(s) && s.sessionKey && n === this.linkName(s.conversation, linkKey(s)))
+                    out.push(s);
+            }
+            catch {
+                /* skip */
+            }
+        }
+        return out;
+    }
+    keysPath(issuer) {
+        return join(this.dir, "keys", hash(issuer, 16) + ".json");
+    }
+    /** The issuer's JWKS as last fetched, and when. */
+    loadKeys(issuer) {
+        const p = this.keysPath(issuer);
+        try {
+            return { body: readFileSync(p, "utf8"), at: statSync(p).mtimeMs };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    saveKeys(issuer, body) {
+        this.ensure("keys");
+        this.write(this.keysPath(issuer), body);
+    }
+    /** Where the pins are (servers.json: MCP server name → app ID). */
+    pinsPath() {
+        return join(this.dir, "servers.json");
+    }
+    /**
+     * connector.Pins: "" if the MCP server may carry the app's beacons (the
+     * pair is pinned the first time either is seen), else why not. A server's
+     * results carry one app's beacons, and an app's come from one server.
+     */
+    pin(server, app) {
+        if (!server || !app)
+            return "the result named no app";
+        let pins = {};
+        let raw;
+        try {
+            raw = readFileSync(this.pinsPath(), "utf8");
+        }
+        catch (e) {
+            // None yet; pins that exist but can't be read fail closed (read as
+            // none, any server could pin itself to any app).
+            if (e.code !== "ENOENT")
+                return PINS_UNREADABLE;
+        }
+        if (raw !== undefined) {
+            try {
+                const f = JSON.parse(raw);
+                if (!f || typeof f.servers !== "object" || !f.servers)
+                    throw new Error("no servers");
+                pins = f.servers;
+            }
+            catch {
+                return PINS_UNREADABLE;
+            }
+        }
+        const got = pins[server];
+        if (got === app)
+            return "";
+        if (got)
+            return `the MCP server "${server}" carries beacons for "${got}" here, not "${app}"`;
+        for (const [s, a] of Object.entries(pins))
+            if (a === app)
+                return `beacons for "${app}" come from the MCP server "${s}" here, not "${server}"`;
+        pins[server] = app;
+        this.ensure(".");
+        this.write(this.pinsPath(), JSON.stringify({ servers: pins }, null, 2));
+        return "";
+    }
+}

package/dist/transport.js

@@ -0,0 +1,474 @@
+// Transport for one conversation's Wakeshift stream link: reading only. It
+// owns no delivery state (deliveries.ts does): it hands each delivery it
+// reads to `receive`, and sends acknowledgments when asked (`ack`).
+//
+// Server-Sent Events first (GET /v1/stream?format=sse), long polling (GET
+// /v1/stream/poll) as the fallback when SSE doesn't get through (a proxy
+// that buffers it), both with the link's token as Authorization: Bearer,
+// never in a URL. The cursor (Last-Event-ID) moves past a delivery only
+// once `receive` has resolved for it, i.e. once it's recorded. hub.rotate
+// is followed to the same origin only; hub.closed and a 401 or 410 (or
+// Wakeshift's link_revoked) end the stream for good; anything else,
+// including another 403 or 404 (a router during a deploy, a firewall),
+// reconnects with backoff. A connection that ends at once without a
+// delivery counts as a failure for the backoff.
+import { CLIENT_HEADER, clientHeader } from "./version.js";
+/** The longest SSE line, and the largest poll answer, read; a longer line is skipped. */
+export const MAX_LINE = 1 << 20;
+export const MAX_RESPONSE = 8 << 20;
+/** A stream link's parts: its origin as https (or http) and its token. */
+export function parseLink(link) {
+    let u;
+    try {
+        u = new URL(link);
+    }
+    catch {
+        return undefined;
+    }
+    const scheme = u.protocol === "wss:" || u.protocol === "https:" ? "https:" : u.protocol === "ws:" || u.protocol === "http:" ? "http:" : "";
+    const token = u.searchParams.get("link") ?? "";
+    if (!scheme || !u.host || !token)
+        return undefined;
+    return { base: `${scheme}//${u.host}`, token };
+}
+export function sameOrigin(a, b) {
+    const x = parseLink(a), y = parseLink(b);
+    return !!x && !!y && x.base === y.base;
+}
+// hub.closed reasons after which the stream goes on (reconnect).
+const RETRY_REASONS = new Set(["restarting", "reconnect", "error"]);
+class Gone extends Error {
+    reason;
+    constructor(reason) {
+        super("gone: " + reason);
+        this.reason = reason;
+    }
+}
+class Replaced extends Error {
+    constructor() {
+        super("replaced");
+    }
+}
+class Outdated extends Error {
+    constructor() {
+        super("Wakeshift no longer serves this version of the plugin");
+    }
+}
+// Wakeshift answered but the stream didn't work: what a proxy that won't
+// pass SSE looks like.
+class SSEBlocked extends Error {
+}
+// A delivery couldn't be recorded: not the stream's fault.
+class RecordFailed extends Error {
+}
+class Unavailable extends Error {
+    retryAfter;
+    constructor(retryAfter) {
+        super("Wakeshift is busy or restarting");
+        this.retryAfter = retryAfter;
+    }
+}
+export class Transport {
+    o;
+    link;
+    f;
+    abort = new AbortController();
+    stopped = false;
+    lastEventId = "";
+    mode = "sse";
+    sseFailures = 0;
+    pollingSince = 0;
+    conn;
+    reconnecting = false;
+    chain = Promise.resolve();
+    progress = false; // a delivery (or a new link) came on the current connection
+    done;
+    resolveDone;
+    constructor(o) {
+        this.o = o;
+        this.link = o.link;
+        this.f = o.fetch ?? fetch;
+        this.done = new Promise((r) => (this.resolveDone = r));
+    }
+    get currentLink() {
+        return this.link;
+    }
+    get transport() {
+        return this.mode;
+    }
+    start() {
+        void this.run();
+        return this;
+    }
+    stop() {
+        this.stopped = true;
+        this.abort.abort();
+    }
+    /** Waits until what's been read so far is recorded. */
+    async settled() {
+        await this.chain;
+    }
+    /**
+     * Drops the SSE connection and makes a new one, so Wakeshift hands out
+     * again what isn't acknowledged (on SSE that comes back only on a new
+     * connection; a poll gets it back by itself).
+     */
+    reconnect() {
+        if (this.mode === "sse" && this.conn && !this.conn.signal.aborted) {
+            this.reconnecting = true;
+            this.conn.abort();
+        }
+    }
+    /**
+     * POST /v1/stream/ack for up to 100 IDs: the HTTP status, or 0 if
+     * Wakeshift couldn't be reached.
+     */
+    async ack(ids) {
+        if (ids.length === 0 || ids.length > 100)
+            throw new Error("ack: 1 to 100 IDs");
+        const p = parseLink(this.link);
+        if (!p)
+            return 401;
+        try {
+            const r = await this.f(`${p.base}/v1/stream/ack`, {
+                method: "POST",
+                headers: { Authorization: `Bearer ${p.token}`, "Content-Type": "application/json", [CLIENT_HEADER]: clientHeader() },
+                body: JSON.stringify({ delivery_ids: ids }),
+                signal: AbortSignal.any([this.abort.signal, AbortSignal.timeout(10000)]),
+                redirect: "error", // never the token to wherever a 3xx points
+            });
+            if ((r.status === 403 || r.status === 404) && (await revoked(r)))
+                return 401;
+            await r.body?.cancel().catch(() => { });
+            return r.status;
+        }
+        catch {
+            return 0;
+        }
+    }
+    log(m) {
+        this.o.log?.(m);
+    }
+    async run() {
+        const minBackoff = this.o.minBackoff ?? 1000;
+        const maxBackoff = this.o.maxBackoff ?? 30000;
+        const pollWait = this.o.pollWait ?? 25000;
+        let backoff = minBackoff;
+        let result = { why: "stopped" };
+        while (!this.stopped) {
+            try {
+                if (this.mode === "poll" && Date.now() - this.pollingSince > (this.o.sseRetryEvery ?? 600000))
+                    this.mode = "sse";
+                if (this.mode === "sse") {
+                    this.progress = false;
+                    const began = Date.now();
+                    await this.sse(); // returns when the stream says to reconnect
+                    if (this.progress || Date.now() - began >= (this.o.healthyAfter ?? 10000)) {
+                        backoff = minBackoff;
+                        continue;
+                    }
+                    // Ended at once with nothing new (a proxy that closes at once, a
+                    // repeated hub.closed "restarting"): don't reconnect in a tight loop.
+                    await sleep(backoff, this.abort.signal);
+                    backoff = Math.min(backoff * 2, maxBackoff);
+                    continue;
+                }
+                const started = Date.now();
+                const fresh = await this.poll();
+                // Nothing new (empty, or only what's recorded and waiting for its
+                // turn, which a poll hands out again at once): don't spin.
+                if (fresh === 0 && Date.now() - started < pollWait / 2) {
+                    await sleep(backoff, this.abort.signal);
+                    backoff = Math.min(backoff * 2, maxBackoff);
+                }
+                else
+                    backoff = minBackoff;
+            }
+            catch (e) {
+                if (this.stopped)
+                    break;
+                if (e instanceof Gone) {
+                    result = { why: "gone", reason: e.reason };
+                    break;
+                }
+                if (e instanceof Replaced) {
+                    result = { why: "replaced" };
+                    break;
+                }
+                if (e instanceof Outdated) {
+                    this.log("Wakeshift no longer serves this version of the plugin: update it to receive messages");
+                    result = { why: "outdated" };
+                    break;
+                }
+                // Only Wakeshift answering and SSE still not working counts (not
+                // Wakeshift being unreachable, which polling wouldn't change).
+                if (this.mode === "sse" && e instanceof SSEBlocked && ++this.sseFailures >= (this.o.sseTries ?? 3)) {
+                    this.log("Server-Sent Events aren't getting through; long polling instead");
+                    this.mode = "poll";
+                    this.pollingSince = Date.now();
+                    this.sseFailures = 0;
+                }
+                const wait = e instanceof Unavailable && e.retryAfter ? e.retryAfter * 1000 : backoff;
+                this.log(`stream: ${e.message}; again in ${Math.round(wait / 1000)}s`);
+                await sleep(wait, this.abort.signal);
+                backoff = Math.min(backoff * 2, maxBackoff);
+            }
+        }
+        await this.chain.catch(() => { });
+        if (this.stopped)
+            result = { why: "stopped" };
+        this.o.onStop?.(result);
+        this.resolveDone(result);
+    }
+    parts() {
+        const p = parseLink(this.link);
+        if (!p)
+            throw new Gone("not a stream link");
+        return p;
+    }
+    async status(r) {
+        if (r.status === 426)
+            throw new Outdated();
+        if (r.status === 401 || r.status === 410)
+            throw new Gone("link_revoked");
+        if ((r.status === 403 || r.status === 404) && (await revoked(r)))
+            throw new Gone("link_revoked");
+        if (r.status === 409)
+            throw new Replaced();
+        if (r.status === 503 || r.status === 429) {
+            const ra = Number(r.headers.get("retry-after"));
+            throw new Unavailable(Number.isFinite(ra) && ra > 0 ? Math.min(ra, 120) : undefined);
+        }
+        if (!r.ok)
+            throw new Error(`Wakeshift answered ${r.status}`);
+    }
+    rotate(next) {
+        if (typeof next !== "string" || !next)
+            return;
+        const p = parseLink(next);
+        if (!p || !sameOrigin(next, this.link))
+            return;
+        const cur = new URL(this.link);
+        const link = `${cur.protocol}//${cur.host}/v1/stream?link=${encodeURIComponent(p.token)}`;
+        if (link === this.link)
+            return;
+        this.link = link;
+        this.progress = true;
+        this.o.onLink?.(link);
+    }
+    // Records deliveries in order, one batch at a time; resolves with how
+    // many were new. The cursor moves only once they're recorded.
+    // Throws if recording fails: the caller stops reading this connection
+    // (or poll) there and reconnects, with the cursor still before it.
+    receive(ds) {
+        const valid = ds.filter((d) => d && typeof d.delivery_id === "string" && d.event && typeof d.event === "object");
+        const p = this.chain.then(async () => {
+            if (valid.length === 0 || this.stopped)
+                return 0;
+            const n = await this.o.receive(valid);
+            this.progress = true;
+            this.lastEventId = valid[valid.length - 1].delivery_id; // SSE ids are delivery IDs
+            return n;
+        });
+        this.chain = p.then(() => { }, () => { });
+        return p.catch((e) => {
+            throw new RecordFailed(`recording failed: ${e.message}`);
+        });
+    }
+    // One SSE connection, until the stream says to reconnect (returns) or
+    // ends any other way (throws).
+    async sse() {
+        const { base, token } = this.parts();
+        const conn = new AbortController();
+        this.conn = conn;
+        this.reconnecting = false;
+        const onStop = () => conn.abort();
+        this.abort.signal.addEventListener("abort", onStop, { once: true });
+        let last = Date.now();
+        const silentFor = this.o.silentFor ?? 50000;
+        let silent = false;
+        let answered = false;
+        const watchdog = setInterval(() => {
+            if (Date.now() - last > silentFor) {
+                silent = true;
+                conn.abort();
+            }
+        }, Math.min(5000, silentFor / 2));
+        try {
+            const headers = { Accept: "text/event-stream", Authorization: `Bearer ${token}`, [CLIENT_HEADER]: clientHeader() };
+            if (this.lastEventId)
+                headers["Last-Event-ID"] = this.lastEventId;
+            const r = await this.f(`${base}/v1/stream?format=sse`, { headers, signal: conn.signal, redirect: "error" });
+            answered = true;
+            await this.status(r);
+            if (!r.body)
+                throw new Error("no body");
+            const reader = r.body.pipeThrough(new TextDecoderStream()).getReader();
+            try {
+                let buf = "";
+                let ev = { data: [], size: 0 };
+                let longLine = false; // the rest of an over-long line is being skipped
+                for (;;) {
+                    const { value, done } = await reader.read();
+                    if (done)
+                        throw new Error("the stream ended");
+                    last = Date.now();
+                    this.sseFailures = 0;
+                    buf += value;
+                    let i;
+                    while ((i = buf.search(/\r\n|\r|\n/)) >= 0) {
+                        const line = buf.slice(0, i);
+                        buf = buf.slice(i + (buf.startsWith("\r\n", i) ? 2 : 1));
+                        if (longLine || line.length > MAX_LINE) {
+                            if (!longLine)
+                                this.log("skipped an over-long stream line");
+                            longLine = false; // its end: the event it was in is dropped
+                            ev = { data: [], size: 0, skip: true };
+                            continue;
+                        }
+                        if (line === "") {
+                            // Each frame is recorded before the next is read.
+                            if (!ev.skip && ev.data.length > 0 && (await this.onFrame(ev.event ?? "message", ev.data.join("\n"))) === "reconnect")
+                                return;
+                            ev = { data: [], size: 0 };
+                            continue;
+                        }
+                        if (line.startsWith(":"))
+                            continue;
+                        const c = line.indexOf(":");
+                        const k = c < 0 ? line : line.slice(0, c);
+                        const v = c < 0 ? "" : line.slice(c + 1).replace(/^ /, "");
+                        if (k === "data") {
+                            ev.size += v.length;
+                            if (ev.size > MAX_LINE * 4)
+                                ev = { data: [], size: 0, skip: true };
+                            if (!ev.skip)
+                                ev.data.push(v);
+                        }
+                        else if (k === "event")
+                            ev.event = v;
+                    }
+                    if (buf.length > MAX_LINE) {
+                        this.log("skipped an over-long stream line");
+                        buf = "";
+                        longLine = true;
+                        ev = { data: [], size: 0, skip: true };
+                    }
+                }
+            }
+            finally {
+                reader.cancel().catch(() => { });
+            }
+        }
+        catch (e) {
+            if (this.reconnecting && !this.stopped)
+                return; // asked to reconnect
+            if (silent && !this.stopped)
+                throw new SSEBlocked(`nothing came on the stream for ${Math.round(silentFor / 1000)}s`);
+            if (answered && !(e instanceof Gone || e instanceof Replaced || e instanceof Outdated || e instanceof Unavailable || e instanceof RecordFailed))
+                throw new SSEBlocked(e.message);
+            throw e;
+        }
+        finally {
+            clearInterval(watchdog);
+            this.abort.signal.removeEventListener("abort", onStop);
+            conn.abort();
+        }
+    }
+    // A frame: "reconnect" when the stream ends here and goes on; throws
+    // when it ends for good.
+    async onFrame(type, data) {
+        let m;
+        try {
+            m = JSON.parse(data);
+        }
+        catch {
+            return undefined;
+        }
+        const t = typeof m.type === "string" ? m.type : type;
+        if (t === "event") {
+            await this.receive([m]); // a failure ends this connection here
+            return undefined;
+        }
+        if (t === "hub.rotate") {
+            this.rotate(m.url);
+            return "reconnect";
+        }
+        if (t === "hub.closed") {
+            const reason = typeof m.reason === "string" ? m.reason : "";
+            if (reason === "replaced")
+                throw new Replaced();
+            if (reason === "update_required")
+                throw new Outdated(); // the minimum was raised; the link stays for the update
+            if (RETRY_REASONS.has(reason))
+                return "reconnect";
+            throw new Gone(reason || "closed");
+        }
+        return undefined;
+    }
+    // One long poll; how many new deliveries it brought.
+    async poll() {
+        const { base, token } = this.parts();
+        await this.chain;
+        const wait = this.o.pollWait ?? 25000;
+        const r = await this.f(`${base}/v1/stream/poll?wait=${wait}ms`, {
+            headers: { Authorization: `Bearer ${token}`, [CLIENT_HEADER]: clientHeader() },
+            signal: AbortSignal.any([this.abort.signal, AbortSignal.timeout(wait + 15000)]),
+            redirect: "error",
+        });
+        await this.status(r);
+        const b = JSON.parse(await bounded(r, MAX_RESPONSE));
+        if (b.rotate?.url)
+            this.rotate(b.rotate.url);
+        const ds = b.deliveries ?? [];
+        return ds.length > 0 ? this.receive(ds) : 0;
+    }
+}
+// Whether a 403 or 404 is Wakeshift's own link_revoked (not a router's or a firewall's).
+async function revoked(r) {
+    try {
+        const b = JSON.parse(await bounded(r, 1 << 16));
+        return b?.error?.code === "link_revoked";
+    }
+    catch {
+        return false;
+    }
+}
+// A response's body as text, refusing one over max bytes.
+async function bounded(r, max) {
+    if (!r.body)
+        return "";
+    const reader = r.body.getReader();
+    const parts = [];
+    let n = 0;
+    try {
+        for (;;) {
+            const { value, done } = await reader.read();
+            if (done)
+                break;
+            n += value.byteLength;
+            if (n > max)
+                throw new Error(`Wakeshift's answer was over ${max} bytes`);
+            parts.push(value);
+        }
+    }
+    finally {
+        reader.cancel().catch(() => { });
+    }
+    return Buffer.concat(parts).toString("utf8");
+}
+export function sleep(ms, signal) {
+    return new Promise((resolve) => {
+        if (signal.aborted)
+            return resolve();
+        const onAbort = () => {
+            clearTimeout(t);
+            resolve();
+        };
+        const t = setTimeout(() => {
+            signal.removeEventListener("abort", onAbort);
+            resolve();
+        }, ms);
+        signal.addEventListener("abort", onAbort, { once: true });
+    });
+}

package/dist/version.js

@@ -0,0 +1,12 @@
+// The plugin's version, which every request to Wakeshift names
+// (internal/connectorversion), so Wakeshift records what's in use and can
+// ask the user to update. "dev" here; `npm run pack` stamps the build's
+// version into dist/version.js (scripts/stamp-version.mjs, from
+// WAKESHIFT_VERSION).
+export const VERSION = "2026.11.03.0404+bb5a6d2";
+export const CLIENT_HEADER = "X-Wakeshift-Connector";
+/** X-Wakeshift-Connector's value: wakeshift-openclaw/<version> openclaw. */
+export function clientHeader(version = VERSION) {
+    const v = /^[0-9A-Za-z][0-9A-Za-z.+_-]{0,63}$/.test(version) ? version : "0";
+    return `wakeshift-openclaw/${v} openclaw`;
+}