@timqi/pier 0.0.5 → 0.0.7

package/dist/core/inbox.js

@@ -10,7 +10,7 @@ import { mkdir, writeFile } from "node:fs/promises";
 import { randomBytes } from "node:crypto";
 import { basename, join } from "node:path";
 import { pierPath } from "../paths.js";
-import { safeName } from "./inbound-file.js";
+import { fileMarker, lostMarker, MAX_INBOUND_BYTES, safeName } from "./inbound-file.js";
 /** Where every inbound file lives; web/files.ts allowlists this root. */
 export const INBOX_DIR = pierPath("inbox");
 /**
@@ -30,3 +30,69 @@ export async function saveInbound(channelId, name, mimeType, bytes) {
     await writeFile(path, bytes, { mode: 0o600, flag: "wx" });
     return path;
 }
+/**
+ * Collect a fetch response's body, refusing past `maxBytes` mid-stream. The
+ * metadata size gate in saveInboundAll is only as honest as the platform's
+ * metadata — absent or wrong, `arrayBuffer()` buffers whatever arrives — so
+ * the read itself is bounded too. Throws with "too large" in the message,
+ * which the loop below translates into the honest lost-marker reason.
+ */
+export async function readCapped(body, maxBytes) {
+    if (!body)
+        return new Uint8Array(0);
+    const parts = [];
+    let size = 0;
+    const reader = body.getReader();
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            size += value.byteLength;
+            if (size > maxBytes)
+                throw new Error(`attachment too large (>${maxBytes} bytes)`);
+            parts.push(value);
+        }
+    }
+    finally {
+        // Also cancels the transfer on the too-large throw.
+        reader.releaseLock();
+        await body.cancel().catch(() => { });
+    }
+    const bytes = new Uint8Array(size);
+    let at = 0;
+    for (const part of parts) {
+        bytes.set(part, at);
+        at += part.byteLength;
+    }
+    return bytes;
+}
+/**
+ * Save a message's attachments; each becomes a marker line for the prompt —
+ * and a failed or oversized one becomes a lost-marker line, never silence
+ * (5b). Written three times, once per adapter, before landing here: the
+ * size gate before the fetch (an unauthorized sender is already filtered by
+ * then, but a movie must not be buffered whole either) and the never-silent
+ * failure path are invariants, and invariants drift when copied.
+ */
+export async function saveInboundAll(channelId, files, log) {
+    const markers = [];
+    for (const file of files) {
+        if (file.size !== undefined && file.size > MAX_INBOUND_BYTES) {
+            markers.push(lostMarker(file.label, "too large"));
+            continue;
+        }
+        try {
+            const got = await file.fetch();
+            const path = await saveInbound(channelId, file.name ?? got.name, got.mimeType ?? file.mimeType, got.bytes);
+            markers.push(fileMarker(path));
+        }
+        catch (err) {
+            log(`attachment download failed: ${String(err)}`);
+            // A fetch that refused mid-stream names its reason; keep it honest.
+            const why = String(err).includes("too large") ? "too large" : "download failed";
+            markers.push(lostMarker(file.label, why));
+        }
+    }
+    return markers;
+}

package/dist/core/types.js

@@ -1,6 +1,10 @@
 // Normative seam types — THIS FILE is the system contract (docs/architecture.md
 // documents the rules around it). Changing a seam is a design decision, not a
 // refactor; keep it implementable over RPC (no Pi types may appear here).
+/** How much of a tool result any surface ever shows. A transcript replay
+ *  carries no more than that: a session's tool output is most of its history
+ *  payload, and the bytes past this point were downloaded to be sliced off. */
+export const MAX_STEP_OUTPUT = 8_000;
 /** Every level Pi accepts, in order. The union is derived so the two cannot
  *  drift, and boundary validators use isThinkingLevel instead of their own copy. */
 export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];

package/dist/db.js

@@ -139,6 +139,12 @@ const MIGRATIONS = [
     note TEXT NOT NULL,
     created_at INTEGER NOT NULL
   );
+  `,
+    // 4 — Projects can render from SQLite without scanning every Pi transcript.
+    `
+  ALTER TABLE session_state ADD COLUMN cwd TEXT;
+  ALTER TABLE session_state ADD COLUMN title TEXT;
+  ALTER TABLE session_state ADD COLUMN created_at INTEGER;
   `,
 ];
 let shared;

package/dist/main.js

@@ -34,6 +34,7 @@ import { startAutoUpdate, UpdateCheck } from "./update.js";
 import { AuthStore, registerAuthRoutes, requireAuth } from "./web/auth.js";
 import { SessionStateStore } from "./web/session-state.js";
 import { createServer } from "./web/server.js";
+import { attachTerminal } from "./web/terminal.js";
 const log = logger("pier");
 // Pier owns the Pi runtime dir. Set before any SDK call resolves a path, so
 // everything Pi derives from its agent dir (auth.json, models.json, sessions,
@@ -280,6 +281,9 @@ const server = serve({ fetch: app.fetch, port, hostname }, () => {
     log.info(`workbench on http://${hostname}:${port}`);
     log.info(`pid ${process.pid}, node ${process.version}, home ${PIER_HOME}`);
 });
+// The one WebSocket surface (see web/terminal.ts); `serve` above builds a
+// plain node:http server, which is the only shape with an upgrade event.
+const terminals = attachTerminal(server, auth);
 // A crash and a clean stop must be distinguishable after the fact, and both
 // left nothing behind before this.
 process.on("uncaughtException", (err) => {
@@ -302,6 +306,7 @@ const shutdown = (stopTasks = true) => {
     // `systemctl restart` into a 90-second wait for SIGKILL.
     setTimeout(() => process.exit(0), 3000).unref();
     stopEviction();
+    terminals.close(); // no shell outlives the workbench
     // The drain path leaves task runs alone: aborting them here would record
     // them cancelled and race their callbacks against dying channels, when the
     // boot-time interrupted marking is the recovery that was promised.

package/dist/web/auth.js

@@ -59,6 +59,7 @@ export class AuthStore {
     #db;
     /** HMAC key for cookies: the hash, so rotating the password expires them. */
     #key;
+    #rotationListeners = new Set();
     constructor(db = pierDb(), print = (m) => log.info(m)) {
         this.#db = db;
         let row = this.#row();
@@ -99,6 +100,13 @@ export class AuthStore {
             .prepare("UPDATE auth SET salt = ?, hash = ?, created_at = ? WHERE id = 1")
             .run(salt, next, Date.now());
         this.#key = next;
+        for (const listener of this.#rotationListeners)
+            listener();
+    }
+    /** A long-lived authenticated surface closes itself when every cookie is
+     *  revoked. The store and listeners share the process lifetime. */
+    onRotation(listener) {
+        this.#rotationListeners.add(listener);
     }
     /** Cookie signing key. Never the password: that is not stored anywhere. */
     get cookieKey() {
@@ -181,19 +189,14 @@ function noteFailure(client) {
         failures.set(client, { count: 1, resetAt: Date.now() + WINDOW_MS });
 }
 /** Browsers name the source of unsafe requests. Compare hosts rather than
- * schemes because TLS commonly terminates at the reverse proxy. */
-function sameOrigin(c) {
-    const origin = c.req.header("origin");
+ * schemes because TLS commonly terminates at the reverse proxy. Shared by HTTP
+ * and WebSocket so the password boundary cannot disagree with itself. */
+function originMatches(origin, host) {
     if (!origin)
         return true; // curl and other non-browser clients
     try {
         const parsed = new URL(origin);
-        const remote = remoteOf(c);
-        const forwarded = remote && loopback(remote)
-            ? c.req.header("x-forwarded-host")?.split(",").at(-1)?.trim()
-            : undefined;
-        const host = forwarded || c.req.header("host") || new URL(c.req.url).host;
-        const external = new URL(`${parsed.protocol}//${host}`);
+        const external = new URL(`${parsed.protocol}//${host ?? ""}`);
         return parsed.origin === origin && external.origin === parsed.origin &&
             external.pathname === "/" && !external.search && !external.hash;
     }
@@ -201,6 +204,30 @@ function sameOrigin(c) {
         return false;
     }
 }
+function sameOrigin(c) {
+    const remote = remoteOf(c);
+    const forwarded = remote && loopback(remote)
+        ? c.req.header("x-forwarded-host")?.split(",").at(-1)?.trim()
+        : undefined;
+    return originMatches(c.req.header("origin"), forwarded || c.req.header("host") || new URL(c.req.url).host);
+}
+/** The same cookie + Origin boundary for a WebSocket upgrade, where no Hono
+ *  context exists before the handshake completes. */
+export function upgradeAuthorized(store, req) {
+    const raw = req.headers.cookie
+        ?.split(";")
+        .map((part) => part.trim())
+        .find((part) => part.startsWith(`${COOKIE}=`))
+        ?.slice(COOKIE.length + 1);
+    if (!valid(store.cookieKey, raw))
+        return false;
+    const remote = req.socket.remoteAddress ?? "";
+    const forwardedHeader = req.headers["x-forwarded-host"];
+    const forwarded = loopback(remote) && typeof forwardedHeader === "string"
+        ? forwardedHeader.split(",").at(-1)?.trim()
+        : undefined;
+    return originMatches(req.headers.origin, forwarded || req.headers.host);
+}
 /** Every route, in one place — no per-route opt-in to forget on the next one. */
 export function requireAuth(store) {
     return async (c, next) => {