seekmux 0.0.0-stage → 0.0.1

package/dist/cli.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+// npx seekmux --server https://seekmux.example.com --token <worker token>
+import { readFileSync } from "node:fs";
+import { parseArgs } from "node:util";
+import { endpoint, run } from "./worker.js";
+const version = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).version;
+const usage = `seekmux ${version} — read pages for a SeekMux gateway in your logged-in Chrome
+
+Usage:
+  npx seekmux --server <url> --token <token> [--slots 1]
+
+Options:
+  --server   The gateway's address, e.g. https://seekmux.example.com
+             (env SEEKMUX_SERVER)
+  --token    This worker's token, from its fetcher on the gateway's
+             Self-hosted fetchers page (env SEEKMUX_WORKER_TOKEN)
+  --slots    Pages read at once, 1 or 2 (default 1)
+  --help     Show this help
+  --version  Show the version
+
+Chrome needs the OpenCLI extension (Browser Bridge) installed and enabled:
+https://github.com/jackwener/opencli#2-install-the-browser-bridge-extension
+`;
+function log(line) {
+    const time = new Date().toLocaleTimeString("en-GB", { hour12: false });
+    console.log(`${time}  ${line}`);
+}
+async function main() {
+    const { values } = parseArgs({
+        options: {
+            server: { type: "string" },
+            token: { type: "string" },
+            slots: { type: "string" },
+            help: { type: "boolean", short: "h" },
+            version: { type: "boolean", short: "v" },
+        },
+    });
+    if (values.help) {
+        process.stdout.write(usage);
+        return;
+    }
+    if (values.version) {
+        console.log(version);
+        return;
+    }
+    const server = values.server ?? process.env.SEEKMUX_SERVER;
+    const token = values.token ?? process.env.SEEKMUX_WORKER_TOKEN;
+    if (!server || !token) {
+        process.stderr.write(usage);
+        process.exitCode = 2;
+        return;
+    }
+    const slots = Number(values.slots ?? 1);
+    if (!Number.isInteger(slots) || slots < 1 || slots > 2) {
+        console.error("--slots must be 1 or 2: the worker drives a single browser");
+        process.exitCode = 2;
+        return;
+    }
+    log(`seekmux worker ${version}`);
+    await run({ url: endpoint(server), token, slots, version, log });
+}
+main().catch((err) => {
+    log(`stopped: ${err instanceof Error ? err.message : String(err)}`);
+    process.exit(1);
+});

package/dist/opencli.js

@@ -0,0 +1,202 @@
+// Runs OpenCLI as a child process and turns what it prints into pages,
+// states and errors. OpenCLI is a dependency of this package, so the version
+// it runs is the one this package was tested with.
+import { spawn } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { FetchError } from "./protocol.js";
+const main = fileURLToPath(import.meta.resolve("@jackwener/opencli"));
+/** The version of OpenCLI this worker runs. */
+export const openCLIVersion = (() => {
+    try {
+        const pkg = JSON.parse(readFileSync(new URL("../../package.json", import.meta.resolve("@jackwener/opencli")), "utf8"));
+        return String(pkg.version);
+    }
+    catch {
+        return "";
+    }
+})();
+/** Thrown when the caller canceled the fetch; nothing is reported for it. */
+export class Canceled extends Error {
+}
+function run(args, opts) {
+    return new Promise((resolve, reject) => {
+        if (opts.signal?.aborted)
+            return reject(new Canceled("canceled"));
+        const env = {
+            ...process.env,
+            // OpenCLI gives up on a browser step after this many seconds.
+            OPENCLI_BROWSER_COMMAND_TIMEOUT: String(Math.max(5, Math.floor(opts.timeoutMs / 1000))),
+            // Close the tab a read opened, so tabs do not pile up in the user's Chrome.
+            OPENCLI_CLOSE_OWNED_TAB: "1",
+        };
+        if (opts.profile)
+            env.OPENCLI_PROFILE = opts.profile;
+        const child = spawn(process.execPath, [main, ...args], { env, stdio: ["ignore", "pipe", "pipe"] });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.setEncoding("utf8").on("data", (chunk) => (stdout += chunk));
+        child.stderr.setEncoding("utf8").on("data", (chunk) => (stderr += chunk));
+        // A canceled read is left to finish: OpenCLI closes the tab it opened
+        // and releases its hold on the site only when the command ends, and has
+        // no signal handler to do it when killed. The slot stays taken until
+        // then. Killing is kept for the deadline, after which OpenCLI reclaims
+        // the hold by itself (within 45s).
+        let ended;
+        const timer = setTimeout(() => {
+            ended ??= "timeout";
+            child.kill("SIGTERM");
+            setTimeout(() => child.kill("SIGKILL"), 2000).unref();
+        }, opts.timeoutMs);
+        const onAbort = () => {
+            ended ??= "canceled";
+        };
+        opts.signal?.addEventListener("abort", onAbort, { once: true });
+        child.on("error", (err) => {
+            clearTimeout(timer);
+            opts.signal?.removeEventListener("abort", onAbort);
+            reject(new FetchError("internal", `could not start OpenCLI: ${err.message}`));
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            opts.signal?.removeEventListener("abort", onAbort);
+            if (ended === "canceled")
+                return reject(new Canceled("canceled"));
+            if (ended === "timeout")
+                return reject(new FetchError("timeout", `OpenCLI did not finish within ${Math.round(opts.timeoutMs / 1000)}s`));
+            resolve({ stdout, stderr, code });
+        });
+    });
+}
+/** Finds the JSON envelope OpenCLI printed, on either stream. */
+function envelope(out) {
+    for (const text of [out.stdout, out.stderr]) {
+        const start = text.indexOf("{");
+        if (start < 0)
+            continue;
+        try {
+            const parsed = JSON.parse(text.slice(start));
+            if (typeof parsed === "object" && parsed && "ok" in parsed)
+                return parsed;
+        }
+        catch {
+            // Not JSON, or not only JSON: try the other stream.
+        }
+    }
+    return undefined;
+}
+/** Maps an OpenCLI failure to the code the gateway acts on. */
+function failure(out) {
+    const env = envelope(out);
+    const code = env?.error?.code ?? "";
+    const message = [env?.error?.message, env?.error?.help].filter(Boolean).join(" — ") || lastLine(out.stderr) || `OpenCLI exited with ${out.code}`;
+    const map = {
+        AUTH_REQUIRED: "login_required",
+        // An HTML page where JSON was expected: a login wall, a rate limit or a
+        // WAF challenge, OpenCLI cannot tell which. The message says as much.
+        LOGIN_WALL: "blocked",
+        EMPTY_RESULT: "empty",
+        TIMEOUT: "timeout",
+        SESSION_BUSY: "busy",
+        BROWSER_CONNECT: "browser_unavailable",
+    };
+    return new FetchError(map[code] ?? "failed", message);
+}
+/**
+ * Says what is wrong with the profile choice, by OpenCLI's own rule: a
+ * chosen profile must be connected; without one, the default is used, else
+ * the only connected profile. It mirrors State.Route on the gateway.
+ */
+export function profileProblem(profiles, chosen) {
+    const connected = profiles.filter((p) => p.connected);
+    if (chosen) {
+        if (!profiles.some((p) => p.id === chosen))
+            return new FetchError("profile_missing", `OpenCLI on the worker does not know the Chrome profile "${chosen}"`);
+        if (!connected.some((p) => p.id === chosen))
+            return new FetchError("browser_unavailable", `the Chrome profile "${chosen}" is not open on the worker`);
+        return undefined;
+    }
+    if (connected.length > 1 && !connected.some((p) => p.default)) {
+        return new FetchError("profile_missing", `${connected.length} Chrome profiles are connected and none is chosen: choose one for OpenCLI in the console`);
+    }
+    if (connected.length === 0)
+        return new FetchError("browser_unavailable", "no Chrome profile is connected to OpenCLI on the worker");
+    return undefined;
+}
+/**
+ * Turns a failed run into its error. When OpenCLI could not reach the
+ * browser, the profiles are read again and judged by profileProblem, rather
+ * than by the wording of OpenCLI's message.
+ */
+async function failed(out, opts) {
+    const err = failure(out);
+    if (err.code !== "browser_unavailable" || opts.builtin)
+        return err;
+    const profiles = await listProfiles().catch(() => undefined);
+    return (profiles && profileProblem(profiles, opts.profile)) ?? err;
+}
+function lastLine(text) {
+    const lines = text.trim().split("\n");
+    return lines[lines.length - 1]?.trim() ?? "";
+}
+/**
+ * Runs an OpenCLI command and returns the data of the JSON it prints. Site
+ * commands are asked for JSON; built-in ones such as doctor print only JSON
+ * and refuse the flag (format: false).
+ */
+export async function json(args, opts, format = true) {
+    const out = await run(format ? [...args, "-f", "json"] : args, opts);
+    const env = envelope(out);
+    if (out.code !== 0 || !env?.ok)
+        throw await failed(out, opts);
+    return env.data;
+}
+/** Runs an OpenCLI command that prints its result as it is. */
+export async function text(args, opts) {
+    const out = await run(args, opts);
+    if (out.code !== 0)
+        throw await failed(out, opts);
+    return out.stdout;
+}
+/** The Chrome profiles OpenCLI knows: connected ones, and those it has an alias or default for. */
+async function listProfiles() {
+    const list = (await json(["profile", "list"], { timeoutMs: 30_000, builtin: true }, false));
+    return (list.profiles ?? []).map((p) => ({
+        id: p.contextId,
+        ...(p.alias ? { alias: p.alias } : {}),
+        ...(p.default ? { default: true } : {}),
+        connected: Boolean(p.connected),
+    }));
+}
+/**
+ * Asks OpenCLI whether it reaches a browser, and which profiles it knows.
+ *
+ * The worker is ready while a Chrome profile is connected. Which profile a
+ * read uses is the gateway's choice, sent with each fetch, so readiness does
+ * not follow doctor's verdict: doctor judges by OpenCLI's local default and
+ * reports several connected profiles without one as not connected.
+ */
+export async function readState() {
+    let doctorProblem;
+    try {
+        // doctor starts the daemon when it is not running.
+        const doctor = (await json(["doctor"], { timeoutMs: 30_000, builtin: true }, false));
+        if (!doctor.extensionConnected || !doctor.connectivity?.ok) {
+            doctorProblem = doctor.connectivity?.error ?? doctor.issues?.[0]?.split("\n")[0];
+        }
+    }
+    catch (err) {
+        doctorProblem = err instanceof Error ? err.message : String(err);
+    }
+    let profiles = [];
+    let listProblem;
+    try {
+        profiles = await listProfiles();
+    }
+    catch (err) {
+        listProblem = err instanceof Error ? err.message : String(err);
+    }
+    const ready = profiles.some((p) => p.connected);
+    const problem = ready ? undefined : (doctorProblem ?? listProblem ?? "no Chrome profile is connected to OpenCLI");
+    return { ready, ...(problem ? { problem } : {}), opencli: openCLIVersion, profiles };
+}

package/dist/protocol.js

@@ -0,0 +1,22 @@
+// The frames exchanged with the gateway. internal/worker/protocol.go is the
+// other side and describes the exchange; change both together.
+export const PROTOCOL_VERSION = 1;
+/** Close codes the gateway ends a connection with. */
+export const CloseCode = {
+    Protocol: 4400,
+    Unauthorized: 4401,
+    Replaced: 4409,
+};
+/** A failed fetch, with the code the gateway acts on. */
+export class FetchError extends Error {
+    code;
+    status;
+    constructor(code, message, status) {
+        super(message);
+        this.code = code;
+        this.status = status;
+    }
+    toWire() {
+        return { code: this.code, message: this.message, ...(this.status ? { status: this.status } : {}) };
+    }
+}

package/dist/sites.js

@@ -0,0 +1,142 @@
+// Reads a page: through a site's OpenCLI adapter when the gateway asked for
+// one and the URL is a post the adapter reads, otherwise as the page renders.
+//
+// Rendering stays close to what OpenCLI returns. It only arranges the rows
+// into Markdown an agent reads in order; it does not try to clean the text,
+// which would risk dropping what the page says.
+import { json, text } from "./opencli.js";
+import { FetchError } from "./protocol.js";
+/** The adapters this worker has, by the gateway's routing rule ids. */
+export const adapters = ["twitter", "reddit"];
+export function match(raw) {
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        return undefined;
+    }
+    const host = url.hostname.toLowerCase().replace(/^(www|mobile|m)\./, "");
+    const path = url.pathname;
+    if (host === "x.com" || host === "twitter.com") {
+        const id = /^\/(?:[^/]+|i\/web|i)\/status(?:es)?\/(\d+)/.exec(path)?.[1];
+        return id ? { site: "twitter", id } : undefined;
+    }
+    if (host === "redd.it") {
+        const id = /^\/([a-z0-9]+)\/?$/i.exec(path)?.[1];
+        return id ? { site: "reddit", target: id } : undefined;
+    }
+    if (host === "reddit.com" || host.endsWith(".reddit.com")) {
+        return /\/comments\/[a-z0-9]+/i.test(path) ? { site: "reddit", target: url.origin + path } : undefined;
+    }
+    return undefined;
+}
+export async function read(url, adapter, opts) {
+    const site = adapter ? match(url) : undefined;
+    switch (site?.site) {
+        case "twitter":
+            return readTweet(url, site.id, opts);
+        case "reddit":
+            return readReddit(url, site.target, opts);
+    }
+    return readPage(url, opts);
+}
+async function readPage(url, opts) {
+    const markdown = await text(["web", "read", "--url", url, "--stdout", "true", "--download-images", "false"], opts);
+    if (!markdown.trim())
+        throw new FetchError("empty", "the page rendered without any text");
+    const title = /^# (.+)$/m.exec(markdown)?.[1]?.trim();
+    return { url, ...(title && title !== "untitled" ? { title } : {}), content: markdown, source: "page" };
+}
+async function readTweet(url, id, opts) {
+    const rows = (await json(["twitter", "thread", id, "--limit", "100"], opts));
+    if (!Array.isArray(rows) || rows.length === 0)
+        throw new FetchError("empty", "the thread came back empty");
+    const main = rows.find((t) => t.id === id) ?? rows[0];
+    // Replies in the order they were written, so a thread split into several
+    // posts reads from its start.
+    const replies = rows.filter((t) => t !== main).sort((a, b) => time(a) - time(b));
+    const authors = new Map(rows.map((t) => [t.id, t.author]));
+    const out = [`# @${main.author} on X`, "", tweetMeta(main), "", unescape(main.text)];
+    if (main.media_urls?.length)
+        out.push("", ...main.media_urls.map((u) => `![](${u})`));
+    if (main.quoted_tweet) {
+        const q = main.quoted_tweet;
+        out.push("", `> Quoting @${q.author}${q.name ? ` (${q.name})` : ""}${q.url ? ` — ${q.url}` : ""}`, ">");
+        out.push(...unescape(q.text).split("\n").map((line) => `> ${line}`));
+    }
+    if (replies.length) {
+        out.push("", `## Replies (${replies.length})`);
+        for (const r of replies) {
+            const to = r.in_reply_to && r.in_reply_to !== main.id && authors.has(r.in_reply_to) ? ` · replying to @${authors.get(r.in_reply_to)}` : "";
+            out.push("", `**@${r.author}**${to} · ${tweetMeta(r, true)}`, "", unescape(r.text));
+            if (r.media_urls?.length)
+                out.push(...r.media_urls.map((u) => `![](${u})`));
+        }
+    }
+    const first = unescape(main.text).split("\n")[0].slice(0, 80);
+    return { url: main.url ?? url, title: `@${main.author} on X: ${first}`, content: out.join("\n") + "\n", source: "twitter" };
+}
+function time(t) {
+    const ms = t.created_at ? Date.parse(t.created_at) : NaN;
+    return Number.isNaN(ms) ? 0 : ms;
+}
+function tweetMeta(t, short = false) {
+    const parts = [];
+    if (!short && t.name)
+        parts.push(t.name);
+    const ms = time(t);
+    if (ms)
+        parts.push(new Date(ms).toISOString().replace("T", " ").slice(0, 16) + " UTC");
+    if (t.likes)
+        parts.push(`${t.likes} likes`);
+    if (!short && t.retweets)
+        parts.push(`${t.retweets} reposts`);
+    if (!short && t.views)
+        parts.push(`${t.views} views`);
+    if (!short && t.url)
+        parts.push(t.url);
+    return parts.join(" · ");
+}
+/** X sends post text HTML-escaped. */
+function unescape(s) {
+    return s.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&amp;/g, "&");
+}
+async function readReddit(url, target, opts) {
+    const args = ["reddit", "read", target, "--limit", "50", "--depth", "4", "--replies", "10", "--expand-more", "true"];
+    const rows = (await json(args, opts));
+    const post = Array.isArray(rows) ? rows.find((r) => r.type === "POST") : undefined;
+    if (!post)
+        throw new FetchError("empty", "the post came back empty");
+    // The post's text is its title, a blank line, and its body.
+    const [title, ...body] = post.text.split("\n");
+    const out = [`# ${title}`, "", `u/${post.author} · ${post.score} points`];
+    const link = post.url_overridden_by_dest;
+    if (link && link !== url)
+        out.push("", `Link: ${link}`);
+    const bodyText = body.join("\n").trim();
+    if (bodyText)
+        out.push("", bodyText);
+    for (const image of [post.preview_image_url, ...(post.gallery_urls ?? [])])
+        if (image)
+            out.push("", `![](${image})`);
+    const comments = rows.filter((r) => r !== post);
+    if (comments.length)
+        out.push("", "## Comments", "");
+    for (const row of comments) {
+        const level = /^L(\d+)$/.exec(row.type) ? Number(row.type.slice(1)) : 0;
+        const indent = "  ".repeat(level);
+        // OpenCLI indents a reply and quotes it with "> " for a table; the list
+        // nesting says the same, so the prefix comes off and the text stays.
+        const prefix = "  ".repeat(level) + (level > 0 ? "> " : "");
+        const lines = row.text.split("\n").map((line) => (line.startsWith(prefix) ? line.slice(prefix.length) : line.trimStart().replace(/^> ?/, "")));
+        if (!row.author) {
+            out.push(`${indent}- *${lines.join(" ").trim()}*`);
+            continue;
+        }
+        out.push(`${indent}- **u/${row.author}** (${row.score} points)`);
+        for (const line of lines)
+            out.push(line ? `${indent}  ${line}` : "");
+    }
+    return { url, title, content: out.join("\n") + "\n", source: "reddit" };
+}

package/dist/worker.js

@@ -0,0 +1,139 @@
+// The connection to the gateway: says hello, reports the browser's state,
+// runs the fetches it is handed and reconnects when the connection drops.
+import { Canceled, readState } from "./opencli.js";
+import { CloseCode, FetchError, PROTOCOL_VERSION } from "./protocol.js";
+import { read } from "./sites.js";
+/** How often the browser's state is checked and sent, which also keeps the connection in use. */
+const STATE_INTERVAL = 30_000;
+/** Turns what the user typed into the URL of the gateway's worker endpoint. */
+export function endpoint(server) {
+    const url = new URL(/^[a-z]+:\/\//i.test(server) ? server : `https://${server}`);
+    url.protocol = url.protocol === "http:" || url.protocol === "ws:" ? "ws:" : "wss:";
+    if (url.pathname === "/" || url.pathname === "")
+        url.pathname = "/worker";
+    url.search = "";
+    url.hash = "";
+    return url.toString();
+}
+/** Runs until the gateway refuses the worker for good. */
+export async function run(opts) {
+    let state = await readState();
+    logState(opts, state);
+    let delay = 1000;
+    for (;;) {
+        const { code, reason, welcomed } = await session(opts, state, (next) => (state = next));
+        if (code === CloseCode.Unauthorized || code === CloseCode.Protocol) {
+            throw new Error(`the gateway refused this worker: ${reason || code}`);
+        }
+        if (code === CloseCode.Replaced) {
+            throw new Error("another worker connected with the same token; this one stops so the two do not take turns");
+        }
+        if (welcomed)
+            delay = 1000;
+        opts.log(`disconnected (${reason || code}); reconnecting in ${delay / 1000}s`);
+        await new Promise((resolve) => setTimeout(resolve, delay));
+        delay = Math.min(delay * 2, 30_000);
+    }
+}
+function logState(opts, state) {
+    const profiles = state.profiles.map((p) => `${p.alias ?? p.id}${p.connected ? "" : " (closed)"}`).join(", ") || "none";
+    opts.log(state.ready ? `browser ready · OpenCLI ${state.opencli} · profiles: ${profiles}` : `browser not ready: ${state.problem}`);
+}
+function session(opts, initial, setState) {
+    return new Promise((resolve) => {
+        let state = initial;
+        let welcomed = false;
+        const running = new Map();
+        const ws = new WebSocket(opts.url);
+        const send = (m) => {
+            if (ws.readyState === WebSocket.OPEN)
+                ws.send(JSON.stringify(m));
+        };
+        // Re-read the state now and then, and right after a fetch found the
+        // browser unreachable; send it when it changed.
+        let checking = false;
+        const check = async () => {
+            if (checking)
+                return;
+            checking = true;
+            try {
+                const next = await readState();
+                const changed = JSON.stringify(next) !== JSON.stringify(state);
+                state = next;
+                setState(next);
+                if (changed)
+                    logState(opts, next);
+                // Sent even unchanged: it keeps the connection in use.
+                send({ type: "state", state: next });
+            }
+            finally {
+                checking = false;
+            }
+        };
+        const timer = setInterval(check, STATE_INTERVAL);
+        ws.addEventListener("open", () => {
+            send({ type: "hello", protocol: PROTOCOL_VERSION, token: opts.token, version: opts.version, slots: opts.slots, state });
+        });
+        ws.addEventListener("message", async (event) => {
+            let m;
+            try {
+                m = JSON.parse(String(event.data));
+            }
+            catch {
+                return;
+            }
+            switch (m.type) {
+                case "welcome":
+                    welcomed = true;
+                    opts.log(`connected to ${opts.url} · ${opts.slots} slot${opts.slots > 1 ? "s" : ""}`);
+                    return;
+                case "cancel":
+                    running.get(m.id)?.abort();
+                    return;
+                case "fetch":
+                    break;
+                default:
+                    return;
+            }
+            const { id, url } = m;
+            if (running.size >= opts.slots) {
+                send({ type: "result", id, error: { code: "busy", message: `the worker is already running ${running.size} fetches` } });
+                return;
+            }
+            const controller = new AbortController();
+            running.set(id, controller);
+            const started = Date.now();
+            opts.log(`→ ${url}${m.adapter ? " (adapter)" : ""}`);
+            try {
+                const page = await read(url, Boolean(m.adapter), { timeoutMs: m.timeout_ms, signal: controller.signal, profile: m.profile || undefined });
+                send({ type: "result", id, page });
+                opts.log(`✓ ${url} · ${page.source} · ${page.content.length} chars · ${seconds(started)}`);
+            }
+            catch (err) {
+                if (err instanceof Canceled) {
+                    opts.log(`· ${url} · canceled by the gateway · ${seconds(started)}`);
+                    return;
+                }
+                const failure = err instanceof FetchError ? err : new FetchError("internal", err instanceof Error ? err.message : String(err));
+                send({ type: "result", id, error: failure.toWire() });
+                opts.log(`✗ ${url} · ${failure.code}: ${failure.message} · ${seconds(started)}`);
+                if (failure.code === "browser_unavailable" || failure.code === "profile_missing")
+                    void check();
+            }
+            finally {
+                running.delete(id);
+            }
+        });
+        ws.addEventListener("close", (event) => {
+            clearInterval(timer);
+            for (const controller of running.values())
+                controller.abort();
+            resolve({ code: event.code, reason: event.reason, welcomed });
+        });
+        // An error is followed by a close event, which ends the session.
+        ws.addEventListener("error", () => { });
+    });
+}
+function seconds(started) {
+    return `${((Date.now() - started) / 1000).toFixed(1)}s`;
+}

package/package.json

@@ -1,6 +1,34 @@
 {
   "name": "seekmux",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.1",
+  "description": "SeekMux worker: reads pages for a SeekMux gateway in your logged-in Chrome, through OpenCLI",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fl0w1nd/seekmux.git",
+    "directory": "worker"
+  },
+  "type": "module",
+  "bin": {
+    "seekmux": "dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22.4"
+  },
+  "scripts": {
+    "build": "tsc -p .",
+    "typecheck": "tsc -p . --noEmit",
+    "start": "node src/cli.ts",
+    "prepack": "tsc -p ."
+  },
+  "dependencies": {
+    "@jackwener/opencli": "^2.0.2"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.6",
+    "typescript": "^7.0.2"
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.