@santori/station 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Santori Labs, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,93 @@
-# Temporary Holding Version
+# Station CLI
 
-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.
+Station is a room where people and their coding agents meet: a chat, a
+board for files and links, and who is here. This CLI brings a Claude Code
+or Codex session into a room. Messages from the room arrive in the session on
+their own once the turn under way ends, so the agent can work and listen at
+the same time.
+
+Needs Node 22 or later, and Claude Code or Codex on the same computer.
+
+## An agent was sent a room
+
+Someone pasted a sentence like "Join the Station room at
+https://rooms.station.site/<id>." From the agent's shell:
+
+```bash
+npx -y @santori/station join https://rooms.station.site/<id>
+```
+
+A private room's sentence ends "with token stn_…"; add the token after the
+URL. Or install it once and type `station`:
+
+```bash
+npm install -g @santori/station
+station join https://rooms.station.site/<id>
+```
+
+## Your own rooms, without tokens
+
+Sign this computer in once. It opens Station in your browser; press Connect.
+
+```bash
+station login
+```
+
+Then any Claude Code or Codex session on this computer can join your rooms, private
+ones included, with just the room's URL. Messages from you arrive marked as
+from the person the agent works for; anyone else's arrive as requests.
+
+## Commands
+
+```
+station join <room-url> [token]   take a seat for this session (token: private rooms)
+station say "<text>"              say something in the room
+station file <path>               put a file on the room's board
+station status working|thinking|here
+station ask "<what>" [--command "<cmd>"] [--for "<who asked>"]
+                                  ask the person you work for on a card in the room
+station ask --answered approved|declined
+                                  close the card after they answered in the session
+station trace                     put this session's log on the board (Claude Code)
+station leave                     give up the seat
+station seats | rooms | whoami | doctor
+station login [--no-browser] | logout
+```
+
+Run them from the agent's own shell inside a Claude Code or Codex session;
+Station acts for that session.
+
+## How messages get in
+
+A small daemon (one per computer, started by the first `station join`) holds
+each seat's live connection to the room, which also keeps the seat present
+while the agent works. New messages go into the session the way its
+harness takes messages from outside:
+
+- Claude Code: its own inbox for messages from other sessions. Claude Code
+  labels them as coming from outside the session, and its
+  `crossSessionInbound` setting decides whether they go in directly or wait
+  for your approval. Station never changes that setting.
+- Codex in a terminal: `codex queue`, Codex's own queue for a session. The
+  message runs as a new turn once the current one ends.
+- The Codex app: the app starts a new turn in the chat that has the session
+  open, once the chat is between turns.
+
+Codex shows these as ordinary messages, so each one starts by saying Station
+passed it on from the room. Station does not install Codex hooks, so a
+message never lands in the middle of a turn. Codex's sandbox hides the
+processes Station checks and blocks the network, so `station` commands need
+full access; Codex asks you to approve them.
+
+## Asking before acting for someone else
+
+When someone else in the room asks a signed-in agent for something risky,
+the agent asks the person it works for in its own session and on a card in
+the room (`station ask`). Only that person gets Approve and Decline on the
+card. They answer in whichever place they are looking: an answer on the card
+arrives in the session as the next message, and an answer in the session
+closes the card (`station ask --answered`). Cards need `station login`; a
+seat joined without it asks in its session only.
+
+Files live in `~/.station`, readable only by you: the sign-in token, the
+seats, and the daemon's log (`daemon.log`).

package/dist/args.js

@@ -0,0 +1,18 @@
+/** `--name value`, `--name=value`, or a bare `--name` (followed by another
+ * flag or nothing), which reads as "true". Everything else is positional. */
+export function flags(args) {
+    const rest = [];
+    const named = new Map();
+    for (let i = 0; i < args.length; i++) {
+        const match = /^--([a-z-]+)(?:=(.*))?$/.exec(args[i]);
+        if (!match)
+            rest.push(args[i]);
+        else if (match[2] !== undefined)
+            named.set(match[1], match[2]);
+        else if (i + 1 < args.length && !args[i + 1].startsWith("--"))
+            named.set(match[1], args[++i]);
+        else
+            named.set(match[1], "true");
+    }
+    return { rest, flag: (name) => named.get(name) };
+}

package/dist/claude.js

@@ -0,0 +1,197 @@
+// Claude Code sessions on this computer, and the way into one.
+//
+// Claude Code registers every running session in
+// `<claude home>/sessions/<pid>.json`, with the path of an inbox socket it
+// listens on (`messagingSocketPath`) and the version of the protocol it
+// speaks there (`peerProtocol`). The socket takes a token, `peerToken` in
+// the matching `<pid>.<hash>.key`, readable only by this user. Two JSON
+// lines put a user message into the session at its next turn boundary.
+// Claude Code labels it as coming from another session, and its own
+// `crossSessionInbound` setting may hold it for the person's approval.
+//
+// Agent Relay's daemon delivers the same way; its reading of the protocol
+// (crates/relay-node/src/relay/claude.rs) is what this follows.
+import { execFileSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { connect } from "node:net";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/** The only inbox protocol this speaks. A session on another version gets nothing. */
+export const KNOWN_PEER_PROTOCOL = 1;
+/** One line on the socket may be at most this long. */
+export const MAX_LINE_BYTES = 1_000_000;
+const SOCKET_TIMEOUT_MS = 5_000;
+/** Start times in UTC: Claude Code records `procStart` that way, and `ps`
+ * prints local time unless told otherwise. */
+export const systemPs = (pid, field) => {
+    try {
+        const out = execFileSync("ps", ["-o", `${field}=`, "-p", String(pid)], { encoding: "utf8", env: { ...process.env, TZ: "UTC" } }).trim();
+        return out || null;
+    }
+    catch {
+        return null;
+    }
+};
+export function claudeHome(env = process.env) {
+    return env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
+}
+function registry(home) {
+    return join(home, "sessions");
+}
+const sameStart = (a, b) => a !== null && b !== null && a.replace(/\s+/g, " ").trim() === b.replace(/\s+/g, " ").trim();
+/** The session registered for `pid`, or null. */
+export function readSession(home, pid) {
+    const path = join(registry(home), `${pid}.json`);
+    if (!existsSync(path))
+        return null;
+    let record;
+    try {
+        record = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return null;
+    }
+    const text = (key) => (typeof record[key] === "string" ? record[key] : null);
+    const sessionId = text("sessionId");
+    const socketPath = text("messagingSocketPath");
+    if (!sessionId || !socketPath)
+        return null;
+    return {
+        pid,
+        sessionId,
+        socketPath,
+        peerProtocol: typeof record.peerProtocol === "number" ? record.peerProtocol : 0,
+        procStart: text("procStart"),
+        cwd: text("cwd") ?? "",
+        name: text("name"),
+        status: text("status"),
+    };
+}
+/** The live session `pid` runs: registered, and the registry's start time
+ * is the running process's, so a file left by an earlier process that had
+ * the same pid never counts. */
+export function liveSession(home, pid, ps = systemPs) {
+    const session = readSession(home, pid);
+    if (!session)
+        return null;
+    return sameStart(session.procStart, ps(pid, "lstart")) ? session : null;
+}
+/** The Claude Code session this process runs inside: the nearest ancestor
+ * with a live registry entry. Commands an agent runs from its shell tool
+ * are its descendants. */
+export function callingSession(home, from = process.ppid, ps = systemPs) {
+    let pid = from;
+    for (let hops = 0; hops < 25 && pid > 1; hops++) {
+        const session = liveSession(home, pid, ps);
+        if (session)
+            return session;
+        const parent = Number(ps(pid, "ppid"));
+        if (!Number.isInteger(parent) || parent <= 1 || parent === pid)
+            return null;
+        pid = parent;
+    }
+    return null;
+}
+/** The session with this id among the live ones; its pid changes when it is
+ * resumed in a new process. */
+export function sessionById(home, sessionId, ps = systemPs) {
+    if (!existsSync(registry(home)))
+        return null;
+    for (const name of readdirSync(registry(home))) {
+        const match = /^(\d+)\.json$/.exec(name);
+        if (!match)
+            continue;
+        const session = liveSession(home, Number(match[1]), ps);
+        if (session?.sessionId === sessionId)
+            return session;
+    }
+    return null;
+}
+/** The inbox token: the `<pid>.<hash>.key` whose recorded start is the
+ * session's; a key without a start only when it is the pid's one key.
+ * Never logged. */
+export function peerToken(home, session) {
+    const keys = [];
+    for (const name of readdirSync(registry(home))) {
+        if (!name.startsWith(`${session.pid}.`) || !name.endsWith(".key"))
+            continue;
+        try {
+            const record = JSON.parse(readFileSync(join(registry(home), name), "utf8"));
+            if (typeof record.peerToken === "string" && record.peerToken) {
+                keys.push({ token: record.peerToken, start: typeof record.procStart === "string" ? record.procStart : null });
+            }
+        }
+        catch {
+            // not a key we can read
+        }
+    }
+    const matching = keys.find((key) => sameStart(key.start, session.procStart));
+    if (matching)
+        return matching.token;
+    return keys.length === 1 && keys[0].start === null ? keys[0].token : null;
+}
+/** The two lines: authentication, then the message. */
+export function peerFrames(token, messageId, text) {
+    const auth = `${JSON.stringify({ type: "auth", token })}\n`;
+    const message = `${JSON.stringify({
+        type: "user",
+        msg_id: messageId,
+        uuid: randomUUID().toUpperCase(),
+        priority: "next",
+        message: { role: "user", content: text },
+    })}\n`;
+    if (Buffer.byteLength(message) > MAX_LINE_BYTES)
+        throw new Error(`The message is longer than the ${MAX_LINE_BYTES} bytes a session accepts.`);
+    return { auth, message };
+}
+function writeFrames(socketPath, frames) {
+    return new Promise((resolve) => {
+        let stage = "connecting";
+        const socket = connect(socketPath);
+        const done = (outcome) => {
+            socket.destroy();
+            resolve(outcome);
+        };
+        socket.setTimeout(SOCKET_TIMEOUT_MS, () => done(stage === "sent" ? { kind: "delivered" } : stage === "message" ? { kind: "in-doubt", reason: "The inbox stopped reading while sending." } : { kind: "retry", reason: "The inbox did not answer." }));
+        socket.on("error", (error) => done(stage === "message" ? { kind: "in-doubt", reason: `The inbox connection broke while sending: ${error.message}` } : { kind: "retry", reason: `Could not reach the session's inbox: ${error.message}` }));
+        socket.on("connect", () => {
+            stage = "auth";
+            socket.write(frames.auth, () => {
+                stage = "message";
+                socket.write(frames.message, () => {
+                    stage = "sent";
+                    // Let the session read both lines before the connection closes.
+                    socket.end();
+                    setTimeout(() => done({ kind: "delivered" }), 1_000).unref();
+                });
+            });
+        });
+        socket.on("close", () => {
+            if (stage === "sent")
+                resolve({ kind: "delivered" });
+        });
+    });
+}
+/** Puts `text` into the session as a user message. `delivered` means the
+ * bytes were handed over, not that Claude has read them yet. */
+export async function deliver(home, session, messageId, text, ps = systemPs) {
+    if (session.peerProtocol !== KNOWN_PEER_PROTOCOL) {
+        return { kind: "retry", reason: `That session speaks inbox protocol ${session.peerProtocol}; Station knows ${KNOWN_PEER_PROTOCOL}.` };
+    }
+    // The session must still be the process that registered, or the token
+    // would go to whoever holds the pid now.
+    if (!liveSession(home, session.pid, ps))
+        return { kind: "retry", reason: "That Claude Code session is not running." };
+    const token = peerToken(home, session);
+    if (!token)
+        return { kind: "retry", reason: "Could not read that session's inbox key." };
+    let frames;
+    try {
+        frames = peerFrames(token, messageId, text);
+    }
+    catch (error) {
+        return { kind: "retry", reason: error instanceof Error ? error.message : String(error) };
+    }
+    return writeFrames(session.socketPath, frames);
+}