@miadi/connector 0.1.6 → 0.1.7

package/dist/oauth.js

@@ -1,6 +1,7 @@
-import { InvalidGrantError, InvalidTokenError } from "@modelcontextprotocol/sdk/server/auth/errors.js";
+import { InvalidGrantError, InvalidTokenError, ServerError } from "@modelcontextprotocol/sdk/server/auth/errors.js";
 import { escapeHtml } from "@miadi/node-service-kit/format";
 import { digest, newSecret } from "./store.js";
+import { MiadiUnavailable } from "./people.js";
 export const SCOPE_READ = "miadi:read";
 export const SCOPE_CONTRIBUTE = "miadi:contribute";
 /**
@@ -18,13 +19,23 @@ const REFRESH_TTL = 90 * 24 * 3600;
 const CODE_TTL = 600;
 const PENDING_TTL = 1800;
 const DIRECT_TTL = 300;
+const CLIENT_IDLE = 30 * 24 * 3600;
+/**
+ * Where a client must send people back to before its sign-in may carry
+ * miadi:approve. The in-chat card's protections (a tool hidden from the model,
+ * a token kept out of the model's context) are host behaviours; these are the
+ * hosts known to keep them.
+ */
+export const DEFAULT_APPROVE_REDIRECT_HOSTS = ["chatgpt.com", "chat.openai.com"];
 const now = () => Math.floor(Date.now() / 1000);
 export class MiadiOAuthProvider {
     state;
     identify;
     issuer;
     confirmPath;
+    /** What Miadi answered for a person token, kept 5 minutes: direct Bearer use and re-checks of signed-in grants. */
     direct = new Map();
+    approveRedirectHosts = DEFAULT_APPROVE_REDIRECT_HOSTS;
     constructor(state, identify, 
     /**
      * The issuer as the metadata states it. It goes back on every authorization
@@ -69,7 +80,7 @@ export class MiadiOAuthProvider {
                 created_at: now(),
             };
         });
-        res.status(200).type("html").send(signInPage({ requestId, client, scopes: wanted(params.scopes), action: this.confirmPath }));
+        res.status(200).type("html").send(signInPage({ requestId, client, scopes: wanted(params.scopes), action: this.confirmPath, redirectUri: params.redirectUri, approvable: this.approvable(client) }));
     }
     /** POST from the sign-in page: the person's token, or a refusal. */
     async confirm(req, res) {
@@ -92,7 +103,16 @@ export class MiadiOAuthProvider {
             res.redirect(302, redirect.href);
             return;
         }
-        const person = await this.identify(String(body.person_token ?? "").trim());
+        let person;
+        try {
+            person = await this.identify(String(body.person_token ?? "").trim());
+        }
+        catch (error) {
+            if (!(error instanceof MiadiUnavailable))
+                throw error;
+            res.status(503).type("html").send(signInPage({ requestId: body.request_id, client, scopes: wanted(pending.params.scopes), action: this.confirmPath, redirectUri: pending.params.redirectUri, approvable: this.approvable(client), error: "Miadi could not be reached. Try again in a minute." }));
+            return;
+        }
         if (!person) {
             res
                 .status(401)
@@ -102,6 +122,8 @@ export class MiadiOAuthProvider {
                 client,
                 scopes: wanted(pending.params.scopes),
                 action: this.confirmPath,
+                redirectUri: pending.params.redirectUri,
+                approvable: this.approvable(client),
                 error: "Miadi did not recognise that person token.",
             }));
             return;
@@ -110,7 +132,7 @@ export class MiadiOAuthProvider {
         if (body.contribute !== "on")
             scopes = scopes.filter((x) => x !== SCOPE_CONTRIBUTE);
         // In-chat approval is opt-in, whatever the client asked for, and only for Miadi's write tier.
-        if (body.approve === "on" && person.api_tier === "write")
+        if (body.approve === "on" && person.api_tier === "write" && this.approvable(client))
             scopes.push(SCOPE_APPROVE);
         if (!scopes.includes(SCOPE_READ))
             scopes.unshift(SCOPE_READ);
@@ -125,6 +147,7 @@ export class MiadiOAuthProvider {
                 resource: pending.params.resource,
                 codeChallenge: pending.params.codeChallenge,
                 redirectUri: pending.params.redirectUri,
+                signed_in_at: now(),
             };
         });
         redirect.searchParams.set("code", code);
@@ -158,6 +181,9 @@ export class MiadiOAuthProvider {
         if (!grant || grant.kind !== "refresh" || grant.client_id !== client.client_id || grant.expires_at < now()) {
             throw new InvalidGrantError("Refresh token is invalid or expired");
         }
+        if (grant.signed_in_at && now() - grant.signed_in_at > REFRESH_TTL) {
+            throw new InvalidGrantError("This sign-in is more than 90 days old; sign in again");
+        }
         const narrowed = scopes?.length ? grant.scopes.filter((x) => scopes.includes(x)) : grant.scopes;
         return this.issue({ ...grant, scopes: narrowed });
     }
@@ -166,19 +192,64 @@ export class MiadiOAuthProvider {
         if (grant && grant.kind === "access") {
             if (grant.expires_at < now())
                 throw new InvalidTokenError("Access token expired");
-            return info(token, grant.client_id, grant.scopes, grant.expires_at, grant.person, grant.resource);
+            // Miadi is asked again (at most every 5 minutes) who the person is now: a
+            // revoked token ends the sign-in, and a lost write tier ends in-chat approval.
+            let person = grant.person;
+            try {
+                const fresh = await this.lookup(grant.person.token);
+                if (!fresh)
+                    throw new InvalidTokenError("Miadi no longer recognises the person behind this sign-in");
+                person = fresh;
+            }
+            catch (error) {
+                if (!(error instanceof MiadiUnavailable))
+                    throw error;
+                // During a short Miadi outage the sign-in keeps the person as last known.
+            }
+            const scopes = person.api_tier === "write" ? grant.scopes : grant.scopes.filter((x) => x !== SCOPE_APPROVE);
+            return info(token, grant.client_id, scopes, grant.expires_at, person, grant.resource);
         }
         // A Miadi person token used directly (terminal clients).
-        const cached = this.direct.get(digest(token));
-        if (cached && cached.until > now()) {
-            return info(token, "direct", DIRECT_SCOPES, cached.until, cached.person);
+        let person;
+        try {
+            person = await this.lookup(token);
+        }
+        catch (error) {
+            if (error instanceof MiadiUnavailable)
+                throw new ServerError("Miadi could not be reached; try again shortly");
+            throw error;
         }
-        const person = await this.identify(token);
         if (!person)
             throw new InvalidTokenError("Unknown token");
-        const until = now() + DIRECT_TTL;
-        this.direct.set(digest(token), { person, until });
-        return info(token, "direct", DIRECT_SCOPES, until, person);
+        return info(token, "direct", DIRECT_SCOPES, this.direct.get(digest(token)).until, person);
+    }
+    /** Miadi's answer for a person token, from the 5-minute cache or fresh. */
+    async lookup(token) {
+        const key = digest(token);
+        const cached = this.direct.get(key);
+        if (cached && cached.until > now())
+            return cached.person;
+        const person = await this.identify(token);
+        if (person)
+            this.direct.set(key, { person, until: now() + DIRECT_TTL });
+        else
+            this.direct.delete(key);
+        return person;
+    }
+    /** May this client's sign-in carry miadi:approve: does it only send people back to a known host? */
+    approvable(client) {
+        const uris = client?.redirect_uris ?? [];
+        if (!uris.length)
+            return false;
+        return uris.every((u) => {
+            try {
+                const url = new URL(String(u));
+                return url.protocol === "https:" && this.approveRedirectHosts.includes(url.hostname);
+            }
+            catch {
+                return false;
+            }
+        });
     }
     async revokeToken(_client, request) {
         this.state.update((s) => {
@@ -190,7 +261,7 @@ export class MiadiOAuthProvider {
         const refresh = newSecret();
         this.state.update((s) => {
             prune(s);
-            const base = { client_id: grant.client_id, person: grant.person, scopes: grant.scopes, resource: grant.resource };
+            const base = { client_id: grant.client_id, person: grant.person, scopes: grant.scopes, resource: grant.resource, signed_in_at: grant.signed_in_at ?? now() };
             s.tokens[digest(access)] = { ...base, kind: "access", expires_at: now() + ACCESS_TTL };
             s.tokens[digest(refresh)] = { ...base, kind: "refresh", expires_at: now() + REFRESH_TTL };
         });
@@ -228,6 +299,11 @@ function prune(s) {
     for (const [k, v] of Object.entries(s.tokens))
         if (v.expires_at < t)
             delete s.tokens[k];
+    // A registered client that holds nothing and was registered over 30 days ago is forgotten.
+    const holding = new Set([...Object.values(s.pending), ...Object.values(s.codes), ...Object.values(s.tokens)].map((x) => x.client_id));
+    for (const [k, c] of Object.entries(s.clients))
+        if (!holding.has(k) && t - Number(c.client_id_issued_at ?? 0) > CLIENT_IDLE)
+            delete s.clients[k];
 }
 function page(title, body) {
     return `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
@@ -250,9 +326,16 @@ button.primary{border-color:var(--accent);outline:1px solid var(--accent)}
 }
 function signInPage(o) {
     const name = o.client?.client_name || o.client?.client_id || "An MCP client";
+    let host = "";
+    try {
+        host = o.redirectUri ? new URL(o.redirectUri).host : "";
+    }
+    catch {
+        /* no host to show */
+    }
     const contribute = o.scopes.includes(SCOPE_CONTRIBUTE);
     return page("Sign in to Miadi", `<h1>Sign in to Miadi</h1>
-<p><strong>${escapeHtml(name)}</strong> asks to use Miadi as you.</p>
+<p><strong>${escapeHtml(name)}</strong> asks to use Miadi as you.${host ? ` After you sign in you return to <strong>${escapeHtml(host)}</strong>.` : ""}</p>
 <ul>
 <li>Read sessions, reviews, episodes, circles and the records people contributed.</li>
 ${contribute ? "<li>Contribute in your name: observations, inquiries, links, handoffs and proposals. Nothing it proposes runs, publishes or closes without a person's approval.</li>" : ""}
@@ -263,8 +346,10 @@ ${o.error ? `<p class="err" role="alert">${escapeHtml(o.error)}</p>` : ""}
 <label for="person_token">Your Miadi person token</label>
 <input id="person_token" name="person_token" type="password" autocomplete="off" required>
 ${contribute ? '<label><input type="checkbox" name="contribute" checked> Allow contributions in my name</label>' : ""}
-<label><input type="checkbox" name="approve"> Let me approve requests on cards inside this client</label>
-<p>Only for people with Miadi's write tier. Each approval is your own click on a card; the assistant cannot approve for you.</p>
+${o.approvable
+        ? `<label><input type="checkbox" name="approve"> Let me approve requests on cards inside this client</label>
+<p>Only for people with Miadi's write tier. Each approval is your own click on a card; the assistant cannot approve for you.</p>`
+        : ""}
 <div class="row">
 <button class="primary" type="submit" name="decision" value="allow">Sign in</button>
 <button type="submit" name="decision" value="deny" formnovalidate>Refuse</button>

package/dist/people.d.ts

@@ -12,4 +12,7 @@ export interface MiadiPerson extends Person {
     api_tier: ApiTier;
     permissions: string[];
 }
+/** Miadi could not be asked: not the same answer as "this token is nobody's". */
+export declare class MiadiUnavailable extends Error {
+}
 export declare function identifyThroughMiadi(miadiUrl: string, fetchImpl?: typeof fetch): (token: string) => Promise<MiadiPerson | null>;

package/dist/people.js

@@ -1,3 +1,6 @@
+/** Miadi could not be asked: not the same answer as "this token is nobody's". */
+export class MiadiUnavailable extends Error {
+}
 export function identifyThroughMiadi(miadiUrl, fetchImpl = fetch) {
     return async (token) => {
         if (!token || token.length < 16)
@@ -6,11 +9,14 @@ export function identifyThroughMiadi(miadiUrl, fetchImpl = fetch) {
         try {
             res = await fetchImpl(`${miadiUrl}/api/identity/me`, {
                 headers: { accept: "application/json", authorization: `Bearer ${token}` },
+                signal: AbortSignal.timeout(10_000),
             });
         }
-        catch {
-            return null;
+        catch (error) {
+            throw new MiadiUnavailable(error instanceof Error ? error.message : String(error));
         }
+        if (res.status >= 500)
+            throw new MiadiUnavailable(`Miadi answered ${res.status}`);
         if (!res.ok)
             return null;
         const me = await res.json().catch(() => null);

package/dist/reviews.js

@@ -62,7 +62,7 @@ export class ReviewClient {
     /** `/review/<id>/json`, optionally pinned to a version. Null on 404. */
     async get(reviewId, version) {
         const q = version ? `?v=${version}` : "";
-        const res = await this.fetchImpl(`${this.baseUrl}/review/${reviewId}/json${q}`, { headers: { accept: "application/json" } });
+        const res = await this.fetchImpl(`${this.baseUrl}/review/${reviewId}/json${q}`, { headers: { accept: "application/json" }, signal: AbortSignal.timeout(15_000) });
         if (res.status === 404)
             return null;
         if (!res.ok)
@@ -74,6 +74,7 @@ export class ReviewClient {
             throw new Error("MIADI_REVIEW_TOKEN is not configured on the connector host");
         const res = await this.fetchImpl(`${this.baseUrl}/api/reviews/search?${new URLSearchParams({ q, limit: String(limit) })}`, {
             headers: { accept: "application/json", authorization: `Bearer ${this.token}` },
+            signal: AbortSignal.timeout(15_000),
         });
         if (!res.ok)
             throw new Error(`review search answered ${res.status}`);

package/dist/server.d.ts

@@ -9,6 +9,8 @@ export interface ConnectorDeps {
     /** The factory directory holding queue/ (default ~/.miadi/factory). */
     factoryDir?: string;
     tmuxSessions?: () => string[];
+    /** Person-token attempts allowed per address in 15 minutes on each sign-in form (default 30). */
+    tokenAttemptsPerWindow?: number;
 }
 export declare function createConnectorApp(config: ConnectorConfig, deps: ConnectorDeps): {
     app: import("express-serve-static-core").Express;

package/dist/server.js

@@ -10,6 +10,7 @@
  * as that person (see tools.ts).
  */
 import express from "express";
+import { rateLimit } from "express-rate-limit";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { mcpAuthRouter, createOAuthMetadata, getOAuthProtectedResourceMetadataUrl } from "@modelcontextprotocol/sdk/server/auth/router.js";
@@ -65,7 +66,15 @@ export function createConnectorApp(config, deps) {
         resourceName: "Miadi",
         serviceDocumentationUrl: new URL("https://github.com/jgwill/Miadi/tree/main/packages/connector"),
     }));
-    app.post("/authorize/confirm", express.urlencoded({ extended: false, limit: "16kb" }), (req, res, next) => {
+    // The forms that take a person token are limited per address, and so are
+    // failed /mcp authentications (a person token may be sent there directly).
+    const attempts = deps.tokenAttemptsPerWindow ?? 30;
+    const limitTokens = () => rateLimit({ windowMs: 15 * 60 * 1000, limit: attempts, standardHeaders: "draft-7", legacyHeaders: false });
+    const confirmLimit = limitTokens();
+    const formLimit = limitTokens();
+    app.use(["/approve", "/records"], (req, res, next) => (req.method === "POST" ? formLimit(req, res, next) : next()));
+    app.use("/mcp", rateLimit({ windowMs: 15 * 60 * 1000, limit: attempts, skipSuccessfulRequests: true, standardHeaders: "draft-7", legacyHeaders: false }));
+    app.post("/authorize/confirm", confirmLimit, express.urlencoded({ extended: false, limit: "16kb" }), (req, res, next) => {
         provider.confirm(req, res).catch(next);
     });
     const approvalDeps = {

package/dist/store.d.ts

@@ -13,6 +13,8 @@ export declare class Ledger<R extends {
     id: string;
 }> {
     private readonly path;
+    /** The parsed file, reused until its size or modification time changes. */
+    private cache;
     constructor(path: string);
     append(record: R): R;
     all(): R[];

package/dist/store.js

@@ -10,7 +10,7 @@
  *                (observations, handoffs, proposals). Append-only: a record
  *                is never edited, a later record supersedes it.
  */
-import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
 import { createHash, randomBytes } from "node:crypto";
 import { join } from "node:path";
 import { readJsonSafe, writeJsonAtomic } from "@miadi/node-service-kit/json";
@@ -57,6 +57,8 @@ export class JsonFile {
 }
 export class Ledger {
     path;
+    /** The parsed file, reused until its size or modification time changes. */
+    cache = null;
     constructor(path) {
         this.path = path;
     }
@@ -67,6 +69,9 @@ export class Ledger {
     all() {
         if (!existsSync(this.path))
             return [];
+        const st = statSync(this.path);
+        if (this.cache && this.cache.size === st.size && this.cache.mtimeMs === st.mtimeMs)
+            return [...this.cache.records];
         const out = [];
         for (const line of readFileSync(this.path, "utf8").split("\n")) {
             if (!line.trim())
@@ -78,7 +83,8 @@ export class Ledger {
                 /* a torn last line from a crash is skipped, not fatal */
             }
         }
-        return out;
+        this.cache = { size: st.size, mtimeMs: st.mtimeMs, records: out };
+        return [...out];
     }
 }
 export function statePaths(dir) {