mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-22 16:10:50 +00:00
* fix(#2697): automated Cursor CLI fix * fix: address Codex review on PR #2734 * fix(ai): keep MCP absolute approval deadline and Escape reject Canceling idle review no longer leaves MCP approvals unbounded past the external agent tool-call window, and Enter-only key stopPropagation lets Escape still reject from Copy/Expand controls. Co-authored-by: Cursor <cursoragent@cursor.com> * fix(ai): keep wrapped CLI target context on approval cards Parse --session from netcatty-tool-cli wrappers into execution context and still show invocation args when the pending card displays an unwrapped command. Co-authored-by: Cursor <cursoragent@cursor.com> * fix(ai): surface Codex reason on pending approval cards Keep agent justification visible in the execution-context strip and still show extra invocation args such as commandActions beside the command block. Co-authored-by: Cursor <cursoragent@cursor.com> * fix(ai): bound Catty approval cancel with absolute deadline Keep Catty confirm-mode approvals from going unbounded after review: cancelApprovalTimeout re-arms the creation absolute deadline (MCP-style) so a late approve cannot outlive the original timeout/stream tool budget. Also harden pending-card Enter: extract isNestedInteractiveApprovalTarget so Copy/Expand (and other nested controls) never Approve Once via bubble. * fix(ai): bound Codex approval cancel and unwrap CLI wrappers cancelInteractionTimeout now re-arms the absolute creation deadline (Catty/MCP style) instead of leaving review unbounded. Also treat netcatty-tool-cli.cjs/.cmd as CLI wrappers so approval Command/Copy shows the remote command after --. * fix: address Codex review on PR #2734 * fix(ai): separate Catty approval idle timer from hard deadline Review activity re-arms a full idle window from now instead of the original absolute remainder, capped by a hard deadline (3x idle, max 30m). Stream tool budgets use the hard deadline so mid-review approvals are not cut off. * fix(ai): re-arm Catty approval idle and sync-deny hard deadline Review interactions kept a one-shot timeoutCancelledRef, so later cancelApprovalTimeout calls no longer re-armed idle. Remove the one-shot and deny synchronously when the hard deadline has already elapsed so a late approve cannot race setTimeout(0). * fix(ai): re-arm approval idle on args-only scroll review Pending approvals without a display command (Codex file-change/permissions, write tools with JSON args) only show the overflow args block. Wire the same onScroll/onWheel markReviewing path used by the command pre so continuous wheel/trackpad review re-arms Catty and MCP/Codex idle timers. --------- Co-authored-by: netcatty-bot <308658023+netcatty-bot@users.noreply.github.com> Co-authored-by: bincxz <16399091+binaricat@users.noreply.github.com> Co-authored-by: Cursor <cursoragent@cursor.com>
272 lines
7.9 KiB
TypeScript
272 lines
7.9 KiB
TypeScript
import assert from 'node:assert/strict';
|
||
import test from 'node:test';
|
||
import { setTimeout as delay } from 'node:timers/promises';
|
||
|
||
import {
|
||
cancelApprovalTimeout,
|
||
clearAllPendingApprovals,
|
||
onApprovalCleared,
|
||
requestApproval,
|
||
resolveApproval,
|
||
} from './approvalGate';
|
||
import { resolveCattyApprovalDeadlines } from './approvalConstants';
|
||
|
||
function stubNow(startMs: number): { advance: (deltaMs: number) => void; restore: () => void } {
|
||
const realNow = Date.now;
|
||
let now = startMs;
|
||
Date.now = () => now;
|
||
return {
|
||
advance: (deltaMs: number) => {
|
||
now += deltaMs;
|
||
},
|
||
restore: () => {
|
||
Date.now = realNow;
|
||
},
|
||
};
|
||
}
|
||
|
||
test('resolveCattyApprovalDeadlines keeps hard deadline >= idle and 3x by default', () => {
|
||
assert.deepEqual(resolveCattyApprovalDeadlines(100), { idleMs: 100, hardDeadlineMs: 300 });
|
||
assert.deepEqual(resolveCattyApprovalDeadlines(5 * 60 * 1000), {
|
||
idleMs: 5 * 60 * 1000,
|
||
hardDeadlineMs: 15 * 60 * 1000,
|
||
});
|
||
// Cap at 30m when 3× would exceed, unless idle itself is larger.
|
||
assert.deepEqual(resolveCattyApprovalDeadlines(20 * 60 * 1000), {
|
||
idleMs: 20 * 60 * 1000,
|
||
hardDeadlineMs: 30 * 60 * 1000,
|
||
});
|
||
assert.deepEqual(resolveCattyApprovalDeadlines(40 * 60 * 1000), {
|
||
idleMs: 40 * 60 * 1000,
|
||
hardDeadlineMs: 40 * 60 * 1000,
|
||
});
|
||
});
|
||
|
||
test('cancelApprovalTimeout re-arms a fresh idle window, not the original absolute remainder', async () => {
|
||
clearAllPendingApprovals();
|
||
const cleared: string[] = [];
|
||
const unsub = onApprovalCleared((ids) => {
|
||
cleared.push(...ids);
|
||
});
|
||
const clock = stubNow(1_000_000);
|
||
|
||
try {
|
||
const toolCallId = `timeout-idle-rearm-${Date.now()}`;
|
||
// idle 100ms, hard 300ms
|
||
const approvalPromise = requestApproval(
|
||
toolCallId,
|
||
'terminal_execute',
|
||
{ sessionId: 's1', command: 'echo hi' },
|
||
'chat-1',
|
||
100,
|
||
);
|
||
|
||
// Review near end of first idle window — previously this left ~30ms absolute
|
||
// remainder and denied while the user was still deciding.
|
||
clock.advance(70);
|
||
cancelApprovalTimeout(toolCallId);
|
||
|
||
// Fresh idle (100ms) should keep the approval pending well past the old
|
||
// absolute mark at t=100.
|
||
await delay(50);
|
||
assert.equal(cleared.includes(toolCallId), false, 'must stay pending through re-armed idle');
|
||
|
||
// Still before hard deadline (300): jump clock so remaining hard is short.
|
||
clock.advance(220); // now = start+290; remaining hard = 10ms; re-arm idle capped to 10
|
||
cancelApprovalTimeout(toolCallId);
|
||
|
||
const outcome = await Promise.race([
|
||
approvalPromise.then((approved) => ({ approved })),
|
||
delay(120).then(() => ({ approved: 'timeout-wait' as const })),
|
||
]);
|
||
assert.deepEqual(outcome, { approved: false });
|
||
assert.ok(cleared.includes(toolCallId));
|
||
} finally {
|
||
clock.restore();
|
||
unsub();
|
||
clearAllPendingApprovals();
|
||
}
|
||
});
|
||
|
||
test('cancelApprovalTimeout survives past the idle deadline while reviewing', async () => {
|
||
clearAllPendingApprovals();
|
||
const cleared: string[] = [];
|
||
const unsub = onApprovalCleared((ids) => {
|
||
cleared.push(...ids);
|
||
});
|
||
const clock = stubNow(3_000_000);
|
||
|
||
try {
|
||
const toolCallId = `timeout-past-idle-${Date.now()}`;
|
||
const idleMs = 80;
|
||
const approvalPromise = requestApproval(
|
||
toolCallId,
|
||
'terminal_execute',
|
||
{ sessionId: 's1', command: 'echo hi' },
|
||
'chat-1',
|
||
idleMs,
|
||
);
|
||
|
||
// Review near end of first idle — re-arms a full idleMs from now (hard = 3x).
|
||
clock.advance(idleMs - 20);
|
||
cancelApprovalTimeout(toolCallId);
|
||
|
||
// Wall-clock past the original idle mark; re-armed idle still has ~idleMs left.
|
||
await delay(40);
|
||
assert.equal(cleared.includes(toolCallId), false, 'active review must outlive original idle');
|
||
|
||
resolveApproval(toolCallId, true);
|
||
assert.equal(await approvalPromise, true);
|
||
} finally {
|
||
clock.restore();
|
||
unsub();
|
||
clearAllPendingApprovals();
|
||
}
|
||
});
|
||
|
||
test('cancelApprovalTimeout still allows explicit approve before hard Catty deadline', async () => {
|
||
clearAllPendingApprovals();
|
||
const clock = stubNow(2_000_000);
|
||
|
||
try {
|
||
const toolCallId = `timeout-approve-${Date.now()}`;
|
||
const approvalPromise = requestApproval(
|
||
toolCallId,
|
||
'sftp_write',
|
||
{ path: '/tmp/x' },
|
||
'chat-1',
|
||
200,
|
||
);
|
||
|
||
clock.advance(150);
|
||
cancelApprovalTimeout(toolCallId);
|
||
resolveApproval(toolCallId, true);
|
||
assert.equal(await approvalPromise, true);
|
||
} finally {
|
||
clock.restore();
|
||
clearAllPendingApprovals();
|
||
}
|
||
});
|
||
|
||
test('cancelApprovalTimeout rejects expired Catty approvals synchronously after hard deadline', async () => {
|
||
clearAllPendingApprovals();
|
||
const cleared: string[] = [];
|
||
const unsub = onApprovalCleared((ids) => {
|
||
cleared.push(...ids);
|
||
});
|
||
const clock = stubNow(4_000_000);
|
||
|
||
try {
|
||
const toolCallId = `timeout-hard-sync-${Date.now()}`;
|
||
// idle 50ms → hard 150ms
|
||
const approvalPromise = requestApproval(
|
||
toolCallId,
|
||
'terminal_execute',
|
||
{ sessionId: 's1', command: 'echo hi' },
|
||
'chat-1',
|
||
50,
|
||
);
|
||
|
||
clock.advance(160); // past hard deadline
|
||
cancelApprovalTimeout(toolCallId);
|
||
|
||
// Must already be denied — no setTimeout(0) race window for approve.
|
||
assert.ok(cleared.includes(toolCallId), 'must clear synchronously when hard deadline elapsed');
|
||
assert.equal(await approvalPromise, false);
|
||
|
||
// Late approve after hard-deadline deny must not resurrect the request.
|
||
resolveApproval(toolCallId, true);
|
||
assert.equal(await approvalPromise, false);
|
||
} finally {
|
||
clock.restore();
|
||
unsub();
|
||
clearAllPendingApprovals();
|
||
}
|
||
});
|
||
|
||
test('repeated cancelApprovalTimeout re-arms idle on each review interaction', async () => {
|
||
clearAllPendingApprovals();
|
||
const cleared: string[] = [];
|
||
const unsub = onApprovalCleared((ids) => {
|
||
cleared.push(...ids);
|
||
});
|
||
const clock = stubNow(5_000_000);
|
||
|
||
try {
|
||
const toolCallId = `timeout-multi-rearm-${Date.now()}`;
|
||
const idleMs = 100;
|
||
const approvalPromise = requestApproval(
|
||
toolCallId,
|
||
'terminal_execute',
|
||
{ sessionId: 's1', command: 'echo hi' },
|
||
'chat-1',
|
||
idleMs,
|
||
);
|
||
|
||
// Simulate successive review events (focus, scroll, key) — each re-arms.
|
||
clock.advance(60);
|
||
cancelApprovalTimeout(toolCallId);
|
||
clock.advance(60);
|
||
cancelApprovalTimeout(toolCallId);
|
||
clock.advance(60);
|
||
cancelApprovalTimeout(toolCallId);
|
||
|
||
// Still before hard deadline (300ms); original idle marks have long passed.
|
||
await delay(20);
|
||
assert.equal(cleared.includes(toolCallId), false, 'each re-arm must keep approval pending');
|
||
|
||
resolveApproval(toolCallId, true);
|
||
assert.equal(await approvalPromise, true);
|
||
} finally {
|
||
clock.restore();
|
||
unsub();
|
||
clearAllPendingApprovals();
|
||
}
|
||
});
|
||
|
||
test('idle approval timeout still auto-denies when the user never reviews', async () => {
|
||
clearAllPendingApprovals();
|
||
const cleared: string[] = [];
|
||
const unsub = onApprovalCleared((ids) => {
|
||
cleared.push(...ids);
|
||
});
|
||
|
||
const toolCallId = `timeout-fire-${Date.now()}`;
|
||
const approved = await requestApproval(
|
||
toolCallId,
|
||
'terminal_execute',
|
||
{ sessionId: 's1', command: 'echo hi' },
|
||
'chat-1',
|
||
30,
|
||
);
|
||
|
||
assert.equal(approved, false);
|
||
assert.ok(cleared.includes(toolCallId));
|
||
|
||
unsub();
|
||
clearAllPendingApprovals();
|
||
});
|
||
|
||
test('cancelApprovalTimeout asks main to drop Codex App Server interaction timers', () => {
|
||
clearAllPendingApprovals();
|
||
const calls: string[] = [];
|
||
const previous = (globalThis as { window?: unknown }).window;
|
||
(globalThis as { window?: unknown }).window = {
|
||
netcatty: {
|
||
cancelCodexAppServerInteractionTimeout: async (id: string) => {
|
||
calls.push(id);
|
||
return { ok: true, cancelled: true };
|
||
},
|
||
},
|
||
};
|
||
|
||
try {
|
||
const toolCallId = `codex_interaction_1_${Date.now()}`;
|
||
cancelApprovalTimeout(toolCallId);
|
||
assert.deepEqual(calls, [toolCallId]);
|
||
} finally {
|
||
(globalThis as { window?: unknown }).window = previous;
|
||
clearAllPendingApprovals();
|
||
}
|
||
});
|