@effected/github-actions 0.35.0 → 0.36.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/Action.js +7 -7
- package/ActionCache.js +4 -4
- package/ActionEnvironment.js +1 -1
- package/ActionInput.js +1 -1
- package/ActionLogger.js +197 -64
- package/ActionManifest.js +2 -2
- package/ActionOutputs.js +2 -2
- package/ActionState.js +1 -1
- package/ActionsIdentityToken.js +2 -2
- package/ActionsProvenance.js +2 -2
- package/ActionsRegistryCredential.js +2 -2
- package/Artifact.js +3 -3
- package/BlobStore.githubCache.js +2 -2
- package/BlobStore.js +4 -4
- package/CacheKey.js +2 -2
- package/CheckDocument.js +1 -1
- package/Checkout.js +361 -0
- package/DetachedProcess.js +4 -4
- package/DryRun.js +1 -1
- package/GitHubMarkdown.js +1 -1
- package/GitHubToken.js +2 -2
- package/ManagedDocument.js +1 -1
- package/OidcTokenIssuer.js +7 -7
- package/PackageManagerInstaller.js +3 -3
- package/README.md +2 -1
- package/Secret.js +1 -1
- package/ToolInstaller.js +4 -4
- package/index.d.ts +569 -103
- package/index.js +3 -2
- package/internal/actionsResults.js +1 -1
- package/internal/blobCause.js +1 -1
- package/internal/blobTransport.js +2 -2
- package/internal/cacheService.js +1 -1
- package/internal/checkout/asciiTrim.js +18 -0
- package/internal/checkout/credentials.js +563 -0
- package/internal/checkout/directory.js +119 -0
- package/internal/checkout/inputs.js +130 -0
- package/internal/checkout/refs.js +143 -0
- package/internal/checkout/settings.js +144 -0
- package/internal/checkout/source.js +418 -0
- package/internal/checkout/unsafePullRequest.js +62 -0
- package/internal/digest.js +1 -1
- package/internal/pnpmExe.js +1 -1
- package/internal/stepLog.js +225 -0
- package/internal/twirp.js +1 -1
- package/package.json +2 -1
package/index.d.ts
CHANGED
|
@@ -21,16 +21,17 @@
|
|
|
21
21
|
*
|
|
22
22
|
* @packageDocumentation
|
|
23
23
|
*/
|
|
24
|
-
import {
|
|
24
|
+
import { Cause, Config, ConfigProvider, Context, Duration, Effect, FileSystem, Layer, Logger, Option, Path, PlatformError, Redacted, Result, Schema, SchemaAST, Scope } from "effect";
|
|
25
25
|
import * as NodeServices from "@effect/platform-node/NodeServices";
|
|
26
|
-
import { Cause, Config, ConfigProvider, Context, Duration, Effect, FileSystem, Layer, Logger, Option, Path, Redacted, Result, Schema, SchemaAST } from "effect";
|
|
27
26
|
import { Digest, Mac, SecureRandom, Signature } from "effect/crypto";
|
|
28
27
|
import { HttpClient } from "effect/http";
|
|
29
|
-
import {
|
|
28
|
+
import { AnnotationProperties, AnnotationProperties as AnnotationProperties$1, WorkflowCommand } from "@effected/github-commands";
|
|
29
|
+
import { ChildProcess, ChildProcessSpawner } from "effect/process";
|
|
30
30
|
import { IdentityToken } from "@effected/oidc";
|
|
31
31
|
import { ActionsOidcClaims, BotIdentity, GitHubApp, GitHubClient, InstallationToken, PermissionLevel, RetryPolicy } from "@effected/github";
|
|
32
32
|
import { SlsaProvenance } from "@effected/sbom";
|
|
33
33
|
import { IntegrityHashBrand, PackageManagerPin, WorkloadCredential } from "@effected/npm";
|
|
34
|
+
import { Git, GitCommandError, NotARepositoryError, UnknownRefError } from "@effected/git";
|
|
34
35
|
declare const ActionEnvironmentError_base: Schema.Class<ActionEnvironmentError, Schema.TaggedStruct<"ActionEnvironmentError", {
|
|
35
36
|
/** `missing` — absent or empty; `malformed` — present but unusable. */
|
|
36
37
|
readonly reason: Schema.Literals<readonly ["missing", "malformed"]>;
|
|
@@ -284,41 +285,38 @@ export declare class ActionEnvironment extends ActionEnvironment_base {
|
|
|
284
285
|
static readonly layerTest: (overrides?: Readonly<Record<string, string>>, payload?: unknown) => Layer.Layer<ActionEnvironment>;
|
|
285
286
|
}
|
|
286
287
|
/**
|
|
287
|
-
* Options for {@link ActionLoggerShape.
|
|
288
|
+
* Options for {@link ActionLoggerShape.step}.
|
|
288
289
|
*
|
|
289
290
|
* @public
|
|
290
291
|
*/
|
|
291
|
-
interface
|
|
292
|
+
interface StepOptions<A> {
|
|
292
293
|
/**
|
|
293
|
-
*
|
|
294
|
+
* How long the step may run before its detail streams live instead of folding.
|
|
294
295
|
*
|
|
295
296
|
* @remarks
|
|
296
|
-
*
|
|
297
|
-
* did. `"discard"` drops it, which is what keeps a green release log to one
|
|
298
|
-
* line per step: the transcript exists only as the failure report. A failure,
|
|
299
|
-
* a defect or an interruption flushes under either setting — the choice is
|
|
300
|
-
* only about what a success is worth in the log.
|
|
297
|
+
* Only the outermost open step's window counts; a step nested inside another ignores its own.
|
|
301
298
|
*/
|
|
302
|
-
readonly
|
|
303
|
-
|
|
304
|
-
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
|
|
299
|
+
readonly window?: Duration.Input;
|
|
300
|
+
/**
|
|
301
|
+
* The result line's text when the step succeeds, computed from its result.
|
|
302
|
+
*
|
|
303
|
+
* @remarks
|
|
304
|
+
* Defaults to the step's name, which is also the text when the function throws.
|
|
305
|
+
*/
|
|
306
|
+
readonly summary?: (result: A) => string;
|
|
310
307
|
/**
|
|
311
|
-
* The
|
|
308
|
+
* The result line's text when the step fails, computed from its failure.
|
|
312
309
|
*
|
|
313
310
|
* @remarks
|
|
314
|
-
* Defaults to
|
|
315
|
-
*
|
|
311
|
+
* Replaces both the name and the message. Defaults to `<name> · <message>`, the message being the first line of the
|
|
312
|
+
* squashed failure's message, which is also the text when the function throws. An interruption always reads
|
|
313
|
+
* `<name> · interrupted`.
|
|
316
314
|
*/
|
|
317
|
-
readonly
|
|
315
|
+
readonly failure?: (cause: Cause.Cause<unknown>) => string;
|
|
318
316
|
}
|
|
319
317
|
/**
|
|
320
|
-
* The members of the {@link ActionLogger} service: log groups
|
|
321
|
-
*
|
|
318
|
+
* The members of the {@link ActionLogger} service: log groups, phases, steps,
|
|
319
|
+
* notices and source annotations.
|
|
322
320
|
*
|
|
323
321
|
* @public
|
|
324
322
|
*/
|
|
@@ -332,12 +330,9 @@ interface ActionLoggerShape {
|
|
|
332
330
|
* `::group::` / `::endgroup::` pair, and a call made inside it writes one
|
|
333
331
|
* `▸ <name>` header line inside the open group instead (line breaks
|
|
334
332
|
* collapsed to spaces, the text neutralized so it cannot be a command). The
|
|
335
|
-
* header
|
|
336
|
-
*
|
|
337
|
-
*
|
|
338
|
-
* buffer before the group closes. That ordering is visible in a failed
|
|
339
|
-
* run's log: the replayed transcript lands BELOW every nested header that
|
|
340
|
-
* was written live, including lines that were logged before the header.
|
|
333
|
+
* header is a line of that step's detail when written inside a
|
|
334
|
+
* {@link ActionLoggerShape.step}, where the depth is already at least 1, and
|
|
335
|
+
* goes out through `Console` otherwise.
|
|
341
336
|
*
|
|
342
337
|
* The depth is fiber-scoped, which leaves four edges:
|
|
343
338
|
*
|
|
@@ -361,81 +356,55 @@ interface ActionLoggerShape {
|
|
|
361
356
|
*/
|
|
362
357
|
readonly group: <A, E, R>(name: string, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
|
|
363
358
|
/**
|
|
364
|
-
* Run an effect under a
|
|
359
|
+
* Run an effect under a phase heading: one bold line, never folded.
|
|
365
360
|
*
|
|
366
361
|
* @remarks
|
|
367
|
-
*
|
|
368
|
-
*
|
|
369
|
-
* `::group::` and no change to the depth. So the groups inside it stay
|
|
370
|
-
* top level and each renders as its own collapsible section in the runner
|
|
371
|
-
* log, which a `group` wrapper cannot give them: the runner does not nest
|
|
372
|
-
* groups, and a wrapper that opened one would swallow every inner group
|
|
373
|
-
* into a header line. Reach for this when a phase encloses groups, and for
|
|
374
|
-
* `group` when it encloses only lines.
|
|
375
|
-
*
|
|
376
|
-
* The header goes out through `Console`, like a group command, so it is
|
|
377
|
-
* never captured into, or discarded with, an enclosing `withBuffer` or
|
|
378
|
-
* `withStep` transcript. Nothing is written when the body ends, and a
|
|
379
|
-
* failure flushes no buffer here: the groups inside do that for their own
|
|
380
|
-
* sections. Called inside an open group it is simply a header line in that
|
|
381
|
-
* group. The test doubles pass the body through unchanged.
|
|
362
|
+
* What a reader scans for. Nothing is written when the phase ends, and the group depth is unchanged, so the steps
|
|
363
|
+
* inside it fold as top-level steps. Inside a step the heading is a line of that step's detail.
|
|
382
364
|
*/
|
|
383
|
-
readonly
|
|
365
|
+
readonly phase: <A, E, R>(title: string, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
|
|
384
366
|
/**
|
|
385
|
-
* Run an effect
|
|
367
|
+
* Run an effect as a step: its detail held, one result line when it ends.
|
|
386
368
|
*
|
|
387
369
|
* @remarks
|
|
388
|
-
*
|
|
389
|
-
*
|
|
390
|
-
*
|
|
391
|
-
*
|
|
392
|
-
*
|
|
393
|
-
*
|
|
394
|
-
*
|
|
370
|
+
* The detail is every log line below `Warn`, `Debug` and `Trace` included whatever the ambient minimum level, every
|
|
371
|
+
* line a nested {@link ActionLoggerShape.group} or step writes, and every line written straight to `Console`'s
|
|
372
|
+
* `log`, `info`, `debug`, `trace`, `warn`, `error` or `dirxml` inside the step (`@effected/cli-kit`'s renderers, a
|
|
373
|
+
* raw `Console.log`). `Console.table`, `dir`, `count`, the `time*` and the `group*` members are not captured: they
|
|
374
|
+
* print through at once. A workflow command written to `Console` is not
|
|
375
|
+
* detail: it goes out at once, so an `::add-mask::` reaches the runner before the secret can appear in any line,
|
|
376
|
+
* except a group command, which becomes a `▸ <title>` header line. Warnings and errors are never held: they go out
|
|
377
|
+
* as annotations the moment they happen, and the result line counts them.
|
|
395
378
|
*
|
|
396
|
-
*
|
|
397
|
-
*
|
|
398
|
-
*
|
|
399
|
-
*
|
|
400
|
-
*
|
|
401
|
-
*
|
|
402
|
-
*
|
|
403
|
-
*
|
|
404
|
-
*/
|
|
405
|
-
readonly withBuffer: <A, E, R>(label: string, effect: Effect.Effect<A, E, R>, options?: WithBufferOptions) => Effect.Effect<A, E, R>;
|
|
406
|
-
/**
|
|
407
|
-
* Run a named step: quiet when it succeeds, its full transcript when it does
|
|
408
|
-
* not.
|
|
409
|
-
*
|
|
410
|
-
* @remarks
|
|
411
|
-
* The composition a release log actually wants, and the one
|
|
412
|
-
* {@link ActionLoggerShape.withBuffer} alone does not reach. Buffering with
|
|
413
|
-
* `{ onSuccess: "discard" }` gets a green step to *zero* lines; this trades
|
|
414
|
-
* that transcript for exactly one:
|
|
379
|
+
* The step's window ({@link StepOptions.window}, 30 seconds by default) is how long the detail is held. A step that
|
|
380
|
+
* runs past it goes live: it writes `… <name> is taking longer than <window>, showing live output`, everything held
|
|
381
|
+
* so far, then each detail line as it happens, indented, and finally its result line, unfolded, with the same marks.
|
|
382
|
+
* A window of zero streams from the start, with the opening line `… <name>`; runner debug (`RUNNER_DEBUG=1`) or an
|
|
383
|
+
* ambient minimum log level of `Debug` or lower makes every window zero. Only the outermost open step has a window:
|
|
384
|
+
* an inner step's own is ignored, and when the outer step is live the inner result lines print as they finish.
|
|
385
|
+
* While two or more steps stream at once, each live detail line is prefixed `[<name>] ` with its outermost step's
|
|
386
|
+
* name.
|
|
415
387
|
*
|
|
416
|
-
*
|
|
417
|
-
*
|
|
418
|
-
*
|
|
419
|
-
* 3. on failure a `❌ <name>` header lands **first**, then the transcript
|
|
420
|
-
* spills beneath it.
|
|
388
|
+
* The result line is `<mark> <summary or name> · <duration>`, the mark `✓` for a success, `⚠` for a success that
|
|
389
|
+
* logged a warning or an error, or in which a nested step failed and was recovered from (here or in any step
|
|
390
|
+
* inside it, each counted on the line), and `✗` for a failure ({@link StepOptions}):
|
|
421
391
|
*
|
|
422
|
-
*
|
|
423
|
-
*
|
|
424
|
-
*
|
|
425
|
-
*
|
|
426
|
-
*
|
|
427
|
-
* test.
|
|
392
|
+
* 1. a success with detail is one folded `::group::` titled by the result line, the detail inside it, unless a
|
|
393
|
+
* nested step failed, which is never folded away;
|
|
394
|
+
* 2. a success without detail is the result line alone;
|
|
395
|
+
* 3. a failure is never folded: the result line, then the detail indented beneath it, then the failure itself
|
|
396
|
+
* propagates unchanged. An interruption is written the same way, as `✗ <name> · interrupted`.
|
|
428
397
|
*
|
|
429
|
-
*
|
|
430
|
-
*
|
|
431
|
-
*
|
|
432
|
-
*
|
|
398
|
+
* A step inside a step opens no group: its result line, and its detail indented above it, are lines of the
|
|
399
|
+
* enclosing step's detail. Inside the step the group depth is at least 1, so `group` and `@effected/cli-kit`'s
|
|
400
|
+
* renderers write plain lines rather than a group the runner cannot nest. A step opened inside a `group` cannot fold
|
|
401
|
+
* either, and writes its result line with the detail indented beneath it.
|
|
433
402
|
*
|
|
434
|
-
*
|
|
435
|
-
*
|
|
436
|
-
*
|
|
403
|
+
* Every line passes through `CommandNeutralizer.text`, so no detail line can be a workflow command. A fiber forked
|
|
404
|
+
* inside a step that logs after the step has ended is not dropped: its lines print as ordinary log lines, unindented
|
|
405
|
+
* and unprefixed, and a step it opens is a new outermost step.
|
|
437
406
|
*/
|
|
438
|
-
readonly
|
|
407
|
+
readonly step: <A, E, R>(name: string, effect: Effect.Effect<A, E, R>, options?: StepOptions<A>) => Effect.Effect<A, E, R>;
|
|
439
408
|
/**
|
|
440
409
|
* Emit a `::notice::` annotation.
|
|
441
410
|
*
|
|
@@ -454,9 +423,29 @@ interface ActionLoggerShape {
|
|
|
454
423
|
*/
|
|
455
424
|
readonly annotated: <A, E, R>(properties: AnnotationProperties$1, effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
|
|
456
425
|
}
|
|
426
|
+
/**
|
|
427
|
+
* One entry of the log {@link ActionLogger.recording} captured: a phase heading, or a step with its detail, outcome and
|
|
428
|
+
* the steps and phases opened inside it.
|
|
429
|
+
*
|
|
430
|
+
* @public
|
|
431
|
+
*/
|
|
432
|
+
type StepLogEntry = {
|
|
433
|
+
readonly kind: "phase";
|
|
434
|
+
readonly title: string;
|
|
435
|
+
} | {
|
|
436
|
+
readonly kind: "step";
|
|
437
|
+
readonly name: string;
|
|
438
|
+
/** `"warning"` is a success that logged a warning or an error, or in which a nested step failed. */
|
|
439
|
+
readonly outcome: "success" | "warning" | "failure" | "interrupted";
|
|
440
|
+
/** The result line's text, without its mark, counts or duration. */
|
|
441
|
+
readonly summary: string;
|
|
442
|
+
/** The lines logged below `Warn` inside the step, not those of nested steps. */
|
|
443
|
+
readonly detail: ReadonlyArray<string>;
|
|
444
|
+
readonly steps: ReadonlyArray<StepLogEntry>;
|
|
445
|
+
};
|
|
457
446
|
declare const ActionLogger_base: Context.ServiceClass<ActionLogger, "@effected/github-actions/ActionLogger", ActionLoggerShape>;
|
|
458
447
|
/**
|
|
459
|
-
* Groups,
|
|
448
|
+
* Groups, phases, steps, notices — and the `Logger` that renders
|
|
460
449
|
* every `Effect.log*` in the kit as a workflow command.
|
|
461
450
|
*
|
|
462
451
|
* @remarks
|
|
@@ -472,7 +461,7 @@ declare const ActionLogger_base: Context.ServiceClass<ActionLogger, "@effected/g
|
|
|
472
461
|
*
|
|
473
462
|
* const program = Effect.gen(function* () {
|
|
474
463
|
* const logger = yield* ActionLogger;
|
|
475
|
-
* yield* logger.
|
|
464
|
+
* yield* logger.phase("Install", logger.step("pnpm", Effect.logInfo("resolving")));
|
|
476
465
|
* });
|
|
477
466
|
* ```
|
|
478
467
|
*
|
|
@@ -480,7 +469,7 @@ declare const ActionLogger_base: Context.ServiceClass<ActionLogger, "@effected/g
|
|
|
480
469
|
*/
|
|
481
470
|
export declare class ActionLogger extends ActionLogger_base {
|
|
482
471
|
/**
|
|
483
|
-
* The service: groups,
|
|
472
|
+
* The service: groups, phases, steps, notices and annotations.
|
|
484
473
|
*
|
|
485
474
|
* @remarks
|
|
486
475
|
* This installs no `Logger`. Without {@link ActionLogger.layerLogger} (or `Action.run`, which installs it) Effect's
|
|
@@ -515,11 +504,51 @@ export declare class ActionLogger extends ActionLogger_base {
|
|
|
515
504
|
* **A recorded exception to the die-on-unstubbed rule**, alongside
|
|
516
505
|
* {@link ActionEnvironment.makeTest}. A logger that dies when a suite logs
|
|
517
506
|
* would make every double unusable, and silence is the honest default for a
|
|
518
|
-
* service whose whole job is output. Group,
|
|
519
|
-
* effect through unchanged, so the double does not model group nesting
|
|
520
|
-
* a test of
|
|
507
|
+
* service whose whole job is output. Group, phase and step wrappers pass their
|
|
508
|
+
* effect through unchanged, so the double does not model group nesting or
|
|
509
|
+
* the step log: a test of that output needs the live {@link ActionLogger.layer}
|
|
510
|
+
* or {@link ActionLogger.recording}.
|
|
521
511
|
*/
|
|
522
512
|
static readonly makeTest: (overrides?: Partial<ActionLoggerShape>) => ActionLoggerShape;
|
|
513
|
+
/**
|
|
514
|
+
* A double that records the step log's structure so a test can assert it.
|
|
515
|
+
*
|
|
516
|
+
* @remarks
|
|
517
|
+
* `entries()` returns the phases and steps opened so far, each step with its detail (every line below `Warn`),
|
|
518
|
+
* outcome, result text and nested steps. The step log itself writes nothing to the console. A raw `Console` write
|
|
519
|
+
* inside a recorded step is not detail and still prints, so test `Console` or `@effected/cli-kit` output against
|
|
520
|
+
* the live layer with `TestConsole`. The other members behave as in {@link ActionLogger.makeTest}.
|
|
521
|
+
*/
|
|
522
|
+
static readonly recording: () => {
|
|
523
|
+
readonly layer: Layer.Layer<ActionLogger>;
|
|
524
|
+
readonly entries: () => ReadonlyArray<StepLogEntry>;
|
|
525
|
+
};
|
|
526
|
+
/**
|
|
527
|
+
* Run a child process, writing its command line, its output and its exit code as the current step's detail.
|
|
528
|
+
*
|
|
529
|
+
* @remarks
|
|
530
|
+
* Writes `$ <display>` (the command line, secrets redacted, unless `display` is given), then each stdout and stderr
|
|
531
|
+
* line as it arrives, then `exit <code>`. Both streams are read concurrently, so a child that fills one pipe cannot
|
|
532
|
+
* deadlock the other. Every line is detail, so the step's held, live and prefix rules apply; stderr lines are
|
|
533
|
+
* detail too, not warnings. Outside any step the lines print live. Resolves with the exit code, whatever it is, and
|
|
534
|
+
* the collected stdout.
|
|
535
|
+
*
|
|
536
|
+
* Reading stops 10 seconds after the child exits, as `@actions/exec` does: a background grandchild that inherited
|
|
537
|
+
* the child's stdout or stderr would otherwise hold the pipe open, and the call with it, for as long as it lives.
|
|
538
|
+
* What it wrote after that is not read.
|
|
539
|
+
*
|
|
540
|
+
* Stdout is decoded as UTF-8 text and logged line by line, so this suits a child whose stdout is text; a binary
|
|
541
|
+
* stdout needs the raw `ChildProcessSpawner` handle.
|
|
542
|
+
*
|
|
543
|
+
* Fails with `PlatformError` when the spawn fails, or when reading the child's output or its exit status fails after
|
|
544
|
+
* it started. A non-zero exit is never an error.
|
|
545
|
+
*/
|
|
546
|
+
static readonly command: (command: ChildProcess.Command, options?: {
|
|
547
|
+
readonly display?: string;
|
|
548
|
+
}) => Effect.Effect<{
|
|
549
|
+
readonly exitCode: number;
|
|
550
|
+
readonly stdout: string;
|
|
551
|
+
}, PlatformError.PlatformError, ChildProcessSpawner.ChildProcessSpawner>;
|
|
523
552
|
/** {@link ActionLogger.makeTest} behind `Layer.succeed`. */
|
|
524
553
|
static readonly layerTest: (overrides?: Partial<ActionLoggerShape>) => Layer.Layer<ActionLogger>;
|
|
525
554
|
/**
|
|
@@ -1041,8 +1070,8 @@ export declare const describeCause: (cause: Cause.Cause<unknown>) => string;
|
|
|
1041
1070
|
*
|
|
1042
1071
|
* - **It does not wrap the program in a log buffer.** A buffer that swallowed
|
|
1043
1072
|
* the transcript on an unhandled defect would leave a run that failed and
|
|
1044
|
-
* printed nothing. `ActionLogger.
|
|
1045
|
-
* exit path including a defect, so the
|
|
1073
|
+
* printed nothing. `ActionLogger.step` is opt-in and writes its result line on
|
|
1074
|
+
* every exit path including a defect, so the holding is where the caller can
|
|
1046
1075
|
* see it.
|
|
1047
1076
|
* - **It does not throw.** The returned promise always resolves; the failure is
|
|
1048
1077
|
* in `process.exitCode`, which is what the runner reads. An action entry
|
|
@@ -3723,6 +3752,443 @@ export declare class CheckDocument extends CheckDocument_base {
|
|
|
3723
3752
|
/** {@link CheckDocument.makeTest} behind a `Layer`. */
|
|
3724
3753
|
static readonly layerTest: (overrides?: Partial<CheckDocumentShape>) => Layer.Layer<CheckDocument>;
|
|
3725
3754
|
}
|
|
3755
|
+
/**
|
|
3756
|
+
* What to check out: a tagged union naming the ref the working tree lands on.
|
|
3757
|
+
*
|
|
3758
|
+
* @remarks
|
|
3759
|
+
* `Event` is the workflow's own `GITHUB_REF` at `GITHUB_SHA`; `Default` is the
|
|
3760
|
+
* repository's default branch. `Ref` takes a raw ref exactly as the `ref` input
|
|
3761
|
+
* of the stock checkout action does. Every member that names something movable
|
|
3762
|
+
* may pin it with `commit`.
|
|
3763
|
+
*
|
|
3764
|
+
* @public
|
|
3765
|
+
*/
|
|
3766
|
+
export declare const CheckoutRef: Schema.TaggedUnion<{
|
|
3767
|
+
readonly Branch: Schema.TaggedStruct<"Branch", {
|
|
3768
|
+
readonly name: Schema.String;
|
|
3769
|
+
readonly commit: Schema.optionalKey<Schema.String>;
|
|
3770
|
+
}>;
|
|
3771
|
+
readonly Commit: Schema.TaggedStruct<"Commit", {
|
|
3772
|
+
readonly sha: Schema.String;
|
|
3773
|
+
}>;
|
|
3774
|
+
readonly Default: Schema.TaggedStruct<"Default", {}>;
|
|
3775
|
+
readonly Event: Schema.TaggedStruct<"Event", {}>;
|
|
3776
|
+
readonly PullRequest: Schema.TaggedStruct<"PullRequest", {
|
|
3777
|
+
readonly number: Schema.Number;
|
|
3778
|
+
readonly kind: Schema.Literals<readonly ["merge", "head"]>;
|
|
3779
|
+
readonly commit: Schema.optionalKey<Schema.String>;
|
|
3780
|
+
}>;
|
|
3781
|
+
readonly Ref: Schema.TaggedStruct<"Ref", {
|
|
3782
|
+
readonly ref: Schema.String;
|
|
3783
|
+
readonly commit: Schema.optionalKey<Schema.String>;
|
|
3784
|
+
}>;
|
|
3785
|
+
readonly Tag: Schema.TaggedStruct<"Tag", {
|
|
3786
|
+
readonly name: Schema.String;
|
|
3787
|
+
readonly commit: Schema.optionalKey<Schema.String>;
|
|
3788
|
+
}>;
|
|
3789
|
+
}>;
|
|
3790
|
+
/**
|
|
3791
|
+
* The ref a checkout lands on.
|
|
3792
|
+
*
|
|
3793
|
+
* @public
|
|
3794
|
+
*/
|
|
3795
|
+
export type CheckoutRef = typeof CheckoutRef.Type;
|
|
3796
|
+
/**
|
|
3797
|
+
* How a checkout authenticates: a token, or an SSH key.
|
|
3798
|
+
*
|
|
3799
|
+
* @remarks
|
|
3800
|
+
* `Ssh` defaults `strict` to `true` and `user` to `"git"`. Its optional `token`
|
|
3801
|
+
* still serves the API calls, as the stock checkout's does. Every secret is a
|
|
3802
|
+
* `Redacted<string>`.
|
|
3803
|
+
*
|
|
3804
|
+
* @public
|
|
3805
|
+
*/
|
|
3806
|
+
export declare const CheckoutAuth: Schema.TaggedUnion<{
|
|
3807
|
+
readonly Ssh: Schema.TaggedStruct<"Ssh", {
|
|
3808
|
+
readonly key: Schema.Redacted<Schema.String>;
|
|
3809
|
+
readonly knownHosts: Schema.optionalKey<Schema.String>;
|
|
3810
|
+
readonly strict: Schema.optionalKey<Schema.Boolean>;
|
|
3811
|
+
readonly user: Schema.optionalKey<Schema.String>;
|
|
3812
|
+
readonly token: Schema.optionalKey<Schema.Redacted<Schema.String>>;
|
|
3813
|
+
}>;
|
|
3814
|
+
readonly Token: Schema.TaggedStruct<"Token", {
|
|
3815
|
+
readonly token: Schema.Redacted<Schema.String>;
|
|
3816
|
+
}>;
|
|
3817
|
+
}>;
|
|
3818
|
+
/**
|
|
3819
|
+
* How a checkout authenticates.
|
|
3820
|
+
*
|
|
3821
|
+
* @public
|
|
3822
|
+
*/
|
|
3823
|
+
export type CheckoutAuth = typeof CheckoutAuth.Type;
|
|
3824
|
+
/**
|
|
3825
|
+
* Everything {@link Checkout.checkout} accepts.
|
|
3826
|
+
*
|
|
3827
|
+
* @remarks
|
|
3828
|
+
* Defaults: `ref` is `Event` when `repository` is the workflow's own
|
|
3829
|
+
* (case-insensitive), else `Default`; `path` `"."`; `credentials` `"job"`;
|
|
3830
|
+
* `clean` true; `depth` 1; `fetchTags` false; `sparse.cone` true; `lfs` false;
|
|
3831
|
+
* `submodules` false; `safeDirectory` true; `serverUrl` the runner's
|
|
3832
|
+
* `GITHUB_SERVER_URL` or `https://github.com` (an empty one counts as omitted);
|
|
3833
|
+
* `stateKey` `"effected-checkout"`.
|
|
3834
|
+
*
|
|
3835
|
+
* @public
|
|
3836
|
+
*/
|
|
3837
|
+
interface CheckoutOptions {
|
|
3838
|
+
/** The repository to check out; the workflow's own when omitted. */
|
|
3839
|
+
readonly repository?: {
|
|
3840
|
+
readonly owner: string;
|
|
3841
|
+
readonly name: string;
|
|
3842
|
+
};
|
|
3843
|
+
/** What to check out. */
|
|
3844
|
+
readonly ref?: CheckoutRef;
|
|
3845
|
+
/** The directory to check out into, relative to the workspace. */
|
|
3846
|
+
readonly path?: string;
|
|
3847
|
+
/** How to authenticate. */
|
|
3848
|
+
readonly auth: CheckoutAuth;
|
|
3849
|
+
/**
|
|
3850
|
+
* Where the credential lives afterwards: for the job, for the action's own run, or nowhere. Under `"job"` and
|
|
3851
|
+
* `"action"` both the token (through `includeIf`) and an SSH key's `core.sshCommand` are persisted in the
|
|
3852
|
+
* repository and its submodules, so later git authenticates either way; `"action"` removes them when the scope
|
|
3853
|
+
* closes.
|
|
3854
|
+
*/
|
|
3855
|
+
readonly credentials?: "job" | "action" | "none";
|
|
3856
|
+
/** Whether to clean the target directory first. */
|
|
3857
|
+
readonly clean?: boolean;
|
|
3858
|
+
/** The fetch depth, or `"full"` for all history. */
|
|
3859
|
+
readonly depth?: number | "full";
|
|
3860
|
+
/** Whether to fetch tags. */
|
|
3861
|
+
readonly fetchTags?: boolean;
|
|
3862
|
+
/** A partial-clone filter, such as `blob:none`. */
|
|
3863
|
+
readonly filter?: string;
|
|
3864
|
+
/** A sparse checkout. */
|
|
3865
|
+
readonly sparse?: {
|
|
3866
|
+
readonly patterns: ReadonlyArray<string>;
|
|
3867
|
+
readonly cone?: boolean;
|
|
3868
|
+
};
|
|
3869
|
+
/** Whether to fetch Git LFS objects. */
|
|
3870
|
+
readonly lfs?: boolean;
|
|
3871
|
+
/** Whether to check out submodules, and whether recursively. */
|
|
3872
|
+
readonly submodules?: boolean | "recursive";
|
|
3873
|
+
/** Whether to mark the checkout a git `safe.directory`. */
|
|
3874
|
+
readonly safeDirectory?: boolean;
|
|
3875
|
+
/**
|
|
3876
|
+
* The GitHub server URL: an absolute `http` or `https` URL, such as `https://ghe.example.com`. One without a scheme
|
|
3877
|
+
* fails {@link CheckoutServerUrlError}.
|
|
3878
|
+
*/
|
|
3879
|
+
readonly serverUrl?: string;
|
|
3880
|
+
/**
|
|
3881
|
+
* The remote URL to use instead of one derived from `serverUrl` and `repository`. With it set, the default branch
|
|
3882
|
+
* is the remote's own `HEAD`, not the API's answer for `repository`.
|
|
3883
|
+
*/
|
|
3884
|
+
readonly remoteUrl?: string;
|
|
3885
|
+
/** Permits checking out fork pull request code from a privileged event. */
|
|
3886
|
+
readonly allowUnsafePrCheckout?: boolean;
|
|
3887
|
+
/**
|
|
3888
|
+
* The state key the cleanup phase reads back. The runner keeps one value per key, so give each `"job"` checkout
|
|
3889
|
+
* of a different path its own key, and call `Checkout.cleanup({ stateKey })` for each; a second one under a key
|
|
3890
|
+
* already in use fails `CheckoutStateKeyInUseError` before it writes anything.
|
|
3891
|
+
*/
|
|
3892
|
+
readonly stateKey?: string;
|
|
3893
|
+
}
|
|
3894
|
+
declare const CheckoutResult_base: Schema.Class<CheckoutResult, Schema.Struct<{
|
|
3895
|
+
/** The resolved ref, or `""` for a bare commit. */
|
|
3896
|
+
readonly ref: Schema.String;
|
|
3897
|
+
/** The commit now checked out. */
|
|
3898
|
+
readonly commit: Schema.String;
|
|
3899
|
+
/** The directory checked out into. */
|
|
3900
|
+
readonly path: Schema.String;
|
|
3901
|
+
/** The repository checked out. */
|
|
3902
|
+
readonly repository: Schema.Struct<{
|
|
3903
|
+
readonly owner: Schema.String;
|
|
3904
|
+
readonly name: Schema.String;
|
|
3905
|
+
}>;
|
|
3906
|
+
}>, {}>;
|
|
3907
|
+
/**
|
|
3908
|
+
* What a checkout resolved to.
|
|
3909
|
+
*
|
|
3910
|
+
* @remarks
|
|
3911
|
+
* `ref` is the resolved ref, as the `ref` output of the stock checkout action
|
|
3912
|
+
* is: `""` for a bare commit.
|
|
3913
|
+
*
|
|
3914
|
+
* @public
|
|
3915
|
+
*/
|
|
3916
|
+
export declare class CheckoutResult extends CheckoutResult_base {}
|
|
3917
|
+
declare const CheckoutGitTooOldError_base: Schema.Class<CheckoutGitTooOldError, Schema.TaggedStruct<"CheckoutGitTooOldError", {
|
|
3918
|
+
/** The git version found. */
|
|
3919
|
+
readonly found: Schema.String;
|
|
3920
|
+
/** The oldest git version supported. */
|
|
3921
|
+
readonly required: Schema.String;
|
|
3922
|
+
}>, import("effect/Cause").YieldableError>;
|
|
3923
|
+
/**
|
|
3924
|
+
* Raised when the runner's git is older than the floor.
|
|
3925
|
+
*
|
|
3926
|
+
* @public
|
|
3927
|
+
*/
|
|
3928
|
+
export declare class CheckoutGitTooOldError extends CheckoutGitTooOldError_base {
|
|
3929
|
+
get message(): string;
|
|
3930
|
+
}
|
|
3931
|
+
declare const CheckoutUnsafePullRequestError_base: Schema.Class<CheckoutUnsafePullRequestError, Schema.TaggedStruct<"CheckoutUnsafePullRequestError", {
|
|
3932
|
+
/** The triggering event, such as `pull_request_target`. */
|
|
3933
|
+
readonly event: Schema.String;
|
|
3934
|
+
/** The repository being checked out. */
|
|
3935
|
+
readonly repository: Schema.String;
|
|
3936
|
+
/** The ref being checked out. */
|
|
3937
|
+
readonly ref: Schema.String;
|
|
3938
|
+
}>, import("effect/Cause").YieldableError>;
|
|
3939
|
+
/**
|
|
3940
|
+
* Raised when a privileged event would check out fork pull request code.
|
|
3941
|
+
*
|
|
3942
|
+
* @public
|
|
3943
|
+
*/
|
|
3944
|
+
export declare class CheckoutUnsafePullRequestError extends CheckoutUnsafePullRequestError_base {
|
|
3945
|
+
get message(): string;
|
|
3946
|
+
}
|
|
3947
|
+
declare const CheckoutRefNotFoundError_base: Schema.Class<CheckoutRefNotFoundError, Schema.TaggedStruct<"CheckoutRefNotFoundError", {
|
|
3948
|
+
/** The ref that was not found, after default-branch resolution. */
|
|
3949
|
+
readonly ref: Schema.String;
|
|
3950
|
+
}>, import("effect/Cause").YieldableError>;
|
|
3951
|
+
/**
|
|
3952
|
+
* Raised when the requested ref does not exist on the remote.
|
|
3953
|
+
*
|
|
3954
|
+
* @remarks
|
|
3955
|
+
* For a `Default` checkout `ref` is the default branch it resolved to, such as
|
|
3956
|
+
* `refs/heads/main`, never `""`.
|
|
3957
|
+
*
|
|
3958
|
+
* @public
|
|
3959
|
+
*/
|
|
3960
|
+
export declare class CheckoutRefNotFoundError extends CheckoutRefNotFoundError_base {
|
|
3961
|
+
get message(): string;
|
|
3962
|
+
}
|
|
3963
|
+
declare const CheckoutCommitMismatchError_base: Schema.Class<CheckoutCommitMismatchError, Schema.TaggedStruct<"CheckoutCommitMismatchError", {
|
|
3964
|
+
/** The ref that was fetched, after default-branch resolution. */
|
|
3965
|
+
readonly ref: Schema.String;
|
|
3966
|
+
/** The commit the caller pinned. */
|
|
3967
|
+
readonly expected: Schema.String;
|
|
3968
|
+
}>, import("effect/Cause").YieldableError>;
|
|
3969
|
+
/**
|
|
3970
|
+
* Raised when a ref resolved to a different commit than the one pinned.
|
|
3971
|
+
*
|
|
3972
|
+
* @public
|
|
3973
|
+
*/
|
|
3974
|
+
export declare class CheckoutCommitMismatchError extends CheckoutCommitMismatchError_base {
|
|
3975
|
+
get message(): string;
|
|
3976
|
+
}
|
|
3977
|
+
declare const CheckoutAuthError_base: Schema.Class<CheckoutAuthError, Schema.TaggedStruct<"CheckoutAuthError", {
|
|
3978
|
+
/** The repository being accessed. */
|
|
3979
|
+
readonly repository: Schema.String;
|
|
3980
|
+
/** What went wrong, with no secret in it. */
|
|
3981
|
+
readonly detail: Schema.String;
|
|
3982
|
+
}>, import("effect/Cause").YieldableError>;
|
|
3983
|
+
/**
|
|
3984
|
+
* Raised when the credentials were refused.
|
|
3985
|
+
*
|
|
3986
|
+
* @public
|
|
3987
|
+
*/
|
|
3988
|
+
export declare class CheckoutAuthError extends CheckoutAuthError_base {
|
|
3989
|
+
get message(): string;
|
|
3990
|
+
}
|
|
3991
|
+
declare const CheckoutPathError_base: Schema.Class<CheckoutPathError, Schema.TaggedStruct<"CheckoutPathError", {
|
|
3992
|
+
/** The path requested. */
|
|
3993
|
+
readonly path: Schema.String;
|
|
3994
|
+
/** The workspace it must stay within. */
|
|
3995
|
+
readonly workspace: Schema.String;
|
|
3996
|
+
}>, import("effect/Cause").YieldableError>;
|
|
3997
|
+
/**
|
|
3998
|
+
* Raised when the target path escapes the workspace.
|
|
3999
|
+
*
|
|
4000
|
+
* @public
|
|
4001
|
+
*/
|
|
4002
|
+
export declare class CheckoutPathError extends CheckoutPathError_base {
|
|
4003
|
+
get message(): string;
|
|
4004
|
+
}
|
|
4005
|
+
declare const CheckoutDefaultBranchError_base: Schema.Class<CheckoutDefaultBranchError, Schema.TaggedStruct<"CheckoutDefaultBranchError", {
|
|
4006
|
+
/** The repository whose default branch is unknown. */
|
|
4007
|
+
readonly repository: Schema.String;
|
|
4008
|
+
/** Why: the API's or `ls-remote`'s failure, with no secret in it. */
|
|
4009
|
+
readonly detail: Schema.String;
|
|
4010
|
+
}>, import("effect/Cause").YieldableError>;
|
|
4011
|
+
/**
|
|
4012
|
+
* Raised when the repository's default branch could not be determined.
|
|
4013
|
+
*
|
|
4014
|
+
* @public
|
|
4015
|
+
*/
|
|
4016
|
+
export declare class CheckoutDefaultBranchError extends CheckoutDefaultBranchError_base {
|
|
4017
|
+
get message(): string;
|
|
4018
|
+
}
|
|
4019
|
+
declare const CheckoutUnqualifiedRefPinError_base: Schema.Class<CheckoutUnqualifiedRefPinError, Schema.TaggedStruct<"CheckoutUnqualifiedRefPinError", {
|
|
4020
|
+
/** The unqualified ref that was pinned. */
|
|
4021
|
+
readonly ref: Schema.String;
|
|
4022
|
+
}>, import("effect/Cause").YieldableError>;
|
|
4023
|
+
/**
|
|
4024
|
+
* Raised when a `Ref` that is not fully qualified is pinned with `commit`.
|
|
4025
|
+
*
|
|
4026
|
+
* @remarks
|
|
4027
|
+
* An unqualified ref pinned to a commit fetches only the commit, and nothing
|
|
4028
|
+
* then names the branch or tag to land on. Pin a branch or tag with `Branch`
|
|
4029
|
+
* or `Tag`, or give `Ref` a full `refs/...` name.
|
|
4030
|
+
*
|
|
4031
|
+
* @public
|
|
4032
|
+
*/
|
|
4033
|
+
export declare class CheckoutUnqualifiedRefPinError extends CheckoutUnqualifiedRefPinError_base {
|
|
4034
|
+
get message(): string;
|
|
4035
|
+
}
|
|
4036
|
+
declare const CheckoutStateKeyInUseError_base: Schema.Class<CheckoutStateKeyInUseError, Schema.TaggedStruct<"CheckoutStateKeyInUseError", {
|
|
4037
|
+
/** The state key already in use. */
|
|
4038
|
+
readonly stateKey: Schema.String;
|
|
4039
|
+
/** The path whose credentials it already records. */
|
|
4040
|
+
readonly path: Schema.String;
|
|
4041
|
+
}>, import("effect/Cause").YieldableError>;
|
|
4042
|
+
/**
|
|
4043
|
+
* Raised when a second `"job"` checkout in one action saves its credentials
|
|
4044
|
+
* under a state key another checkout of a different path already used.
|
|
4045
|
+
*
|
|
4046
|
+
* @remarks
|
|
4047
|
+
* The runner keeps one value per state key, so the post entry's
|
|
4048
|
+
* {@link Checkout.cleanup} would find only the later record and leave the
|
|
4049
|
+
* earlier checkout's credentials behind. Give each `"job"` checkout its own
|
|
4050
|
+
* `stateKey` and call `Checkout.cleanup({ stateKey })` for each.
|
|
4051
|
+
*
|
|
4052
|
+
* @public
|
|
4053
|
+
*/
|
|
4054
|
+
export declare class CheckoutStateKeyInUseError extends CheckoutStateKeyInUseError_base {
|
|
4055
|
+
get message(): string;
|
|
4056
|
+
}
|
|
4057
|
+
declare const CheckoutServerUrlError_base: Schema.Class<CheckoutServerUrlError, Schema.TaggedStruct<"CheckoutServerUrlError", {
|
|
4058
|
+
/** The server URL as given. */
|
|
4059
|
+
readonly serverUrl: Schema.String;
|
|
4060
|
+
/** Why it was refused. */
|
|
4061
|
+
readonly detail: Schema.String;
|
|
4062
|
+
}>, import("effect/Cause").YieldableError>;
|
|
4063
|
+
/**
|
|
4064
|
+
* Raised when the GitHub server URL is not an absolute `http` or `https` URL.
|
|
4065
|
+
*
|
|
4066
|
+
* @remarks
|
|
4067
|
+
* Checked once, before any git runs, for `serverUrl`, the `github-server-url`
|
|
4068
|
+
* input {@link Checkout.fromInputs} reads, and the runner's `GITHUB_SERVER_URL`.
|
|
4069
|
+
* A host with no scheme, such as `ghe.example.com`, is refused rather than
|
|
4070
|
+
* given `https://`, as the stock checkout action refuses it.
|
|
4071
|
+
*
|
|
4072
|
+
* @public
|
|
4073
|
+
*/
|
|
4074
|
+
export declare class CheckoutServerUrlError extends CheckoutServerUrlError_base {
|
|
4075
|
+
get message(): string;
|
|
4076
|
+
}
|
|
4077
|
+
/**
|
|
4078
|
+
* Anything that can go wrong checking out a repository.
|
|
4079
|
+
*
|
|
4080
|
+
* @remarks
|
|
4081
|
+
* One class per failure, so each member carries exactly the fields its own
|
|
4082
|
+
* message needs and `Effect.catchTag` recovers from one without catching the
|
|
4083
|
+
* others.
|
|
4084
|
+
*
|
|
4085
|
+
* @public
|
|
4086
|
+
*/
|
|
4087
|
+
type CheckoutError = CheckoutGitTooOldError | CheckoutUnsafePullRequestError | CheckoutRefNotFoundError | CheckoutCommitMismatchError | CheckoutAuthError | CheckoutPathError | CheckoutDefaultBranchError | CheckoutUnqualifiedRefPinError | CheckoutStateKeyInUseError | CheckoutServerUrlError;
|
|
4088
|
+
/**
|
|
4089
|
+
* Checks a repository out the way the stock checkout action does, on `@effected/git`.
|
|
4090
|
+
*
|
|
4091
|
+
* @public
|
|
4092
|
+
*/
|
|
4093
|
+
export declare class Checkout {
|
|
4094
|
+
/**
|
|
4095
|
+
* Checks a repository out, in the stock checkout action's order: version
|
|
4096
|
+
* check, unsafe pull request guard, directory preparation, `init`, auth,
|
|
4097
|
+
* default branch, one fetch, ref verification, LFS, sparse set, checkout,
|
|
4098
|
+
* submodules.
|
|
4099
|
+
*
|
|
4100
|
+
* @remarks
|
|
4101
|
+
* Requires git 2.39.0 or later and fails {@link CheckoutGitTooOldError}
|
|
4102
|
+
* before any other git runs. Every secret is masked first.
|
|
4103
|
+
*
|
|
4104
|
+
* An existing repository of the same remote is reused (lock files removed,
|
|
4105
|
+
* `HEAD` detached, local and conflicting remote-tracking branches deleted,
|
|
4106
|
+
* and with `clean` a `clean -ffdx` and `reset --hard HEAD`); any other
|
|
4107
|
+
* directory has its contents deleted. The fetch, the default branch lookup
|
|
4108
|
+
* and the LFS fetch are retried, as the stock action retries them. Every git
|
|
4109
|
+
* step runs under a 30 minute ceiling: a checkout after a partial-clone
|
|
4110
|
+
* fetch, an LFS smudge or a clean of a big tree can take as long as a fetch.
|
|
4111
|
+
*
|
|
4112
|
+
* The credentials' lifetime is `options.credentials`: `"job"` saves what
|
|
4113
|
+
* was written under `stateKey` before any fetch, for {@link Checkout.cleanup}
|
|
4114
|
+
* in the post step, refusing a second `"job"` checkout of another path
|
|
4115
|
+
* under a key already in use; `"action"` removes it when the enclosing `Scope`
|
|
4116
|
+
* closes, on success, failure or interruption; `"none"` removes it before
|
|
4117
|
+
* this returns. The temporary global config holding `safe.directory` is
|
|
4118
|
+
* discarded when this returns, whatever the lifetime.
|
|
4119
|
+
*
|
|
4120
|
+
* The log is one phase, `Checkout <owner>/<name> @ <ref>`, with one step
|
|
4121
|
+
* per phase of work; each step's detail is the git transcript. The
|
|
4122
|
+
* repository's object format and default branch come from the GitHub API
|
|
4123
|
+
* (the default branch from the remote's `HEAD` instead for an SSH key or a
|
|
4124
|
+
* `remoteUrl`), as the stock action asks it: through a client built from the checkout's
|
|
4125
|
+
* own token against its own server's API base (`<origin>/api/v3` for a GitHub
|
|
4126
|
+
* Enterprise Server `serverUrl`). An ambient `GitHubClient` is used only when
|
|
4127
|
+
* the checkout has no token, an `Ssh` auth without one. A failed default
|
|
4128
|
+
* branch lookup is {@link CheckoutDefaultBranchError}, its `detail` the reason.
|
|
4129
|
+
*/
|
|
4130
|
+
static readonly checkout: (options: CheckoutOptions) => Effect.Effect<CheckoutResult, CheckoutError | GitCommandError | NotARepositoryError | UnknownRefError | ActionStateError | ActionEnvironmentError | PlatformError.PlatformError, Scope.Scope | Git | FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner | SecureRandom.SecureRandom | ActionEnvironment | ActionOutputs | ActionState | ActionLogger>;
|
|
4131
|
+
/**
|
|
4132
|
+
* Runs the post-step cleanup of a `"job"` checkout: reads the record saved
|
|
4133
|
+
* under `stateKey` and removes everything the checkout wrote.
|
|
4134
|
+
*
|
|
4135
|
+
* @remarks
|
|
4136
|
+
* No saved record is a no-op. Removal covers the credentials file, the SSH
|
|
4137
|
+
* files, `includeIf`, the extraheader, `core.sshCommand` and the submodules'
|
|
4138
|
+
* `insteadOf`, with `safe.directory` handled for the repository as the stock
|
|
4139
|
+
* post step does. It never fails: every failure, an unreadable record
|
|
4140
|
+
* included, becomes a warning, so a post step cannot turn a green job red.
|
|
4141
|
+
* It is uninterruptible, so a cancelled job cannot leave credentials behind.
|
|
4142
|
+
*/
|
|
4143
|
+
static readonly cleanup: (options?: {
|
|
4144
|
+
readonly stateKey?: string;
|
|
4145
|
+
}) => Effect.Effect<void, never, Git | FileSystem.FileSystem | Path.Path | ChildProcessSpawner.ChildProcessSpawner | SecureRandom.SecureRandom | ActionEnvironment | ActionState | ActionLogger>;
|
|
4146
|
+
/**
|
|
4147
|
+
* Reads {@link CheckoutOptions} from the action's inputs, on the stock
|
|
4148
|
+
* checkout action's input surface, so an action can expose a
|
|
4149
|
+
* checkout-compatible interface unchanged.
|
|
4150
|
+
*
|
|
4151
|
+
* @remarks
|
|
4152
|
+
* Reads `repository`, `ref`, `token`, `ssh-key`, `ssh-known-hosts`,
|
|
4153
|
+
* `ssh-strict`, `ssh-user`, `persist-credentials`, `path`, `clean`, `filter`,
|
|
4154
|
+
* `sparse-checkout`, `sparse-checkout-cone-mode`, `fetch-depth`,
|
|
4155
|
+
* `fetch-tags`, `show-progress` (read and ignored), `lfs`, `submodules`,
|
|
4156
|
+
* `set-safe-directory`, `github-server-url` and `allow-unsafe-pr-checkout`,
|
|
4157
|
+
* each as `<prefix><name>` when a prefix is given. `token` is required; a
|
|
4158
|
+
* present `ssh-key` makes the auth `Ssh`, carrying the token for the API
|
|
4159
|
+
* calls.
|
|
4160
|
+
*
|
|
4161
|
+
* `persist-credentials` true is `"job"` and false `"none"`; `fetch-depth` at
|
|
4162
|
+
* or below zero, or not a number, is `"full"`; `submodules` is `recursive`,
|
|
4163
|
+
* `true` or else false. Every boolean reads as the stock action reads it:
|
|
4164
|
+
* true only for a case-insensitive `true`, false for any other value, and
|
|
4165
|
+
* an absent or empty input takes the stock action's in-code default, which
|
|
4166
|
+
* for `persist-credentials` is false, not the manifest's `true` (on a
|
|
4167
|
+
* runner an unsupplied input arrives as the manifest default, so only an
|
|
4168
|
+
* explicit empty value meets the in-code one). `ref` is trimmed of ASCII
|
|
4169
|
+
* whitespace only, so a leading BOM or NBSP survives as part of a `Ref`:
|
|
4170
|
+
* empty is `Event` for the workflow's own repository and `Default`
|
|
4171
|
+
* otherwise, a bare 40 or 64 hex value is a `Commit`, anything else a `Ref`.
|
|
4172
|
+
*
|
|
4173
|
+
* The `path` is not validated here; {@link Checkout.checkout} refuses one
|
|
4174
|
+
* that leaves the workspace.
|
|
4175
|
+
*/
|
|
4176
|
+
static readonly fromInputs: (options?: {
|
|
4177
|
+
readonly prefix?: string;
|
|
4178
|
+
}) => Effect.Effect<CheckoutOptions, Config.ConfigError | ActionEnvironmentError, ActionEnvironment>;
|
|
4179
|
+
/**
|
|
4180
|
+
* Declares the action inputs {@link Checkout.fromInputs} reads, with the
|
|
4181
|
+
* stock checkout action's descriptions and defaults, for an author to merge
|
|
4182
|
+
* into `action.yml`.
|
|
4183
|
+
*/
|
|
4184
|
+
static readonly inputs: (options?: {
|
|
4185
|
+
readonly prefix?: string;
|
|
4186
|
+
}) => Readonly<Record<string, ActionManifestInput>>;
|
|
4187
|
+
/** Publishes a {@link CheckoutResult}'s `ref` and `commit` as step outputs. */
|
|
4188
|
+
static readonly writeOutputs: (result: CheckoutResult, options?: {
|
|
4189
|
+
readonly prefix?: string;
|
|
4190
|
+
}) => Effect.Effect<void, ActionOutputError, ActionOutputs>;
|
|
4191
|
+
}
|
|
3726
4192
|
/**
|
|
3727
4193
|
* The kit's check-state vocabulary.
|
|
3728
4194
|
*
|
|
@@ -5765,5 +6231,5 @@ export declare class Secret {
|
|
|
5765
6231
|
*/
|
|
5766
6232
|
static readonly adopt: (name: string) => Config.Config<Redacted.Redacted<string>>;
|
|
5767
6233
|
}
|
|
5768
|
-
export { type ActionCacheShape, type ActionEnvironmentShape, type ActionInputRecording, type ActionLoggerShape, type ActionManifestError, type ActionManifestRuns, type ActionManifestUsage, type ActionOutputError, type ActionOutputsShape, type ActionRunOptions, type ActionServices, type ActionStateShape, type AnnotationProperties, type ArtifactItem, type ArtifactRef, type ArtifactShape, type BlobEnvelopeError, type BlobStoreShape, type CacheKeyError, type CheckDocumentOptions, type CheckDocumentShape, type CheckDocumentSink, type CheckFlushOutcome, type CheckRunConclusion, type CheckRunProjection, type ClientLayerOptions, type DataBlobTransfer, type DetachedProcessError, type DetachedProcessOps, type DetachedSpawnOptions, type DownloadOptions, type DownloadResult, type DryRunShape, type ExtractOptions, type FileBlobTransfer, type GitHubHeadingDepth, type GitHubListOptions, type GitHubRowSchema, type GitHubSchemaTable, type GitHubSchemaTableColumn, type GitHubSchemaTableColumns, type GitHubSchemaTableFormatRequiredKeys, type GitHubSchemaTableFormattedColumn, type GitHubSchemaTableOptions, type ManagedDocumentSource, type OidcTokenIssuerShape, type PackageManagerInstallOptions, type PackageManagerInstallerShape, type PairsOptions, type PathPrependEnv, type PathPrependOptions, type ProvisionFileOptions, type ProvisionOptions, type ProvisionedFile, type ReadOptions, type ReadinessOptions, type RecordedOutputMember, type RecordingOidcTokenIssuer, type RecordingOutputs, type S3Config, type
|
|
6234
|
+
export { type ActionCacheShape, type ActionEnvironmentShape, type ActionInputRecording, type ActionLoggerShape, type ActionManifestError, type ActionManifestRuns, type ActionManifestUsage, type ActionOutputError, type ActionOutputsShape, type ActionRunOptions, type ActionServices, type ActionStateShape, type AnnotationProperties, type ArtifactItem, type ArtifactRef, type ArtifactShape, type BlobEnvelopeError, type BlobStoreShape, type CacheKeyError, type CheckDocumentOptions, type CheckDocumentShape, type CheckDocumentSink, type CheckFlushOutcome, type CheckRunConclusion, type CheckRunProjection, type CheckoutError, type CheckoutOptions, type ClientLayerOptions, type DataBlobTransfer, type DetachedProcessError, type DetachedProcessOps, type DetachedSpawnOptions, type DownloadOptions, type DownloadResult, type DryRunShape, type ExtractOptions, type FileBlobTransfer, type GitHubHeadingDepth, type GitHubListOptions, type GitHubRowSchema, type GitHubSchemaTable, type GitHubSchemaTableColumn, type GitHubSchemaTableColumns, type GitHubSchemaTableFormatRequiredKeys, type GitHubSchemaTableFormattedColumn, type GitHubSchemaTableOptions, type ManagedDocumentSource, type OidcTokenIssuerShape, type PackageManagerInstallOptions, type PackageManagerInstallerShape, type PairsOptions, type PathPrependEnv, type PathPrependOptions, type ProvisionFileOptions, type ProvisionOptions, type ProvisionedFile, type ReadOptions, type ReadinessOptions, type RecordedOutputMember, type RecordingOidcTokenIssuer, type RecordingOutputs, type S3Config, type StepLogEntry, type StepOptions, type StoredBlob, type ToolDownloadOptions, type ToolInstallerShape, type UploadOptions, type UploadResult, WorkflowCommand };
|
|
5769
6235
|
//# sourceMappingURL=index.d.ts.map
|