Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
import { beforeEach, describe, expect, it, vi } from 'vitest';
const storage = vi.hoisted(() => new Map<string, string>());
const asyncStorage = vi.hoisted(() => ({
getItem: vi.fn(async (key: string) => storage.get(key) ?? null),
setItem: vi.fn(async (key: string, value: string) => {
storage.set(key, value);
}),
removeItem: vi.fn(async (key: string) => {
storage.delete(key);
}),
}));
vi.mock('@react-native-async-storage/async-storage', () => ({
default: asyncStorage,
}));
import {
__testing,
forgetPendingPrecreatedWorktree,
holdPrecreatedWorktreeRegistration,
isPrecreatedWorktreeRegistrationInFlight,
listPendingPrecreatedWorktrees,
parseDiscardPrecreatedAck,
recoverPendingPrecreatedWorktrees,
registerPendingPrecreatedWorktree,
} from '@/session/precreatedWorktreeRecovery';
const ACCOUNT = 'account-a';
const RECORD = {
sessionId: 'session-1',
deviceId: 'device-1',
path: '/repo/.cindy-worktrees/auto-one',
createdAt: Date.now() - 100,
phase: 'precreated' as const,
};
const RESERVATION = {
sessionId: 'session-reserved',
deviceId: 'device-1',
recoveryKey: 'recovery-key-1234567890',
createdAt: Date.now() - 100,
phase: 'reserved' as const,
};
describe('precreated worktree recovery ledger', () => {
it('fences a timed-out reservation before a delayed create arrives', async () => {
await registerPendingPrecreatedWorktree(ACCOUNT, RESERVATION);
const cancelled = new Set<string>();
const directories = new Set<string>();
const discardPrecreated = vi.fn(async () => ({ discarded: true }));
const result = await recoverPendingPrecreatedWorktrees(ACCOUNT, {
openLink: async () => {}, discardPrecreated,
cancelPrecreated: async (_device, input) => {
cancelled.add(input.sessionId);
return { discarded: true };
},
isSessionClaimed: async () => false,
});
// The original create is delivered after cancellation's ACK, without a create ACK on mobile.
if (!cancelled.has(RESERVATION.sessionId)) directories.add(RESERVATION.sessionId);
expect(result).toMatchObject({ recovered: 1 });
expect(discardPrecreated).not.toHaveBeenCalled();
expect(directories.size).toBe(0);
expect(await listPendingPrecreatedWorktrees(ACCOUNT)).toEqual([]);
});
it.each(['reserved', 'precreated', 'session-create-started'] as const)(
'retains %s on an old host even when legacy discard could acknowledge absence', async (phase) => {
await registerPendingPrecreatedWorktree(ACCOUNT, { ...RESERVATION, phase });
const discardPrecreated = vi.fn(async () => ({ discarded: true }));
const result = await recoverPendingPrecreatedWorktrees(ACCOUNT, {
openLink: async () => {}, discardPrecreated, isSessionClaimed: async () => false,
});
expect(result).toMatchObject({ recovered: 0, retained: 1 });
expect(discardPrecreated).not.toHaveBeenCalled();
expect(await listPendingPrecreatedWorktrees(ACCOUNT)).toHaveLength(1);
},
);
it('awaits durable draft cancellation and retains the ledger if that write fails', async () => {
await registerPendingPrecreatedWorktree(ACCOUNT, RESERVATION);
let fail!: (error: Error) => void;
let writing!: () => void;
const started = new Promise<void>((resolve) => { writing = resolve; });
const pending = new Promise<void>((_resolve, reject) => { fail = reject; });
const recovery = recoverPendingPrecreatedWorktrees(ACCOUNT, {
openLink: async () => {}, discardPrecreated: vi.fn(),
cancelPrecreated: async () => ({ discarded: true }),
isSessionClaimed: async () => false,
onDiscarded: () => { writing(); return pending; },
});
await started;
expect(await listPendingPrecreatedWorktrees(ACCOUNT)).toHaveLength(1);
fail(new Error('disk full'));
expect(await recovery).toMatchObject({ recovered: 0, retained: 1 });
expect(await listPendingPrecreatedWorktrees(ACCOUNT)).toHaveLength(1);
});
beforeEach(async () => {
await __testing.drainMutations();
storage.clear();
asyncStorage.getItem.mockReset();
asyncStorage.setItem.mockReset();
asyncStorage.removeItem.mockReset();
asyncStorage.getItem.mockImplementation(
async (key: string) => storage.get(key) ?? null,
);
asyncStorage.setItem.mockImplementation(
async (key: string, value: string) => {
storage.set(key, value);
},
);
asyncStorage.removeItem.mockImplementation(async (key: string) => {
storage.delete(key);
});
__testing.resetVolatileLedgers();
});
it('persists records per account and removes only the matching record', async () => {
await expect(
registerPendingPrecreatedWorktree(ACCOUNT, RECORD),
).resolves.toBe(true);
await expect(
registerPendingPrecreatedWorktree('account-b', {
...RECORD,
sessionId: 'session-other',
}),
).resolves.toBe(true);
await expect(listPendingPrecreatedWorktrees(ACCOUNT)).resolves.toEqual([
RECORD,
]);
await expect(
listPendingPrecreatedWorktrees('account-b'),
).resolves.toHaveLength(1);
await forgetPendingPrecreatedWorktree(ACCOUNT, {
sessionId: RECORD.sessionId,
path: RECORD.path,
createdAt: RECORD.createdAt,
});
await expect(listPendingPrecreatedWorktrees(ACCOUNT)).resolves.toEqual([]);
await expect(
listPendingPrecreatedWorktrees('account-b'),
).resolves.toHaveLength(1);
});
it('persists a pathless reservation and recovers it by recoveryKey after a process restart', async () => {
await expect(
registerPendingPrecreatedWorktree(ACCOUNT, RESERVATION),
).resolves.toBe(true);
// 清掉所有进程内镜像,模拟 App 被系统杀掉后重新启动。
__testing.resetVolatileLedgers();
await expect(listPendingPrecreatedWorktrees(ACCOUNT)).resolves.toEqual([
RESERVATION,
]);
const cancelPrecreated = vi.fn(async () => ({ discarded: true }));
await expect(
recoverPendingPrecreatedWorktrees(ACCOUNT, {
discardPrecreated: vi.fn(),
openLink: vi.fn(async () => undefined),
cancelPrecreated,
isSessionClaimed: vi.fn(async () => false),
sleep: async () => undefined,
}),
).resolves.toMatchObject({
attempted: 1,
recovered: 1,
retained: 0,
storageReadable: true,
});
expect(cancelPrecreated).toHaveBeenCalledWith('device-1', {
sessionId: RESERVATION.sessionId,
recoveryKey: RESERVATION.recoveryKey,
});
await expect(listPendingPrecreatedWorktrees(ACCOUNT)).resolves.toEqual([]);
});
it('upgrades a reservation with the create response path and forgets it by recoveryKey identity', async () => {
await registerPendingPrecreatedWorktree(ACCOUNT, RESERVATION);
await registerPendingPrecreatedWorktree(ACCOUNT, {
...RESERVATION,
path: RECORD.path,
});
await expect(listPendingPrecreatedWorktrees(ACCOUNT)).resolves.toEqual([{
...RESERVATION,
path: RECORD.path,
}]);
await forgetPendingPrecreatedWorktree(ACCOUNT, {
sessionId: RESERVATION.sessionId,
recoveryKey: RESERVATION.recoveryKey,
createdAt: RESERVATION.createdAt,
});
await expect(listPendingPrecreatedWorktrees(ACCOUNT)).resolves.toEqual([]);
});
it('keeps the durable pathless reservation when the post-create path update fails', async () => {
await expect(
registerPendingPrecreatedWorktree(ACCOUNT, RESERVATION),
).resolves.toBe(true);
asyncStorage.setItem.mockRejectedValueOnce(new Error('disk unavailable'));
await expect(
registerPendingPrecreatedWorktree(ACCOUNT, {
...RESERVATION,
path: RECORD.path,
}),
).resolves.toBe(false);
// App 退出会丢掉带 path 的 volatile 镜像;磁盘上的首次 reservation 仍可恢复。
__testing.resetVolatileLedgers();
await expect(listPendingPrecreatedWorktrees(ACCOUNT)).resolves.toEqual([
RESERVATION,
]);
const cancelPrecreated = vi.fn(async () => ({ discarded: true }));
await recoverPendingPrecreatedWorktrees(ACCOUNT, {
discardPrecreated: vi.fn(),
openLink: vi.fn(async () => undefined),
cancelPrecreated,
isSessionClaimed: vi.fn(async () => false),
sleep: async () => undefined,
});
expect(cancelPrecreated).toHaveBeenCalledWith('device-1', {
sessionId: RESERVATION.sessionId,
recoveryKey: RESERVATION.recoveryKey,
});
});
it('never lets an equal-time persisted phase downgrade a retain-only volatile phase', async () => {
const precreated = {
...RESERVATION,
path: RECORD.path,
phase: 'precreated' as const,
};
await expect(registerPendingPrecreatedWorktree(ACCOUNT, precreated)).resolves.toBe(true);
asyncStorage.setItem.mockRejectedValueOnce(new Error('disk unavailable'));
const started = { ...precreated, phase: 'session-create-started' as const };
await expect(registerPendingPrecreatedWorktree(ACCOUNT, started)).resolves.toBe(false);
await expect(listPendingPrecreatedWorktrees(ACCOUNT)).resolves.toEqual([started]);
const discardPrecreated = vi.fn(async () => ({ discarded: true }));
await expect(recoverPendingPrecreatedWorktrees(ACCOUNT, {
openLink: vi.fn(async () => undefined),
discardPrecreated,
isSessionClaimed: vi.fn(async () => false),
sleep: async () => undefined,
})).resolves.toMatchObject({ recovered: 0, retained: 1 });
expect(discardPrecreated).not.toHaveBeenCalled();
});
it('marks registration in flight so startup recovery cannot race the write', async () => {
let release!: () => void;
const blocked = new Promise<void>((resolve) => {
release = resolve;
});
asyncStorage.setItem.mockImplementationOnce(
async (key: string, value: string) => {
await blocked;
storage.set(key, value);
},
);
const releaseHold = holdPrecreatedWorktreeRegistration(RECORD.sessionId);
const pending = registerPendingPrecreatedWorktree(ACCOUNT, RECORD);
expect(isPrecreatedWorktreeRegistrationInFlight(RECORD.sessionId)).toBe(
true,
);
release();
await expect(pending).resolves.toBe(true);
expect(isPrecreatedWorktreeRegistrationInFlight(RECORD.sessionId)).toBe(
true,
);
releaseHold();
expect(isPrecreatedWorktreeRegistrationInFlight(RECORD.sessionId)).toBe(
false,
);
});
it('retains an in-process record when AsyncStorage persistence fails', async () => {
asyncStorage.setItem.mockRejectedValueOnce(new Error('disk unavailable'));
await expect(
registerPendingPrecreatedWorktree(ACCOUNT, RECORD),
).resolves.toBe(false);
expect(storage.size).toBe(0);
// 下一次显式读取从 volatile ledger 找回 obligation,并在存储恢复后补写。
await expect(listPendingPrecreatedWorktrees(ACCOUNT)).resolves.toEqual([
RECORD,
]);
expect(storage.size).toBe(1);
});
it('does not overwrite an unknown persisted ledger when AsyncStorage reads fail', async () => {
await registerPendingPrecreatedWorktree(ACCOUNT, RECORD);
__testing.resetVolatileLedgers();
asyncStorage.getItem.mockRejectedValueOnce(new Error('read unavailable'));
await expect(listPendingPrecreatedWorktrees(ACCOUNT)).resolves.toEqual([]);
expect(storage.size).toBe(1);
expect(asyncStorage.removeItem).not.toHaveBeenCalled();
await expect(listPendingPrecreatedWorktrees(ACCOUNT)).resolves.toEqual([
RECORD,
]);
});
it('reports an unreadable ledger so callers can block another worktree', async () => {
await registerPendingPrecreatedWorktree(ACCOUNT, RECORD);
__testing.resetVolatileLedgers();
asyncStorage.getItem.mockRejectedValueOnce(new Error('read unavailable'));
const cancelPrecreated = vi.fn();
await expect(
recoverPendingPrecreatedWorktrees(ACCOUNT, {
discardPrecreated: vi.fn(),
openLink: vi.fn(),
cancelPrecreated,
isSessionClaimed: vi.fn(),
sleep: async () => undefined,
}),
).resolves.toMatchObject({
attempted: 0,
recovered: 0,
retained: 0,
storageReadable: false,
});
expect(cancelPrecreated).not.toHaveBeenCalled();
expect(storage.size).toBe(1);
});
it('preserves malformed persisted JSON and reports it as unreadable', async () => {
const key = __testing.storageKeyForAccount(ACCOUNT);
expect(key).not.toBeNull();
storage.set(key as string, '{{{');
const cancelPrecreated = vi.fn();
await expect(
recoverPendingPrecreatedWorktrees(ACCOUNT, {
discardPrecreated: vi.fn(),
openLink: vi.fn(),
cancelPrecreated,
isSessionClaimed: vi.fn(),
sleep: async () => undefined,
}),
).resolves.toMatchObject({
attempted: 0,
recovered: 0,
retained: 0,
storageReadable: false,
});
expect(cancelPrecreated).not.toHaveBeenCalled();
expect(storage.get(key as string)).toBe('{{{');
expect(asyncStorage.removeItem).not.toHaveBeenCalled();
await expect(
registerPendingPrecreatedWorktree(ACCOUNT, RECORD),
).resolves.toBe(false);
expect(storage.get(key as string)).toBe('{{{');
});
it('refuses to register a record without an account namespace', async () => {
await expect(
registerPendingPrecreatedWorktree('', RECORD),
).resolves.toBe(false);
await expect(listPendingPrecreatedWorktrees('')).resolves.toEqual([]);
expect(storage.size).toBe(0);
});
it('recovers successfully and defers records owned by a live creation task', async () => {
await registerPendingPrecreatedWorktree(ACCOUNT, RECORD);
const openLink = vi.fn(async () => undefined);
const cancelPrecreated = vi.fn(async () => ({ discarded: true }));
await expect(
recoverPendingPrecreatedWorktrees(ACCOUNT, {
discardPrecreated: vi.fn(),
openLink,
cancelPrecreated,
isSessionClaimed: vi.fn(async () => false),
sleep: async () => undefined,
}),
).resolves.toMatchObject({
attempted: 1,
recovered: 1,
retained: 0,
});
expect(cancelPrecreated).toHaveBeenCalledWith('device-1', {
sessionId: 'session-1',
path: RECORD.path,
});
await expect(listPendingPrecreatedWorktrees(ACCOUNT)).resolves.toEqual([]);
await registerPendingPrecreatedWorktree(ACCOUNT, RECORD);
await expect(
recoverPendingPrecreatedWorktrees(ACCOUNT, {
discardPrecreated: vi.fn(),
openLink,
cancelPrecreated,
isSessionClaimed: vi.fn(async () => false),
shouldDefer: () => true,
sleep: async () => undefined,
}),
).resolves.toMatchObject({
attempted: 0,
deferred: 1,
retained: 0,
});
await expect(listPendingPrecreatedWorktrees(ACCOUNT)).resolves.toEqual([
RECORD,
]);
});
it('removes a record only when a precondition failure is confirmed as a claimed session', async () => {
await registerPendingPrecreatedWorktree(ACCOUNT, RECORD);
const claimedAfterFailure = vi.fn()
.mockResolvedValueOnce(false)
.mockResolvedValueOnce(true);
await expect(
recoverPendingPrecreatedWorktrees(ACCOUNT, {
discardPrecreated: vi.fn(),
openLink: vi.fn(async () => undefined),
cancelPrecreated: vi.fn(async () => {
throw Object.assign(new Error('session claimed'), {
code: 'PRECONDITION_FAILED',
});
}),
isSessionClaimed: claimedAfterFailure,
sleep: async () => undefined,
}),
).resolves.toMatchObject({ recovered: 1, retained: 0 });
expect(claimedAfterFailure).toHaveBeenCalledTimes(2);
await expect(listPendingPrecreatedWorktrees(ACCOUNT)).resolves.toEqual([]);
await registerPendingPrecreatedWorktree(ACCOUNT, RECORD);
await expect(
recoverPendingPrecreatedWorktrees(ACCOUNT, {
discardPrecreated: vi.fn(),
openLink: vi.fn(async () => undefined),
cancelPrecreated: vi.fn(async () => {
throw Object.assign(new Error('worktree has changes'), {
code: 'PRECONDITION_FAILED',
});
}),
isSessionClaimed: vi.fn(async () => false),
sleep: async () => undefined,
}),
).resolves.toMatchObject({ recovered: 0, retained: 1 });
await expect(listPendingPrecreatedWorktrees(ACCOUNT)).resolves.toEqual([
RECORD,
]);
});
it('clears an already claimed record before calling an unsupported discard channel', async () => {
await registerPendingPrecreatedWorktree(ACCOUNT, RECORD);
const cancelPrecreated = vi.fn();
const isSessionClaimed = vi.fn(async () => true);
await expect(
recoverPendingPrecreatedWorktrees(ACCOUNT, {
discardPrecreated: vi.fn(),
openLink: vi.fn(async () => undefined),
cancelPrecreated,
isSessionClaimed,
sleep: async () => undefined,
}),
).resolves.toMatchObject({ recovered: 1, retained: 0 });
expect(isSessionClaimed).toHaveBeenCalledWith('device-1', 'session-1');
expect(cancelPrecreated).not.toHaveBeenCalled();
await expect(listPendingPrecreatedWorktrees(ACCOUNT)).resolves.toEqual([]);
});
it('reconciles ownership after an old desktop rejects the discard channel', async () => {
await registerPendingPrecreatedWorktree(ACCOUNT, RECORD);
const isSessionClaimed = vi.fn()
.mockResolvedValueOnce(false)
.mockResolvedValueOnce(true);
const cancelPrecreated = vi.fn(async () => {
throw Object.assign(new Error('old desktop'), {
code: 'CHANNEL_NOT_ALLOWED',
});
});
await expect(
recoverPendingPrecreatedWorktrees(ACCOUNT, {
discardPrecreated: vi.fn(),
openLink: vi.fn(async () => undefined),
cancelPrecreated,
isSessionClaimed,
sleep: async () => undefined,
}),
).resolves.toMatchObject({ recovered: 1, retained: 0 });
expect(cancelPrecreated).toHaveBeenCalledTimes(1);
expect(isSessionClaimed).toHaveBeenCalledTimes(2);
await expect(listPendingPrecreatedWorktrees(ACCOUNT)).resolves.toEqual([]);
});
it('retains unsupported, mismatched, and transient cleanup failures', async () => {
await registerPendingPrecreatedWorktree(ACCOUNT, RECORD);
await expect(
recoverPendingPrecreatedWorktrees(ACCOUNT, {
discardPrecreated: vi.fn(),
openLink: vi.fn(async () => undefined),
cancelPrecreated: vi.fn(async () => {
throw Object.assign(new Error('old desktop'), {
code: 'CHANNEL_NOT_ALLOWED',
});
}),
isSessionClaimed: vi.fn(async () => false),
sleep: async () => undefined,
}),
).resolves.toMatchObject({ recovered: 0, retained: 1 });
await expect(listPendingPrecreatedWorktrees(ACCOUNT)).resolves.toEqual([
RECORD,
]);
await registerPendingPrecreatedWorktree(ACCOUNT, RECORD);
await expect(
recoverPendingPrecreatedWorktrees(ACCOUNT, {
discardPrecreated: vi.fn(),
openLink: vi.fn(async () => undefined),
cancelPrecreated: vi.fn(async () => {
throw Object.assign(new Error('registered path mismatch'), {
code: 'PERMISSION_DENIED',
});
}),
isSessionClaimed: vi.fn(async () => false),
sleep: async () => undefined,
}),
).resolves.toMatchObject({ recovered: 0, retained: 1 });
await expect(listPendingPrecreatedWorktrees(ACCOUNT)).resolves.toEqual([
RECORD,
]);
await registerPendingPrecreatedWorktree(ACCOUNT, RECORD);
await expect(
recoverPendingPrecreatedWorktrees(ACCOUNT, {
discardPrecreated: vi.fn(),
openLink: vi.fn(async () => undefined),
cancelPrecreated: vi.fn(async () => {
throw Object.assign(new Error('device offline'), {
code: 'DEVICE_OFFLINE',
});
}),
isSessionClaimed: vi.fn(async () => false),
sleep: async () => undefined,
}),
).resolves.toMatchObject({ recovered: 0, retained: 1 });
await expect(listPendingPrecreatedWorktrees(ACCOUNT)).resolves.toEqual([
RECORD,
]);
});
it('retains started and legacy obligations when host cancellation is unavailable', async () => {
const started = {
...RECORD,
recoveryKey: 'recovery-key-started-123456',
phase: 'session-create-started' as const,
};
await registerPendingPrecreatedWorktree(ACCOUNT, started);
const discardPrecreated = vi.fn();
await expect(
recoverPendingPrecreatedWorktrees(ACCOUNT, {
openLink: vi.fn(async () => undefined),
discardPrecreated,
isSessionClaimed: vi.fn(async () => false),
sleep: async () => undefined,
}),
).resolves.toMatchObject({ recovered: 0, retained: 1 });
expect(discardPrecreated).not.toHaveBeenCalled();
const key = __testing.storageKeyForAccount(ACCOUNT) as string;
const legacy = {
sessionId: 'legacy-session',
deviceId: 'device-1',
path: '/repo/.cindy-worktrees/legacy',
createdAt: Date.now(),
};
storage.set(key, JSON.stringify({ version: 1, records: [legacy] }));
__testing.resetVolatileLedgers();
await expect(
recoverPendingPrecreatedWorktrees(ACCOUNT, {
openLink: vi.fn(async () => undefined),
discardPrecreated,
isSessionClaimed: vi.fn(async () => false),
sleep: async () => undefined,
}),
).resolves.toMatchObject({ recovered: 0, retained: 1, storageReadable: true });
expect(discardPrecreated).not.toHaveBeenCalled();
await expect(listPendingPrecreatedWorktrees(ACCOUNT)).resolves.toEqual([
expect.objectContaining({
sessionId: 'legacy-session',
phase: 'session-create-started',
}),
]);
});
it.each(['session-create-started', undefined] as const)('recovers %s only after a host cancellation ACK', async (phase) => {
const record = { ...RECORD, phase };
storage.set(__testing.storageKeyForAccount(ACCOUNT)!, JSON.stringify({ version: 1, records: [record] }));
const discardPrecreated = vi.fn();
const cancelPrecreated = vi.fn(async () => ({ discarded: true }));
const onDiscarded = vi.fn();
const result = await recoverPendingPrecreatedWorktrees(ACCOUNT, {
openLink: async () => {}, discardPrecreated, cancelPrecreated, onDiscarded,
isSessionClaimed: async () => false,
});
expect(result).toMatchObject({ recovered: 1, retained: 0 });
expect(cancelPrecreated).toHaveBeenCalledWith(RECORD.deviceId, { sessionId: RECORD.sessionId, path: RECORD.path });
expect(discardPrecreated).not.toHaveBeenCalled();
expect(onDiscarded).toHaveBeenCalledTimes(1);
expect(await listPendingPrecreatedWorktrees(ACCOUNT)).toEqual([]);
});
it.each(['unsupported', 'malformed', 'occupied'])('retains the record when cancellation is %s', async (failure) => {
const record = { ...RECORD, phase: 'session-create-started' as const };
await registerPendingPrecreatedWorktree(ACCOUNT, record);
const onDiscarded = vi.fn();
const discardPrecreated = vi.fn();
const result = await recoverPendingPrecreatedWorktrees(ACCOUNT, {
openLink: async () => {}, discardPrecreated, onDiscarded,
cancelPrecreated: async () => {
if (failure === 'malformed') return {};
throw Object.assign(new Error(failure), { code: failure === 'unsupported' ? 'CHANNEL_NOT_ALLOWED' : 'PRECONDITION_FAILED' });
},
isSessionClaimed: async () => false,
});
expect(result).toMatchObject({ recovered: 0, retained: 1 });
expect(discardPrecreated).not.toHaveBeenCalled();
expect(onDiscarded).not.toHaveBeenCalled();
expect(await listPendingPrecreatedWorktrees(ACCOUNT)).toEqual([record]);
});
it('does not cancel or hide an exact-id task that was already created', async () => {
await registerPendingPrecreatedWorktree(ACCOUNT, { ...RECORD, phase: 'session-create-started' });
const cancelPrecreated = vi.fn();
const onDiscarded = vi.fn();
await recoverPendingPrecreatedWorktrees(ACCOUNT, {
openLink: async () => {}, discardPrecreated: vi.fn(), cancelPrecreated, onDiscarded,
isSessionClaimed: async () => true,
});
expect(cancelPrecreated).not.toHaveBeenCalled();
expect(onDiscarded).not.toHaveBeenCalled();
expect(await listPendingPrecreatedWorktrees(ACCOUNT)).toEqual([]);
});
it('requires a strict discard ACK and prefers recoveryKey over path', async () => {
const record = {
...RECORD,
recoveryKey: 'recovery-key-preferred-123456',
};
await registerPendingPrecreatedWorktree(ACCOUNT, record);
const cancelPrecreated = vi.fn(async () => ({}));
await expect(
recoverPendingPrecreatedWorktrees(ACCOUNT, {
discardPrecreated: vi.fn(),
openLink: vi.fn(async () => undefined),
cancelPrecreated,
isSessionClaimed: vi.fn(async () => false),
sleep: async () => undefined,
}),
).resolves.toMatchObject({ recovered: 0, retained: 1 });
expect(cancelPrecreated).toHaveBeenCalledWith('device-1', {
sessionId: record.sessionId,
recoveryKey: record.recoveryKey,
});
await expect(listPendingPrecreatedWorktrees(ACCOUNT)).resolves.toEqual([record]);
});
it('accepts only an unambiguous discard acknowledgement', () => {
expect(parseDiscardPrecreatedAck({ discarded: true })).toEqual({ discarded: true });
expect(parseDiscardPrecreatedAck({
discarded: true,
branchDeleted: false,
})).toEqual({ discarded: true, branchDeleted: false });
for (const value of [
null,
{},
{ discarded: false },
{ discarded: true, branchDeleted: 'yes' },
{ discarded: true, error: { code: 'FAILED' } },
{ discarded: true, ok: false },
]) {
expect(parseDiscardPrecreatedAck(value)).toBeNull();
}
});
it('keeps valid JSON with an unknown version or malformed record unreadable and untouched', async () => {
const key = __testing.storageKeyForAccount(ACCOUNT) as string;
for (const payload of [
{ version: 2, records: [RECORD] },
{ version: 1, records: [{ ...RECORD, phase: 'corrupt-phase' }] },
{
version: 1,
records: [
{ ...RECORD, phase: 'session-create-started' },
{ ...RECORD, phase: 'precreated' },
],
},
{
version: 1,
records: Array.from({ length: 33 }, (_, index) => ({
...RECORD,
sessionId: `session-${index}`,
path: `/repo/.cindy-worktrees/${index}`,
})),
},
]) {
const raw = JSON.stringify(payload);
storage.set(key, raw);
__testing.resetVolatileLedgers();
const cancelPrecreated = vi.fn();
await expect(
recoverPendingPrecreatedWorktrees(ACCOUNT, {
discardPrecreated: vi.fn(),
openLink: vi.fn(),
cancelPrecreated,
isSessionClaimed: vi.fn(),
sleep: async () => undefined,
}),
).resolves.toMatchObject({ storageReadable: false, attempted: 0 });
expect(cancelPrecreated).not.toHaveBeenCalled();
expect(storage.get(key)).toBe(raw);
}
});
it('cancels an old owner while retrying and lets the new owner recover its own ledger', async () => {
await registerPendingPrecreatedWorktree(ACCOUNT, RECORD);
const accountB = 'account-b';
const recordB = {
...RECORD,
sessionId: 'session-b',
};
await registerPendingPrecreatedWorktree(accountB, recordB);
let currentOwner = ACCOUNT;
const openLinkA = vi.fn()
.mockRejectedValueOnce(Object.assign(new Error('device offline'), {
code: 'DEVICE_OFFLINE',
}))
.mockResolvedValue(undefined);
const sleepA = vi.fn(async () => {
currentOwner = accountB;
});
const isSessionClaimedA = vi.fn(async () => false);
const discardA = vi.fn(async () => ({ discarded: true }));
await expect(
recoverPendingPrecreatedWorktrees(ACCOUNT, {
discardPrecreated: vi.fn(),
openLink: openLinkA,
cancelPrecreated: discardA,
isSessionClaimed: isSessionClaimedA,
sleep: sleepA,
isCurrent: () => currentOwner === ACCOUNT,
}),
).resolves.toMatchObject({
attempted: 1,
recovered: 0,
retained: 0,
});
expect(openLinkA).toHaveBeenCalledTimes(1);
expect(isSessionClaimedA).not.toHaveBeenCalled();
expect(discardA).not.toHaveBeenCalled();
await expect(listPendingPrecreatedWorktrees(ACCOUNT)).resolves.toEqual([
RECORD,
]);
const discardB = vi.fn(async () => ({ discarded: true }));
await expect(
recoverPendingPrecreatedWorktrees(accountB, {
discardPrecreated: vi.fn(),
openLink: vi.fn(async () => undefined),
cancelPrecreated: discardB,
isSessionClaimed: vi.fn(async () => false),
sleep: async () => undefined,
isCurrent: () => currentOwner === accountB,
}),
).resolves.toMatchObject({
attempted: 1,
recovered: 1,
retained: 0,
});
expect(discardB).toHaveBeenCalledWith('device-1', {
sessionId: recordB.sessionId,
path: recordB.path,
});
await expect(listPendingPrecreatedWorktrees(accountB)).resolves.toEqual([]);
});
});