pullfrog 0.1.7 → 0.1.9

package/dist/utils/proxy.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Mint an OpenRouter proxy key via `/api/proxy-token` and inject it as
+ * `OPENROUTER_API_KEY` for runs that route through Pullfrog Router (managed
+ * billing accounts) or OSS-grant paths.
+ *
+ * Authenticates one of two ways:
+ *   - production: GitHub Actions OIDC token via `core.getIDToken`
+ *   - local dev (`API_URL` is localhost): `x-dev-repo` header bypass
+ *
+ * `runProxyResolution` is the entrypoint `main.ts` calls. It wraps
+ * `resolveProxyModel` and renders the user-facing copy itself (job summary
+ * + PR progress comment) before rethrowing the structured error — handled
+ * here, not in the outer `main()` catch, because `toolContext` doesn't
+ * exist yet at this point in the pipeline.
+ *
+ *   - 402 → `BillingError` (card declined, balance empty, 3DS, etc.)
+ *   - 503 → `TransientError` (transient sync issue — retry next dispatch)
+ */
+import type { ToolState } from "../toolState.ts";
+import type { ResolvedPayload } from "./payload.ts";
+export interface OidcCredentials {
+    requestUrl: string;
+    requestToken: string;
+}
+/**
+ * Run `resolveProxyModel`; if it throws a Billing or Transient error, render
+ * the user-facing summary, mirror it to the PR progress comment, and rethrow.
+ *
+ * The rethrow is intentional: these errors are terminal for the run, and
+ * letting them surface lets `runMain` exit non-zero so GH Actions applies
+ * the workflow's retry policy. We catch them *here* (before the main try)
+ * because the outer catch needs `toolContext` (which isn't built yet) for
+ * its general-purpose rendering path — a BillingError landing in the outer
+ * catch would get rendered with `core.setFailed` only, losing the
+ * actionable copy + the PR-comment mirror.
+ */
+export declare function runProxyResolution(ctx: {
+    payload: ResolvedPayload;
+    oss: boolean;
+    proxyModel?: string | undefined;
+    oidcCredentials: OidcCredentials | null;
+    repo: {
+        owner: string;
+        name: string;
+    };
+    toolState: ToolState;
+}): Promise<void>;

package/dist/utils/runContext.d.ts

@@ -42,15 +42,6 @@ export interface RepoSettings {
  * `"payg"` = card on file / pay-as-you-go.
  */
 export type AccountPlan = "none" | "payg";
-/**
- * "Is Pullfrog absorbing marginal infra cost for this repo?" — composite
- * predicate over the two orthogonal dimensions (repo-level OSS, account-level
- * plan). Mirrors `isInfraCovered` in the server's `utils/billing.ts`.
- */
-export declare function isInfraCovered(params: {
-    isOss: boolean;
-    plan: AccountPlan;
-}): boolean;
 export interface RunContext {
     settings: RepoSettings;
     apiToken: string;

package/dist/utils/runErrorRenderer.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Classify + render the error thrown out of the main run try-block into a
+ * pair of user-facing markdown bodies — one for the GitHub Actions job
+ * summary tab, one for the PR progress comment.
+ *
+ * Four classifications, in priority order:
+ *
+ *   1. `BillingError` — either the proxy-token mint already threw one (402
+ *      handled inline) or the agent runtime surfaced an OpenRouter
+ *      "key budget exhausted" string mid-run. Both render via
+ *      `formatBillingErrorSummary` so the user sees actionable copy.
+ *
+ *   2. Activity-timeout hang — `errorMessage` starts with
+ *      `"activity timeout"` or `"agent still pending"`. The harness keeps
+ *      structured diagnostic state on `toolState.agentDiagnostic`;
+ *      `formatAgentHangBody` renders that as a markdown block.
+ *
+ *   3. API-key auth error — `isApiKeyAuthError` sniffs the raw error string;
+ *      `formatApiKeyErrorSummary` renders provider + console-link copy.
+ *
+ *   4. Default — a generic `❌ Pullfrog failed` block with the raw error
+ *      message in a fenced code block. Same body for both surfaces.
+ *
+ * The hang body and the API-key body diverge between the two surfaces only
+ * in that the job summary wraps them in the `### ❌ Pullfrog failed` H3
+ * banner; the PR comment uses the bare body since it already has Pullfrog
+ * branding in its footer.
+ */
+import type { AgentDiagnostic } from "./agentHangReport.ts";
+export type RenderedRunError = {
+    summary: string;
+    comment: string;
+};
+export declare function renderRunError(input: {
+    errorMessage: string;
+    repo: {
+        owner: string;
+        name: string;
+    };
+    agentDiagnostic: AgentDiagnostic | undefined;
+}): RenderedRunError;

package/dist/utils/runLifecycle.d.ts

@@ -0,0 +1,75 @@
+/**
+ * End-of-run cleanup phases extracted out of `main.ts`. Three shapes:
+ *
+ *   - `persistRunArtifacts`: best-effort post-review cleanup + summary +
+ *     learnings persistence. Shared by both the success path and the
+ *     error-catch path; idempotent (each step has its own guard against
+ *     double-execution).
+ *
+ *   - `finalizeSuccessRun`: success-only — calls `persistRunArtifacts`
+ *     first, then surfaces harness-side failures in the progress comment,
+ *     deletes stranded progress comments, writes the GitHub Actions job
+ *     summary, and emits the structured output marker.
+ *
+ *   - `writeRunErrorOutputs`: error-only — writes the rendered error
+ *     summary to the Actions summary tab and mirrors it to the PR
+ *     progress comment. The catch path calls this and then
+ *     `persistRunArtifacts` separately so the rendered error lands before
+ *     the persistence calls, in case the latter throw.
+ *
+ * All three swallow their own non-fatal errors (`log.debug` or empty
+ * `catch {}`) so a cleanup failure can't flip an already-decided run
+ * outcome.
+ */
+import type { AgentResult } from "../agents/shared.ts";
+import type { ToolContext } from "../mcp/server.ts";
+import type { ToolState } from "../toolState.ts";
+import type { RenderedRunError } from "./runErrorRenderer.ts";
+/**
+ * Best-effort cleanup shared by both run-end paths:
+ *   1. post-review cleanup (dispatch follow-up re-review on submitted reviews)
+ *   2. persist the agent-edited PR summary tmpfile
+ *   3. persist the agent-edited repo-level learnings tmpfile
+ *
+ * Each step is idempotent and swallows its own errors. Safe to call from
+ * both `main()`'s success path and its catch path.
+ */
+export declare function persistRunArtifacts(toolContext: ToolContext): Promise<void>;
+/**
+ * Run the success-path cleanup waterfall:
+ *
+ *   1. shared best-effort cleanup via `persistRunArtifacts`
+ *   2. when the harness returned `success=false` (e.g. unsubmitted-review
+ *      gate exhausted retries, stop-hook persistently failing), surface
+ *      the error in the progress comment so the user sees it instead of a
+ *      deleted-comment void
+ *   3. when the run succeeded and the progress comment was never finalized
+ *      via `report_progress`, delete it (three sub-cases — orphan
+ *      "Leaping into action" comment, abandoned checklist, agent wrote
+ *      a substantive artifact via another MCP write tool but skipped
+ *      report_progress)
+ *   4. write the GitHub Actions step summary (best-effort — a write
+ *      failure must not throw past this point because we'd hit the outer
+ *      catch and clobber any progress comment we just wrote)
+ *   5. emit the structured output marker for tests + workflow consumers
+ */
+export declare function finalizeSuccessRun(input: {
+    toolContext: ToolContext;
+    toolState: ToolState;
+    result: AgentResult;
+    repo: {
+        owner: string;
+        name: string;
+    };
+}): Promise<void>;
+/**
+ * Write the rendered error to the GitHub Actions job summary tab + mirror
+ * to the PR progress comment when one exists. Catch path only.
+ *
+ * `lastProgressBody` and the usage table are appended to the summary so the
+ * partial work the agent did before failing isn't lost.
+ */
+export declare function writeRunErrorOutputs(input: {
+    rendered: RenderedRunError;
+    toolState: ToolState;
+}): Promise<void>;

package/dist/utils/runStartupLog.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Startup log formatting for the resolver pipeline. Computes the
+ * "model / agent / push / shell / timeout" block that main.ts prints
+ * after resolving the agent + model + payload.
+ */
+import type { ResolvedPayload } from "./payload.ts";
+/**
+ * Emit the startup block ("» model / agent / push / shell / timeout") after
+ * the agent and model are resolved. Single side-effect; no return.
+ */
+export declare function logRunStartup(ctx: {
+    payload: ResolvedPayload;
+    resolvedModel: string | undefined;
+    agentName: string;
+}): void;

package/dist/utils/subprocess.d.ts

@@ -43,6 +43,7 @@ export interface SpawnOptions {
     timeout?: number;
     activityTimeout?: number;
     onActivityTimeout?: (() => void) | undefined;
+    isPausedExternally?: () => boolean;
     cwd?: string;
     stdio?: ("pipe" | "ignore" | "inherit")[];
     onStdout?: (chunk: string) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pullfrog",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "type": "module",
   "bin": {
     "pullfrog": "dist/cli.mjs",
@@ -16,6 +16,7 @@
     "typecheck": "tsc --noEmit",
     "build": "node esbuild.config.js && tsc -p tsconfig.exports.json",
     "check:entrypoints": "node scripts/check-entrypoint-imports.ts",
+    "docker": "node docker.ts",
     "play": "node play.ts",
     "runtest": "node test/run.ts",
     "scratch": "node scratch.ts",
@@ -49,7 +50,7 @@
     "fastmcp": "^3.34.0",
     "file-type": "^21.3.0",
     "husky": "^9.0.0",
-    "opencode-ai": "1.1.56",
+    "opencode-ai": "1.15.1",
     "package-manager-detector": "^1.6.0",
     "picocolors": "^1.1.1",
     "semver": "^7.7.3",