test/folder-delete.test.js
Rama main · réplica de lectura del repositorio original.
var test = require("node:test");
var assert = require("node:assert");
var fs = require("fs");
var os = require("os");
var path = require("path");
var createSessionManager = require("../lib/sessions").createSessionManager;
var sessionProvenance = require("../lib/session-provenance");
var folders = require("../lib/session-folders");
var attachSessionDelete = require("../lib/project-session-delete").attachSessionDelete;
var attachFolders = require("../lib/project-session-folders").attachSessionFolders;
function env(keys) {
var set = {};
keys.forEach(function (k) { set[k] = true; });
return { canOrganize: function (k) { return !!set[k]; }, exists: function (k) { return !!set[k]; } };
}
function apply(state, op, keys) {
return folders.applyOperation(state, op, env(keys || ["a", "b", "c", "d"]));
}
// --- Pure model: contents move, delete never reaches it ---
test("delete_folder defaults to Unfiled and old requests keep that meaning", function () {
var s = apply(folders.defaultState(), { op: "create_folder", name: "Work" });
var work = s.folderId;
s = apply(s.state, { op: "place_session", sessionKey: "a", folderId: work }).state;
var legacy = apply(s, { op: "delete_folder", folderId: work });
assert.ok(legacy.state);
assert.deepStrictEqual(legacy.state.folders, []);
assert.strictEqual(legacy.state.assignments.a, undefined, "contents are Unfiled");
var explicit = apply(s, { op: "delete_folder", folderId: work, mode: "unfiled" });
assert.deepStrictEqual(explicit.state.assignments, {});
});
test("moving to another folder keeps the source order and appends to the destination", function () {
var s = folders.defaultState();
var a = apply(s, { op: "create_folder", name: "A" });
var b = apply(a.state, { op: "create_folder", name: "B" });
var from = a.folderId;
var to = b.folderId;
s = b.state;
["a", "b", "c"].forEach(function (k) { s = apply(s, { op: "place_session", sessionKey: k, folderId: from }).state; });
s = apply(s, { op: "set_order", containerKey: from, order: ["c", "a", "b"] }).state;
s = apply(s, { op: "place_session", sessionKey: "d", folderId: to, order: ["d"] }).state;
var moved = apply(s, { op: "delete_folder", folderId: from, mode: "move", destinationId: to });
assert.ok(moved.state, moved.error);
assert.deepStrictEqual(moved.state.folders.map(function (f) { return f.id; }), [to]);
assert.deepStrictEqual(moved.state.orders[to], ["d", "c", "a", "b"]);
["a", "b", "c", "d"].forEach(function (k) { assert.strictEqual(moved.state.assignments[k], to); });
assert.strictEqual(moved.state.orders[from], undefined);
});
test("Favorites is a tag, not a destination; bad destinations are refused before any change", function () {
var s = apply(folders.defaultState(), { op: "create_folder", name: "A" });
var id = s.folderId;
s = apply(s.state, { op: "place_session", sessionKey: "a", folderId: id }).state;
["favorites", "f_gone0000", id, "unfiled", "", undefined, 5].forEach(function (dest) {
var r = apply(s, { op: "delete_folder", folderId: id, mode: "move", destinationId: dest });
assert.ok(r.error, String(dest));
});
assert.ok(apply(s, { op: "delete_folder", folderId: id, mode: "delete" }).error, "deleting sessions is not a model operation");
assert.ok(apply(s, { op: "delete_folder", folderId: "favorites" }).error, "Favorites cannot be deleted");
assert.ok(apply(s, { op: "delete_folder", folderId: "unfiled" }).error, "Unfiled cannot be deleted");
});
// --- Handler with the real session manager and deletion service ---
function fixture(t, options) {
options = options || {};
var dir = fs.mkdtempSync(path.join(os.tmpdir(), "clay-folder-delete-"));
t.after(function () { fs.rmSync(dir, { recursive: true, force: true }); });
var sm = createSessionManager({ cwd: path.join(dir, "project"), sessionsBase: path.join(dir, "sessions"),
cliSessionsDir: path.join(dir, "cli"), send: function () {}, sendTo: function () {} });
sm.installedVendors = ["claude", "codex"];
sm.modelsByVendor = { claude: [{ value: "claude-model" }], codex: [{ value: "codex-model" }] };
var stored = {};
var denied = new Set();
var sent = [];
var calls = [];
var users = {
isMultiUser: function () { return !!options.multiUser; },
canAccessSession: function (userId, session) { return (session.ownerId || null) === userId && !denied.has(session.localId); },
getEffectivePermissions: function () { return { sessionDelete: options.deletePermission !== false }; },
getSessionFolders: function (uid, slug) { return folders.normalizeState(stored[uid + "/" + slug]); },
setSessionFolders: function (uid, slug, st) {
if (f && f.throwOnSave) throw new Error("disk full");
if (options.failSave) return { error: "Could not save folders" };
stored[uid + "/" + slug] = folders.normalizeState(st);
return { ok: true, state: stored[uid + "/" + slug] };
},
};
var f = null;
var wsA = options.multiUser ? { _clayUser: { id: "u1" } } : {};
var wsB = options.multiUser ? { _clayUser: { id: "u2" } } : null;
var clients = new Set([wsA]);
if (wsB) clients.add(wsB);
function sendTo(ws, msg) { sent.push({ ws: ws, msg: msg }); }
var sessionDelete = attachSessionDelete({
sm: sm, usersModule: users, osUsers: null, sendTo: sendTo,
tm: { close: function (id) { calls.push("pty:" + id); } },
getProjectAccess: function () { return { visibility: "public" }; },
stopTitleWatcher: function (s) { if (s._titleWatcherStop) s._titleWatcherStop(); },
});
var handler = attachFolders({
sm: sm, usersModule: users, slug: "proj", clients: clients, sendTo: sendTo,
getProjectAccess: function () { return { visibility: "public" }; }, sessionDelete: sessionDelete,
});
f = { sm: sm, handler: handler, ws: wsA, wsB: wsB, sent: sent, calls: calls, denied: denied, stored: stored, nextRid: 0 };
f.make = function (name, ownerId, extra) {
var s = sm.createSessionRaw(Object.assign({ cliSessionId: "cli-" + name, vendor: "codex", model: "codex-model", ownerId: ownerId || null }, extra || {}));
s.title = name;
s._titleWatcherStop = function () { calls.push("watcher:" + name); };
return s;
};
f.worker = function (driver, name) {
var w = f.make(name, driver.ownerId);
sessionProvenance.markWorker(driver, w, sm.sessions);
return w;
};
f.alive = function (s) { return sm.sessions.get(s.localId) === s; };
f.last = function (type, rid) {
for (var i = sent.length - 1; i >= 0; i--) if (sent[i].msg.type === type && (rid === undefined || sent[i].msg.requestId === rid)) return sent[i].msg;
return null;
};
f.send = function (ws, msg) { handler.handleMessage(ws || f.ws, Object.assign({ slug: "proj" }, msg)); };
f.op = function (op, ws) { f.send(ws, { type: "session_folders_op", op: op }); };
f.state = function (ws) { f.send(ws, { type: "session_folders_get" }); return f.last("session_folders_state").state; };
f.createFolder = function (name, ws) {
var rid = "c" + (++f.nextRid);
f.send(ws, { type: "session_folders_op", requestId: rid, op: { op: "create_folder", name: name } });
return f.last("session_folders_state", rid).folderId;
};
f.file = function (session, folderId, ws) { f.op({ op: "place_session", sessionId: session.localId, folderId: folderId }, ws); };
f.preview = function (folderId, ws) {
var rid = "p" + (++f.nextRid);
f.send(ws, { type: "session_folders_delete_preview", folderId: folderId, requestId: rid });
return f.last("session_folders_delete_preview_result", rid) || f.last("session_folders_state", rid);
};
f.remove = function (folderId, extra, ws) {
var pv = f.preview(folderId, ws);
var rid = "d" + (++f.nextRid);
f.send(ws, Object.assign({ type: "session_folders_delete", folderId: folderId, requestId: rid, token: pv.token }, extra));
return { rid: rid, reply: f.last("session_folders_state", rid), preview: pv };
};
return f;
}
// One Driver (two Worker generations, one of them hidden from the sidebar), a
// standalone session and an unrelated Driver outside the folder.
function build(t, options) {
var f = fixture(t, options);
var owner = options && options.multiUser ? "u1" : null;
var driver = f.make("driver", owner);
var gen1 = f.worker(driver, "gen1");
var gen2 = f.worker(driver, "gen2");
gen1.hidden = true;
var plain = f.make("plain", owner);
var outside = f.make("outside", owner);
var outsideWorker = f.worker(outside, "outside-worker");
var work = f.createFolder("Work", f.ws);
var other = f.createFolder("Other", f.ws);
f.file(driver, work);
f.file(plain, work);
return Object.assign(f, { driver: driver, gen1: gen1, gen2: gen2, plain: plain, outside: outside, outsideWorker: outsideWorker, work: work, other: other });
}
test("preview reports the server's full membership, Workers included, with no origin keys", function (t) {
var f = build(t);
var pv = f.preview(f.work);
assert.strictEqual(pv.type, "session_folders_delete_preview_result");
assert.strictEqual(pv.sessionCount, 2, "two organizable sessions");
assert.strictEqual(pv.workerCount, 2, "both Worker generations, hidden one included");
assert.strictEqual(pv.totalCount, 4);
assert.strictEqual(pv.canDeleteSessions, true);
assert.ok(typeof pv.token === "string" && pv.token.length >= 16);
var json = JSON.stringify(pv);
[f.driver, f.plain, f.gen1].forEach(function (s) { assert.strictEqual(json.indexOf(s.sessionOriginId), -1, "no origin id in the preview"); });
assert.strictEqual(f.preview("favorites").error, "Folder not found");
assert.strictEqual(f.preview("unfiled").error, "Folder not found");
});
test("move to Unfiled: nothing is deleted and the folder goes away", function (t) {
var f = build(t);
var r = f.remove(f.work, { mode: "unfiled" });
assert.ok(!r.reply.error, r.reply.error);
assert.strictEqual(r.reply.folderDeleted, f.work);
assert.ok(f.alive(f.driver) && f.alive(f.gen1) && f.alive(f.plain));
var st = f.state();
assert.deepStrictEqual(st.folders.map(function (x) { return x.id; }), [f.other]);
assert.strictEqual(st.assignments[f.driver.localId], undefined);
});
test("move to another folder keeps sessions and refuses a bad destination untouched", function (t) {
var f = build(t);
["", f.work, "unfiled", "f_missing00"].forEach(function (dest) {
var r = f.remove(f.work, { mode: "move", destinationId: dest });
assert.match(r.reply.error, /another folder/, "destination " + dest);
});
assert.ok(f.state().folders.some(function (x) { return x.id === f.work; }), "folder still exists");
var ok = f.remove(f.work, { mode: "move", destinationId: f.other });
assert.ok(!ok.reply.error, ok.reply.error);
var st = f.state();
assert.strictEqual(st.assignments[f.driver.localId], f.other);
assert.strictEqual(st.assignments[f.plain.localId], f.other);
assert.ok(f.alive(f.driver) && f.alive(f.plain));
var third = f.createFolder("Third");
f.file(f.outside, third);
var toFav = f.remove(third, { mode: "move", destinationId: "favorites" });
assert.match(toFav.reply.error, /another folder/, "Favorites is a tag, not a destination");
assert.ok(f.state().folders.some(function (x) { return x.id === third; }));
});
test("delete mode needs the explicit confirmation, then removes sessions, Workers and the folder", function (t) {
var f = build(t);
var unconfirmed = f.remove(f.work, { mode: "delete" });
assert.match(unconfirmed.reply.error, /Confirm/);
assert.ok(f.alive(f.driver) && f.alive(f.plain), "nothing deleted without confirmation");
var r = f.remove(f.work, { mode: "delete", confirmDelete: true });
assert.ok(!r.reply.error, r.reply.error);
assert.ok(!f.alive(f.driver) && !f.alive(f.plain), "members deleted");
assert.ok(!f.alive(f.gen1) && !f.alive(f.gen2), "every Worker generation deleted, hidden included");
assert.ok(f.alive(f.outside) && f.alive(f.outsideWorker), "unrelated Driver and Worker untouched");
assert.ok(f.calls.indexOf("watcher:driver") !== -1, "runtime cleanup ran");
assert.ok(!f.state().folders.some(function (x) { return x.id === f.work; }));
});
test("without delete permission nothing is deleted and the folder stays", function (t) {
var f = build(t, { multiUser: true, deletePermission: false });
var pv = f.preview(f.work);
assert.strictEqual(pv.canDeleteSessions, false);
assert.match(pv.deleteBlockedReason, /permission/);
var r = f.remove(f.work, { mode: "delete", confirmDelete: true });
assert.match(r.reply.error, /permission/);
assert.ok(f.alive(f.driver) && f.alive(f.gen1) && f.alive(f.plain));
assert.ok(f.state().folders.some(function (x) { return x.id === f.work; }));
var moved = f.remove(f.work, { mode: "unfiled" });
assert.ok(!moved.reply.error, "moving still works");
});
test("an inaccessible owned Worker blocks the whole deletion before anything is removed", function (t) {
var f = build(t, { multiUser: true });
f.denied.add(f.gen2.localId);
var pv = f.preview(f.work);
assert.strictEqual(pv.canDeleteSessions, false);
var r = f.remove(f.work, { mode: "delete", confirmDelete: true });
assert.match(r.reply.error, /not accessible/);
assert.ok(f.alive(f.driver) && f.alive(f.gen1) && f.alive(f.gen2) && f.alive(f.plain));
assert.ok(f.state().folders.some(function (x) { return x.id === f.work; }), "folder kept");
});
test("a session filed after the preview makes the request stale and changes nothing", function (t) {
var f = build(t);
var pv = f.preview(f.work);
var late = f.make("late", null);
f.file(late, f.work);
var rid = "late-1";
f.send(null, { type: "session_folders_delete", folderId: f.work, mode: "delete", confirmDelete: true, token: pv.token, requestId: rid });
var reply = f.last("session_folders_state", rid);
assert.match(reply.error, /changed/);
assert.strictEqual(reply.stale, true);
var fresh = f.last("session_folders_delete_preview_result", rid);
assert.strictEqual(fresh.sessionCount, 3, "a fresh preview follows");
assert.notStrictEqual(fresh.token, pv.token);
assert.ok(f.alive(f.driver) && f.alive(f.late || late) && f.alive(f.plain), "nothing deleted");
assert.ok(f.state().folders.some(function (x) { return x.id === f.work; }));
f.send(null, { type: "session_folders_delete", folderId: f.work, mode: "unfiled", requestId: "late-2", token: fresh.token });
assert.ok(!f.last("session_folders_state", "late-2").error);
});
test("a new Worker generation after the preview also invalidates a delete", function (t) {
var f = build(t);
var pv = f.preview(f.work);
f.worker(f.driver, "gen3");
f.send(null, { type: "session_folders_delete", folderId: f.work, mode: "delete", confirmDelete: true, token: pv.token, requestId: "w1" });
assert.strictEqual(f.last("session_folders_state", "w1").stale, true);
assert.ok(f.alive(f.driver));
});
test("missing or forged tokens, bad modes and wrong projects are refused", function (t) {
var f = build(t);
f.send(null, { type: "session_folders_delete", folderId: f.work, mode: "unfiled", requestId: "x1" });
assert.strictEqual(f.last("session_folders_state", "x1").stale, true, "no token");
f.send(null, { type: "session_folders_delete", folderId: f.work, mode: "unfiled", requestId: "x2", token: "forged" });
assert.strictEqual(f.last("session_folders_state", "x2").stale, true);
var pv = f.preview(f.work);
f.send(null, { type: "session_folders_delete", folderId: f.work, mode: "shred", requestId: "x3", token: pv.token });
assert.match(f.last("session_folders_state", "x3").error, /Choose what happens/);
f.send(null, { type: "session_folders_delete", slug: "other-project", folderId: f.work, mode: "unfiled", requestId: "x4", token: pv.token });
assert.match(f.last("session_folders_state", "x4").error, /different project/);
f.send(null, { type: "session_folders_delete", folderId: "favorites", mode: "unfiled", requestId: "x5", token: pv.token });
assert.match(f.last("session_folders_state", "x5").error, /not found/);
assert.ok(f.state().folders.some(function (x) { return x.id === f.work; }));
assert.ok(f.alive(f.driver) && f.alive(f.plain));
});
test("another user cannot preview or delete this user's folder or sessions", function (t) {
var f = build(t, { multiUser: true });
var pv = f.preview(f.work, f.ws);
assert.strictEqual(f.preview(f.work, f.wsB).error, "Folder not found", "folders are personal");
f.send(f.wsB, { type: "session_folders_delete", folderId: f.work, mode: "delete", confirmDelete: true, token: pv.token, requestId: "o1" });
assert.strictEqual(f.last("session_folders_state", "o1").error, "Folder not found");
assert.ok(f.alive(f.driver) && f.alive(f.plain));
});
test("an unavoidable partial deletion failure keeps the folder and says sessions may be gone", function (t) {
var f = build(t);
var original = f.sm.deleteSessionsBulk;
f.sm.deleteSessionsBulk = function (ids, ws) {
original.call(f.sm, [ids[0]], ws);
throw new Error("disk failure");
};
var quiet = console.error;
console.error = function () {};
var r;
try { r = f.remove(f.work, { mode: "delete", confirmDelete: true }); } finally { console.error = quiet; f.sm.deleteSessionsBulk = original; }
assert.match(r.reply.error, /part way/);
assert.match(r.reply.error, /may already have been deleted/);
assert.strictEqual(r.reply.folderDeleted, undefined, "no success acknowledgement");
assert.ok(f.state().folders.some(function (x) { return x.id === f.work; }), "folder kept");
assert.strictEqual(Object.keys(r.reply.state.assignments).length, 1, "the reply reflects what is left in the folder");
});
test("a throwing save on a move changes nothing and is not acknowledged", function (t) {
var f = build(t);
var pv = f.preview(f.work);
f.throwOnSave = true;
var quiet = console.error;
console.error = function () {};
try { f.send(null, { type: "session_folders_delete", folderId: f.work, mode: "move", destinationId: f.other, token: pv.token, requestId: "t1" }); }
finally { console.error = quiet; f.throwOnSave = false; }
var reply = f.last("session_folders_state", "t1");
assert.match(reply.error, /nothing was changed/);
assert.strictEqual(reply.folderDeleted, undefined);
assert.ok(f.alive(f.driver) && f.alive(f.plain), "sessions untouched");
var st = f.state();
assert.ok(st.folders.some(function (x) { return x.id === f.work; }), "folder still there");
assert.strictEqual(st.assignments[f.driver.localId], f.work, "assignments unchanged");
});
test("a throwing save after session deletion reports the honest partial outcome", function (t) {
var f = build(t);
var pv = f.preview(f.work);
f.throwOnSave = true;
var quiet = console.error;
console.error = function () {};
try { f.send(null, { type: "session_folders_delete", folderId: f.work, mode: "delete", confirmDelete: true, token: pv.token, requestId: "t2" }); }
finally { console.error = quiet; f.throwOnSave = false; }
var reply = f.last("session_folders_state", "t2");
assert.match(reply.error, /sessions were deleted but the folder could not be removed/);
assert.strictEqual(reply.folderDeleted, undefined, "no success acknowledgement");
assert.ok(!f.alive(f.driver) && !f.alive(f.plain) && !f.alive(f.gen1), "the sessions really are gone");
assert.ok(f.state().folders.some(function (x) { return x.id === f.work; }), "the folder is still listed so it can be deleted again");
var retry = f.remove(f.work, { mode: "unfiled" });
assert.ok(!retry.reply.error, "a second attempt removes the now empty folder");
});
test("an empty folder is deleted directly and unaffected sessions stay", function (t) {
var f = build(t);
var pv = f.preview(f.other);
assert.strictEqual(pv.sessionCount, 0);
var r = f.remove(f.other, { mode: "unfiled" });
assert.ok(!r.reply.error);
assert.ok(f.alive(f.driver) && f.alive(f.plain));
});
test("the old delete_folder operation still moves contents to Unfiled", function (t) {
var f = build(t);
f.op({ op: "delete_folder", folderId: f.work });
var st = f.last("session_folders_state").state;
assert.ok(!st.folders.some(function (x) { return x.id === f.work; }));
assert.strictEqual(st.assignments[f.driver.localId], undefined);
assert.ok(f.alive(f.driver) && f.alive(f.plain));
f.op({ op: "delete_folder", folderId: f.other, mode: "delete" });
assert.ok(f.last("session_folders_state").error, "the old operation can never delete sessions");
});
test("dual membership: deleting a folder keeps surviving favorites' tags, deleting chats prunes them, and counts ignore the tag", function (t) {
var f = build(t);
f.op({ op: "set_favorite", sessionId: f.driver.localId, favorite: true });
f.op({ op: "set_favorite", sessionId: f.outside.localId, favorite: true });
var pv = f.preview(f.work);
assert.strictEqual(pv.sessionCount, 2, "the folder's members are counted once each, whether or not they are favorites");
assert.strictEqual(pv.totalCount, 4, "a favorited Driver is not counted twice");
var moved = f.remove(f.work, { mode: "unfiled" });
assert.ok(!moved.reply.error, moved.reply.error);
var st = f.state();
assert.deepStrictEqual(st.favorites.slice().sort(), [f.driver.localId, f.outside.localId].sort(), "tags survive a folder deletion that keeps the chats");
var again = f.createFolder("Again");
f.file(f.driver, again);
var gone = f.remove(again, { mode: "delete", confirmDelete: true });
assert.ok(!gone.reply.error, gone.reply.error);
assert.ok(!f.alive(f.driver));
assert.deepStrictEqual(f.state().favorites, [f.outside.localId], "deleting the chat prunes its tag; other tags stay");
});