ccmanager 4.3.1 → 4.4.0

package/dist/components/Menu.test.js

@@ -319,8 +319,44 @@ describe('Menu component Effect-based error handling', () => {
         }
         expect(onMenuAction).toHaveBeenCalledWith({
             type: 'sessionActions',
+            worktree: cachedWorktree,
             session: cachedSession,
-            worktreePath: '/test/cached',
+        });
+    });
+    it('should open the actions menu with Space on a worktree row that has no session', async () => {
+        const { Effect } = await import('effect');
+        const sessionlessWorktree = {
+            path: '/test/no-session',
+            branch: 'feature/no-session',
+            isMainWorktree: false,
+            hasSession: false,
+        };
+        vi.spyOn(sessionManager, 'getAllSessions').mockReturnValue([]);
+        vi.spyOn(worktreeService, 'getWorktreesEffect').mockReturnValue(Effect.succeed([sessionlessWorktree]));
+        vi.spyOn(worktreeService, 'getDefaultBranchEffect').mockReturnValue(Effect.succeed('main'));
+        const onMenuAction = vi.fn();
+        vi.mocked(useInput).mockClear();
+        render(_jsx(Menu, { sessionManager: sessionManager, worktreeService: worktreeService, initialSnapshot: {
+                worktrees: [sessionlessWorktree],
+                defaultBranch: 'main',
+            }, onMenuAction: onMenuAction, version: "test" }));
+        await new Promise(resolve => setTimeout(resolve, 0));
+        // Menu's hotkey handler bails out when raw mode is unavailable.
+        const origSetRawMode = process.stdin.setRawMode;
+        process.stdin.setRawMode = vi.fn();
+        try {
+            const calls = vi.mocked(useInput).mock.calls;
+            const handler = calls[calls.length - 1]?.[0];
+            expect(handler).toBeDefined();
+            handler(' ', makeKey());
+        }
+        finally {
+            process.stdin.setRawMode = origSetRawMode;
+        }
+        expect(onMenuAction).toHaveBeenCalledWith({
+            type: 'sessionActions',
+            worktree: sessionlessWorktree,
+            session: undefined,
         });
     });
 });

package/dist/components/RestoreSessions.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import type { SessionRecord } from '../services/sessionRestoreStore.js';
+interface RestoreSessionsProps {
+    sessions: SessionRecord[];
+    /** Whether to show which project each session belongs to. */
+    showProject?: boolean;
+    onRestore: () => void;
+    onDiscard: () => void;
+}
+/**
+ * Startup offer to launch the sessions that were open when ccmanager last ran.
+ *
+ * Restoring runs each session's command preset in its worktree again; the
+ * previous terminal output and conversation are not brought back. Declining
+ * forgets the listed sessions, so the offer does not reappear on the next
+ * start.
+ */
+declare const RestoreSessions: React.FC<RestoreSessionsProps>;
+export default RestoreSessions;

package/dist/components/RestoreSessions.js

@@ -0,0 +1,28 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import path from 'path';
+import Confirmation from './Confirmation.js';
+import { describeRecordPreset } from '../services/sessionRestorer.js';
+/**
+ * Startup offer to launch the sessions that were open when ccmanager last ran.
+ *
+ * Restoring runs each session's command preset in its worktree again; the
+ * previous terminal output and conversation are not brought back. Declining
+ * forgets the listed sessions, so the offer does not reappear on the next
+ * start.
+ */
+const RestoreSessions = ({ sessions, showProject = false, onRestore, onDiscard, }) => {
+    const message = (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["Found ", sessions.length, " session", sessions.length === 1 ? '' : 's', " from the last time ccmanager ran. Start", ' ', sessions.length === 1 ? 'it' : 'them', " again?"] }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: sessions.map(session => (_jsxs(Text, { children: ['  ', _jsx(Text, { color: "green", children: path.basename(session.worktreePath) }), session.sessionName ? ` (${session.sessionName})` : '', _jsxs(Text, { dimColor: true, children: [' ', "\u2014 ", describeRecordPreset(session), showProject ? ` — ${path.basename(session.projectPath)}` : ''] })] }, session.id))) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Each session runs its command again in its worktree. Previous output and conversation are not restored." }) })] }));
+    return (_jsx(Confirmation, { title: _jsx(Text, { bold: true, children: "Restore previous sessions" }), message: message, options: [
+            { label: 'Restore', value: 'restore', color: 'green' },
+            { label: "Don't restore", value: 'discard', color: 'red' },
+        ], onSelect: value => {
+            if (value === 'restore') {
+                onRestore();
+            }
+            else {
+                onDiscard();
+            }
+        }, hint: _jsx(Text, { dimColor: true, children: "Use \u2191\u2193 to navigate, Enter to select. Declining forgets these sessions." }) }));
+};
+export default RestoreSessions;

package/dist/components/SessionActions.d.ts

@@ -1,8 +1,23 @@
 import React from 'react';
-export type SessionActionType = 'newSession' | 'rename' | 'kill';
+export type SessionActionType = 'newSession' | 'rename' | 'kill' | 'deleteWorktree';
 interface SessionActionsProps {
-    sessionLabel: string;
+    /**
+     * Name of the session this menu was opened from. Absent for a worktree row
+     * that has no session yet.
+     */
+    sessionLabel?: string;
     worktreePath: string;
+    /**
+     * Whether the row this menu was opened from has a running session. Session
+     * specific actions (rename, close) are hidden when it does not.
+     */
+    hasSession?: boolean;
+    /**
+     * Whether the worktree of this row may be deleted; see isDeletableWorktree.
+     * The delete entry is hidden rather than shown-and-rejected so no
+     * unselectable option appears.
+     */
+    canDeleteWorktree?: boolean;
     onSelect: (action: SessionActionType) => void;
     onCancel: () => void;
 }

package/dist/components/SessionActions.js

@@ -1,29 +1,31 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text, useInput } from 'ink';
 import SelectInput from 'ink-select-input';
-const items = [
-    { label: 'S  New session in same directory', value: 'newSession' },
-    { label: 'R  Rename this session', value: 'rename' },
-    { label: 'X  Close session', value: 'kill' },
-];
-const SessionActions = ({ sessionLabel, worktreePath, onSelect, onCancel, }) => {
+const buildItems = (hasSession, canDeleteWorktree) => {
+    const items = [
+        { label: 'S  New session in this worktree', value: 'newSession' },
+    ];
+    if (hasSession) {
+        items.push({ label: 'R  Rename this session', value: 'rename' });
+        items.push({ label: 'X  Close session', value: 'kill' });
+    }
+    if (canDeleteWorktree) {
+        items.push({ label: 'D  Delete this worktree', value: 'deleteWorktree' });
+    }
+    return items;
+};
+const SessionActions = ({ sessionLabel, worktreePath, hasSession = true, canDeleteWorktree = false, onSelect, onCancel, }) => {
+    const items = buildItems(hasSession, canDeleteWorktree);
     useInput((input, key) => {
         if (key.escape) {
             onCancel();
             return;
         }
-        switch (input.toLowerCase()) {
-            case 's':
-                onSelect('newSession');
-                break;
-            case 'r':
-                onSelect('rename');
-                break;
-            case 'x':
-                onSelect('kill');
-                break;
+        const shortcut = items.find(item => item.label[0]?.toLowerCase() === input.toLowerCase());
+        if (shortcut) {
+            onSelect(shortcut.value);
         }
     });
-    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: "Session Actions" }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: sessionLabel }), _jsxs(Text, { dimColor: true, children: ["Directory: ", worktreePath] })] }), _jsx(Box, { marginTop: 1, children: _jsx(SelectInput, { items: items, onSelect: item => onSelect(item.value) }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "S/R/X or arrow keys + Enter | Escape to cancel" }) })] }));
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsx(Text, { bold: true, color: "cyan", children: hasSession ? 'Session Actions' : 'Worktree Actions' }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [sessionLabel && _jsx(Text, { dimColor: true, children: sessionLabel }), _jsxs(Text, { dimColor: true, children: ["Directory: ", worktreePath] })] }), _jsx(Box, { marginTop: 1, children: _jsx(SelectInput, { items: items, onSelect: item => onSelect(item.value) }) }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: [items.map(item => item.label[0]).join('/'), " or arrow keys + Enter | Escape to cancel"] }) })] }));
 };
 export default SessionActions;

package/dist/components/SessionActions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/SessionActions.test.js

@@ -0,0 +1,94 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink-testing-library';
+import { useInput } from 'ink';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import SessionActions from './SessionActions.js';
+const makeKey = (overrides = {}) => ({
+    upArrow: false,
+    downArrow: false,
+    leftArrow: false,
+    rightArrow: false,
+    pageDown: false,
+    pageUp: false,
+    home: false,
+    end: false,
+    return: false,
+    escape: false,
+    ctrl: false,
+    shift: false,
+    tab: false,
+    backspace: false,
+    delete: false,
+    meta: false,
+    ...overrides,
+});
+// Mock ink to avoid stdin issues and to capture the hotkey handler
+vi.mock('ink', async () => {
+    const actual = await vi.importActual('ink');
+    return {
+        ...actual,
+        useInput: vi.fn(),
+    };
+});
+// Mock SelectInput to render items as simple text
+vi.mock('ink-select-input', async () => {
+    const React = await vi.importActual('react');
+    const { Text, Box } = await vi.importActual('ink');
+    return {
+        default: ({ items }) => React.createElement(Box, { flexDirection: 'column' }, items.map((item, index) => React.createElement(Text, { key: index }, item.label))),
+    };
+});
+const getLastInputHandler = () => {
+    const calls = vi.mocked(useInput).mock.calls;
+    const handler = calls[calls.length - 1]?.[0];
+    expect(handler).toBeDefined();
+    return handler;
+};
+describe('SessionActions', () => {
+    beforeEach(() => {
+        vi.mocked(useInput).mockClear();
+    });
+    it('should show session actions and the delete entry for a deletable worktree', () => {
+        const { lastFrame } = render(_jsx(SessionActions, { sessionLabel: "Session #1", worktreePath: "/repo/worktrees/feature", hasSession: true, canDeleteWorktree: true, onSelect: vi.fn(), onCancel: vi.fn() }));
+        const frame = lastFrame();
+        expect(frame).toContain('Session Actions');
+        expect(frame).toContain('New session in this worktree');
+        expect(frame).toContain('Rename this session');
+        expect(frame).toContain('Close session');
+        expect(frame).toContain('Delete this worktree');
+    });
+    it('should hide session-specific actions for a worktree without a session', () => {
+        const { lastFrame } = render(_jsx(SessionActions, { worktreePath: "/repo/worktrees/feature", hasSession: false, canDeleteWorktree: true, onSelect: vi.fn(), onCancel: vi.fn() }));
+        const frame = lastFrame();
+        expect(frame).toContain('Worktree Actions');
+        expect(frame).toContain('New session in this worktree');
+        expect(frame).toContain('Delete this worktree');
+        expect(frame).not.toContain('Rename this session');
+        expect(frame).not.toContain('Close session');
+    });
+    it('should hide the delete entry when the worktree cannot be deleted', () => {
+        const { lastFrame } = render(_jsx(SessionActions, { sessionLabel: "Session #1", worktreePath: "/repo", hasSession: true, canDeleteWorktree: false, onSelect: vi.fn(), onCancel: vi.fn() }));
+        expect(lastFrame()).not.toContain('Delete this worktree');
+    });
+    it('should dispatch deleteWorktree on the D hotkey when deletion is offered', () => {
+        const onSelect = vi.fn();
+        render(_jsx(SessionActions, { worktreePath: "/repo/worktrees/feature", hasSession: false, canDeleteWorktree: true, onSelect: onSelect, onCancel: vi.fn() }));
+        getLastInputHandler()('d', makeKey());
+        expect(onSelect).toHaveBeenCalledWith('deleteWorktree');
+    });
+    it('should ignore hotkeys of actions that are not offered', () => {
+        const onSelect = vi.fn();
+        render(_jsx(SessionActions, { sessionLabel: "Session #1", worktreePath: "/repo", hasSession: true, canDeleteWorktree: false, onSelect: onSelect, onCancel: vi.fn() }));
+        const handler = getLastInputHandler();
+        handler('d', makeKey());
+        expect(onSelect).not.toHaveBeenCalled();
+        handler('x', makeKey());
+        expect(onSelect).toHaveBeenCalledWith('kill');
+    });
+    it('should cancel on Escape', () => {
+        const onCancel = vi.fn();
+        render(_jsx(SessionActions, { sessionLabel: "Session #1", worktreePath: "/repo", hasSession: true, canDeleteWorktree: true, onSelect: vi.fn(), onCancel: onCancel }));
+        getLastInputHandler()('', makeKey({ escape: true }));
+        expect(onCancel).toHaveBeenCalled();
+    });
+});

package/dist/hooks/useAvailableLabelWidth.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Number of terminal columns a worktree/session row label may occupy.
+ * Passed to calculateColumnPositions, which drops the aligned session-state
+ * column when the resulting layout would not fit in it.
+ */
+export declare function useAvailableLabelWidth(): number;

package/dist/hooks/useAvailableLabelWidth.js

@@ -0,0 +1,15 @@
+import { useStdout } from 'ink';
+// Columns a list row spends before the assembled label: the SelectInput
+// indicator ("❯ " or two spaces) plus the number prefix ("0 ❯ " / "  ❯ ").
+const ROW_PREFIX_WIDTH = 6;
+// Terminal width assumed when stdout reports none (e.g. a non-TTY test stream).
+const FALLBACK_TERMINAL_WIDTH = 80;
+/**
+ * Number of terminal columns a worktree/session row label may occupy.
+ * Passed to calculateColumnPositions, which drops the aligned session-state
+ * column when the resulting layout would not fit in it.
+ */
+export function useAvailableLabelWidth() {
+    const { stdout } = useStdout();
+    return Math.max(0, (stdout.columns || FALLBACK_TERMINAL_WIDTH) - ROW_PREFIX_WIDTH);
+}

package/dist/services/config/globalConfigManager.js

@@ -3,27 +3,18 @@
  * This module is for internal use within the config directory only.
  * External code should use ConfigEditor or ConfigReader instead.
  */
-import { homedir } from 'os';
 import { join } from 'path';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { DEFAULT_SHORTCUTS, } from '../../types/index.js';
 import { DEFAULT_TIMEOUT_SECONDS } from '../../constants/autoApproval.js';
+import { ensureConfigDir } from '../../utils/configDir.js';
 class GlobalConfigManager {
     configPath;
     legacyShortcutsPath;
     configDir;
     config = {};
     constructor() {
-        // Determine config directory based on platform
-        const homeDir = homedir();
-        this.configDir =
-            process.platform === 'win32'
-                ? join(process.env['APPDATA'] || join(homeDir, 'AppData', 'Roaming'), 'ccmanager')
-                : join(homeDir, '.config', 'ccmanager');
-        // Ensure config directory exists
-        if (!existsSync(this.configDir)) {
-            mkdirSync(this.configDir, { recursive: true });
-        }
+        this.configDir = ensureConfigDir();
         this.configPath = join(this.configDir, 'config.json');
         this.legacyShortcutsPath = join(this.configDir, 'shortcuts.json');
         this.loadConfig();

package/dist/services/globalSessionOrchestrator.d.ts

@@ -12,6 +12,13 @@ declare class GlobalSessionOrchestrator {
     destroyProjectSessions(projectPath: string): void;
     getProjectPaths(): string[];
     getProjectSessions(projectPath: string): Session[];
+    /**
+     * Keep the durable session record in step with one manager's sessions, so a
+     * later ccmanager run can offer to launch them again. This orchestrator is
+     * the only place that knows which project a manager belongs to, which is why
+     * the wiring lives here rather than inside SessionManager.
+     */
+    private trackSessionsForRestore;
 }
 export declare const globalSessionOrchestrator: GlobalSessionOrchestrator;
 export {};

package/dist/services/globalSessionOrchestrator.js

@@ -1,4 +1,6 @@
 import { SessionManager } from './sessionManager.js';
+import { getCurrentRepositoryRoot } from '../utils/gitUtils.js';
+import { sessionRestoreStore } from './sessionRestoreStore.js';
 class GlobalSessionOrchestrator {
     static instance;
     projectManagers = new Map();
@@ -6,6 +8,7 @@ class GlobalSessionOrchestrator {
     constructor() {
         // Create a global session manager for single-project mode
         this.globalManager = new SessionManager();
+        this.trackSessionsForRestore(this.globalManager);
     }
     static getInstance() {
         if (!GlobalSessionOrchestrator.instance) {
@@ -22,6 +25,7 @@ class GlobalSessionOrchestrator {
         let manager = this.projectManagers.get(projectPath);
         if (!manager) {
             manager = new SessionManager();
+            this.trackSessionsForRestore(manager, projectPath);
             this.projectManagers.set(projectPath, manager);
         }
         return manager;
@@ -37,6 +41,11 @@ class GlobalSessionOrchestrator {
         return sessions;
     }
     destroyAllSessions() {
+        // Every caller of this method is quitting ccmanager, and the sessions
+        // being torn down here are exactly the ones the next run should offer to
+        // restore. Stop updating the durable record first so the teardown does
+        // not erase them.
+        sessionRestoreStore.suspendTracking();
         // Destroy sessions in global manager
         this.globalManager.destroy();
         // Destroy sessions in all project managers
@@ -63,5 +72,36 @@ class GlobalSessionOrchestrator {
         }
         return [];
     }
+    /**
+     * Keep the durable session record in step with one manager's sessions, so a
+     * later ccmanager run can offer to launch them again. This orchestrator is
+     * the only place that knows which project a manager belongs to, which is why
+     * the wiring lives here rather than inside SessionManager.
+     */
+    trackSessionsForRestore(manager, projectPath) {
+        manager.on('sessionCreated', (session) => {
+            sessionRestoreStore.record({
+                id: session.id,
+                // The global manager has no project path of its own: its sessions
+                // belong to the repository ccmanager was started in.
+                projectPath: projectPath ?? getCurrentRepositoryRoot(),
+                worktreePath: session.worktreePath,
+                presetId: session.presetId,
+                sessionName: session.sessionName,
+                devcontainerConfig: session.devcontainerConfig,
+                ownerPid: process.pid,
+                createdAt: Date.now(),
+            });
+        });
+        manager.on('sessionRenamed', (session) => {
+            sessionRestoreStore.rename(session.id, session.sessionName);
+        });
+        // A destroyed session is one that should stay gone: either the user
+        // killed it or the launched command exited on its own. The exception is
+        // the teardown on quit, which suspends tracking beforehand.
+        manager.on('sessionDestroyed', (session) => {
+            sessionRestoreStore.forget(session.id);
+        });
+    }
 }
 export const globalSessionOrchestrator = GlobalSessionOrchestrator.getInstance();

package/dist/services/globalSessionOrchestrator.restore.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/globalSessionOrchestrator.restore.test.js

@@ -0,0 +1,76 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { EventEmitter } from 'events';
+const recordMock = vi.fn();
+const forgetMock = vi.fn();
+const renameMock = vi.fn();
+const suspendTrackingMock = vi.fn();
+vi.mock('./sessionRestoreStore.js', () => ({
+    sessionRestoreStore: {
+        record: (...args) => recordMock(...args),
+        forget: (...args) => forgetMock(...args),
+        rename: (...args) => renameMock(...args),
+        suspendTracking: () => suspendTrackingMock(),
+    },
+}));
+vi.mock('../utils/gitUtils.js', () => ({
+    getCurrentRepositoryRoot: () => '/current/repo',
+}));
+class MockSessionManager extends EventEmitter {
+    getAllSessions() {
+        return [];
+    }
+    destroy() { }
+}
+vi.mock('./sessionManager.js', () => ({
+    SessionManager: MockSessionManager,
+}));
+const { globalSessionOrchestrator } = await import('./globalSessionOrchestrator.js');
+const session = (overrides = {}) => ({
+    id: 'session-1',
+    worktreePath: '/repo/worktrees/feature',
+    presetId: 'preset-1',
+    sessionName: undefined,
+    devcontainerConfig: undefined,
+    ...overrides,
+});
+describe('GlobalSessionOrchestrator session record', () => {
+    beforeEach(() => {
+        recordMock.mockClear();
+        forgetMock.mockClear();
+        renameMock.mockClear();
+        suspendTrackingMock.mockClear();
+    });
+    it('records a session of the current repository when there is no project path', () => {
+        const manager = globalSessionOrchestrator.getManagerForProject();
+        manager.emit('sessionCreated', session());
+        expect(recordMock).toHaveBeenCalledWith(expect.objectContaining({
+            id: 'session-1',
+            projectPath: '/current/repo',
+            worktreePath: '/repo/worktrees/feature',
+            presetId: 'preset-1',
+            ownerPid: process.pid,
+        }));
+    });
+    it('records a session under the project its manager belongs to', () => {
+        const manager = globalSessionOrchestrator.getManagerForProject('/other/project');
+        manager.emit('sessionCreated', session({ id: 'session-2' }));
+        expect(recordMock).toHaveBeenCalledWith(expect.objectContaining({
+            id: 'session-2',
+            projectPath: '/other/project',
+        }));
+    });
+    it('forgets a session that was killed or exited', () => {
+        const manager = globalSessionOrchestrator.getManagerForProject();
+        manager.emit('sessionDestroyed', session());
+        expect(forgetMock).toHaveBeenCalledWith('session-1');
+    });
+    it('keeps the record in step with a rename', () => {
+        const manager = globalSessionOrchestrator.getManagerForProject();
+        manager.emit('sessionRenamed', session({ sessionName: 'review' }));
+        expect(renameMock).toHaveBeenCalledWith('session-1', 'review');
+    });
+    it('stops tracking before quitting, so the sessions stay restorable', () => {
+        globalSessionOrchestrator.destroyAllSessions();
+        expect(suspendTrackingMock).toHaveBeenCalled();
+    });
+});

package/dist/services/projectManager.js

@@ -2,10 +2,10 @@ import { WorktreeService } from './worktreeService.js';
 import { ENV_VARS } from '../constants/env.js';
 import { promises as fs } from 'fs';
 import path from 'path';
-import { homedir } from 'os';
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { Effect } from 'effect';
 import { FileSystemError, ConfigError } from '../types/errors.js';
+import { ensureConfigDir } from '../utils/configDir.js';
 export class ProjectManager {
     currentMode;
     currentProject;
@@ -31,15 +31,7 @@ export class ProjectManager {
             this.currentMode = 'normal';
         }
         // Initialize recent projects
-        const homeDir = homedir();
-        this.configDir =
-            process.platform === 'win32'
-                ? path.join(process.env['APPDATA'] || path.join(homeDir, 'AppData', 'Roaming'), 'ccmanager')
-                : path.join(homeDir, '.config', 'ccmanager');
-        // Ensure config directory exists
-        if (!existsSync(this.configDir)) {
-            mkdirSync(this.configDir, { recursive: true });
-        }
+        this.configDir = ensureConfigDir();
         this.dataPath = path.join(this.configDir, 'recent-projects.json');
         this.loadRecentProjects();
     }

package/dist/services/sessionManager.d.ts

@@ -83,6 +83,12 @@ export declare class SessionManager extends EventEmitter implements ISessionMana
     private setupBackgroundHandler;
     private cleanupSession;
     getSessionById(id: string): Session | undefined;
+    /**
+     * Assign a user-facing name to a session. Goes through the manager rather
+     * than mutating the session object directly so that listeners (currently the
+     * restore record) learn about the new name.
+     */
+    renameSession(sessionId: string, sessionName?: string): void;
     getSessionsForWorktree(worktreePath: string): Session[];
     setSessionActive(sessionId: string, active: boolean): void;
     private emitRestoreSnapshot;

package/dist/services/sessionManager.js

@@ -342,6 +342,7 @@ export class SessionManager extends EventEmitter {
             stateCheckInterval: undefined, // Will be set in setupBackgroundHandler
             isPrimaryCommand: options.isPrimaryCommand ?? true,
             presetName: options.presetName,
+            presetId: options.presetId,
             detectionStrategy,
             devcontainerConfig: options.devcontainerConfig ?? undefined,
             stateMutex: new Mutex(createInitialSessionStateData()),
@@ -385,6 +386,7 @@ export class SessionManager extends EventEmitter {
                     command,
                     fallbackArgs: preset.fallbackArgs,
                     presetName: preset.name,
+                    presetId: preset.id,
                     detectionStrategy: preset.detectionStrategy,
                 });
                 if (launch.stdinPayload) {
@@ -569,6 +571,19 @@ export class SessionManager extends EventEmitter {
     getSessionById(id) {
         return this.sessions.get(id);
     }
+    /**
+     * Assign a user-facing name to a session. Goes through the manager rather
+     * than mutating the session object directly so that listeners (currently the
+     * restore record) learn about the new name.
+     */
+    renameSession(sessionId, sessionName) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            return;
+        }
+        session.sessionName = sessionName;
+        this.emit('sessionRenamed', session);
+    }
     getSessionsForWorktree(worktreePath) {
         return Array.from(this.sessions.values()).filter(s => s.worktreePath === worktreePath);
     }
@@ -878,6 +893,7 @@ export class SessionManager extends EventEmitter {
                     command: preset.command,
                     fallbackArgs: preset.fallbackArgs,
                     presetName: preset.name,
+                    presetId: preset.id,
                     detectionStrategy: preset.detectionStrategy,
                     devcontainerConfig,
                 });

package/dist/services/sessionRestoreStore.d.ts

@@ -0,0 +1,75 @@
+import { DevcontainerConfig } from '../types/index.js';
+/** Format version of the on-disk file, so future changes can be detected. */
+export declare const SESSION_RECORD_VERSION = 1;
+export declare const SESSION_RECORD_FILE_NAME = "sessions.json";
+/** A single session, described well enough to launch it again. */
+export interface SessionRecord {
+    /** Id of the in-memory session this record was written for. */
+    id: string;
+    /**
+     * Git repository root the session belongs to. Used to only offer sessions
+     * of the repository the user is actually opening.
+     */
+    projectPath: string;
+    worktreePath: string;
+    /**
+     * Id of the command preset the session was launched with. Absent when the
+     * preset could not be determined; the default preset is then used on
+     * restore. Only the id is stored — the command itself stays owned by the
+     * preset configuration.
+     */
+    presetId?: string;
+    /** User-assigned session name, if the user renamed the session. */
+    sessionName?: string;
+    /** Devcontainer commands the session was launched through, if any. */
+    devcontainerConfig?: DevcontainerConfig;
+    /**
+     * Process id of the ccmanager run that owns this session. A record whose
+     * owner process is still running belongs to another live ccmanager and must
+     * not be restored, or the same session would end up running twice.
+     */
+    ownerPid: number;
+    createdAt: number;
+}
+export declare class SessionRestoreStore {
+    private explicitFilePath?;
+    /**
+     * While true, mutations are ignored. Set just before ccmanager tears its
+     * sessions down on exit: those sessions are exactly the ones the next run
+     * should offer to restore, so their records must survive the teardown.
+     */
+    private trackingSuspended;
+    constructor(filePath?: string);
+    /**
+     * Resolved lazily rather than in the constructor so that merely importing
+     * this module does not create the configuration directory.
+     */
+    private get filePath();
+    /** All recorded sessions, including ones owned by other ccmanager runs. */
+    list(): SessionRecord[];
+    /** Add a session to the record, replacing any earlier record with the same id. */
+    record(session: SessionRecord): void;
+    /**
+     * Drop sessions from the record, so they are not offered on the next run.
+     * Called when a session ends for a reason that means it should stay ended:
+     * the user killed it, or the launched command exited by itself.
+     */
+    forget(...ids: string[]): void;
+    /**
+     * Keep a renamed session's name in the record. An absent name means the
+     * user cleared it.
+     */
+    rename(id: string, sessionName?: string): void;
+    /**
+     * Stop applying further mutations. Used when ccmanager is shutting down and
+     * destroys its sessions: without this the teardown would erase precisely the
+     * records the next run needs.
+     */
+    suspendTracking(): void;
+    /** Resume applying mutations. Counterpart of {@link suspendTracking}. */
+    resumeTracking(): void;
+    isTrackingSuspended(): boolean;
+    private read;
+    private write;
+}
+export declare const sessionRestoreStore: SessionRestoreStore;