runline 0.32.0 → 0.34.0

package/dist/plugins/gett/src/shared.js

@@ -1,21 +1,18 @@
 import { randomUUID } from "node:crypto";
-import { authedFetch } from "../../_shared/authedFetch.js";
-import { arr, num, numOrNull, obj, pick, readBounded, seg as segment, } from "../../_shared/provider.js";
-import { coordinatedAccessToken } from "../../_shared/tokenRefresh.js";
+import { AuthError } from "runline";
+import { credentialRequest, pathSegment } from "../../_shared/credentials.js";
+import { arr, num, numOrNull, obj, pick } from "../../_shared/provider.js";
+import { appHeaders, gettCredential } from "./credentials.js";
+export { APP_VERSION } from "./credentials.js";
 export { arr, num, numOrNull, obj, pick };
 /**
- * Transport and credentials for the Gett consumer surface.
- *
- * One host, one bearer, one refresh grant. Everything above this file works in
- * terms of `http`/`authed` and never reaches the network itself.
+ * The Gett consumer surface: one host, one bearer, one refresh grant, all
+ * signed through the declared credential. Everything above this file works
+ * in terms of `authed` and never reaches the network itself.
  */
-const HOST = "b2cgateway.gett.com";
-const UA = "Gett/android/10.48.187";
-export const APP_VERSION = "10.48.187";
 /** Dizengoff Sq, TLV — a location that always has supply, used when none is given. */
 export const DEF_LAT = 32.0779;
 export const DEF_LON = 34.7743;
-const MAX_RESPONSE_BYTES = 4 * 1024 * 1024;
 const DEFAULT_TOKEN_TTL_MS = 3_600_000;
 export const cfgOf = (ctx) => (ctx.connection.config || {});
 /**
@@ -24,7 +21,7 @@ export const cfgOf = (ctx) => (ctx.connection.config || {});
  * Gett signals refusal inside the body on some endpoints (`rc`) and in a status
  * string on others, and answers 200 either way. An explicit `rc` decides; failing
  * that an explicit status decides; a body carrying neither is an acceptance,
- * because `http` has already rejected every non-2xx. Erring the other way would
+ * because every non-2xx has already been rejected. Erring the other way would
  * report a booked ride as unbooked, and the caller would order a second car.
  */
 export function accepted(body) {
@@ -53,10 +50,11 @@ export function normPhone(input) {
         return `972${digits.slice(1)}`;
     return `972${digits}`;
 }
-export const seg = (value, what) => segment(value, what, "gett");
+/** A configured or caller-supplied value as one path segment; surrounding whitespace is not part of it. */
+export const seg = (value) => pathSegment(String(value ?? "").trim());
 // ---------- HTTP ----------
 /** Carries the status for control flow without putting a provider body in the message. */
-class GettError extends Error {
+export class GettError extends Error {
     status;
     constructor(status, endpoint) {
         super(`gett: request failed (HTTP ${status}) on ${endpoint}`);
@@ -65,33 +63,12 @@ class GettError extends Error {
     }
 }
 /** The account's phone is in nearly every path; it never belongs in an error. */
-function endpointOf(path) {
+export function endpointOf(path) {
     return path.split("?")[0].replace(/\/phone\/[^/]+/, "/phone/{phone}");
 }
-export async function http(ctx, path, opts = {}) {
-    const cfg = cfgOf(ctx);
-    const { method = "GET", body = null, token = null } = opts;
-    const payload = body == null ? null : JSON.stringify(body);
-    const headers = {
-        accept: "application/json",
-        "user-agent": UA,
-        "app-platform": "android",
-        "app-version": APP_VERSION,
-        "x-device-id": cfg.deviceId || "",
-        "x-client-device-unique-id": cfg.clientDeviceUniqueId || "",
-        "x-country-code": "IL",
-    };
-    if (token)
-        headers.authorization = `Bearer ${token}`;
-    if (payload)
-        headers["content-type"] = "application/json; charset=UTF-8";
-    const endpoint = endpointOf(path);
-    const res = await authedFetch(`https://${HOST}${path}`, {
-        method,
-        headers,
-        body: payload,
-    });
-    const text = await readBounded(res, MAX_RESPONSE_BYTES, `gett: response exceeded the size limit on ${endpoint}`);
+/** A 2xx body as an object; anything that is not JSON reads as empty. */
+export async function bodyOf(res, path) {
+    const text = await res.text();
     let parsed = null;
     try {
         parsed = text ? JSON.parse(text) : null;
@@ -102,7 +79,7 @@ export async function http(ctx, path, opts = {}) {
     // The body can hold tokens, the OTP, or the account holder's details; the
     // status and the redacted endpoint are what a caller can act on.
     if (!res.ok)
-        throw new GettError(res.status, endpoint);
+        throw new GettError(res.status, endpointOf(path));
     return obj(parsed);
 }
 /**
@@ -123,58 +100,38 @@ export async function ensureDevice(ctx) {
     if (Object.keys(patch).length)
         await ctx.updateConnection(patch);
 }
-// ---------- credentials ----------
 export function expiresAt(expiresIn) {
     const seconds = numOrNull(expiresIn);
     return Date.now() + (seconds ? seconds * 1000 : DEFAULT_TOKEN_TTL_MS);
 }
 /**
- * The refresh grant itself.
- *
- * `?lc=en` is REQUIRED on every /auth/token call: the app sends it and the server
- * 400s with an empty body without it. Access-token TTL is irrelevant to the grant
- * (a bearer expired by days still refreshes), so a genuine 400 here means the
- * refresh token itself is dead and a fresh owner login is required.
- *
- * Called only from inside an update owner, and always with an explicit token, so
- * it can never re-enter the connection store.
+ * What a failed renewal means to the owner: no stored login, or a refresh
+ * token Gett no longer honours — both mended by the owner login.
  */
-async function refreshGrant(ctx, cfg) {
+function sessionError(error) {
+    if (!(error instanceof AuthError))
+        return error;
+    if (error.code === "invalid_credentials")
+        return new Error("gett: not connected — run account.requestCode({ phone }) -> account.verifyCode({ code }) -> account.verifyCard({ card })");
+    if (error.code === "reconnect_required" ||
+        (error.code === "provider_rejected" && error.status === 400))
+        return new Error("gett: session expired (refresh rejected) — re-run the owner login: account.requestCode -> account.verifyCode -> account.verifyCard");
+    return error;
+}
+/** A call on the gateway, signed with the session's access token and renewed on demand. */
+export async function authed(ctx, path, opts = {}) {
+    let res;
     try {
-        return await http(ctx, `/gl/api/v2/phone/${seg(cfg.phone, "phone")}/auth/token?lc=en`, {
-            method: "POST",
-            token: cfg.accessToken || cfg.refreshToken,
-            body: { grant_type: "refresh_token", refresh_token: cfg.refreshToken },
+        res = await credentialRequest(ctx, gettCredential, {
+            target: "api",
+            path: path.replace(/^\//, ""),
+            method: opts.method ?? "GET",
+            headers: appHeaders(ctx.connection.config),
+            ...(opts.body == null ? {} : { json: opts.body }),
         });
     }
-    catch (e) {
-        if (e instanceof GettError && e.status === 400) {
-            throw new Error("gett: session expired (refresh rejected) — re-run the owner login: account.requestCode -> account.verifyCode -> account.verifyCard");
-        }
-        throw e;
+    catch (error) {
+        throw sessionError(error);
     }
-}
-export async function accessToken(ctx, force = false) {
-    const cfg = cfgOf(ctx);
-    if (!cfg.refreshToken)
-        throw new Error("gett: not connected — run account.requestCode({ phone }) -> account.verifyCode({ code }) -> account.verifyCard({ card })");
-    if (!cfg.phone)
-        throw new Error("gett: no phone configured");
-    // Renewal runs under the store's update ownership, so parallel actions
-    // coalesce onto one grant instead of clobbering each other's rotated token.
-    return coordinatedAccessToken(ctx, async (current) => {
-        const resp = await refreshGrant(ctx, current);
-        const issued = pick(resp.access_token);
-        if (!issued)
-            throw new Error("gett: token refresh returned no access_token");
-        const rotated = pick(resp.refresh_token);
-        return {
-            accessToken: issued,
-            accessTokenExpiresAt: expiresAt(resp.expires_in),
-            ...(rotated ? { refreshToken: rotated } : {}),
-        };
-    }, force);
-}
-export async function authed(ctx, path, opts = {}) {
-    return http(ctx, path, { ...opts, token: await accessToken(ctx) });
+    return bodyOf(res, path);
 }

package/dist/plugins/ghost/src/credentials.js

@@ -0,0 +1,36 @@
+import { httpsBase, staticCredential } from "../../_shared/credentials.js";
+/**
+ * An Admin API key (`<id>:<hex secret>`), from which the transport signs a
+ * fresh five-minute JWT for every request, sent as `Authorization: Ghost
+ * <token>` to the site's unversioned Admin API base. The site URL is
+ * public config and must be HTTPS.
+ */
+export const ghostCredential = staticCredential({
+    id: "ghost",
+    auth: {
+        kind: "static",
+        parts: ["adminKey"],
+        placements: [
+            {
+                in: "jwt",
+                part: "adminKey",
+                name: "Authorization",
+                prefix: "Ghost ",
+                audience: "/admin/",
+            },
+        ],
+    },
+    local: { adminKey: "adminApiKey" },
+    targets: (config) => ({
+        admin: {
+            baseUrl: httpsBase(config.url, "ghost/api/admin/"),
+            methods: ["GET", "POST", "PUT", "DELETE"],
+        },
+    }),
+    probe: {
+        target: "admin",
+        path: "site/",
+        method: "GET",
+        acceptedStatuses: [200],
+    },
+});

package/dist/plugins/ghost/src/index.js

@@ -1,60 +1,19 @@
-async function apiRequest(url, adminApiKey, method, endpoint, body, qs) {
-    // Ghost Admin API uses JWT. Key format: {id}:{secret}
-    const [id, secret] = adminApiKey.split(":");
-    // Create JWT manually using HMAC-SHA256
-    const header = btoa(JSON.stringify({ alg: "HS256", typ: "JWT", kid: id })).replace(/=/g, "");
-    const now = Math.floor(Date.now() / 1000);
-    const payload = btoa(JSON.stringify({ iat: now, exp: now + 300, aud: "/admin/" })).replace(/=/g, "");
-    const enc = new TextEncoder();
-    const keyData = new Uint8Array((secret.match(/.{2}/g) ?? []).map((b) => parseInt(b, 16)));
-    const cryptoKey = await crypto.subtle.importKey("raw", keyData, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
-    const sig = await crypto.subtle.sign("HMAC", cryptoKey, enc.encode(`${header}.${payload}`));
-    const sigStr = btoa(String.fromCharCode(...new Uint8Array(sig)))
-        .replace(/\+/g, "-")
-        .replace(/\//g, "_")
-        .replace(/=/g, "");
-    const token = `${header}.${payload}.${sigStr}`;
-    const base = url.replace(/\/$/, "");
-    const fullUrl = new URL(`${base}/ghost/api/v2/admin${endpoint}`);
-    if (qs) {
-        for (const [k, v] of Object.entries(qs)) {
-            if (v !== undefined && v !== null)
-                fullUrl.searchParams.set(k, String(v));
-        }
-    }
-    const opts = {
+import { credentialJson, pathSegment } from "../../_shared/credentials.js";
+import { ghostCredential } from "./credentials.js";
+/** A Ghost Admin API call; GET and DELETE carry no body. */
+function req(ctx, method, path, body, query) {
+    return credentialJson(ctx, ghostCredential, "ghost", {
+        target: "admin",
+        path,
         method,
-        headers: {
-            Authorization: `Ghost ${token}`,
-            "Content-Type": "application/json",
-        },
-    };
-    if (body &&
-        Object.keys(body).length > 0 &&
-        method !== "GET" &&
-        method !== "DELETE") {
-        opts.body = JSON.stringify(body);
-    }
-    const res = await fetch(fullUrl.toString(), opts);
-    if (!res.ok)
-        throw new Error(`Ghost API error ${res.status}: ${await res.text()}`);
-    if (res.status === 204)
-        return { success: true };
-    return res.json();
-}
-function getConn(ctx) {
-    return {
-        url: ctx.connection.config.url.replace(/\/$/, ""),
-        adminApiKey: ctx.connection.config.adminApiKey,
-    };
-}
-function req(ctx, method, endpoint, body, qs) {
-    const { url, adminApiKey } = getConn(ctx);
-    return apiRequest(url, adminApiKey, method, endpoint, body, qs);
+        query,
+        ...(body && method !== "GET" && method !== "DELETE" ? { json: body } : {}),
+    });
 }
 export default function ghost(rl) {
     rl.setName("ghost");
     rl.setVersion("0.1.0");
+    rl.setCredential(ghostCredential);
     rl.setConnectionSchema({
         url: {
             type: "string",
@@ -133,7 +92,7 @@ export default function ghost(rl) {
                 post.featured = featured;
             if (slug)
                 post.slug = slug;
-            const data = (await req(ctx, "POST", "/posts/", { posts: [post] }, qs));
+            const data = (await req(ctx, "POST", "posts/", { posts: [post] }, qs));
             return data.posts?.[0];
         },
     });
@@ -156,9 +115,9 @@ export default function ghost(rl) {
                 qs.formats = formats;
             let endpoint;
             if (slug)
-                endpoint = `/posts/slug/${slug}/`;
+                endpoint = `posts/slug/${pathSegment(slug)}/`;
             else if (id)
-                endpoint = `/posts/${id}/`;
+                endpoint = `posts/${pathSegment(id)}/`;
             else
                 throw new Error("Provide either id or slug");
             const data = (await req(ctx, "GET", endpoint, undefined, qs));
@@ -204,7 +163,7 @@ export default function ghost(rl) {
                 qs.formats = formats;
             if (order)
                 qs.order = order;
-            const data = (await req(ctx, "GET", "/posts/", undefined, qs));
+            const data = (await req(ctx, "GET", "posts/", undefined, qs));
             return data.posts;
         },
     });
@@ -241,7 +200,7 @@ export default function ghost(rl) {
         async execute(input, ctx) {
             const { postId, title, html, lexical, status, publishedAt, tags, featured, slug, } = input;
             // Need updated_at for optimistic locking
-            const existing = (await req(ctx, "GET", `/posts/${postId}/`, undefined, {
+            const existing = (await req(ctx, "GET", `posts/${pathSegment(postId)}/`, undefined, {
                 fields: "id,updated_at",
             }));
             const currentPost = existing.posts[0];
@@ -267,7 +226,7 @@ export default function ghost(rl) {
                 post.featured = featured;
             if (slug)
                 post.slug = slug;
-            const data = (await req(ctx, "PUT", `/posts/${postId}/`, { posts: [post] }, qs));
+            const data = (await req(ctx, "PUT", `posts/${pathSegment(postId)}/`, { posts: [post] }, qs));
             return data.posts?.[0];
         },
     });
@@ -278,7 +237,7 @@ export default function ghost(rl) {
             postId: { type: "string", required: true, description: "Post ID" },
         },
         async execute(input, ctx) {
-            await req(ctx, "DELETE", `/posts/${input.postId}/`);
+            await req(ctx, "DELETE", `posts/${pathSegment(input.postId)}/`);
             return { success: true };
         },
     });

package/dist/plugins/github/src/credentials.js

@@ -0,0 +1,18 @@
+import { httpsBase, staticCredential } from "../../_shared/credentials.js";
+export const GITHUB_API_VERSION = "2022-11-28";
+/**
+ * A personal access token, sent as a bearer to the configured API origin —
+ * github.com by default, a GitHub Enterprise host when baseUrl says so.
+ */
+export const githubCredential = staticCredential({
+    id: "github",
+    auth: { kind: "bearer" },
+    local: { secret: "token" },
+    targets: (config) => ({
+        api: {
+            baseUrl: httpsBase(config.baseUrl ?? "https://api.github.com", ""),
+            methods: ["GET", "POST", "PUT", "PATCH", "DELETE"],
+            allowedHeaders: ["X-GitHub-Api-Version"],
+        },
+    }),
+});