Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
[codex] Structure client VCS action errors (#3263)
Julius Marmingeff0f702c7cb5
diff --git a/apps/web/src/state/sourceControlActions.ts b/apps/web/src/state/sourceControlActions.tsindex 3f532739f..297ae5717 100644--- a/apps/web/src/state/sourceControlActions.ts+++ b/apps/web/src/state/sourceControlActions.ts@@ -126,12 +126,6 @@ function resolveScope(scope: SourceControlActionScope) {};}-function unavailableResult(message: string) {- return AsyncResult.failure<never, VcsActionUnavailableError>(- Cause.fail(new VcsActionUnavailableError({ message })),- );-}-export function useSourceControlActionRunning(scope: SourceControlActionScope,kinds: ReadonlyArray<SourceControlActionKind>,@@ -149,7 +143,15 @@ export function useVcsInitAction(scope: SourceControlActionScope) {const action = useCallback(async () => {const target = resolveScope(scope);if (target === null) {- return unavailableResult("Git init is unavailable.");+ return AsyncResult.failure<never, VcsActionUnavailableError>(+ Cause.fail(+ new VcsActionUnavailableError({+ operation: "init",+ environmentId: scope.environmentId,+ cwd: scope.cwd,+ }),+ ),+ );}return init({environmentId: target.environmentId,@@ -172,7 +174,15 @@ export function useVcsPullAction(scope: SourceControlActionScope) {const action = useCallback(async () => {const target = resolveScope(scope);if (target === null) {- return unavailableResult("Git pull is unavailable.");+ return AsyncResult.failure<never, VcsActionUnavailableError>(+ Cause.fail(+ new VcsActionUnavailableError({+ operation: "pull",+ environmentId: scope.environmentId,+ cwd: scope.cwd,+ }),+ ),+ );}return pull({environmentId: target.environmentId,@@ -211,7 +221,15 @@ export function useGitStackedAction(scope: SourceControlActionScope) {onProgress?: (event: GitActionProgressEvent) => void;}) => {if (resolveScope(scope) === null) {- return unavailableResult("Git action is unavailable.");+ return AsyncResult.failure<never, VcsActionUnavailableError>(+ Cause.fail(+ new VcsActionUnavailableError({+ operation: "run_change_request",+ environmentId: scope.environmentId,+ cwd: scope.cwd,+ }),+ ),+ );}return runStackedAction({actionId: input.actionId,@@ -257,7 +275,15 @@ export function useSourceControlPublishRepositoryAction(scope: SourceControlActi}) => {const target = resolveScope(scope);if (target === null) {- return unavailableResult("Repository publishing is unavailable.");+ return AsyncResult.failure<never, VcsActionUnavailableError>(+ Cause.fail(+ new VcsActionUnavailableError({+ operation: "publish_repository",+ environmentId: scope.environmentId,+ cwd: scope.cwd,+ }),+ ),+ );}return publishRepository({environmentId: target.environmentId,@@ -286,7 +312,15 @@ export function usePreparePullRequestThreadAction(scope: SourceControlActionScopasync (input: { reference: string; mode: "local" | "worktree"; threadId?: ThreadId }) => {const target = resolveScope(scope);if (target === null) {- return unavailableResult("Pull request thread preparation is unavailable.");+ return AsyncResult.failure<never, VcsActionUnavailableError>(+ Cause.fail(+ new VcsActionUnavailableError({+ operation: "prepare_pull_request_thread",+ environmentId: scope.environmentId,+ cwd: scope.cwd,+ }),+ ),+ );}return preparePullRequestThread({environmentId: target.environmentId,diff --git a/packages/client-runtime/src/state/vcsAction.test.ts b/packages/client-runtime/src/state/vcsAction.test.tsindex b2ac95073..7e618535a 100644--- a/packages/client-runtime/src/state/vcsAction.test.ts+++ b/packages/client-runtime/src/state/vcsAction.test.ts@@ -7,6 +7,7 @@ import { describe, expect, it } from "@effect/vitest";import * as Cause from "effect/Cause";import * as Effect from "effect/Effect";import * as Layer from "effect/Layer";+import * as Schema from "effect/Schema";import * as Stream from "effect/Stream";import { AsyncResult, Atom, AtomRegistry } from "effect/unstable/reactivity";@@ -21,12 +22,18 @@ import {EMPTY_VCS_ACTION_STATE,getVcsActionTargetKey,normalizeVcsActionProgressEvent,+ parseVcsActionTargetKey,+ VcsActionMissingTerminalEventError,+ VcsActionRemoteFailureError,+ VcsActionTargetKeyParseError,+ VcsActionUnavailableError,} from "./vcsAction.ts";const actionId = "action-123";const action = "commit_push" as const;const cwd = "/repo";const environmentId = EnvironmentId.make("environment-1");+const isVcsActionUnavailableError = Schema.is(VcsActionUnavailableError);const result: GitRunStackedActionResult = {action,branch: {@@ -57,6 +64,28 @@ function progress<T extends GitActionProgressEvent>(event: T): T {}describe("vcsActionState", () => {+ it("preserves malformed target key diagnostics and the native cause without copying the key", () => {+ const key = "not-json-with-credential=do-not-log";+ let error: unknown;++ try {+ parseVcsActionTargetKey(key);+ } catch (cause) {+ error = cause;+ }++ expect(error).toBeInstanceOf(VcsActionTargetKeyParseError);+ expect(error).toMatchObject({ keyLength: key.length, cause: expect.any(SyntaxError) });+ expect(error).not.toHaveProperty("key");+ expect((error as Error).message).not.toContain(key);+ });++ it("rejects invalid target key shapes", () => {+ const key = JSON.stringify([environmentId]);++ expect(() => parseVcsActionTargetKey(key)).toThrowError(VcsActionTargetKeyParseError);+ });+it("projects phase and hook progress without owning the async operation", () => {const initial = beginVcsActionState({operation: "run_change_request",@@ -254,6 +283,7 @@ describe("vcsActionState", () => {target,transportActionId,actionId,+ action,onProgress: (event) =>Effect.sync(() => {observed.push(event);@@ -266,6 +296,85 @@ describe("vcsActionState", () => {}),);+ it.effect("retains structural remote failure context without copying the remote payload", () =>+ Effect.gen(function* () {+ const target = { environmentId, cwd };+ const transportActionId = createVcsActionTransportId(target, actionId);+ const remoteMessage = "The remote rejected the push with credential=do-not-log.";+ const error = yield* consumeVcsActionProgress(+ Stream.fromIterable<GitActionProgressEvent>([+ {+ actionId: transportActionId,+ action,+ cwd,+ kind: "action_failed",+ phase: "push",+ message: remoteMessage,+ },+ ]),+ {+ target,+ transportActionId,+ actionId,+ action,+ onProgress: () => Effect.void,+ },+ ).pipe(Effect.flip);++ expect(error).toBeInstanceOf(VcsActionRemoteFailureError);+ expect(error).toMatchObject({+ actionId,+ transportActionId,+ action,+ environmentId,+ cwd,+ phase: "push",+ remoteMessageLength: remoteMessage.length,+ });+ expect(error).not.toHaveProperty("detail");+ expect(error.message).toBe("Source control action 'commit_push' failed during push.");+ expect(error.message).not.toContain(remoteMessage);+ }),+ );++ it.effect("reports a missing terminal event as a protocol failure", () =>+ Effect.gen(function* () {+ const target = { environmentId, cwd };+ const transportActionId = createVcsActionTransportId(target, actionId);+ const error = yield* consumeVcsActionProgress(+ Stream.fromIterable<GitActionProgressEvent>([+ {+ actionId: transportActionId,+ action,+ cwd,+ kind: "phase_started",+ phase: "commit",+ label: "Committing...",+ },+ ]),+ {+ target,+ transportActionId,+ actionId,+ action,+ onProgress: () => Effect.void,+ },+ ).pipe(Effect.flip);++ expect(error).toBeInstanceOf(VcsActionMissingTerminalEventError);+ expect(error).toMatchObject({+ actionId,+ transportActionId,+ action,+ environmentId,+ cwd,+ });+ expect(error.message).toBe(+ "Source control action 'commit_push' ended without a terminal result.",+ );+ }),+ );+it("keys mutation ownership by environment and cwd", () => {const runtime = Atom.runtime(Layer.empty) as unknown as Atom.AtomRuntime<EnvironmentRegistry,@@ -286,6 +395,38 @@ describe("vcsActionState", () => {registry.dispose();});+ it("retains the incomplete target and operation when tracking is unavailable", async () => {+ const runtime = Atom.runtime(Layer.empty) as unknown as Atom.AtomRuntime<+ EnvironmentRegistry,+ never+ >;+ const manager = createVcsActionManager(runtime);+ const registry = AtomRegistry.make();+ const result = await manager.track(+ registry,+ { environmentId, cwd: null },+ { operation: "pull", label: "Pulling latest changes" },+ async () => AsyncResult.success(undefined),+ );++ expect(AsyncResult.isFailure(result)).toBe(true);+ if (AsyncResult.isFailure(result)) {+ const error = Cause.squash(result.cause);+ expect(error).toBeInstanceOf(VcsActionUnavailableError);+ if (!isVcsActionUnavailableError(error)) {+ throw error;+ }+ expect(error).toMatchObject({+ operation: "pull",+ environmentId,+ cwd: null,+ });+ expect(error.message).toBe("Source control operation 'pull' is unavailable.");+ }++ registry.dispose();+ });+it("tracks finite mutations without letting an older completion clear newer state", async () => {const runtime = Atom.runtime(Layer.empty) as unknown as Atom.AtomRuntime<EnvironmentRegistry,diff --git a/packages/client-runtime/src/state/vcsAction.ts b/packages/client-runtime/src/state/vcsAction.tsindex b06f5ac65..8ae3219a2 100644--- a/packages/client-runtime/src/state/vcsAction.ts+++ b/packages/client-runtime/src/state/vcsAction.ts@@ -1,10 +1,11 @@import {EnvironmentId,type EnvironmentId as EnvironmentIdType,+ GitActionProgressPhase,type GitActionProgressEvent,type GitRunStackedActionInput,type GitRunStackedActionResult,- type GitStackedAction,+ GitStackedAction,WS_METHODS,} from "@t3tools/contracts";import * as Cause from "effect/Cause";@@ -24,16 +25,18 @@ import {} from "./runtime.ts";import { vcsCommandScheduler } from "./vcsCommandScheduler.ts";-export type VcsActionOperation =- | "refresh_status"- | "run_change_request"- | "pull"- | "switch_ref"- | "create_ref"- | "create_worktree"- | "init"- | "publish_repository"- | "prepare_pull_request_thread";+export const VcsActionOperation = Schema.Literals([+ "refresh_status",+ "run_change_request",+ "pull",+ "switch_ref",+ "create_ref",+ "create_worktree",+ "init",+ "publish_repository",+ "prepare_pull_request_thread",+]);+export type VcsActionOperation = typeof VcsActionOperation.Type;export interface VcsActionState {readonly isRunning: boolean;@@ -77,16 +80,66 @@ export interface RunVcsStackedActionInput {export class VcsActionUnavailableError extends Schema.TaggedErrorClass<VcsActionUnavailableError>()("VcsActionUnavailableError",{- message: Schema.String,+ operation: VcsActionOperation,+ environmentId: Schema.NullOr(EnvironmentId),+ cwd: Schema.NullOr(Schema.String),},-) {}+) {+ override get message(): string {+ return `Source control operation '${this.operation.replaceAll("_", " ")}' is unavailable.`;+ }+}++export class VcsActionRemoteFailureError extends Schema.TaggedErrorClass<VcsActionRemoteFailureError>()(+ "VcsActionRemoteFailureError",+ {+ actionId: Schema.String,+ transportActionId: Schema.String,+ action: GitStackedAction,+ environmentId: EnvironmentId,+ cwd: Schema.String,+ phase: Schema.NullOr(GitActionProgressPhase),+ remoteMessageLength: Schema.Number,+ },+) {+ override get message(): string {+ const phase = this.phase === null ? "execution" : this.phase;+ return `Source control action '${this.action}' failed during ${phase}.`;+ }+}-export class VcsActionExecutionError extends Schema.TaggedErrorClass<VcsActionExecutionError>()(- "VcsActionExecutionError",+export class VcsActionMissingTerminalEventError extends Schema.TaggedErrorClass<VcsActionMissingTerminalEventError>()(+ "VcsActionMissingTerminalEventError",{- message: Schema.String,+ actionId: Schema.String,+ transportActionId: Schema.String,+ action: GitStackedAction,+ environmentId: EnvironmentId,+ cwd: Schema.String,},-) {}+) {+ override get message(): string {+ return `Source control action '${this.action}' ended without a terminal result.`;+ }+}++export class VcsActionTargetKeyParseError extends Schema.TaggedErrorClass<VcsActionTargetKeyParseError>()(+ "VcsActionTargetKeyParseError",+ {+ keyLength: Schema.Number,+ cause: Schema.Defect(),+ },+) {+ override get message(): string {+ return `Invalid source control action target key (${this.keyLength} characters).`;+ }+}++export const VcsActionExecutionError = Schema.Union([+ VcsActionRemoteFailureError,+ VcsActionMissingTerminalEventError,+]);+export type VcsActionExecutionError = typeof VcsActionExecutionError.Type;export const EMPTY_VCS_ACTION_STATE = Object.freeze<VcsActionState>({isRunning: false,@@ -104,6 +157,9 @@ export const EMPTY_VCS_ACTION_STATE = Object.freeze<VcsActionState>({const nowMs = (): number => DateTime.toEpochMillis(DateTime.nowUnsafe());let nextLocalActionId = 0;+const decodeVcsActionTargetKey = Schema.decodeUnknownSync(+ Schema.Tuple([EnvironmentId, Schema.String]),+);export const vcsActionStateAtom = Atom.family((key: string) => {return Atom.make(EMPTY_VCS_ACTION_STATE).pipe(@@ -124,12 +180,13 @@ export function getVcsActionTargetKey(target: VcsActionTarget): string | null {return JSON.stringify([target.environmentId, target.cwd]);}-function parseVcsActionTargetKey(key: string): ResolvedVcsActionTarget {- const [environmentId, cwd] = JSON.parse(key) as [string, string];- return {- environmentId: EnvironmentId.make(environmentId),- cwd,- };+export function parseVcsActionTargetKey(key: string): ResolvedVcsActionTarget {+ try {+ const [environmentId, cwd] = decodeVcsActionTargetKey(JSON.parse(key));+ return { environmentId, cwd };+ } catch (cause) {+ throw new VcsActionTargetKeyParseError({ keyLength: key.length, cause });+ }}export function getVcsActionStateAtom(target: VcsActionTarget) {@@ -200,6 +257,7 @@ export function consumeVcsActionProgress<E, R>(readonly target: ResolvedVcsActionTarget;readonly transportActionId: string;readonly actionId: string;+ readonly action: GitStackedAction;readonly onProgress: (event: GitActionProgressEvent) => Effect.Effect<void>;},): Effect.Effect<GitRunStackedActionResult, E | VcsActionExecutionError, R> {@@ -226,15 +284,25 @@ export function consumeVcsActionProgress<E, R>(return Effect.succeed(terminalEvent.result);}if (terminalEvent?.kind === "action_failed") {- return Effect.fail(- new VcsActionExecutionError({- message: terminalEvent.message,+ return Effect.fail<VcsActionExecutionError>(+ new VcsActionRemoteFailureError({+ actionId: input.actionId,+ transportActionId: input.transportActionId,+ action: terminalEvent.action,+ environmentId: input.target.environmentId,+ cwd: input.target.cwd,+ phase: terminalEvent.phase,+ remoteMessageLength: terminalEvent.message.length,}),);}- return Effect.fail(- new VcsActionExecutionError({- message: "Source control action ended without a result.",+ return Effect.fail<VcsActionExecutionError>(+ new VcsActionMissingTerminalEventError({+ actionId: input.actionId,+ transportActionId: input.transportActionId,+ action: input.action,+ environmentId: input.target.environmentId,+ cwd: input.target.cwd,}),);}),@@ -339,18 +407,25 @@ export function applyVcsActionProgressEvent(export function createVcsActionManager<R, E>(runtime: Atom.AtomRuntime<EnvironmentRegistry | R, E>,) {- const unavailableTargetKey = "vcs-action-target:unavailable";const runStackedActionCommands = new Map<string,AtomCommand<RunVcsStackedActionInput, GitRunStackedActionResult, unknown>>();- const getRunStackedActionCommand = (key: string) => {- const existing = runStackedActionCommands.get(key);+ const getRunStackedActionCommand = (requestedTarget: VcsActionTarget) => {+ const targetKey = getVcsActionTargetKey(requestedTarget);+ const commandKey =+ targetKey ??+ JSON.stringify([+ "vcs-action-target:unavailable",+ requestedTarget.environmentId,+ requestedTarget.cwd,+ ]);+ const existing = runStackedActionCommands.get(commandKey);if (existing !== undefined) {return existing;}- const target = key === unavailableTargetKey ? null : parseVcsActionTargetKey(key);- const stateAtom = target === null ? EMPTY_VCS_ACTION_ATOM : vcsActionStateAtom(key);+ const target = targetKey === null ? null : parseVcsActionTargetKey(targetKey);+ const stateAtom = targetKey === null ? EMPTY_VCS_ACTION_ATOM : vcsActionStateAtom(targetKey);const command = createRuntimeCommand<EnvironmentRegistry | R,E,@@ -358,14 +433,16 @@ export function createVcsActionManager<R, E>(GitRunStackedActionResult,unknown>(runtime, {- label: `vcs-action:run-stacked:${key}`,+ label: `vcs-action:run-stacked:${commandKey}`,scheduler: vcsCommandScheduler,- concurrency: { mode: "serial", key: () => key },+ concurrency: { mode: "serial", key: () => commandKey },execute: (input: RunVcsStackedActionInput, registry) => {if (target === null) {return Effect.fail(new VcsActionUnavailableError({- message: "Source control action is unavailable.",+ operation: "run_change_request",+ environmentId: requestedTarget.environmentId,+ cwd: requestedTarget.cwd,}),);}@@ -396,6 +473,7 @@ export function createVcsActionManager<R, E>(target,transportActionId,actionId: input.actionId,+ action: input.action,onProgress: (event) =>Effect.sync(() => {const current = registry.get(stateAtom);@@ -427,7 +505,7 @@ export function createVcsActionManager<R, E>();},});- runStackedActionCommands.set(key, command);+ runStackedActionCommands.set(commandKey, command);return command;};@@ -446,10 +524,7 @@ export function createVcsActionManager<R, E>(return {stateAtom: getVcsActionStateAtom,- runStackedAction: (target: VcsActionTarget) => {- const key = getVcsActionTargetKey(target);- return getRunStackedActionCommand(key ?? unavailableTargetKey);- },+ runStackedAction: (target: VcsActionTarget) => getRunStackedActionCommand(target),track: async <A, E>(registry: AtomRegistry.AtomRegistry,target: VcsActionTarget,@@ -461,7 +536,9 @@ export function createVcsActionManager<R, E>(return AsyncResult.failure<never, VcsActionUnavailableError>(Cause.fail(new VcsActionUnavailableError({- message: "Source control action is unavailable.",+ operation: input.operation,+ environmentId: target.environmentId,+ cwd: target.cwd,}),),);