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.
fix(server): stop kills lingering Claude work (#5891)
Theo Browne4d12e52223f3
diff --git a/apps/server/src/provider/Layers/ClaudeAdapter.test.ts b/apps/server/src/provider/Layers/ClaudeAdapter.test.tsindex 1f971a612..6ec0a1ab6 100644--- a/apps/server/src/provider/Layers/ClaudeAdapter.test.ts+++ b/apps/server/src/provider/Layers/ClaudeAdapter.test.ts@@ -54,12 +54,11 @@ class FakeClaudeQuery implements AsyncIterable<SDKMessage> {private done = false;private failure: unknown | undefined;- public readonly interruptCalls: Array<void> = [];- public readonly stopTaskCalls: Array<string> = [];public readonly setModelCalls: Array<string | undefined> = [];public readonly setPermissionModeCalls: Array<string> = [];public readonly setMaxThinkingTokensCalls: Array<number | null> = [];public closeCalls = 0;+ public closeError: unknown | undefined;emit(message: SDKMessage): void {if (this.done) {@@ -95,14 +94,6 @@ class FakeClaudeQuery implements AsyncIterable<SDKMessage> {}}- readonly interrupt = async (): Promise<void> => {- this.interruptCalls.push(undefined);- };-- readonly stopTask = async (taskId: string): Promise<void> => {- this.stopTaskCalls.push(taskId);- };-readonly setModel = async (model?: string): Promise<void> => {this.setModelCalls.push(model);};@@ -117,6 +108,9 @@ class FakeClaudeQuery implements AsyncIterable<SDKMessage> {readonly close = (): void => {this.closeCalls += 1;+ if (this.closeError !== undefined) {+ throw this.closeError;+ }this.finish();};@@ -1580,7 +1574,7 @@ describe("ClaudeAdapterLive", () => {);});- it.effect("interruptTurn settles every acknowledged live task before interrupting", () => {+ it.effect("interruptTurn settles live tasks and closes the provider session", () => {const harness = makeHarness();return Effect.gen(function* () {const adapter = yield* ClaudeAdapter;@@ -1645,9 +1639,12 @@ describe("ClaudeAdapterLive", () => {);yield* adapter.interruptTurn(session.threadId);- // Only the still-live task is stopped; interrupt always fires after.- assert.deepEqual(harness.query.stopTaskCalls, ["task-live"]);- assert.equal(harness.query.interruptCalls.length, 1);+ // Closing the session is the hard stop because SDK interrupt can leave+ // resumed background work alive.+ assert.equal(harness.query.closeCalls, 1);++ const sessions = yield* adapter.listSessions();+ assert.equal(sessions.length, 0);const stoppedTaskEvents = Array.from(yield* Fiber.join(stoppedTaskEventFiber));assert.equal(stoppedTaskEvents.length, 1);@@ -1665,6 +1662,172 @@ describe("ClaudeAdapterLive", () => {);});+ it.effect("keeps the session available when process close fails", () => {+ const harness = makeHarness();+ return Effect.gen(function* () {+ const adapter = yield* ClaudeAdapter;+ const session = yield* adapter.startSession({+ threadId: THREAD_ID,+ provider: ProviderDriverKind.make("claudeAgent"),+ runtimeMode: "full-access",+ });+ harness.query.closeError = new Error("close failed");++ const result = yield* adapter.interruptTurn(session.threadId).pipe(Effect.result);++ assert.equal(result._tag, "Failure");+ if (result._tag === "Failure") {+ assert.equal(result.failure._tag, "ProviderAdapterProcessError");+ }+ assert.equal(harness.query.closeCalls, 1);+ assert.equal(yield* adapter.hasSession(session.threadId), true);+ assert.equal((yield* adapter.listSessions())[0]?.status, "ready");+ }).pipe(+ Effect.provideService(Random.Random, makeDeterministicRandomService()),+ Effect.provide(harness.layer),+ );+ });++ it.effect("stopAll attempts every session when one process close fails", () => {+ const queries: FakeClaudeQuery[] = [];+ const layer = Layer.effect(+ ClaudeAdapter,+ Effect.gen(function* () {+ const claudeConfig = decodeClaudeSettings({});+ return yield* makeClaudeAdapter(claudeConfig, {+ createQuery: () => {+ const query = new FakeClaudeQuery();+ queries.push(query);+ return query;+ },+ });+ }),+ ).pipe(+ Layer.provideMerge(ServerConfig.layerTest("/tmp/claude-adapter-test", "/tmp")),+ Layer.provideMerge(ServerSettingsService.layerTest()),+ Layer.provideMerge(NodeServices.layer),+ );++ return Effect.gen(function* () {+ const adapter = yield* ClaudeAdapter;+ yield* adapter.startSession({+ threadId: THREAD_ID,+ provider: ProviderDriverKind.make("claudeAgent"),+ runtimeMode: "full-access",+ });+ yield* adapter.startSession({+ threadId: RESUME_THREAD_ID,+ provider: ProviderDriverKind.make("claudeAgent"),+ runtimeMode: "full-access",+ });+ const firstQuery = queries[0];+ if (!firstQuery) {+ return;+ }+ firstQuery.closeError = new Error("close failed");++ const result = yield* adapter.stopAll().pipe(Effect.result);++ assert.equal(result._tag, "Failure");+ assert.equal(queries[0]?.closeCalls, 1);+ assert.equal(queries[1]?.closeCalls, 1);+ assert.equal(yield* adapter.hasSession(THREAD_ID), true);+ assert.equal(yield* adapter.hasSession(RESUME_THREAD_ID), false);+ }).pipe(+ Effect.provideService(Random.Random, makeDeterministicRandomService()),+ Effect.provide(layer),+ );+ });++ it.effect("keeps a resumed replacement session during slow stop cleanup", () => {+ const queries: FakeClaudeQuery[] = [];+ let signalUsageStarted: () => void = () => undefined;+ const usageStarted = new Promise<void>((resolve) => {+ signalUsageStarted = resolve;+ });+ const layer = Layer.effect(+ ClaudeAdapter,+ Effect.gen(function* () {+ const claudeConfig = decodeClaudeSettings({});+ return yield* makeClaudeAdapter(claudeConfig, {+ createQuery: () => {+ const query = new FakeClaudeQuery();+ if (queries.length === 0) {+ Object.assign(query, {+ getContextUsage: async () => {+ signalUsageStarted();+ return await new Promise<never>(() => undefined);+ },+ });+ }+ queries.push(query);+ return query;+ },+ });+ }),+ ).pipe(+ Layer.provideMerge(ServerConfig.layerTest("/tmp/claude-adapter-test", "/tmp")),+ Layer.provideMerge(ServerSettingsService.layerTest()),+ Layer.provideMerge(NodeServices.layer),+ );++ return Effect.gen(function* () {+ const adapter = yield* ClaudeAdapter;+ const runtimeEventsFiber = yield* Stream.take(adapter.streamEvents, 8).pipe(+ Stream.runCollect,+ Effect.forkChild,+ );+ const firstSession = yield* adapter.startSession({+ threadId: THREAD_ID,+ provider: ProviderDriverKind.make("claudeAgent"),+ runtimeMode: "full-access",+ });+ yield* adapter.sendTurn({+ threadId: firstSession.threadId,+ input: "hello",+ attachments: [],+ });++ const interruptFiber = yield* adapter+ .interruptTurn(firstSession.threadId)+ .pipe(Effect.forkChild);+ yield* Effect.promise(() => usageStarted);+ assert.equal(queries[0]?.closeCalls, 1);++ const replacement = yield* adapter.startSession({+ threadId: THREAD_ID,+ provider: ProviderDriverKind.make("claudeAgent"),+ runtimeMode: "full-access",+ resumeCursor: firstSession.resumeCursor,+ });+ yield* TestClock.adjust("1 second");+ yield* Fiber.join(interruptFiber);++ const activeSessions = yield* adapter.listSessions();+ const runtimeEvents = Array.from(yield* Fiber.join(runtimeEventsFiber));+ assert.equal(queries.length, 2);+ assert.equal(queries[1]?.closeCalls, 0);+ assert.equal(activeSessions.length, 1);+ assert.deepEqual(activeSessions[0]?.resumeCursor, replacement.resumeCursor);+ assert.deepEqual(+ runtimeEvents+ .filter((event) => event.type.startsWith("session."))+ .map((event) => event.type),+ [+ "session.started",+ "session.configured",+ "session.state.changed",+ "session.started",+ "session.configured",+ "session.state.changed",+ ],+ );+ }).pipe(+ Effect.provideService(Random.Random, makeDeterministicRandomService()),+ Effect.provide(layer),+ );+ });+it.effect("workflow member coalescing: identical snapshots suppress, changes emit", () => {const harness = makeHarness();return Effect.gen(function* () {diff --git a/apps/server/src/provider/Layers/ClaudeAdapter.ts b/apps/server/src/provider/Layers/ClaudeAdapter.tsindex 5715b68a1..02d73e372 100644--- a/apps/server/src/provider/Layers/ClaudeAdapter.ts+++ b/apps/server/src/provider/Layers/ClaudeAdapter.ts@@ -282,9 +282,6 @@ interface ClaudeSessionContext {}interface ClaudeQueryRuntime extends AsyncIterable<SDKMessage> {- readonly interrupt: () => Promise<void>;- /** SDK Query.stopTask — present on real queries; optional for test doubles. */- readonly stopTask?: (taskId: string) => Promise<void>;readonly setModel: (model?: string) => Promise<void>;readonly setPermissionMode: (mode: PermissionMode) => Promise<void>;readonly setMaxThinkingTokens: (maxThinkingTokens: number | null) => Promise<void>;@@ -2106,13 +2103,13 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (} catch {return undefined;}- });- if (!usage) {+ }).pipe(Effect.timeoutOption("1 second"));+ if (Option.isNone(usage) || !usage.value) {return undefined;}- context.lastKnownContextWindow = usage.maxTokens;- return normalizeClaudeContextUsageApiSnapshot(usage, totalProcessedTokens);+ context.lastKnownContextWindow = usage.value.maxTokens;+ return normalizeClaudeContextUsageApiSnapshot(usage.value, totalProcessedTokens);});const emitProposedPlanCompleted = Effect.fn("emitProposedPlanCompleted")(function* (@@ -3636,8 +3633,42 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* () {if (context.stopped) return;+ // Schedule process termination before any cleanup that can wait on the+ // provider. The SDK closes stdin, then escalates from SIGTERM to SIGKILL.+ yield* Effect.try({+ try: () => context.query.close(),+ catch: (cause) =>+ new ProviderAdapterProcessError({+ provider: PROVIDER,+ threadId: context.session.threadId,+ detail: "Failed to close Claude runtime query.",+ cause,+ }),+ });+context.stopped = true;+ for (const taskId of Array.from(context.liveTaskIds)) {+ if (!context.liveTaskIds.delete(taskId)) {+ continue;+ }+ const stamp = yield* makeEventStamp();+ yield* offerRuntimeEvent({+ type: "task.completed",+ eventId: stamp.eventId,+ provider: PROVIDER,+ createdAt: stamp.createdAt,+ threadId: context.session.threadId,+ ...(context.turnState ? { turnId: asCanonicalTurnId(context.turnState.turnId) } : {}),+ payload: {+ taskId: RuntimeTaskId.make(taskId),+ status: "stopped",+ ...taskLinkageFor(context.taskAgents, taskId),+ },+ providerRefs: nativeProviderRefs(context),+ });+ }+for (const [requestId, pending] of context.pendingApprovals) {yield* Deferred.succeed(pending.decision, "cancel");const stamp = yield* makeEventStamp();@@ -3676,26 +3707,6 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (yield* Fiber.interrupt(streamFiber);}- yield* Effect.try({- try: () => context.query.close(),- catch: (cause) =>- new ProviderAdapterProcessError({- provider: PROVIDER,- threadId: context.session.threadId,- detail: "Failed to close Claude runtime query.",- cause,- }),- }).pipe(- Effect.catch((error) =>- emitRuntimeError(context, "Failed to close Claude runtime query.", {- errorTag: error._tag,- provider: error.provider,- threadId: error.threadId,- detail: error.detail,- }),- ),- );-const updatedAt = yield* nowIso;context.session = {...context.session,@@ -3704,7 +3715,7 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (updatedAt,};- if (options?.emitExitEvent !== false) {+ if (options?.emitExitEvent !== false && sessions.get(context.session.threadId) === context) {const stamp = yield* makeEventStamp();yield* offerRuntimeEvent({type: "session.exited",@@ -3720,7 +3731,9 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (});}- sessions.delete(context.session.threadId);+ if (sessions.get(context.session.threadId) === context) {+ sessions.delete(context.session.threadId);+ }});const requireSession = (@@ -3765,16 +3778,7 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (});yield* stopSessionInternal(existingContext, {emitExitEvent: false,- }).pipe(- // Replacement cleanup is best-effort: never block the new session on- // either typed failures or unexpected defects from tearing down the old one.- Effect.catchCause((cause) =>- Effect.logWarning("claude.session.replace.stop-failed", {- threadId: input.threadId,- cause,- }),- ),- );+ });}const startedAt = yield* nowIso;@@ -4466,62 +4470,10 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (const interruptTurn: ClaudeAdapterShape["interruptTurn"] = Effect.fn("interruptTurn")(function* (threadId, _turnId) {const context = yield* requireSession(threadId);- // Stop-everything semantics: users reach for Stop precisely when a- // fleet ran away. interrupt() alone only ends the parent turn —- // background subagents/shells keep running and keep burning tokens.- // Stop every live task first (best-effort per task: one refusal must- // not strand the rest or block the turn interrupt), then interrupt.- if (context.query.stopTask && context.liveTaskIds.size > 0) {- const liveIds = Array.from(context.liveTaskIds);- // Bounded: a wedged child's stopTask promise may never settle- // (Effect.ignore handles rejection, not non-resolution), and the- // parent interrupt below MUST still run — Stop matters most during- // runaway fleets (review finding). Per-task timeout keeps one hung- // child from consuming the whole budget.- yield* Effect.forEach(- liveIds,- (taskId) =>- Effect.gen(function* () {- const stopAcknowledged = yield* Effect.tryPromise({- // Invoke through the query object: SDK methods rely on `this`.- try: () => context.query.stopTask!(taskId),- catch: () => undefined,- }).pipe(- Effect.timeoutOption("3 seconds"),- Effect.orElseSucceed(() => Option.none()),- );- if (Option.isNone(stopAcknowledged) || !context.liveTaskIds.delete(taskId)) {- return;- }-- // stopTask only acknowledges the control request. Its separate- // task_notification can lose the race with interrupt(), so make- // the acknowledged stop authoritative for the durable UI state.- const stamp = yield* makeEventStamp();- yield* offerRuntimeEvent({- type: "task.completed",- eventId: stamp.eventId,- provider: PROVIDER,- createdAt: stamp.createdAt,- threadId: context.session.threadId,- ...(context.turnState- ? { turnId: asCanonicalTurnId(context.turnState.turnId) }- : {}),- payload: {- taskId: RuntimeTaskId.make(taskId),- status: "stopped",- ...taskLinkageFor(context.taskAgents, taskId),- },- providerRefs: nativeProviderRefs(context),- });- }).pipe(Effect.ignore),- { concurrency: 8, discard: true },- ).pipe(Effect.timeoutOption("10 seconds"), Effect.ignore);- }- yield* Effect.tryPromise({- try: () => context.query.interrupt(),- catch: (cause) => toRequestError(threadId, "turn/interrupt", cause),- });+ // interrupt() can acknowledge while resumed background tasks keep the+ // CLI alive. Stop is a hard session boundary for Claude, so close the+ // query and let the SDK escalate to SIGKILL when graceful exit fails.+ yield* stopSessionInternal(context);},);@@ -4594,25 +4546,26 @@ export const makeClaudeAdapter = Effect.fn("makeClaudeAdapter")(function* (return context !== undefined && !context.stopped;});- const stopAll: ClaudeAdapterShape["stopAll"] = () =>- Effect.forEach(- sessions,- ([, context]) =>- stopSessionInternal(context, {- emitExitEvent: true,- }),- { discard: true },+ const stopSessions = Effect.fn("stopSessions")(function* (+ contexts: ReadonlyArray<ClaudeSessionContext>,+ emitExitEvent: boolean,+ ) {+ const results = yield* Effect.forEach(contexts, (context) =>+ stopSessionInternal(context, { emitExitEvent }).pipe(Effect.result),);+ for (const result of results) {+ if (result._tag === "Failure") {+ return yield* Effect.fail(result.failure);+ }+ }+ });++ const stopAll: ClaudeAdapterShape["stopAll"] = () =>+ stopSessions(Array.from(sessions.values()), true);+yield* Effect.addFinalizer(() =>- Effect.forEach(- sessions,- ([, context]) =>- stopSessionInternal(context, {- emitExitEvent: false,- }),- { discard: true },- ).pipe(+ stopSessions(Array.from(sessions.values()), false).pipe(Effect.catch((cause) =>Effect.logError("Failed to emit Claude session shutdown event.", { cause }),),