pullfrog 0.1.30 → 0.1.31

package/dist/utils/setup.d.ts

@@ -1,5 +1,5 @@
 import type { ShellPermission } from "../external.ts";
-import type { ToolState } from "../toolState.ts";
+import { type ToolState } from "../toolState.ts";
 import type { OctokitWithPlugins } from "./github.ts";
 export interface SetupOptions {
     tempDir: string;
@@ -61,15 +61,30 @@ export interface GitContext {
     postCheckoutScript: string | null;
 }
 export type SetupGitParams = GitContext;
+/** GitContext plus an explicit working-tree directory (primary cwd or a
+ * secondary clone under ctx.tmpdir/xrepo/<name>). */
+export interface ConfigureRepoGitParams extends GitContext {
+    dir: string;
+}
 /**
- * setup git configuration and authentication for the repository.
+ * setup git configuration + authentication for the PRIMARY repo working tree
+ * (process.cwd()). thin wrapper over configureRepoGit. preserves the existing
+ * single-repo call shape in main.ts.
+ */
+export declare function setupGit(params: SetupGitParams): Promise<void>;
+/**
+ * setup git configuration and authentication for a repository working tree at
+ * `params.dir`. used for the primary repo (dir = cwd) and for secondary repos
+ * cloned on demand by checkout_repo (dir = ctx.tmpdir/xrepo/<name>).
  * - configures git identity (user.email, user.name)
  * - sets up authentication via gitToken (minimal contents:write)
+ * - records pushUrl + initialHead onto the repo's RepoToolState (must already
+ *   be registered in toolState.repos)
  *
  * gitToken is a minimal-permission token (contents + workflows) used for git operations.
  * it is assumed to be potentially exfiltratable, so it has limited scope.
  */
-export declare function setupGit(params: SetupGitParams): Promise<void>;
+export declare function configureRepoGit(params: ConfigureRepoGitParams): Promise<void>;
 /**
  * snapshot the current HEAD as either a branch name (when on a named branch)
  * or a literal SHA (when detached). used by setupGit to pin the run-entry

package/dist/utils/token.d.ts

@@ -1,4 +1,4 @@
-import type { PushPermission } from "../external.ts";
+import type { PushPermission, XrepoConfig } from "../external.ts";
 import { acquireNewToken, type OidcCredentials } from "./github.ts";
 export { acquireNewToken as acquireInstallationToken };
 export { revokeGitHubInstallationToken as revokeInstallationToken };
@@ -20,10 +20,13 @@ export declare function getJobToken(): string;
 export type TokenRef = {
     gitToken: string;
     mcpToken: string;
+    readToken?: string | undefined;
+    refreshGitToken?: ((stale: string) => Promise<string>) | undefined;
     [Symbol.asyncDispose]: () => Promise<void>;
 };
 type ResolveTokensParams = {
     push: PushPermission;
+    xrepo?: XrepoConfig | 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
@@ -34,11 +37,16 @@ type ResolveTokensParams = {
 /**
  * resolve tokens for the action run.
  *
- * creates two separate tokens:
+ * creates two separate tokens (three on cross-repo runs):
  * - gitToken: contents permission based on `push` setting (assumed exfiltratable)
  *   - push: enabled → contents:write (can push)
  *   - push: disabled → contents:read (read-only)
  * - mcpToken: full installation token - used for GitHub API calls in MCP tools (not exfiltratable)
+ * - readToken (xrepo only): contents:read over the read set, for cloning read-tier secondaries
+ *
+ * on cross-repo runs, gitToken + mcpToken are scoped to the WRITE set (always
+ * incl. the primary), so a writable secondary can take PRs; read-only
+ * secondaries route through readToken instead.
  *
  * security-conscious users can pass their own token via GH_TOKEN env var or inputs.token.
  */

package/dist/yes/index.d.ts

@@ -0,0 +1,32 @@
+import type { StandardSchemaV1 } from "./standard-schema.ts";
+export type { StandardSchemaV1 } from "./standard-schema.ts";
+export declare function range(n: number): number[];
+export declare function range(start: number, end: number): number[];
+export declare function range(n: number, fn: (i: number) => number): number[];
+export declare function schedule(fn: (i: number) => number, count: number): number[];
+type InferInput<S> = S extends StandardSchemaV1<infer I, any> ? I : never;
+type InferOutput<S> = S extends StandardSchemaV1<any, infer O> ? O : never;
+export interface OpOptions<TReturn = any> {
+    name?: string;
+    ttl?: number;
+    maxItems?: number;
+    retries?: number[];
+    cacheHit?: ((key: string) => void) | null;
+    cacheMiss?: ((key: string) => void) | null;
+    skipCache?: (result: TReturn) => boolean;
+    bail?: (error: unknown) => boolean;
+}
+export interface OpObjectOptions<TInputSchema extends StandardSchemaV1 | undefined = undefined, TOutputSchema extends StandardSchemaV1 | undefined = undefined, TRun extends (input: TInputSchema extends StandardSchemaV1 ? InferOutput<TInputSchema> : any, ctx?: any) => Promise<TOutputSchema extends StandardSchemaV1 ? InferInput<TOutputSchema> : any> = (input: TInputSchema extends StandardSchemaV1 ? InferOutput<TInputSchema> : any, ctx?: any) => Promise<TOutputSchema extends StandardSchemaV1 ? InferInput<TOutputSchema> : any>> extends OpOptions<TOutputSchema extends StandardSchemaV1 ? InferOutput<TOutputSchema> : Awaited<ReturnType<TRun>>> {
+    input?: TInputSchema;
+    output?: TOutputSchema;
+    run: TRun;
+}
+type AnyAsyncFn = (...args: any[]) => Promise<any>;
+type Input<F extends AnyAsyncFn> = Parameters<F>[0];
+export type OpFunction<F extends AnyAsyncFn> = F & {
+    clear: (key?: Input<F>) => void;
+    has: (key: Input<F>) => boolean;
+    invalidate: (predicate: (key: Input<F>) => boolean) => number;
+};
+export declare function op<F extends AnyAsyncFn>(fn: F, options?: OpOptions<Awaited<ReturnType<F>>>): OpFunction<F>;
+export declare function op<TInputSchema extends StandardSchemaV1 | undefined = undefined, TOutputSchema extends StandardSchemaV1 | undefined = undefined, TRun extends (input: TInputSchema extends StandardSchemaV1 ? InferOutput<TInputSchema> : any, ctx?: any) => Promise<TOutputSchema extends StandardSchemaV1 ? InferInput<TOutputSchema> : any> = (input: TInputSchema extends StandardSchemaV1 ? InferOutput<TInputSchema> : any, ctx?: any) => Promise<TOutputSchema extends StandardSchemaV1 ? InferInput<TOutputSchema> : any>>(options: OpObjectOptions<TInputSchema, TOutputSchema, TRun>): OpFunction<(input: TInputSchema extends StandardSchemaV1 ? InferInput<TInputSchema> : Parameters<TRun>[0], ctx?: TRun extends (input: any, ctx: infer C, ...rest: any[]) => any ? C : never) => Promise<TOutputSchema extends StandardSchemaV1 ? InferOutput<TOutputSchema> : Awaited<ReturnType<TRun>>>>;

package/dist/yes/standard-schema.d.ts

@@ -0,0 +1,117 @@
+/** The Standard Typed interface. This is a base type extended by other specs. */
+export interface StandardTypedV1<Input = unknown, Output = Input> {
+    /** The Standard properties. */
+    readonly "~standard": StandardTypedV1.Props<Input, Output>;
+}
+export declare namespace StandardTypedV1 {
+    /** The Standard Typed properties interface. */
+    interface Props<Input = unknown, Output = Input> {
+        /** The version number of the standard. */
+        readonly version: 1;
+        /** The vendor name of the schema library. */
+        readonly vendor: string;
+        /** Inferred types associated with the schema. */
+        readonly types?: Types<Input, Output> | undefined;
+    }
+    /** The Standard Typed types interface. */
+    interface Types<Input = unknown, Output = Input> {
+        /** The input type of the schema. */
+        readonly input: Input;
+        /** The output type of the schema. */
+        readonly output: Output;
+    }
+    /** Infers the input type of a Standard Typed. */
+    type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+    /** Infers the output type of a Standard Typed. */
+    type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+/** The Standard Schema interface. */
+export interface StandardSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard Schema properties. */
+    readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+export declare namespace StandardSchemaV1 {
+    /** The Standard Schema properties interface. */
+    interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+        /** Validates unknown input values. */
+        readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+    }
+    /** The result interface of the validate function. */
+    type Result<Output> = SuccessResult<Output> | FailureResult;
+    /** The result interface if validation succeeds. */
+    interface SuccessResult<Output> {
+        /** The typed output value. */
+        readonly value: Output;
+        /** A falsy value for `issues` indicates success. */
+        readonly issues?: undefined;
+    }
+    interface Options {
+        /** Explicit support for additional vendor-specific parameters, if needed. */
+        readonly libraryOptions?: Record<string, unknown> | undefined;
+    }
+    /** The result interface if validation fails. */
+    interface FailureResult {
+        /** The issues of failed validation. */
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    /** The issue interface of the failure output. */
+    interface Issue {
+        /** The error message of the issue. */
+        readonly message: string;
+        /** The path of the issue, if any. */
+        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+    }
+    /** The path segment interface of the issue. */
+    interface PathSegment {
+        /** The key representing a path segment. */
+        readonly key: PropertyKey;
+    }
+    /** The Standard types interface. */
+    interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {
+    }
+    /** Infers the input type of a Standard. */
+    type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+    /** Infers the output type of a Standard. */
+    type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+/** The Standard JSON Schema interface. */
+export interface StandardJSONSchemaV1<Input = unknown, Output = Input> {
+    /** The Standard JSON Schema properties. */
+    readonly "~standard": StandardJSONSchemaV1.Props<Input, Output>;
+}
+export declare namespace StandardJSONSchemaV1 {
+    /** The Standard JSON Schema properties interface. */
+    interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+        /** Methods for generating the input/output JSON Schema. */
+        readonly jsonSchema: StandardJSONSchemaV1.Converter;
+    }
+    /** The Standard JSON Schema converter interface. */
+    interface Converter {
+        /** Converts the input type to JSON Schema. May throw if conversion is not supported. */
+        readonly input: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+        /** Converts the output type to JSON Schema. May throw if conversion is not supported. */
+        readonly output: (options: StandardJSONSchemaV1.Options) => Record<string, unknown>;
+    }
+    /**
+     * The target version of the generated JSON Schema.
+     *
+     * It is *strongly recommended* that implementers support `"draft-2020-12"` and `"draft-07"`, as they are both in wide use. All other targets can be implemented on a best-effort basis. Libraries should throw if they don't support a specified target.
+     *
+     * The `"openapi-3.0"` target is intended as a standardized specifier for OpenAPI 3.0 which is a superset of JSON Schema `"draft-04"`.
+     */
+    type Target = "draft-2020-12" | "draft-07" | "openapi-3.0" | ({} & string);
+    /** The options for the input/output methods. */
+    interface Options {
+        /** Specifies the target version of the generated JSON Schema. Support for all versions is on a best-effort basis. If a given version is not supported, the library should throw. */
+        readonly target: Target;
+        /** Explicit support for additional vendor-specific parameters, if needed. */
+        readonly libraryOptions?: Record<string, unknown> | undefined;
+    }
+    /** The Standard types interface. */
+    interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {
+    }
+    /** Infers the input type of a Standard. */
+    type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+    /** Infers the output type of a Standard. */
+    type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}