@effected/github-actions 0.18.1 → 0.19.1

package/Action.js

@@ -5,7 +5,7 @@ import { ActionLogger } from "./ActionLogger.js";
 import { ActionOutputs } from "./ActionOutputs.js";
 import { ActionState } from "./ActionState.js";
 import { NodeServices } from "@effect/platform-node";
-import { Cause, Effect, Exit, Layer, Option, Result } from "effect";
+import { Cause, Effect, Exit, Layer, LogLevel, Option, References, Result } from "effect";
 import { FetchHttpClient } from "effect/http";
 
 //#region src/Action.ts
@@ -40,6 +40,15 @@ var ActionRuntime = class {
 	static layer = Layer.mergeAll(ActionLogger.layer, ActionLogger.layerLogger, ActionState.layer, ActionInput.layerDefault).pipe(Layer.provideMerge(ActionOutputs.layer), Layer.provideMerge(ActionEnvironment.layer), Layer.provideMerge(Layer.mergeAll(NodeServices.layer, FetchHttpClient.layer)));
 };
 /**
+* Lower the minimum log level to `Debug` for the program when the runner has
+* step debugging on — and never raise it.
+*/
+const withStepDebugLogLevel = (program) => Effect.gen(function* () {
+	const stepDebug = yield* (yield* ActionEnvironment).isDebug;
+	const minimum = yield* References.MinimumLogLevel;
+	return yield* stepDebug && LogLevel.isGreaterThan(minimum, "Debug") ? Effect.provideService(program, References.MinimumLogLevel, "Debug") : program;
+});
+/**
 * A readable one-line summary of why an action failed.
 *
 * @remarks
@@ -80,6 +89,14 @@ const describeError = (error) => {
 * reports a failure and then recovers is not doomed by a side effect it cannot
 * undo.
 *
+* It also honours **step debugging**: when the runner sets `RUNNER_DEBUG=1`, it
+* lowers core's `References.MinimumLogLevel` from its `Info` default to
+* `Debug`, so `Effect.logDebug` anywhere in the program — or in any
+* `@effected` library it calls — reaches the runner as a `::debug::` line
+* rather than being filtered before a logger sees it. It only ever lowers the
+* level, and `{ stepDebugLogLevel: false }` ({@link ActionRunOptions}) opts
+* out.
+*
 * Two things it deliberately does **not** do:
 *
 * - **It does not wrap the program in a log buffer.** The package this replaces
@@ -122,7 +139,7 @@ var Action = class {
 	static run = (program, options = {}) => {
 		const extra = options.layer;
 		const composed = extra === void 0 ? ActionRuntime.layer : Layer.mergeAll(ActionRuntime.layer, Layer.provide(extra, ActionRuntime.layer));
-		const runnable = program.pipe(Effect.provide(composed), Effect.exit, Effect.flatMap((exit) => Exit.isSuccess(exit) ? Effect.void : Effect.sync(() => {
+		const runnable = (options.stepDebugLogLevel === false ? program : withStepDebugLogLevel(program)).pipe(Effect.provide(composed), Effect.exit, Effect.flatMap((exit) => Exit.isSuccess(exit) ? Effect.void : Effect.sync(() => {
 			const detail = Cause.pretty(exit.cause);
 			if (detail.trim() !== "") console.log(WorkflowCommand.render("debug", {}, detail));
 			console.log(WorkflowCommand.render("error", {}, `Action failed: ${describeCause(exit.cause)}`));

package/README.md

@@ -59,6 +59,8 @@ await Action.run(program);
 
 `Action.run` provides `ActionServices` (environment, logger, outputs, state, the Node platform and an `HttpClient`) by default. A capability with a heavier dependency — the cache, artifacts, the blob store — is one extra line: `Action.run(program, { layer: ActionCache.layer })`.
 
+Step debugging works without wiring: when the runner sets `RUNNER_DEBUG=1`, `Action.run` lowers Effect's minimum log level to `Debug`, so `Effect.logDebug` calls show up as `::debug::` lines. It only ever lowers the level; pass `{ stepDebugLogLevel: false }` to keep it as it is.
+
 ## Reading inputs
 
 Every accessor shares one absence rule: the runner writes `""` for an input the workflow omitted, and this package reads that the same as unset — **missing data**, not an empty value. An optional input needs `Config.withDefault` (or `Config.option`) at the call site:

package/index.d.ts

@@ -378,7 +378,10 @@ interface ActionLoggerShape {
    * the ambient minimum log level is already `Debug` or lower — someone asking
    * for verbose output wants it live, and that overrides
    * `onSuccess: "discard"` too: asking for debug output means wanting to see
-   * what a green step did.
+   * what a green step did. Under `Action.run` the two conditions coincide,
+   * because step debugging is what lowers the ambient level to `Debug`; the
+   * step-debug check still stands on its own for a program that opted out
+   * with `stepDebugLogLevel: false` or runs outside `Action.run`.
    */
   readonly withBuffer: <A, E, R>(label: string, effect: Effect.Effect<A, E, R>, options?: WithBufferOptions) => Effect.Effect<A, E, R>;
   /**
@@ -898,6 +901,24 @@ interface ActionRunOptions<R> {
    * what makes `{ layer: ActionCache.layer }` compile with no further wiring.
    */
   readonly layer?: Layer.Layer<R, never, ActionServices> | undefined;
+  /**
+   * Whether step debugging lowers the minimum log level to `Debug`.
+   *
+   * @remarks
+   * Defaults to `true`. With step debugging on (`RUNNER_DEBUG=1`, read through
+   * {@link ActionEnvironmentShape.isDebug}), `Action.run` lowers core's
+   * `References.MinimumLogLevel` — `Info` by default — to `Debug` for the whole
+   * program, so `Effect.logDebug` calls reach the runner as `::debug::` lines
+   * instead of being filtered before any logger sees them. It only ever
+   * **lowers**: a level already at `Debug` or below, from the `layer` option,
+   * is left alone.
+   *
+   * Pass `false` to keep the ambient level regardless of step debugging — an
+   * action whose debug output is too heavy to show even to someone who asked
+   * for it. A program can still provide its own `MinimumLogLevel` either way;
+   * the innermost provision wins.
+   */
+  readonly stepDebugLogLevel?: boolean | undefined;
 }
 /**
  * A readable one-line summary of why an action failed.
@@ -924,6 +945,14 @@ export declare const describeCause: (cause: Cause.Cause<unknown>) => string;
  * reports a failure and then recovers is not doomed by a side effect it cannot
  * undo.
  *
+ * It also honours **step debugging**: when the runner sets `RUNNER_DEBUG=1`, it
+ * lowers core's `References.MinimumLogLevel` from its `Info` default to
+ * `Debug`, so `Effect.logDebug` anywhere in the program — or in any
+ * `@effected` library it calls — reaches the runner as a `::debug::` line
+ * rather than being filtered before a logger sees it. It only ever lowers the
+ * level, and `{ stepDebugLogLevel: false }` ({@link ActionRunOptions}) opts
+ * out.
+ *
  * Two things it deliberately does **not** do:
  *
  * - **It does not wrap the program in a log buffer.** The package this replaces

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/github-actions",
-	"version": "0.18.1",
+	"version": "0.19.1",
 	"private": false,
 	"description": "The GitHub Actions runtime: env, inputs, outputs, state, logging, cache, artifacts, blob storage, OIDC and the token bridge.",
 	"keywords": [
@@ -46,7 +46,7 @@
 		"@effected/sbom": "^0.9.1",
 		"@effected/semver": "^0.10.1",
 		"@effected/templates": "^0.9.1",
-		"@effected/walker": "^0.13.0"
+		"@effected/walker": "^0.14.0"
 	},
 	"peerDependencies": {
 		"@effect/platform-node": "4.0.0-rc.118",