Skip to content

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 mobile relay token-store failures (#3309)

Julius Marmingef2cb14e77486
diff --git a/apps/mobile/src/features/cloud/managedRelayTokenStore.test.ts b/apps/mobile/src/features/cloud/managedRelayTokenStore.test.ts
index 616fc1add..9642e5f63 100644
--- a/apps/mobile/src/features/cloud/managedRelayTokenStore.test.ts
+++ b/apps/mobile/src/features/cloud/managedRelayTokenStore.test.ts
@@ -1,5 +1,7 @@
import { expect, it } from "@effect/vitest";
import * as Effect from "effect/Effect";
+import * as Logger from "effect/Logger";
+import * as SecureStore from "expo-secure-store";
import { vi } from "vite-plus/test";
const secureStore = vi.hoisted(() => new Map<string, string>());
@@ -16,7 +18,10 @@ vi.mock("expo-secure-store", () => ({
}),
}));
-import { managedRelayAccessTokenStore } from "./managedRelayTokenStore";
+import {
+ ManagedRelayTokenStoreError,
+ managedRelayAccessTokenStore,
+} from "./managedRelayTokenStore";
it.effect("round-trips and clears persisted managed relay access tokens", () =>
Effect.gen(function* () {
@@ -49,3 +54,32 @@ it.effect("falls back to an empty cache when persisted data is invalid", () =>
expect(yield* managedRelayAccessTokenStore.load).toEqual([]);
}),
);
+
+it.effect("logs structured storage failures before falling back to an empty cache", () => {
+ const messages: Array<unknown> = [];
+ const logger = Logger.make(({ message }) => {
+ messages.push(message);
+ });
+ const cause = new Error("secure store unavailable");
+ vi.mocked(SecureStore.getItemAsync).mockRejectedValueOnce(cause);
+
+ return Effect.gen(function* () {
+ expect(yield* managedRelayAccessTokenStore.load).toEqual([]);
+
+ const message = messages.find(
+ (candidate) =>
+ Array.isArray(candidate) && candidate[0] === "Managed relay token store operation failed.",
+ );
+ expect(message).toBeDefined();
+ const context = (message as ReadonlyArray<unknown>)[1] as {
+ readonly cause: ManagedRelayTokenStoreError;
+ };
+ expect(context.cause).toBeInstanceOf(ManagedRelayTokenStoreError);
+ expect(context.cause).toMatchObject({
+ operation: "read",
+ storageKey: "t3code.cloud.relay-access-tokens",
+ cause,
+ });
+ expect(context.cause.message).not.toContain(cause.message);
+ }).pipe(Effect.provide(Logger.layer([logger], { mergeWithExisting: false })));
+});
diff --git a/apps/mobile/src/features/cloud/managedRelayTokenStore.ts b/apps/mobile/src/features/cloud/managedRelayTokenStore.ts
index 460c71c1f..0730f277f 100644
--- a/apps/mobile/src/features/cloud/managedRelayTokenStore.ts
+++ b/apps/mobile/src/features/cloud/managedRelayTokenStore.ts
@@ -1,5 +1,4 @@
import { ManagedRelay } from "@t3tools/client-runtime/relay";
-import * as Data from "effect/Data";
import * as Effect from "effect/Effect";
import * as Schema from "effect/Schema";
import * as SecureStore from "expo-secure-store";
@@ -31,36 +30,50 @@ const decodeManagedRelayAccessTokenCache = Schema.decodeUnknownEffect(
);
const encodeManagedRelayAccessTokenCache = Schema.encodeEffect(ManagedRelayAccessTokenCacheSchema);
-export class ManagedRelayTokenStoreError extends Data.TaggedError("ManagedRelayTokenStoreError")<{
- readonly message: string;
- readonly cause: unknown;
-}> {}
-
-const storeError =
- (message: string) =>
- (cause: unknown): ManagedRelayTokenStoreError =>
- new ManagedRelayTokenStoreError({ message, cause });
+export class ManagedRelayTokenStoreError extends Schema.TaggedErrorClass<ManagedRelayTokenStoreError>()(
+ "ManagedRelayTokenStoreError",
+ {
+ operation: Schema.Literals(["read", "decode", "encode", "write", "clear"]),
+ storageKey: Schema.String,
+ cause: Schema.Defect(),
+ },
+) {
+ override get message(): string {
+ return `Managed relay token store operation "${this.operation}" failed for key "${this.storageKey}".`;
+ }
+}
-function logStoreFailure(operation: string) {
- return (error: ManagedRelayTokenStoreError) =>
- Effect.logWarning(`Managed relay token store ${operation} failed.`).pipe(
- Effect.annotateLogs({
- errorTag: error._tag,
- message: error.message,
- }),
- );
+function logStoreFailure(error: ManagedRelayTokenStoreError) {
+ return Effect.logWarning("Managed relay token store operation failed.", {
+ errorTag: error._tag,
+ operation: error.operation,
+ storageKey: error.storageKey,
+ cause: error,
+ });
}
const loadManagedRelayAccessTokens = Effect.tryPromise({
try: () => SecureStore.getItemAsync(MANAGED_RELAY_TOKEN_CACHE_KEY),
- catch: storeError("Could not read persisted relay access tokens."),
+ catch: (cause) =>
+ new ManagedRelayTokenStoreError({
+ operation: "read",
+ storageKey: MANAGED_RELAY_TOKEN_CACHE_KEY,
+ cause,
+ }),
}).pipe(
Effect.flatMap((encoded) =>
encoded === null
? Effect.succeed<ReadonlyArray<ManagedRelay.ManagedRelayAccessTokenCacheEntry>>([])
: decodeManagedRelayAccessTokenCache(encoded).pipe(
Effect.map((cache) => cache.entries),
- Effect.mapError(storeError("Persisted relay access tokens are invalid.")),
+ Effect.mapError(
+ (cause) =>
+ new ManagedRelayTokenStoreError({
+ operation: "decode",
+ storageKey: MANAGED_RELAY_TOKEN_CACHE_KEY,
+ cause,
+ }),
+ ),
),
),
);
@@ -72,34 +85,48 @@ const saveManagedRelayAccessTokens = (
version: MANAGED_RELAY_TOKEN_CACHE_VERSION,
entries,
}).pipe(
- Effect.mapError(storeError("Could not encode relay access tokens.")),
+ Effect.mapError(
+ (cause) =>
+ new ManagedRelayTokenStoreError({
+ operation: "encode",
+ storageKey: MANAGED_RELAY_TOKEN_CACHE_KEY,
+ cause,
+ }),
+ ),
Effect.flatMap((encoded) =>
Effect.tryPromise({
try: () => SecureStore.setItemAsync(MANAGED_RELAY_TOKEN_CACHE_KEY, encoded),
- catch: storeError("Could not persist relay access tokens."),
+ catch: (cause) =>
+ new ManagedRelayTokenStoreError({
+ operation: "write",
+ storageKey: MANAGED_RELAY_TOKEN_CACHE_KEY,
+ cause,
+ }),
}),
),
);
const clearManagedRelayAccessTokens = Effect.tryPromise({
try: () => SecureStore.deleteItemAsync(MANAGED_RELAY_TOKEN_CACHE_KEY),
- catch: storeError("Could not clear persisted relay access tokens."),
+ catch: (cause) =>
+ new ManagedRelayTokenStoreError({
+ operation: "clear",
+ storageKey: MANAGED_RELAY_TOKEN_CACHE_KEY,
+ cause,
+ }),
});
export const managedRelayAccessTokenStore: ManagedRelay.ManagedRelayAccessTokenStore = {
load: loadManagedRelayAccessTokens.pipe(
- Effect.tapError(logStoreFailure("load")),
+ Effect.tapError(logStoreFailure),
Effect.orElseSucceed(() => []),
Effect.withSpan("mobile.managedRelayTokenStore.load"),
),
save: Effect.fn("mobile.managedRelayTokenStore.save")((entries) =>
- saveManagedRelayAccessTokens(entries).pipe(
- Effect.tapError(logStoreFailure("save")),
- Effect.ignore,
- ),
+ saveManagedRelayAccessTokens(entries).pipe(Effect.tapError(logStoreFailure), Effect.ignore),
),
clear: clearManagedRelayAccessTokens.pipe(
- Effect.tapError(logStoreFailure("clear")),
+ Effect.tapError(logStoreFailure),
Effect.ignore,
Effect.withSpan("mobile.managedRelayTokenStore.clear"),
),