Skip to content

Commit 4d12e52

Browse files
authored
fix(server): stop kills lingering Claude work (pingdotgg#5891)
1 parent 3db38b8 commit 4d12e52

2 files changed

Lines changed: 241 additions & 125 deletions

File tree

‎apps/server/src/provider/Layers/ClaudeAdapter.test.ts‎

Lines changed: 177 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -54,12 +54,11 @@ class FakeClaudeQuery implements AsyncIterable<SDKMessage> {
5454
private done = false;
5555
private failure: unknown | undefined;
5656

57-
public readonly interruptCalls: Array<void> = [];
58-
public readonly stopTaskCalls: Array<string> = [];
5957
public readonly setModelCalls: Array<string | undefined> = [];
6058
public readonly setPermissionModeCalls: Array<string> = [];
6159
public readonly setMaxThinkingTokensCalls: Array<number | null> = [];
6260
public closeCalls = 0;
61+
public closeError: unknown | undefined;
6362

6463
emit(message: SDKMessage): void {
6564
if (this.done) {
@@ -95,14 +94,6 @@ class FakeClaudeQuery implements AsyncIterable<SDKMessage> {
9594
}
9695
}
9796

98-
readonly interrupt = async (): Promise<void> => {
99-
this.interruptCalls.push(undefined);
100-
};
101-
102-
readonly stopTask = async (taskId: string): Promise<void> => {
103-
this.stopTaskCalls.push(taskId);
104-
};
105-
10697
readonly setModel = async (model?: string): Promise<void> => {
10798
this.setModelCalls.push(model);
10899
};
@@ -117,6 +108,9 @@ class FakeClaudeQuery implements AsyncIterable<SDKMessage> {
117108

118109
readonly close = (): void => {
119110
this.closeCalls += 1;
111+
if (this.closeError !== undefined) {
112+
throw this.closeError;
113+
}
120114
this.finish();
121115
};
122116

@@ -1580,7 +1574,7 @@ describe("ClaudeAdapterLive", () => {
15801574
);
15811575
});
15821576

1583-
it.effect("interruptTurn settles every acknowledged live task before interrupting", () => {
1577+
it.effect("interruptTurn settles live tasks and closes the provider session", () => {
15841578
const harness = makeHarness();
15851579
return Effect.gen(function* () {
15861580
const adapter = yield* ClaudeAdapter;
@@ -1645,9 +1639,12 @@ describe("ClaudeAdapterLive", () => {
16451639
);
16461640
yield* adapter.interruptTurn(session.threadId);
16471641

1648-
// Only the still-live task is stopped; interrupt always fires after.
1649-
assert.deepEqual(harness.query.stopTaskCalls, ["task-live"]);
1650-
assert.equal(harness.query.interruptCalls.length, 1);
1642+
// Closing the session is the hard stop because SDK interrupt can leave
1643+
// resumed background work alive.
1644+
assert.equal(harness.query.closeCalls, 1);
1645+
1646+
const sessions = yield* adapter.listSessions();
1647+
assert.equal(sessions.length, 0);
16511648

16521649
const stoppedTaskEvents = Array.from(yield* Fiber.join(stoppedTaskEventFiber));
16531650
assert.equal(stoppedTaskEvents.length, 1);
@@ -1665,6 +1662,172 @@ describe("ClaudeAdapterLive", () => {
16651662
);
16661663
});
16671664

1665+
it.effect("keeps the session available when process close fails", () => {
1666+
const harness = makeHarness();
1667+
return Effect.gen(function* () {
1668+
const adapter = yield* ClaudeAdapter;
1669+
const session = yield* adapter.startSession({
1670+
threadId: THREAD_ID,
1671+
provider: ProviderDriverKind.make("claudeAgent"),
1672+
runtimeMode: "full-access",
1673+
});
1674+
harness.query.closeError = new Error("close failed");
1675+
1676+
const result = yield* adapter.interruptTurn(session.threadId).pipe(Effect.result);
1677+
1678+
assert.equal(result._tag, "Failure");
1679+
if (result._tag === "Failure") {
1680+
assert.equal(result.failure._tag, "ProviderAdapterProcessError");
1681+
}
1682+
assert.equal(harness.query.closeCalls, 1);
1683+
assert.equal(yield* adapter.hasSession(session.threadId), true);
1684+
assert.equal((yield* adapter.listSessions())[0]?.status, "ready");
1685+
}).pipe(
1686+
Effect.provideService(Random.Random, makeDeterministicRandomService()),
1687+
Effect.provide(harness.layer),
1688+
);
1689+
});
1690+
1691+
it.effect("stopAll attempts every session when one process close fails", () => {
1692+
const queries: FakeClaudeQuery[] = [];
1693+
const layer = Layer.effect(
1694+
ClaudeAdapter,
1695+
Effect.gen(function* () {
1696+
const claudeConfig = decodeClaudeSettings({});
1697+
return yield* makeClaudeAdapter(claudeConfig, {
1698+
createQuery: () => {
1699+
const query = new FakeClaudeQuery();
1700+
queries.push(query);
1701+
return query;
1702+
},
1703+
});
1704+
}),
1705+
).pipe(
1706+
Layer.provideMerge(ServerConfig.layerTest("/tmp/claude-adapter-test", "/tmp")),
1707+
Layer.provideMerge(ServerSettingsService.layerTest()),
1708+
Layer.provideMerge(NodeServices.layer),
1709+
);
1710+
1711+
return Effect.gen(function* () {
1712+
const adapter = yield* ClaudeAdapter;
1713+
yield* adapter.startSession({
1714+
threadId: THREAD_ID,
1715+
provider: ProviderDriverKind.make("claudeAgent"),
1716+
runtimeMode: "full-access",
1717+
});
1718+
yield* adapter.startSession({
1719+
threadId: RESUME_THREAD_ID,
1720+
provider: ProviderDriverKind.make("claudeAgent"),
1721+
runtimeMode: "full-access",
1722+
});
1723+
const firstQuery = queries[0];
1724+
if (!firstQuery) {
1725+
return;
1726+
}
1727+
firstQuery.closeError = new Error("close failed");
1728+
1729+
const result = yield* adapter.stopAll().pipe(Effect.result);
1730+
1731+
assert.equal(result._tag, "Failure");
1732+
assert.equal(queries[0]?.closeCalls, 1);
1733+
assert.equal(queries[1]?.closeCalls, 1);
1734+
assert.equal(yield* adapter.hasSession(THREAD_ID), true);
1735+
assert.equal(yield* adapter.hasSession(RESUME_THREAD_ID), false);
1736+
}).pipe(
1737+
Effect.provideService(Random.Random, makeDeterministicRandomService()),
1738+
Effect.provide(layer),
1739+
);
1740+
});
1741+
1742+
it.effect("keeps a resumed replacement session during slow stop cleanup", () => {
1743+
const queries: FakeClaudeQuery[] = [];
1744+
let signalUsageStarted: () => void = () => undefined;
1745+
const usageStarted = new Promise<void>((resolve) => {
1746+
signalUsageStarted = resolve;
1747+
});
1748+
const layer = Layer.effect(
1749+
ClaudeAdapter,
1750+
Effect.gen(function* () {
1751+
const claudeConfig = decodeClaudeSettings({});
1752+
return yield* makeClaudeAdapter(claudeConfig, {
1753+
createQuery: () => {
1754+
const query = new FakeClaudeQuery();
1755+
if (queries.length === 0) {
1756+
Object.assign(query, {
1757+
getContextUsage: async () => {
1758+
signalUsageStarted();
1759+
return await new Promise<never>(() => undefined);
1760+
},
1761+
});
1762+
}
1763+
queries.push(query);
1764+
return query;
1765+
},
1766+
});
1767+
}),
1768+
).pipe(
1769+
Layer.provideMerge(ServerConfig.layerTest("/tmp/claude-adapter-test", "/tmp")),
1770+
Layer.provideMerge(ServerSettingsService.layerTest()),
1771+
Layer.provideMerge(NodeServices.layer),
1772+
);
1773+
1774+
return Effect.gen(function* () {
1775+
const adapter = yield* ClaudeAdapter;
1776+
const runtimeEventsFiber = yield* Stream.take(adapter.streamEvents, 8).pipe(
1777+
Stream.runCollect,
1778+
Effect.forkChild,
1779+
);
1780+
const firstSession = yield* adapter.startSession({
1781+
threadId: THREAD_ID,
1782+
provider: ProviderDriverKind.make("claudeAgent"),
1783+
runtimeMode: "full-access",
1784+
});
1785+
yield* adapter.sendTurn({
1786+
threadId: firstSession.threadId,
1787+
input: "hello",
1788+
attachments: [],
1789+
});
1790+
1791+
const interruptFiber = yield* adapter
1792+
.interruptTurn(firstSession.threadId)
1793+
.pipe(Effect.forkChild);
1794+
yield* Effect.promise(() => usageStarted);
1795+
assert.equal(queries[0]?.closeCalls, 1);
1796+
1797+
const replacement = yield* adapter.startSession({
1798+
threadId: THREAD_ID,
1799+
provider: ProviderDriverKind.make("claudeAgent"),
1800+
runtimeMode: "full-access",
1801+
resumeCursor: firstSession.resumeCursor,
1802+
});
1803+
yield* TestClock.adjust("1 second");
1804+
yield* Fiber.join(interruptFiber);
1805+
1806+
const activeSessions = yield* adapter.listSessions();
1807+
const runtimeEvents = Array.from(yield* Fiber.join(runtimeEventsFiber));
1808+
assert.equal(queries.length, 2);
1809+
assert.equal(queries[1]?.closeCalls, 0);
1810+
assert.equal(activeSessions.length, 1);
1811+
assert.deepEqual(activeSessions[0]?.resumeCursor, replacement.resumeCursor);
1812+
assert.deepEqual(
1813+
runtimeEvents
1814+
.filter((event) => event.type.startsWith("session."))
1815+
.map((event) => event.type),
1816+
[
1817+
"session.started",
1818+
"session.configured",
1819+
"session.state.changed",
1820+
"session.started",
1821+
"session.configured",
1822+
"session.state.changed",
1823+
],
1824+
);
1825+
}).pipe(
1826+
Effect.provideService(Random.Random, makeDeterministicRandomService()),
1827+
Effect.provide(layer),
1828+
);
1829+
});
1830+
16681831
it.effect("workflow member coalescing: identical snapshots suppress, changes emit", () => {
16691832
const harness = makeHarness();
16701833
return Effect.gen(function* () {

0 commit comments

Comments
 (0)