pullfrog 0.1.64 → 0.1.66

package/dist/utils/learnings.d.ts

@@ -57,11 +57,7 @@ export declare function readLearningsFile(path: string): Promise<string | null>;
  * Best-effort: any failure is logged and does not affect the run's success
  * status. Skips the PATCH when the file is byte-trim-identical to its seed —
  * the agent didn't touch it, so writing the same content back would just
- * burn a `LearningsRevision` row and an API round-trip.
- *
- * `ctx.toolState.model` is forwarded so `LearningsRevision.model` keeps
- * populating; it powers the per-revision attribution badge in the UI
- * history view.
+ * burn an API round-trip.
  *
  * `learningsPersistAttempted` guards against double-execution between the
  * normal end-of-run path and the SIGINT/SIGTERM handler.

package/dist/utils/learningsTruncate.d.ts

@@ -5,8 +5,8 @@
  * `action/internal/index.ts` without dragging the entire MCP type graph
  * along — `learnings.ts` imports `ToolContext` for its runtime helpers,
  * and pulling that into the SDK-facing `internal` barrel expands the
- * type graph reachable from root `tsc` and `cf-worker-indexing` to every
- * tool module under `action/mcp/`. keeping these helpers MCP-free is the
+ * type graph reachable from root `tsc` to every tool module under
+ * `action/mcp/`. keeping these helpers MCP-free is the
  * cheap structural fix.
  *
  * see `action/utils/learnings.ts` for the full learnings-file lifecycle.

package/dist/utils/oauthShared.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Provider-agnostic OAuth primitives shared by the Codex and Grok chains.
+ * Pure stdlib (Buffer) so both the action runtime and the Next.js server can
+ * import it via pullfrog/internal.
+ *
+ * Both chains mint JWT access tokens whose `exp` we read as a freshness hint,
+ * and both rotate their refresh token on every use — so both need the same
+ * "the provider rejected this permanently" signal.
+ */
+/**
+ * Thrown when an OAuth provider rejects a refresh token (4xx).
+ *
+ * `chainIsDead` is decided by the CALLER, because the two providers we talk to
+ * disagree about how to say it and only the caller knows its own dialect:
+ * xAI answers RFC 6749 (`{"error":"invalid_grant"}`) while OpenAI nests an
+ * object and discriminates on `error.code` (`token_expired`). A rejection we
+ * cannot classify — a CDN error page in front of the token endpoint, say — is
+ * NOT dead: latching there would retire every customer's working credential
+ * over a transient edge event.
+ */
+export declare class OAuthInvalidGrantError extends Error {
+    readonly status: number;
+    /** whether the provider said this refresh chain is permanently unusable, so
+     * the rotation core may latch it out of use until the user re-mints. */
+    readonly chainIsDead: boolean;
+    constructor(provider: string, status: number, body: string, chainIsDead: boolean);
+}
+/** parse a token-endpoint error body, or null when it is not a JSON object.
+ * Each provider's refresh reads its own discriminator out of the result. */
+export declare function parseOAuthErrorBody(body: string): Record<string, unknown> | null;
+/** decode a JWT payload's `exp` claim and return it in ms since epoch.
+ * returns null if the token isn't a parseable JWT or has no `exp` claim —
+ * caller falls back to "treat as expired".
+ *
+ * We don't verify the signature (we'd need the issuer's JWKS); we're only
+ * using the claim as a freshness hint. The real auth check happens at the
+ * provider when the token is used, so trusting a forged JWT here would just
+ * delay the inevitable 401. No security boundary at this decode step. */
+export declare function decodeJwtExpMs(token: string): number | null;

package/dist/utils/payload.d.ts

@@ -19,6 +19,7 @@ export declare const JsonPayload: import("arktype/internal/variants/object.ts").
         write: string[];
         unavailable?: string[];
     } | undefined;
+    xrepoGrant?: string | undefined;
     timeout?: string | undefined;
     progressComment?: {
         id: string;
@@ -66,6 +67,7 @@ export declare function resolvePayload(resolvedPromptInput: ResolvedPromptInput,
         write: string[];
         unavailable?: string[];
     } | undefined;
+    xrepoGrant: string | undefined;
     timeout: string | undefined;
     cwd: string | undefined;
     progressComment: {

package/dist/utils/token.d.ts

@@ -29,6 +29,12 @@ type ResolveTokensParams = {
     push: PushPermission;
     authorPermission: AuthorPermission | undefined;
     xrepo?: XrepoConfig | undefined;
+    /**
+     * handle to the cross-repo grant the server persisted for this run. required
+     * alongside `xrepo`: the mint endpoint refuses a `repos` list without one,
+     * because the runner's list is attacker-controlled on a manual dispatch.
+     */
+    xrepoGrant?: string | undefined;
     /**
      * OIDC credentials stashed by main.ts before the restricted-mode env wipe —
      * the mid-run MCP token refresh mints from this snapshot (#891). null when

package/dist/utils/xaiOAuth.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Pure-stdlib (fetch) xAI/Grok OAuth: device-code login + refresh.
+ *
+ * Lives here (not in a CLI module) so the Next.js server side can import it
+ * via pullfrog/internal without dragging in node:child_process. Used by:
+ *   - action/commands/auth.ts   (`pullfrog auth grok` device-code login)
+ *   - action/utils/codexHome.ts (materialize into opencode's auth.json)
+ *   - utils/xaiSecretRotation.ts (server-side rotation at run-context)
+ *
+ * We talk to xAI's OAuth endpoints directly rather than shelling out to the
+ * Grok CLI the way `auth codex` shells out to `codex login`. The Grok CLI is
+ * a curl|bash install that nothing else in the flow needs, and the device
+ * grant is ~60 lines of fetch — requiring a second CLI to obtain a
+ * credential opencode consumes natively would be gratuitous.
+ *
+ * See wiki/grok-auth.md.
+ */
+export interface XaiAuthBody {
+    auth_mode: "grok";
+    tokens: {
+        access_token: string;
+        refresh_token: string;
+    };
+    last_refresh?: string;
+    /**
+     * ISO timestamp of an `invalid_grant` rejection. xAI rotates the refresh
+     * token on every use, so a rejection is PERMANENT until the user re-runs
+     * `pullfrog auth grok`. Without the latch the server re-issues the same
+     * doomed refresh on every run, each holding a Postgres row lock across an
+     * external call — the failure mode measured for Codex in
+     * [#1101](https://github.com/pullfrog/app/issues/1101). Cleared implicitly:
+     * `pullfrog auth grok` and `PUT /api/runtime/secret` write a fresh blob
+     * without it, which re-arms rotation.
+     */
+    refresh_rejected_at?: string;
+}
+/** Public Grok-CLI OAuth client. Identical to the `oidc_client_id` the Grok
+ * CLI writes into its own `~/.grok/auth.json` and to opencode's XaiAuthPlugin
+ * CLIENT_ID — one chain, so a token minted here refreshes anywhere. */
+export declare const XAI_OAUTH_CLIENT_ID = "b1a00492-073a-47ea-816f-4c329264a828";
+export declare const XAI_OAUTH_TOKEN_URL = "https://auth.x.ai/oauth2/token";
+export declare const XAI_DEVICE_CODE_URL = "https://auth.x.ai/oauth2/device/code";
+export declare const XAI_DEVICE_CODE_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code";
+/** `api:access` is the scope that lets the subscription token authorize
+ * api.x.ai — without it the credential logs in but cannot infer. */
+export declare const XAI_OAUTH_SCOPE = "openid profile email offline_access grok-cli:access api:access";
+/** force one refresh round-trip against xAI. returns the rotated blob; does
+ * NOT persist — the caller writes it back wherever the token lives.
+ *
+ * The 10s timeout matters server-side: `maybeRotateXaiSecret` holds a DB row
+ * lock across this call, so the cap keeps us inside the enclosing transaction
+ * budget and guarantees queued callers get a turn. Real latency is sub-second. */
+export declare function refreshXaiAuthBody(body: XaiAuthBody): Promise<XaiAuthBody>;
+/** parse + validate a stored Grok blob. returns null on any shape mismatch —
+ * caller treats null as "no grok auth". */
+export declare function parseXaiAuthBody(raw: string): XaiAuthBody | null;
+/** serialize to the canonical stored form. */
+export declare function stringifyXaiAuthBody(body: XaiAuthBody): string;
+export interface XaiDeviceCode {
+    deviceCode: string;
+    userCode: string;
+    /** pre-filled URL when xAI supplies one, else the bare verification URL. */
+    verificationUrl: string;
+    intervalMs: number;
+    expiresAtMs: number;
+}
+/** RFC 8628 step 1: ask xAI for a device code. The user approves in a browser
+ * on any device — no loopback callback server, so this works unchanged from a
+ * container, an SSH session, or a locked-down workstation. */
+export declare function startXaiDeviceAuth(): Promise<XaiDeviceCode>;
+/** RFC 8628 step 2: long-poll the token endpoint until the user approves.
+ * Honors the spec's `authorization_pending` / `slow_down` back-off. Resolves
+ * with the minted chain, or throws on denial / expiry. */
+export declare function pollXaiDeviceAuth(device: XaiDeviceCode): Promise<XaiAuthBody>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pullfrog",
-  "version": "0.1.64",
+  "version": "0.1.66",
   "type": "module",
   "bin": {
     "pullfrog": "dist/cli.mjs",