fix: preserve validation initialization and ordinary input failures

Author: taras

packages/cli/src/repl/elicitation.ts

@@ -59,7 +59,7 @@ export interface ReplFieldConstraint {
 
 /** One field the form presents, in the order the schema declared it. */
 export interface ReplFormField extends ReplFieldConstraint {
-  readonly secret: boolean;
+  readonly secret?: boolean;
   /** The schema's own label for it, when it wrote one. */
   readonly title: string | undefined;
   readonly description: string | undefined;
@@ -421,7 +421,7 @@ export function readQuestionForm(schema: Json): ReplQuestionForm {
         choices: choicesOf(field, path),
         minLength: minLengthOf(field, path),
         required: required.includes(name),
-        secret: field.writeOnly === true,
+        ...(field.writeOnly === true ? { secret: true } : {}),
       }),
     );
   }

packages/cli/tests/protected-input-forms.test.ts

@@ -28,7 +28,8 @@ describe("protected local forms", () => {
     if (question === undefined) {
       throw new Error("No active question.");
     }
-    expect(question.form.fields.map((field) => field.secret)).toEqual([true, false]);
+    expect(question.form.fields.map((field) => field.secret === true)).toEqual([true, false]);
+    expect(Object.hasOwn(question.form.fields[1], "secret")).toBe(false);
     const value = String(Math.floor(100000 + Math.random() * 900000));
     const invalid = question.submit({ code: value.slice(0, 2), public: "useful" });
     expect(invalid.kind).toBe("invalid");

packages/core/src/expand.ts

@@ -1,4 +1,4 @@
-import { inputValues } from "./secrets/inputs.ts";
+import { inputValues, validateLiveReturnValue } from "./secrets/inputs.ts";
 import type { ProtectedInput } from "./secrets/inputs.ts";
 /**
  * Expansion engine (spec §5).
@@ -147,12 +147,7 @@ import {
 } from "@executablemd/durable-streams";
 import type { DurablePosition, Workflow } from "@executablemd/durable-streams";
 import { SourceOwner } from "./source-owner.ts";
-import {
-  SchemaValidationError,
-  validateProps,
-  validateReturnValue,
-  validateLiveReturnValue,
-} from "./validate.ts";
+import { SchemaValidationError, validateProps, validateReturnValue } from "./validate.ts";
 import { isJsonObject, parseJson } from "./json.ts";
 import { healSegment } from "./heal.ts";
 import { scanSegments, splitTextFences } from "./scanner.ts";

packages/core/src/secrets/inputs.ts

@@ -1,4 +1,9 @@
-import { compileReturnsSchema, ReturnValidationError, normalizeIssues } from "../validate.ts";
+import {
+  compileReturnsSchema,
+  ReturnValidationError,
+  normalizeIssues,
+  validateReturnValue,
+} from "../validate.ts";
 import type { ReturnsSchema } from "../types.ts";
 import { createContext, Err, Ok, ensure } from "effection";
 import type { Operation, Result } from "effection";
@@ -193,7 +198,7 @@ export function* createInputOwner(
       known.add(value);
       candidates = [...known]
         .filter((entered) => entered.length > 0)
-        .toSorted((left, right) => right.length - left.length);
+        .sort((left, right) => right.length - left.length);
       return leaf;
     },
     record: (value) => attempt(() => encode(value)),
@@ -361,3 +366,15 @@ export function inspectInputOwner(owner: SecretInputOwner): InputValues {
   }
   return inspect(false);
 }
+
+export function* validateLiveReturnValue(
+  name: string,
+  value: unknown,
+  schema: ReturnsSchema,
+): Operation<unknown> {
+  const inputs = yield* inputValues();
+  if (inputs?.contains(value)) {
+    return yield* inputs.validate(value, name, schema);
+  }
+  return yield* validateReturnValue(name, value, schema);
+}

packages/core/src/secrets/policy.ts

@@ -253,7 +253,12 @@ export function* clearsLiveOutput(content: string): Operation<boolean> {
   }
 }
 
-function projectInputEvent(event: DurableEvent, inputs: InputValues): DurableEvent {
+function projectInputEvent(received: DurableEvent, inputs: InputValues): DurableEvent {
+  const serialized = parseDurableEvent(serializeDurableEvent(received));
+  if (!serialized.ok) {
+    throw serialized.error;
+  }
+  const event = serialized.value;
   const project = (value: unknown) => {
     const safe = inputs.display(value);
     if (!safe.ok) {

packages/core/src/validate.ts

@@ -1,4 +1,3 @@
-import { inputValues } from "./secrets/inputs.ts";
 import { Ajv } from "ajv";
 import type { ErrorObject, ValidateFunction } from "ajv";
 import { createContext } from "effection";
@@ -316,15 +315,3 @@ function preciseInstancePath(issue: NormalizedIssue): string {
 function escapePointerToken(token: string): string {
   return token.replace(/~/g, "~0").replace(/\//g, "~1");
 }
-
-export function* validateLiveReturnValue(
-  name: string,
-  value: unknown,
-  schema: ReturnsSchema,
-): Operation<unknown> {
-  const inputs = yield* inputValues();
-  if (inputs?.contains(value)) {
-    return yield* inputs.validate(value, name, schema);
-  }
-  return yield* validateReturnValue(name, value, schema);
-}

packages/core/tests/protected-input.test.ts

@@ -784,3 +784,33 @@ describe("the private process result boundary", () => {
     expect(safe).toBe(true);
   });
 });
+
+import { useSecretDetection } from "../src/secrets/policy.ts";
+
+describe("serialized failure projection", () => {
+  it("projects the actual journal representation when optional error fields are undefined", function* () {
+    const inputs = yield* attachInputOwner(yield* createInputOwner());
+    const entered = String(Math.floor(100000 + Math.random() * 900000));
+    inputs.protect({ coroutine: "root", index: 0, field: "code" }, entered);
+    const stream = new InMemoryStream();
+    const detection = yield* useSecretDetection(undefined, stream, inputs);
+    yield* detection.journal.append({
+      type: "yield",
+      coroutineId: "root",
+      description: { type: "failure-probe", name: "failure-probe" },
+      result: { status: "err", error: { message: entered, name: undefined, stack: undefined } },
+    });
+    const event = stream.snapshot()[0];
+    expect(
+      event.type === "yield" &&
+        event.result.status === "err" &&
+        event.result.error.message === "[redacted]",
+    ).toBe(true);
+    expect(
+      event.result.status === "err" &&
+        !Object.hasOwn(event.result.error, "stack") &&
+        !Object.hasOwn(event.result.error, "name"),
+    ).toBe(true);
+    expect(JSON.stringify(stream.snapshot()).includes(entered)).toBe(false);
+  });
+});