|
| 1 | +import * as NodeHttpServer from "@effect/platform-node/NodeHttpServer"; |
| 2 | +import * as ThreadMonitorSignalCallbacks from "./ThreadMonitorSignalCallbacks.ts"; |
1 | 3 | import { assert, describe, it } from "@effect/vitest"; |
2 | 4 | import * as NodeServices from "@effect/platform-node/NodeServices"; |
3 | 5 | import { |
@@ -2893,3 +2895,143 @@ it.effect("replays an accepted Stop before delivery without cancelling newer wat |
2893 | 2895 | ), |
2894 | 2896 | ), |
2895 | 2897 | ); |
| 2898 | + |
| 2899 | +it.effect( |
| 2900 | + "signal callbacks survive ended turns and service restarts without broad MCP credentials", |
| 2901 | + () => |
| 2902 | + Effect.gen(function* () { |
| 2903 | + const config = yield* ServerConfig; |
| 2904 | + const callbackRuntime = ThreadMonitorSignalCallbacks.layer.pipe( |
| 2905 | + Layer.provideMerge(ThreadMonitor.layer), |
| 2906 | + Layer.provide(computerLayer), |
| 2907 | + Layer.provideMerge(orchestrationLayer(persistentDatabase(config.dbPath))), |
| 2908 | + Layer.provide(RepositoryIdentityResolver.layer), |
| 2909 | + Layer.provide(Layer.succeed(ServerConfig, config)), |
| 2910 | + Layer.provide(SqlitePersistence.layerFromPath(config.dbPath)), |
| 2911 | + Layer.provide(NodeHttpServer.layerTest), |
| 2912 | + Layer.provide(NodeServices.layer), |
| 2913 | + ); |
| 2914 | + const monitor = yield* Effect.scoped( |
| 2915 | + Effect.gen(function* () { |
| 2916 | + yield* seedThread; |
| 2917 | + yield* startTestRun(); |
| 2918 | + const callbacks = yield* ThreadMonitorSignalCallbacks.ThreadMonitorSignalCallbacks; |
| 2919 | + const timer = yield* callbacks.create({ |
| 2920 | + threadId, |
| 2921 | + monitor: { label: "Timer", schedule: { type: "after", durationMs: 60_000 } }, |
| 2922 | + }); |
| 2923 | + assert.isUndefined(timer.signalCallback); |
| 2924 | + const monitor = yield* callbacks.create({ |
| 2925 | + threadId, |
| 2926 | + monitor: { label: "Build result", schedule: { type: "signal" } }, |
| 2927 | + }); |
| 2928 | + assert.isDefined(monitor.signalCallback); |
| 2929 | + assert.notInclude( |
| 2930 | + monitor.signalCallback!.url, |
| 2931 | + monitor.signalCallback!.authorizationHeader, |
| 2932 | + ); |
| 2933 | + yield* completeTestRun; |
| 2934 | + return monitor; |
| 2935 | + }).pipe(Effect.provide(Layer.fresh(callbackRuntime))), |
| 2936 | + ); |
| 2937 | + |
| 2938 | + yield* Effect.scoped( |
| 2939 | + Effect.gen(function* () { |
| 2940 | + const callbacks = yield* ThreadMonitorSignalCallbacks.ThreadMonitorSignalCallbacks; |
| 2941 | + const service = yield* ThreadMonitorService; |
| 2942 | + const signal = { |
| 2943 | + monitorId: monitor.id, |
| 2944 | + authorizationHeader: monitor.signalCallback!.authorizationHeader, |
| 2945 | + result: { summary: "Build succeeded.", evidence: "exit=0" }, |
| 2946 | + }; |
| 2947 | + assert.strictEqual( |
| 2948 | + (yield* callbacks |
| 2949 | + .signal({ ...signal, authorizationHeader: undefined }) |
| 2950 | + .pipe(Effect.flip)).code, |
| 2951 | + "unauthorized", |
| 2952 | + ); |
| 2953 | + assert.strictEqual( |
| 2954 | + (yield* callbacks |
| 2955 | + .signal({ ...signal, monitorId: ThreadMonitorId.make("different-monitor") }) |
| 2956 | + .pipe(Effect.flip)).code, |
| 2957 | + "unauthorized", |
| 2958 | + ); |
| 2959 | + assert.deepEqual(yield* callbacks.signal(signal), { status: "triggered" }); |
| 2960 | + yield* TestClock.adjust("1 second"); |
| 2961 | + yield* service.checkNow({ threadId, check: { monitorId: monitor.id } }); |
| 2962 | + assert.deepEqual( |
| 2963 | + yield* callbacks.signal({ |
| 2964 | + ...signal, |
| 2965 | + result: { summary: "Duplicate must not replace evidence." }, |
| 2966 | + }), |
| 2967 | + { status: "delivered" }, |
| 2968 | + ); |
| 2969 | + const stored = (yield* service.status({ threadId, query: { monitorId: monitor.id } })) |
| 2970 | + .monitors[0]!; |
| 2971 | + assert.deepEqual(stored.trigger, { |
| 2972 | + reason: "signal", |
| 2973 | + summary: "Build succeeded.", |
| 2974 | + evidence: "exit=0", |
| 2975 | + }); |
| 2976 | + assert.isFalse("signalCallback" in stored); |
| 2977 | + assert.strictEqual(stored.deliveryAttempts, 1); |
| 2978 | + const projection = yield* (yield* ProjectionStore.ProjectionStoreV2).getThreadProjection( |
| 2979 | + threadId, |
| 2980 | + ); |
| 2981 | + assert.strictEqual( |
| 2982 | + projection.messages.filter( |
| 2983 | + (message) => message.notification?.systemEvent?.type === "monitor.continuation", |
| 2984 | + ).length, |
| 2985 | + 1, |
| 2986 | + ); |
| 2987 | + |
| 2988 | + const engine = yield* OrchestratorV2; |
| 2989 | + yield* engine.dispatch({ |
| 2990 | + type: "thread.archive", |
| 2991 | + commandId: CommandId.make("callback-archive"), |
| 2992 | + threadId, |
| 2993 | + }); |
| 2994 | + assert.strictEqual( |
| 2995 | + (yield* callbacks.signal(signal).pipe(Effect.flip)).code, |
| 2996 | + "unavailable", |
| 2997 | + ); |
| 2998 | + yield* engine.dispatch({ |
| 2999 | + type: "thread.unarchive", |
| 3000 | + commandId: CommandId.make("callback-unarchive"), |
| 3001 | + threadId, |
| 3002 | + }); |
| 3003 | + |
| 3004 | + const cancelled = yield* callbacks.create({ |
| 3005 | + threadId, |
| 3006 | + monitor: { label: "Cancelled job", schedule: { type: "signal" } }, |
| 3007 | + }); |
| 3008 | + yield* service.cancel({ threadId, cancel: { monitorId: cancelled.id } }); |
| 3009 | + assert.strictEqual( |
| 3010 | + (yield* callbacks |
| 3011 | + .signal({ |
| 3012 | + monitorId: cancelled.id, |
| 3013 | + authorizationHeader: cancelled.signalCallback!.authorizationHeader, |
| 3014 | + result: {}, |
| 3015 | + }) |
| 3016 | + .pipe(Effect.flip)).code, |
| 3017 | + "unavailable", |
| 3018 | + ); |
| 3019 | + yield* engine.dispatch({ |
| 3020 | + type: "thread.delete", |
| 3021 | + commandId: CommandId.make("callback-delete"), |
| 3022 | + threadId, |
| 3023 | + }); |
| 3024 | + assert.strictEqual( |
| 3025 | + (yield* callbacks.signal(signal).pipe(Effect.flip)).code, |
| 3026 | + "unavailable", |
| 3027 | + ); |
| 3028 | + }).pipe(Effect.provide(Layer.fresh(callbackRuntime))), |
| 3029 | + ); |
| 3030 | + }).pipe( |
| 3031 | + Effect.provide( |
| 3032 | + ServerConfig.layerTest(process.cwd(), { prefix: "t3-monitor-callback-test-" }).pipe( |
| 3033 | + Layer.provideMerge(NodeServices.layer), |
| 3034 | + ), |
| 3035 | + ), |
| 3036 | + ), |
| 3037 | +); |
0 commit comments