@luckydraw/cumulus 1.0.44 → 1.0.45

package/dist/gateway/server.js

@@ -9,6 +9,7 @@
  *   GET  /api/thread/:name/status   — thread info + adaptive state
  *   GET  /api/threads               — list all threads
  *   DELETE /api/thread/:name        — delete thread (requires X-Confirm: delete)
+ *   POST /api/thread/:name/rename   — rename a thread or co-thread (body: { name })
  *   POST /api/migrate               — sync thread + clone repo + set projectDir
  *   POST /api/media/upload          — upload file to media directory (returns URL)
  *   GET  /media/*                   — serve uploaded media files (no auth)
@@ -39,6 +40,7 @@ import { allNamespaceKeys, demoMintDenial, extraMcpServersForThread, licenseBann
 import { configureVapid, sendNotification, subscribe as pushSubscribe, unsubscribe as pushUnsubscribe, } from './push.js';
 import { automatedSender, isAutomatedSender, STALL_NUDGE_MARKER } from './senders.js';
 import { definiteStallForMessage, extractDanglingSentence, isStalled, pendingWakeReason, } from './stall-detection.js';
+import { executeThreadRename, planThreadRename, THREAD_FILE_EXTENSIONS, ThreadRenameError, } from './thread-rename.js';
 import { validateTranscriptFlush, ingestTranscriptFlush } from './transcript-ingest.js';
 const threadQueues = new Map();
 const threadBusy = new Map();
@@ -175,6 +177,23 @@ let threadActivityListener = null;
 export function setThreadActivityListener(fn) {
     threadActivityListener = fn;
 }
+// Task 186 — a rename has to reach every open tab, or the sidebar keeps a
+// name that no longer exists and its next click 404s. Same shape and the same
+// reason as the activity listener above: only the adapter can reach sockets.
+let threadRenameListener = null;
+export function setThreadRenameListener(fn) {
+    threadRenameListener = fn;
+}
+function notifyThreadRenamed(from, to) {
+    if (!threadRenameListener)
+        return;
+    try {
+        threadRenameListener(from, to);
+    }
+    catch (err) {
+        console.error(`[Gateway] thread rename listener failed for "${from}": ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
 /**
  * Announce a change in whether a thread is running a turn.
  *
@@ -339,6 +358,8 @@ let federationRouter;
  * out here — the same pattern `federationRouter` above already uses.
  */
 let jobRegistry;
+/** Module-level mirror of the scheduler handle: `handleRenameThread` re-arms timers (task 186). */
+let schedulerHandle;
 /**
  * Pipeline options for spawning turns outside a request context (agent queue
  * drains). Set once at server startup; the object is shared with the running
@@ -1386,6 +1407,87 @@ async function handleDeleteThread(threadName, req, res) {
         jsonResponse(res, 500, { error: String(err) });
     }
 }
+/**
+ * Re-key one server-side map from `from` to `to`, if it has an entry.
+ * Exists so `handleRenameThread` lists every map once and cannot half-move one.
+ */
+function moveMapKey(map, from, to) {
+    if (!map.has(from))
+        return;
+    map.set(to, map.get(from));
+    map.delete(from);
+}
+/**
+ * POST /api/thread/:name/rename — body `{ name }` (task 186).
+ *
+ * `planThreadRename` refuses anything illegal before a byte moves;
+ * `executeThreadRename` moves the on-disk rows. What is left for this handler
+ * is everything that lives only in this process: caches, queues, the stall
+ * timer, jobs, schedules — and telling the sockets. Each one is listed here
+ * and nowhere else, so the rename module stays free of server state and this
+ * handler stays the single place a name changes at runtime.
+ */
+async function handleRenameThread(threadName, req, res, namespaces) {
+    let body;
+    try {
+        body = JSON.parse(await readBody(req));
+    }
+    catch {
+        jsonResponse(res, 400, { error: 'Invalid JSON body' });
+        return;
+    }
+    const newName = (body.name ?? '').trim();
+    if (!newName) {
+        jsonResponse(res, 400, { error: 'Missing "name"' });
+        return;
+    }
+    const exists = (name) => THREAD_FILE_EXTENSIONS.some(ext => fs.existsSync(path.join(THREADS_DIR, `${name}${ext}`)));
+    try {
+        const plan = await planThreadRename(threadName, newName, {
+            namespaces,
+            threadExists: exists,
+            threadBusy: name => threadBusy.get(name) === true,
+            coThreadMasterOf: resolveCoThreadMaster,
+            coThreadsOf: async (master) => (await loadThreadConfigExact(master)).coThreads ?? [],
+        });
+        const result = await executeThreadRename(plan, {
+            threadsDir: THREADS_DIR,
+            projectDirFor,
+        });
+        for (const move of plan.moves) {
+            clearThreadCache(move.from);
+            threadBusy.delete(move.from);
+            moveMapKey(threadQueues, move.from, move.to);
+            moveMapKey(userQueues, move.from, move.to);
+            moveMapKey(agentQueues, move.from, move.to);
+            moveMapKey(bridgeContexts, move.from, move.to);
+            moveMapKey(stallNudgeCounts, move.from, move.to);
+            // A pending stall check would read the old name's history, which is gone.
+            // Cancelled rather than moved: the thread is idle (rule 6) and the next
+            // busy→idle edge arms a fresh one under the new name.
+            const stall = stallTimers.get(move.from);
+            if (stall) {
+                clearTimeout(stall);
+                stallTimers.delete(move.from);
+            }
+            jobRegistry?.rename(move.from, move.to);
+            // The moved config carries the schedules; the old name's config is gone.
+            schedulerHandle?.reloadThread(move.from);
+            schedulerHandle?.reloadThread(move.to);
+            notifyThreadRenamed(move.from, move.to);
+        }
+        console.log(`[Gateway] renamed thread "${plan.from}" → "${plan.to}"` +
+            (plan.coThreads.length ? ` with ${plan.coThreads.length} co-thread(s)` : ''));
+        jsonResponse(res, 200, { renamed: true, ...result });
+    }
+    catch (err) {
+        if (err instanceof ThreadRenameError) {
+            jsonResponse(res, err.status, { error: err.message });
+            return;
+        }
+        jsonResponse(res, 500, { error: String(err) });
+    }
+}
 async function handleDeleteMessages(threadName, req, res) {
     const confirm = req.headers['x-confirm'];
     if (confirm !== 'delete') {
@@ -2707,6 +2809,11 @@ export async function startGatewayServer(options) {
                 await handleDeleteThread(params.name, req, res);
                 return;
             }
+            // POST /api/thread/:name/rename — rename a thread or co-thread (task 186)
+            if (routePath === '/api/thread/:name/rename' && req.method === 'POST') {
+                await handleRenameThread(params.name, req, res, namespaces);
+                return;
+            }
             // DELETE /api/thread/:name/messages
             if (routePath === '/api/thread/:name/messages' && req.method === 'DELETE') {
                 await handleDeleteMessages(params.name, req, res);
@@ -3073,6 +3180,7 @@ export async function startGatewayServer(options) {
                 },
                 setScheduler: (s) => {
                     scheduler = s;
+                    schedulerHandle = s;
                 },
                 setJobRegistry: (r) => {
                     jobRegistry = r;