@qwen-code/channel-base 0.22.2-preview.1 → 0.22.3

package/dist/named-session-manager.js

@@ -0,0 +1,695 @@
+import { randomUUID } from 'node:crypto';
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from 'node:fs';
+import { dirname } from 'node:path';
+import process from 'node:process';
+import { canonicalizeWorkspacePath } from './paths.js';
+const REGISTRY_VERSION = 1;
+const MAX_OPEN_TASKS = 8;
+const TASK_NAME_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]{0,31}$/;
+export class NamedSessionManager {
+    channelName;
+    cwd;
+    canonicalCwd;
+    filePath;
+    router;
+    isBusy;
+    now;
+    registry;
+    ownerOperations = new Map();
+    constructor(options) {
+        this.channelName = options.channelName;
+        this.cwd = options.cwd;
+        this.canonicalCwd = canonicalizeWorkspacePath(options.cwd);
+        this.filePath = options.filePath;
+        this.router = options.router;
+        this.isBusy = options.isBusy;
+        this.now = options.now ?? Date.now;
+        this.registry = this.readRegistry();
+    }
+    resolve(input, expectedSessionId, reserve) {
+        return this.withOwnerLock(input, () => this.resolveLocked(input, expectedSessionId, reserve));
+    }
+    resolveAfterPreparation(input, prepare, needsSession, reserve) {
+        return this.withOwnerLock(input, async () => {
+            if ((await prepare()) === false)
+                return { status: 'aborted' };
+            if (!needsSession())
+                return { status: 'bypassed' };
+            try {
+                return {
+                    status: 'resolved',
+                    sessionId: await this.resolveLocked(input, undefined, reserve),
+                };
+            }
+            catch (error) {
+                return { status: 'resolve_error', error };
+            }
+        });
+    }
+    list(input, includeClosed) {
+        return this.withOwnerLock(input, async () => {
+            const owner = await this.ensureOwner(input, false);
+            if (!owner)
+                return [];
+            return owner.tasks
+                .filter((task) => includeClosed || task.status === 'open')
+                .map((task) => this.view(owner, task));
+        });
+    }
+    current(input) {
+        return this.withOwnerLock(input, async () => {
+            const owner = await this.ensureOwner(input, false);
+            if (!owner?.activeTaskName)
+                return undefined;
+            const task = this.findTask(owner, owner.activeTaskName);
+            return task ? this.selection(owner, task) : undefined;
+        });
+    }
+    create(input, name) {
+        return this.withOwnerLock(input, async () => {
+            this.validateName(name);
+            const existingOwner = await this.ensureOwner(input, false);
+            const owner = existingOwner ?? this.createOwner(input, null, []);
+            if (this.findTask(owner, name)) {
+                throw new Error(`Task "${name}" already exists.`);
+            }
+            if (this.openTaskCount(owner) >= MAX_OPEN_TASKS) {
+                throw new Error('You already have eight open tasks. Close one before creating another.');
+            }
+            this.assertCanLeaveSelected(owner, undefined);
+            const timestamp = this.nextTimestamp(owner);
+            const target = this.target(input);
+            const sessionId = await this.createSession(target, this.cwd, `Could not create task "${name}".`);
+            const task = {
+                name,
+                sessionId,
+                cwd: this.cwd,
+                isolation: 'shared',
+                status: 'open',
+                target,
+                createdAt: timestamp,
+                updatedAt: timestamp,
+                lastSelectedAt: timestamp,
+            };
+            const nextOwner = {
+                ...owner,
+                activeTaskName: name,
+                tasks: [...owner.tasks, task],
+            };
+            try {
+                this.commitOwner(nextOwner);
+            }
+            catch (error) {
+                await this.router
+                    .detachManagedSession(sessionId)
+                    .catch(() => undefined);
+                throw error;
+            }
+            this.router.activateManagedSession(sessionId, target, this.cwd);
+            return this.selection(nextOwner, task);
+        });
+    }
+    use(input, name) {
+        return this.withOwnerLock(input, async () => {
+            const owner = await this.ensureOwner(input, false);
+            if (!owner)
+                throw new Error('No named tasks exist in this chat.');
+            const task = this.findTask(owner, name);
+            if (!task)
+                throw new Error(`Task "${name}" was not found.`);
+            this.assertCanLeaveSelected(owner, task.name);
+            if (this.isBusy(task.sessionId)) {
+                throw new Error(`Task "${task.name}" is still running or waiting for permission.`);
+            }
+            if (task.status === 'closed' &&
+                this.openTaskCount(owner) >= MAX_OPEN_TASKS) {
+                throw new Error('You already have eight open tasks. Close one before reopening another.');
+            }
+            const timestamp = this.nextTimestamp(owner);
+            const loaded = await this.loadTask(task, `Could not load task "${task.name}". The current task was not changed.`);
+            const updatedTask = {
+                ...task,
+                status: 'open',
+                updatedAt: timestamp,
+                lastSelectedAt: timestamp,
+            };
+            const nextOwner = this.replaceTask(owner, updatedTask, task.name);
+            try {
+                this.commitOwner(nextOwner);
+            }
+            catch (error) {
+                if (loaded) {
+                    await this.router
+                        .detachManagedSession(task.sessionId)
+                        .catch(() => undefined);
+                }
+                throw error;
+            }
+            this.router.activateManagedSession(task.sessionId, task.target, task.cwd);
+            return this.selection(nextOwner, updatedTask);
+        });
+    }
+    close(input, name) {
+        return this.withOwnerLock(input, async () => {
+            const owner = await this.ensureOwner(input, false);
+            if (!owner)
+                throw new Error('No named tasks exist in this chat.');
+            const task = this.findTask(owner, name);
+            if (!task)
+                throw new Error(`Task "${name}" was not found.`);
+            if (task.status === 'closed') {
+                throw new Error(`Task "${task.name}" is already closed.`);
+            }
+            if (this.isBusy(task.sessionId)) {
+                throw new Error(`Task "${task.name}" is still running or waiting for permission.`);
+            }
+            const wasActive = this.sameName(owner.activeTaskName, task.name);
+            const timestamp = this.nextTimestamp(owner);
+            const replacement = wasActive
+                ? owner.tasks
+                    .filter((candidate) => candidate.status === 'open' &&
+                    !this.sameName(candidate.name, task.name))
+                    .sort((a, b) => b.lastSelectedAt - a.lastSelectedAt)[0]
+                : undefined;
+            let replacementLoaded = false;
+            if (replacement) {
+                if (this.isBusy(replacement.sessionId)) {
+                    throw new Error(`Task "${replacement.name}" is still running or waiting for permission.`);
+                }
+                replacementLoaded = await this.loadTask(replacement, `Could not load fallback task "${replacement.name}". Task "${task.name}" was not closed.`);
+            }
+            const closedTask = {
+                ...task,
+                status: 'closed',
+                updatedAt: timestamp,
+            };
+            let nextOwner = this.replaceTask(owner, closedTask, wasActive ? (replacement?.name ?? null) : owner.activeTaskName);
+            const selectedReplacement = replacement
+                ? {
+                    ...replacement,
+                    updatedAt: timestamp,
+                    lastSelectedAt: timestamp,
+                }
+                : undefined;
+            if (selectedReplacement) {
+                nextOwner = this.replaceTask(nextOwner, selectedReplacement, selectedReplacement.name);
+            }
+            try {
+                this.commitOwner(nextOwner);
+            }
+            catch (error) {
+                if (replacement && replacementLoaded) {
+                    await this.router
+                        .detachManagedSession(replacement.sessionId)
+                        .catch(() => undefined);
+                }
+                throw error;
+            }
+            if (replacement) {
+                this.router.activateManagedSession(replacement.sessionId, replacement.target, replacement.cwd);
+            }
+            try {
+                await this.router.detachManagedSession(task.sessionId);
+            }
+            catch (error) {
+                this.commitOwner(owner);
+                this.router.forgetManagedSession(task.sessionId);
+                await this.loadTask(task, `Task "${task.name}" could not be restored after close failed.`);
+                if (wasActive) {
+                    this.router.activateManagedSession(task.sessionId, task.target, task.cwd);
+                }
+                throw new Error(`Failed to close task "${task.name}".`, {
+                    cause: error,
+                });
+            }
+            const activeTask = nextOwner.activeTaskName
+                ? this.findTask(nextOwner, nextOwner.activeTaskName)
+                : undefined;
+            return {
+                closed: this.view(nextOwner, closedTask),
+                ...(activeTask ? { active: this.view(nextOwner, activeTask) } : {}),
+            };
+        });
+    }
+    reset(input) {
+        return this.withOwnerLock(input, async () => {
+            const owner = await this.ensureOwner(input, false);
+            if (!owner?.activeTaskName)
+                return undefined;
+            const task = this.findTask(owner, owner.activeTaskName);
+            if (!task || task.status !== 'open')
+                return undefined;
+            const timestamp = this.nextTimestamp(owner);
+            const sessionId = await this.createSession(task.target, task.cwd, `Could not reset task "${task.name}".`);
+            const updatedTask = {
+                ...task,
+                sessionId,
+                updatedAt: timestamp,
+                lastSelectedAt: timestamp,
+            };
+            const nextOwner = this.replaceTask(owner, updatedTask, task.name);
+            try {
+                this.commitOwner(nextOwner);
+            }
+            catch (error) {
+                await this.router
+                    .detachManagedSession(sessionId)
+                    .catch(() => undefined);
+                throw error;
+            }
+            this.router.activateManagedSession(sessionId, updatedTask.target, updatedTask.cwd);
+            this.router.forgetManagedSession(task.sessionId);
+            return {
+                name: task.name,
+                previousSessionId: task.sessionId,
+                sessionId,
+            };
+        });
+    }
+    async ensureOwner(input, createDefault) {
+        const existing = this.getOwner(input);
+        if (existing)
+            return existing;
+        const sessionId = this.router.getSession(this.channelName, input.senderId, input.chatId);
+        const routedTarget = sessionId
+            ? this.router.getTarget(sessionId)
+            : undefined;
+        if (sessionId &&
+            routedTarget &&
+            (routedTarget.channelName !== this.channelName ||
+                routedTarget.chatId !== input.chatId ||
+                routedTarget.senderId !== input.senderId)) {
+            this.adoptForeignLegacyRoute(sessionId, routedTarget);
+        }
+        if (sessionId &&
+            routedTarget?.channelName === this.channelName &&
+            routedTarget.chatId === input.chatId &&
+            routedTarget.senderId === input.senderId) {
+            const routedCwd = this.router.getSessionCwd(sessionId);
+            if (routedCwd !== undefined && !this.isCurrentCwd(routedCwd)) {
+                await this.router
+                    .detachManagedSession(sessionId)
+                    .catch(() => undefined);
+            }
+            else {
+                const timestamp = this.nextTimestamp();
+                const task = {
+                    name: 'default',
+                    sessionId,
+                    cwd: routedCwd ?? this.cwd,
+                    isolation: 'shared',
+                    status: 'open',
+                    target: routedTarget,
+                    createdAt: timestamp,
+                    updatedAt: timestamp,
+                    lastSelectedAt: timestamp,
+                };
+                const adopted = this.createOwner(input, task.name, [task]);
+                this.commitOwner(adopted);
+                return adopted;
+            }
+        }
+        if (!createDefault)
+            return undefined;
+        const target = this.target(input);
+        const timestamp = this.nextTimestamp();
+        const createdSessionId = await this.createSession(target, this.cwd, 'Could not create the default task.');
+        const task = {
+            name: 'default',
+            sessionId: createdSessionId,
+            cwd: this.cwd,
+            isolation: 'shared',
+            status: 'open',
+            target,
+            createdAt: timestamp,
+            updatedAt: timestamp,
+            lastSelectedAt: timestamp,
+        };
+        const created = this.createOwner(input, task.name, [task]);
+        try {
+            this.commitOwner(created);
+        }
+        catch (error) {
+            await this.router
+                .detachManagedSession(createdSessionId)
+                .catch(() => undefined);
+            throw error;
+        }
+        this.router.activateManagedSession(createdSessionId, target, this.cwd);
+        return created;
+    }
+    async resolveLocked(input, expectedSessionId, reserve) {
+        const owner = await this.ensureOwner(input, true);
+        if (!owner?.activeTaskName)
+            return undefined;
+        const task = this.findTask(owner, owner.activeTaskName);
+        if (!task || task.status !== 'open') {
+            throw new Error('The selected Channel task is unavailable.');
+        }
+        if (expectedSessionId !== undefined &&
+            task.sessionId !== expectedSessionId) {
+            return undefined;
+        }
+        const release = reserve?.(task.sessionId);
+        try {
+            await this.loadTask(task, `Could not load task "${task.name}". No replacement session was created.`);
+            this.router.activateManagedSession(task.sessionId, task.target, task.cwd);
+            return task.sessionId;
+        }
+        catch (error) {
+            release?.();
+            throw error;
+        }
+    }
+    adoptForeignLegacyRoute(sessionId, target) {
+        const cwd = this.router.getSessionCwd(sessionId);
+        if (target.channelName !== this.channelName ||
+            cwd === undefined ||
+            !this.isCurrentCwd(cwd)) {
+            this.router.forgetManagedSession(sessionId);
+            return;
+        }
+        const existing = this.getOwner(target);
+        if (existing) {
+            if (existing.tasks.some((task) => task.sessionId === sessionId))
+                return;
+            this.router.forgetManagedSession(sessionId);
+            return;
+        }
+        const timestamp = this.nextTimestamp();
+        const task = {
+            name: 'default',
+            sessionId,
+            cwd,
+            isolation: 'shared',
+            status: 'open',
+            target,
+            createdAt: timestamp,
+            updatedAt: timestamp,
+            lastSelectedAt: timestamp,
+        };
+        this.commitOwner(this.createOwner(target, task.name, [task]));
+    }
+    assertCanLeaveSelected(owner, nextTaskName) {
+        if (!owner.activeTaskName ||
+            (nextTaskName && this.sameName(owner.activeTaskName, nextTaskName))) {
+            return;
+        }
+        const selected = this.findTask(owner, owner.activeTaskName);
+        if (selected && this.isBusy(selected.sessionId)) {
+            throw new Error(`Task "${selected.name}" is still running or waiting for permission.`);
+        }
+    }
+    async loadTask(task, failureMessage) {
+        try {
+            return (await this.router.loadManagedSession(task.sessionId, task.target, task.cwd)).loaded;
+        }
+        catch (error) {
+            throw new Error(failureMessage, { cause: error });
+        }
+    }
+    async createSession(target, cwd, failureMessage) {
+        try {
+            return await this.router.createManagedSession(target, cwd);
+        }
+        catch (error) {
+            throw new Error(failureMessage, { cause: error });
+        }
+    }
+    withOwnerLock(input, operation) {
+        const key = JSON.stringify([
+            this.channelName,
+            input.chatId,
+            input.senderId,
+        ]);
+        const previous = this.ownerOperations.get(key) ?? Promise.resolve();
+        const result = previous.catch(() => undefined).then(operation);
+        const tail = result.then(() => undefined, () => undefined);
+        this.ownerOperations.set(key, tail);
+        return result.finally(() => {
+            if (this.ownerOperations.get(key) === tail) {
+                this.ownerOperations.delete(key);
+            }
+        });
+    }
+    getOwner(input) {
+        const owner = this.registry.owners.find((candidate) => candidate.channelName === this.channelName &&
+            candidate.chatId === input.chatId &&
+            candidate.senderId === input.senderId);
+        return owner ? this.cloneOwner(owner) : undefined;
+    }
+    createOwner(input, activeTaskName, tasks) {
+        return {
+            channelName: this.channelName,
+            chatId: input.chatId,
+            senderId: input.senderId,
+            activeTaskName,
+            tasks,
+        };
+    }
+    target(input) {
+        return {
+            channelName: this.channelName,
+            senderId: input.senderId,
+            chatId: input.chatId,
+            ...(input.threadId !== undefined ? { threadId: input.threadId } : {}),
+            ...(input.isGroup !== undefined ? { isGroup: input.isGroup } : {}),
+        };
+    }
+    findTask(owner, name) {
+        const normalized = this.normalizeName(name);
+        return owner.tasks.find((task) => this.normalizeName(task.name) === normalized);
+    }
+    replaceTask(owner, task, activeTaskName) {
+        return {
+            ...owner,
+            activeTaskName,
+            tasks: owner.tasks.map((candidate) => this.sameName(candidate.name, task.name) ? task : candidate),
+        };
+    }
+    view(owner, task) {
+        return {
+            name: task.name,
+            status: task.status,
+            isolation: task.isolation,
+            active: task.status === 'open' &&
+                this.sameName(owner.activeTaskName, task.name),
+        };
+    }
+    selection(owner, task) {
+        return { ...this.view(owner, task), sessionId: task.sessionId };
+    }
+    openTaskCount(owner) {
+        return owner.tasks.filter((task) => task.status === 'open').length;
+    }
+    nextTimestamp(owner) {
+        const now = this.now();
+        if (!Number.isSafeInteger(now) || now < 0) {
+            throw new Error('Invalid named-session clock value.');
+        }
+        let timestamp = now;
+        for (const task of owner?.tasks ?? []) {
+            timestamp = Math.max(timestamp, task.createdAt + 1, task.updatedAt + 1, task.lastSelectedAt + 1);
+        }
+        if (!Number.isSafeInteger(timestamp)) {
+            throw new Error('Named-session timestamp limit reached.');
+        }
+        return timestamp;
+    }
+    validateName(name) {
+        if (!TASK_NAME_PATTERN.test(name)) {
+            throw new Error('Task names must be 1-32 ASCII letters, numbers, underscores, or hyphens and start with a letter or number.');
+        }
+    }
+    normalizeName(name) {
+        return name.toLowerCase();
+    }
+    sameName(a, b) {
+        return a !== null && this.normalizeName(a) === this.normalizeName(b);
+    }
+    cloneOwner(owner) {
+        return {
+            ...owner,
+            tasks: owner.tasks.map((task) => ({
+                ...task,
+                target: { ...task.target },
+            })),
+        };
+    }
+    commitOwner(owner) {
+        const owners = this.registry.owners.map((candidate) => candidate.channelName === owner.channelName &&
+            candidate.chatId === owner.chatId &&
+            candidate.senderId === owner.senderId
+            ? owner
+            : candidate);
+        if (!owners.some((candidate) => candidate.channelName === owner.channelName &&
+            candidate.chatId === owner.chatId &&
+            candidate.senderId === owner.senderId)) {
+            owners.push(owner);
+        }
+        const next = { version: REGISTRY_VERSION, owners };
+        if (!this.isRegistry(next)) {
+            throw new Error('Invalid named-session registry update.');
+        }
+        this.writeRegistry(next);
+        this.registry = next;
+    }
+    readRegistry() {
+        if (!existsSync(this.filePath)) {
+            return { version: REGISTRY_VERSION, owners: [] };
+        }
+        let value;
+        try {
+            value = JSON.parse(readFileSync(this.filePath, 'utf8'));
+        }
+        catch (error) {
+            throw new Error(`Failed to read named-session registry: ${this.filePath}`, {
+                cause: error,
+            });
+        }
+        if (!this.isRegistry(value)) {
+            if (this.isRegistry(value, false)) {
+                const stalePath = `${this.filePath}.stale-${randomUUID()}`;
+                try {
+                    renameSync(this.filePath, stalePath);
+                }
+                catch (error) {
+                    throw new Error('Failed to archive stale named-session registry.', {
+                        cause: error,
+                    });
+                }
+                process.stderr.write('[NamedSessionManager] Archived a stale registry after the channel working directory changed.\n');
+                return { version: REGISTRY_VERSION, owners: [] };
+            }
+            throw new Error(`Invalid named-session registry: ${this.filePath}`);
+        }
+        return value;
+    }
+    writeRegistry(registry) {
+        const dir = dirname(this.filePath);
+        const tempPath = `${this.filePath}.${process.pid}-${randomUUID()}.tmp`;
+        try {
+            mkdirSync(dir, { recursive: true, mode: 0o700 });
+            try {
+                chmodSync(dir, 0o700);
+            }
+            catch {
+                // Some filesystems do not implement POSIX modes.
+            }
+            writeFileSync(tempPath, JSON.stringify(registry, null, 2), {
+                encoding: 'utf8',
+                mode: 0o600,
+            });
+            renameSync(tempPath, this.filePath);
+            try {
+                chmodSync(this.filePath, 0o600);
+            }
+            catch {
+                // Some filesystems do not implement POSIX modes.
+            }
+        }
+        catch (error) {
+            throw new Error('Failed to persist named-session registry.', {
+                cause: error,
+            });
+        }
+        finally {
+            try {
+                rmSync(tempPath, { force: true });
+            }
+            catch {
+                // Best-effort temporary-file cleanup.
+            }
+        }
+    }
+    isRegistry(value, requireCurrentCwd = true) {
+        if (!this.isRecord(value) || value['version'] !== REGISTRY_VERSION) {
+            return false;
+        }
+        const owners = value['owners'];
+        if (!Array.isArray(owners))
+            return false;
+        const ownerKeys = new Set();
+        const sessionIds = new Set();
+        for (const owner of owners) {
+            if (!this.isOwner(owner, ownerKeys, sessionIds, requireCurrentCwd)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    isOwner(value, ownerKeys, sessionIds, requireCurrentCwd) {
+        if (!this.isRecord(value))
+            return false;
+        const channelName = value['channelName'];
+        const chatId = value['chatId'];
+        const senderId = value['senderId'];
+        const activeTaskName = value['activeTaskName'];
+        const tasks = value['tasks'];
+        if (channelName !== this.channelName ||
+            typeof chatId !== 'string' ||
+            typeof senderId !== 'string' ||
+            (activeTaskName !== null && typeof activeTaskName !== 'string') ||
+            !Array.isArray(tasks)) {
+            return false;
+        }
+        const ownerKey = JSON.stringify([channelName, chatId, senderId]);
+        if (ownerKeys.has(ownerKey))
+            return false;
+        ownerKeys.add(ownerKey);
+        const names = new Set();
+        let openTasks = 0;
+        let activeFound = activeTaskName === null;
+        for (const task of tasks) {
+            if (!this.isTask(task, channelName, chatId, senderId, requireCurrentCwd)) {
+                return false;
+            }
+            const normalized = this.normalizeName(task.name);
+            if (names.has(normalized) || sessionIds.has(task.sessionId))
+                return false;
+            names.add(normalized);
+            sessionIds.add(task.sessionId);
+            if (task.status === 'open')
+                openTasks++;
+            if (activeTaskName !== null &&
+                task.status === 'open' &&
+                this.sameName(activeTaskName, task.name)) {
+                activeFound = true;
+            }
+        }
+        return openTasks <= MAX_OPEN_TASKS && activeFound;
+    }
+    isTask(value, channelName, chatId, senderId, requireCurrentCwd) {
+        if (!this.isRecord(value) || !this.isRecord(value['target']))
+            return false;
+        const target = value['target'];
+        return (typeof value['name'] === 'string' &&
+            TASK_NAME_PATTERN.test(value['name']) &&
+            typeof value['sessionId'] === 'string' &&
+            value['sessionId'].length > 0 &&
+            typeof value['cwd'] === 'string' &&
+            (!requireCurrentCwd || this.isCurrentCwd(value['cwd'])) &&
+            value['isolation'] === 'shared' &&
+            (value['status'] === 'open' || value['status'] === 'closed') &&
+            this.isTimestamp(value['createdAt']) &&
+            this.isTimestamp(value['updatedAt']) &&
+            this.isTimestamp(value['lastSelectedAt']) &&
+            target['channelName'] === channelName &&
+            target['chatId'] === chatId &&
+            target['senderId'] === senderId &&
+            (target['threadId'] === undefined ||
+                typeof target['threadId'] === 'string') &&
+            (target['isGroup'] === undefined ||
+                typeof target['isGroup'] === 'boolean'));
+    }
+    isCurrentCwd(cwd) {
+        return canonicalizeWorkspacePath(cwd) === this.canonicalCwd;
+    }
+    isTimestamp(value) {
+        return (typeof value === 'number' && Number.isSafeInteger(value) && value >= 0);
+    }
+    isRecord(value) {
+        return typeof value === 'object' && value !== null && !Array.isArray(value);
+    }
+}
+//# sourceMappingURL=named-session-manager.js.map