@ohzw/worktree-command-tui 0.1.4 → 0.1.6

package/dist/core/command-runner.js

@@ -1,6 +1,55 @@
-import { closeSync, mkdirSync, openSync } from 'node:fs';
+import { appendFileSync, closeSync, copyFileSync, mkdirSync, openSync, realpathSync } from 'node:fs';
 import { spawn } from 'node:child_process';
 import path from 'node:path';
+function writeLogLine(logPath, text) {
+    appendFileSync(logPath, text, 'utf8');
+}
+function isContainedPath(root, target, allowEqual) {
+    const relativePath = path.relative(root, target);
+    return (allowEqual && relativePath === '') || (relativePath !== '' && !relativePath.startsWith('..') && !path.isAbsolute(relativePath));
+}
+function resolveSourcePath(root, inputPath) {
+    const realRoot = realpathSync(root);
+    const source = path.resolve(realRoot, inputPath);
+    if (!isContainedPath(realRoot, source, false)) {
+        throw new Error(`source must stay under ${realRoot}`);
+    }
+    const realSource = realpathSync(source);
+    if (!isContainedPath(realRoot, realSource, false)) {
+        throw new Error(`source must stay under ${realRoot}`);
+    }
+    return realSource;
+}
+function resolveDestinationPath(root, inputPath) {
+    const realRoot = realpathSync(root);
+    const destination = path.resolve(realRoot, inputPath);
+    const basename = path.basename(destination);
+    if (basename === '' || basename === '.' || basename === '..') {
+        throw new Error(`destination must stay under ${realRoot}`);
+    }
+    mkdirSync(path.dirname(destination), { recursive: true });
+    const realParent = realpathSync(path.dirname(destination));
+    if (!isContainedPath(realRoot, realParent, true)) {
+        throw new Error(`destination must stay under ${realRoot}`);
+    }
+    return path.join(realParent, basename);
+}
+function runBuiltInCommand(input) {
+    if (input.command[0] !== 'copy-root-file') {
+        return false;
+    }
+    if (input.command.length !== 3) {
+        throw new Error(`${input.errorLabel} requires arguments: source and destination path`);
+    }
+    if (input.workspaceRoot === undefined) {
+        throw new Error(`${input.errorLabel} copy-root-file requires workspaceRoot`);
+    }
+    const source = resolveSourcePath(input.workspaceRoot, input.command[1] ?? '');
+    const destination = resolveDestinationPath(input.cwd, input.command[2] ?? '');
+    copyFileSync(source, destination);
+    writeLogLine(input.logPath, `copied ${source} -> ${destination}\n`);
+    return true;
+}
 function getLogEnvironment() {
     return {
         ...process.env,
@@ -8,7 +57,7 @@ function getLogEnvironment() {
         CLICOLOR_FORCE: process.env.CLICOLOR_FORCE ?? '1',
     };
 }
-export function runCommandToLog({ command, cwd, logsDir, logFileBase, errorLabel = 'setup command', }) {
+export function runCommandToLog({ command, cwd, logsDir, logFileBase, errorLabel = 'setup command', workspaceRoot, }) {
     mkdirSync(logsDir, { recursive: true });
     const logPath = path.join(logsDir, `${logFileBase}.log`);
     const fd = openSync(logPath, 'a');
@@ -22,6 +71,20 @@ export function runCommandToLog({ command, cwd, logsDir, logFileBase, errorLabel
         closeSync(fd);
         return true;
     };
+    try {
+        if (runBuiltInCommand({ command, cwd, logPath, workspaceRoot, errorLabel })) {
+            if (finalize()) {
+                resolve({ logPath });
+            }
+            return promise;
+        }
+    }
+    catch (error) {
+        if (finalize()) {
+            reject(new Error(`${errorLabel}: ${error instanceof Error ? error.message : String(error)}; see ${logPath}`));
+        }
+        return promise;
+    }
     const child = spawn(command[0], command.slice(1), {
         cwd,
         env: getLogEnvironment(),

package/dist/core/config-lifecycle.d.ts

@@ -17,9 +17,9 @@ export declare function isSafeNamespace(value: unknown): value is string;
 export declare function toSafeNamespace(value: string): string;
 export declare function validateToolConfig(raw: unknown): ToolConfig;
 export declare function createDefaultToolConfig(options: DefaultToolConfigOptions): ToolConfig;
+export declare function renderConfigJsonc(config: ToolConfig): string;
 export declare function loadToolConfig({ repoRoot }: {
     repoRoot: string;
 }): Promise<ToolConfig>;
-export declare function renderConfigJsonc(config: ToolConfig): string;
 export declare function findExistingConfigPath(workspaceRoot: string, fileExists: (filePath: string) => Promise<boolean>): Promise<string | null>;
 export declare function writeToolConfigForRepo({ workspaceRoot, force, config }: ConfigInitOptions, fileExists: (filePath: string) => Promise<boolean>): Promise<ConfigInitResult>;

package/dist/core/config-lifecycle.js

@@ -37,6 +37,28 @@ function readOrphanMatchers(value) {
     }
     return matchers;
 }
+function isNonEmptyStringArray(value) {
+    return Array.isArray(value) && value.length > 0 && value.every(part => isNonEmptyString(part));
+}
+function readOptionalSetupCommands(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(value) || value.length === 0) {
+        throw new Error('setupCommand must be a non-empty string array or an array of non-empty string arrays when set');
+    }
+    const looksLikeSingleCommand = value.every(part => isNonEmptyString(part));
+    if (looksLikeSingleCommand) {
+        return [value];
+    }
+    if (!value.every(part => Array.isArray(part))) {
+        throw new Error('setupCommand must be a non-empty string array or an array of non-empty string arrays when set');
+    }
+    if (!value.every(part => isNonEmptyStringArray(part))) {
+        throw new Error('setupCommand must be a non-empty string array or an array of non-empty string arrays when set');
+    }
+    return value;
+}
 function readRequiredCommand(value, fieldName) {
     if (!Array.isArray(value) || value.length === 0 || value.some(part => !isNonEmptyString(part))) {
         throw new Error(`${fieldName} must be a non-empty string array`);
@@ -52,24 +74,51 @@ function readOptionalCommand(value, fieldName) {
     }
     return value;
 }
-function readPort(value) {
+function readPort(value, fieldName) {
     if (typeof value !== 'number' || !Number.isInteger(value) || value < 1 || value > 65535) {
-        throw new Error('port must be an integer between 1 and 65535');
+        throw new Error(`${fieldName} must be an integer between 1 and 65535`);
+    }
+    return value;
+}
+function readPorts(value) {
+    if (value === undefined) {
+        return [];
+    }
+    if (!Array.isArray(value) || value.length === 0 || value.some(port => typeof port !== 'number' || !Number.isInteger(port) || port < 1 || port > 65535)) {
+        throw new Error('ports must be a non-empty array of integers between 1 and 65535');
     }
     return value;
 }
+function uniquePorts(ports) {
+    return [...new Set(ports)];
+}
+function mergeConfiguredPorts(legacyPort, configuredPorts) {
+    const merged = configuredPorts.length > 0 ? configuredPorts : legacyPort === undefined ? [] : [legacyPort];
+    const resolved = uniquePorts(merged);
+    if (resolved.length === 0) {
+        throw new Error('port or ports must be configured');
+    }
+    return resolved;
+}
+function readPortList(port, ports) {
+    const legacyPort = port === undefined ? undefined : readPort(port, 'port');
+    const configuredPorts = readPorts(ports);
+    return mergeConfiguredPorts(legacyPort, configuredPorts);
+}
 export function validateToolConfig(raw) {
     const config = (raw ?? {});
     const command = readRequiredCommand(config.command, 'command');
     if (!isSafeNamespace(config.namespace)) {
         throw new Error(`namespace must match ${SAFE_NAMESPACE_DESCRIPTION}`);
     }
+    const ports = readPortList(config.port, config.ports);
     return {
         namespace: config.namespace,
         command,
-        setupCommand: readOptionalCommand(config.setupCommand, 'setupCommand'),
+        setupCommand: readOptionalSetupCommands(config.setupCommand),
         editorCommand: readOptionalCommand(config.editorCommand, 'editorCommand'),
-        port: readPort(config.port),
+        port: ports[0] ?? 0,
+        ports,
         requiredFiles: readStringList(config.requiredFiles, 'requiredFiles'),
         orphanMatchers: readOrphanMatchers(config.orphanMatchers),
     };
@@ -78,38 +127,20 @@ export function createDefaultToolConfig(options) {
     return validateToolConfig({
         namespace: toSafeNamespace(options.namespaceSeed),
         command: [options.packageManager, 'run', options.script],
-        setupCommand: [options.packageManager, 'install'],
+        setupCommand: [[options.packageManager, 'install']],
         editorCommand: ['code'],
-        port: 3000,
+        ports: [3000],
         requiredFiles: ['package.json'],
         orphanMatchers: [],
     });
 }
-async function readConfigFile(configPath) {
-    if ((await stat(configPath)).size > MAX_CONFIG_BYTES) {
-        throw new Error('config file is too large');
-    }
-    return readFile(configPath, 'utf8');
-}
-async function readFirstConfig(repoRoot) {
-    let firstError;
-    for (const fileName of CONFIG_FILE_NAMES) {
-        try {
-            return await readConfigFile(path.join(repoRoot, fileName));
-        }
-        catch (error) {
-            firstError ??= error;
-        }
-    }
-    throw firstError;
-}
-export async function loadToolConfig({ repoRoot }) {
-    return validateToolConfig(parseJsonc(await readFirstConfig(repoRoot)));
-}
 export function renderConfigJsonc(config) {
     const setupCommandSection = config.setupCommand === undefined ? '' : `
-  // Optional command run manually with the setup key in the selected worktree.
+  // Optional command(s) run manually with the setup key in the selected worktree.
   // Review before running in untrusted worktrees; package installs may run lifecycle scripts.
+  // When this is an array of arrays, each entry is executed in order.
+  // Built-in helper: ["copy-root-file", ".env", ".env"]
+  // copies .env from the repository root to the selected worktree.
   "setupCommand": ${JSON.stringify(config.setupCommand)},
 `;
     const editorCommandSection = config.editorCommand === undefined ? '' : `
@@ -126,8 +157,9 @@ export function renderConfigJsonc(config) {
   // Treat this config as trusted code. argv form avoids shell metacharacter expansion.
   "command": ${JSON.stringify(config.command)},
 ${setupCommandSection}${editorCommandSection}
-  // TCP port owned by the command, used when stopping stale/orphaned processes.
-  "port": ${JSON.stringify(config.port)},
+  // TCP ports owned by the command, used when stopping stale/orphaned processes.
+  // Include all ports your command may bind.
+  "ports": ${JSON.stringify(config.ports)},
 
   // Files that must exist in a worktree before the command can be started there.
   "requiredFiles": ${JSON.stringify(config.requiredFiles)},
@@ -139,6 +171,27 @@ ${setupCommandSection}${editorCommandSection}
 }
 `;
 }
+async function readConfigFile(configPath) {
+    if ((await stat(configPath)).size > MAX_CONFIG_BYTES) {
+        throw new Error('config file is too large');
+    }
+    return readFile(configPath, 'utf8');
+}
+async function readFirstConfig(repoRoot) {
+    let firstError;
+    for (const fileName of CONFIG_FILE_NAMES) {
+        try {
+            return await readConfigFile(path.join(repoRoot, fileName));
+        }
+        catch (error) {
+            firstError ??= error;
+        }
+    }
+    throw firstError;
+}
+export async function loadToolConfig({ repoRoot }) {
+    return validateToolConfig(parseJsonc(await readFirstConfig(repoRoot)));
+}
 export async function findExistingConfigPath(workspaceRoot, fileExists) {
     for (const fileName of CONFIG_FILE_NAMES) {
         const configPath = path.join(workspaceRoot, fileName);

package/dist/core/config.d.ts

@@ -4,9 +4,10 @@ export declare const CONFIG_FILE_NAMES: readonly [".worktree-command-tui.jsonc",
 export interface ToolConfig {
     namespace: string;
     command: string[];
-    setupCommand?: string[];
+    setupCommand?: string[][];
     editorCommand?: string[];
     port: number;
+    ports: number[];
     requiredFiles: string[];
     orphanMatchers: string[];
 }

package/dist/core/debounced-resize.d.ts

@@ -0,0 +1,7 @@
+type ResizeListener = (...args: unknown[]) => void;
+interface ResizeEventSource {
+    on(event: string | symbol, listener: ResizeListener): ResizeEventSource;
+    off(event: string | symbol, listener: ResizeListener): ResizeEventSource;
+}
+export declare function debounceResizeListeners(source: ResizeEventSource, debounceMs: number): () => void;
+export {};

package/dist/core/debounced-resize.js

@@ -0,0 +1,39 @@
+export function debounceResizeListeners(source, debounceMs) {
+    const originalOn = source.on.bind(source);
+    const originalOff = source.off.bind(source);
+    const resizeListeners = new Set();
+    let resizeTimer;
+    let latestArgs = [];
+    const emitDebouncedResize = (...args) => {
+        latestArgs = args;
+        clearTimeout(resizeTimer);
+        resizeTimer = setTimeout(() => {
+            resizeTimer = undefined;
+            const listeners = [...resizeListeners];
+            for (const listener of listeners) {
+                listener(...latestArgs);
+            }
+        }, debounceMs);
+    };
+    originalOn('resize', emitDebouncedResize);
+    source.on = ((event, listener) => {
+        if (event === 'resize') {
+            resizeListeners.add(listener);
+            return source;
+        }
+        return originalOn(event, listener);
+    });
+    source.off = ((event, listener) => {
+        if (event === 'resize') {
+            resizeListeners.delete(listener);
+            return source;
+        }
+        return originalOff(event, listener);
+    });
+    return () => {
+        clearTimeout(resizeTimer);
+        originalOff('resize', emitDebouncedResize);
+        source.on = originalOn;
+        source.off = originalOff;
+    };
+}

package/dist/core/git-metadata.d.ts

@@ -14,6 +14,9 @@ export interface GitStatusSummary {
     upstreamUnavailable: boolean;
     workingTree?: WorkingTreeInfo;
 }
+export interface HeadCommitInfo {
+    message: string;
+}
 export interface RepoContext {
     workspaceRoot: string;
     mainWorktreePath: string;
@@ -22,4 +25,5 @@ export interface RepoContext {
 export declare function parseGitStatusSummary(output: string): GitStatusSummary;
 export declare function readGitStatusSummary(cwd: string): Promise<GitStatusSummary>;
 export declare function readBranchCreatedAtMs(cwd: string, branch: string): Promise<number | null>;
+export declare function readHeadCommitInfo(cwd: string): Promise<HeadCommitInfo | null>;
 export declare function resolveRepoContext(cwd: string): Promise<RepoContext>;

package/dist/core/git-metadata.js

@@ -72,6 +72,15 @@ export async function readBranchCreatedAtMs(cwd, branch) {
         return null;
     }
 }
+export async function readHeadCommitInfo(cwd) {
+    try {
+        const { stdout } = await execFileAsync('git', ['log', '-1', '--format=%s'], { cwd });
+        return { message: stdout.trim() };
+    }
+    catch {
+        return null;
+    }
+}
 export async function resolveRepoContext(cwd) {
     const [{ stdout: workspaceRootRaw }, { stdout: gitCommonDirRaw }] = await Promise.all([
         execFileAsync('git', ['rev-parse', '--show-toplevel'], { cwd }),

package/dist/core/process-control.d.ts

@@ -6,6 +6,6 @@ export interface CleanupDeps {
 }
 export declare function stopSessionWithFallback(input: {
     pgid: number;
-    port: number;
+    ports: number[];
     orphanMatchers: string[];
 }, deps: CleanupDeps): Promise<boolean>;

package/dist/core/process-control.js

@@ -6,7 +6,9 @@ export async function stopSessionWithFallback(input, deps) {
     if (!(await deps.isSessionAlive(input.pgid))) {
         return true;
     }
-    await deps.killPortOwner(input.port, input.pgid);
+    for (const port of input.ports) {
+        await deps.killPortOwner(port, input.pgid);
+    }
     for (const matcher of input.orphanMatchers) {
         await deps.killOrphans(matcher, input.pgid);
     }

package/dist/core/runtime-state.d.ts

@@ -17,6 +17,7 @@ export interface RuntimeStateAdapter {
         cwd: string;
         logsDir: string;
         logFileBase: string;
+        workspaceRoot: string | undefined;
     }) => Promise<{
         logPath: string;
     }>;
@@ -37,6 +38,7 @@ export interface RuntimeStateAdapter {
 export interface RuntimeStateOptions {
     config: ToolConfig;
     paths: SessionPaths;
+    workspaceRoot?: string;
     adapter: RuntimeStateAdapter;
 }
-export declare function createRuntimeStateActions({ config, paths, adapter }: RuntimeStateOptions): AppActions;
+export declare function createRuntimeStateActions({ config, paths, workspaceRoot, adapter }: RuntimeStateOptions): AppActions;

package/dist/core/runtime-state.js

@@ -2,7 +2,7 @@ import path from 'node:path';
 function toLogFileBase(branch) {
     return branch.replace(/[\\/]/g, '-');
 }
-export function createRuntimeStateActions({ config, paths, adapter }) {
+export function createRuntimeStateActions({ config, paths, workspaceRoot, adapter }) {
     const refreshLogs = async () => {
         const active = await adapter.readActive();
         return {
@@ -40,8 +40,8 @@ export function createRuntimeStateActions({ config, paths, adapter }) {
         };
     };
     const setup = async (worktreePath) => {
-        const setupCommand = config.setupCommand;
-        if (setupCommand === undefined) {
+        const setupCommands = config.setupCommand;
+        if (setupCommands === undefined) {
             const model = await adapter.refresh();
             return {
                 ...model,
@@ -51,21 +51,34 @@ export function createRuntimeStateActions({ config, paths, adapter }) {
         const branch = await adapter.readWorktreeBranch(worktreePath);
         const logFileBase = `${toLogFileBase(branch)}.setup`;
         const setupLogPath = path.join(paths.logsDir, `${logFileBase}.log`);
-        try {
-            await adapter.runSetup({
-                command: setupCommand,
-                cwd: worktreePath,
-                logsDir: paths.logsDir,
-                logFileBase,
-            });
-        }
-        catch (error) {
-            const model = await adapter.refresh();
-            return {
-                ...model,
-                status: { kind: 'error', message: error instanceof Error ? error.message : String(error) },
-                logs: await adapter.readLogs(setupLogPath),
-            };
+        for (let index = 0; index < setupCommands.length; index += 1) {
+            const setupCommand = setupCommands[index];
+            if (setupCommand === undefined) {
+                const model = await adapter.refresh();
+                return {
+                    ...model,
+                    status: { kind: 'error', message: `setup command ${index + 1} is not configured` },
+                    logs: await adapter.readLogs(setupLogPath),
+                };
+            }
+            try {
+                await adapter.runSetup({
+                    command: setupCommand,
+                    cwd: worktreePath,
+                    logsDir: paths.logsDir,
+                    logFileBase,
+                    workspaceRoot,
+                });
+            }
+            catch (error) {
+                const model = await adapter.refresh();
+                const commandLabel = setupCommands.length > 1 ? `setup command ${index + 1}/${setupCommands.length} ` : '';
+                return {
+                    ...model,
+                    status: { kind: 'error', message: `${commandLabel}${error instanceof Error ? error.message : String(error)}`.trim() },
+                    logs: await adapter.readLogs(setupLogPath),
+                };
+            }
         }
         const model = await adapter.refresh();
         return {
@@ -99,6 +112,7 @@ export function createRuntimeStateActions({ config, paths, adapter }) {
             pid: started.pid,
             pgid: started.pgid,
             port: config.port,
+            ports: config.ports,
             logPath: started.logPath,
             startedAt: adapter.nowIso(),
         });

package/dist/core/runtime.d.ts

@@ -1,5 +1,5 @@
 import { type WorktreeRow } from './git-worktrees.js';
-import { type UpstreamInfo, type WorkingTreeInfo } from './git-metadata.js';
+import { type UpstreamInfo, type WorkingTreeInfo, type HeadCommitInfo } from './git-metadata.js';
 import { type PullRequestInfo } from './github-metadata.js';
 import { type LogEntry } from './log-reader.js';
 export type RowTag = 'main' | 'active' | 'invalid' | 'external' | 'legacy';
@@ -8,6 +8,7 @@ export interface AppRow {
     shortPath: string;
     branch: string;
     headSha?: string;
+    headCommit?: HeadCommitInfo;
     tags: RowTag[];
     upstream?: UpstreamInfo;
     upstreamUnavailable?: boolean;
@@ -47,6 +48,6 @@ export interface AppActions {
     openPullRequest: (worktreePath: string) => Promise<AppModel>;
     deleteWorktree: (worktreePath: string) => Promise<AppModel>;
 }
-export declare function toAppRow(mainWorktreePath: string, worktree: WorktreeRow, activePath: string | null, invalidReason: string | null, metadata: Pick<AppRow, 'upstream' | 'upstreamUnavailable' | 'workingTree' | 'pullRequest' | 'branchCreatedAtMs'>): AppRow;
+export declare function toAppRow(mainWorktreePath: string, worktree: WorktreeRow, activePath: string | null, invalidReason: string | null, metadata: Pick<AppRow, 'upstream' | 'upstreamUnavailable' | 'workingTree' | 'pullRequest' | 'branchCreatedAtMs' | 'headCommit'>): AppRow;
 export declare function buildInitialModel(cwd: string): Promise<AppModel>;
 export declare function buildActions(cwd: string): Promise<AppActions>;

package/dist/core/runtime.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { promisify } from 'node:util';
 import { loadToolConfig } from './config-lifecycle.js';
 import { readWorktrees, sortWorktrees, toShortPath } from './git-worktrees.js';
-import { readGitStatusSummary, readBranchCreatedAtMs, resolveRepoContext } from './git-metadata.js';
+import { readGitStatusSummary, readBranchCreatedAtMs, readHeadCommitInfo, resolveRepoContext } from './git-metadata.js';
 import { readPullRequestInfo } from './github-metadata.js';
 import { readLogs } from './log-reader.js';
 import { getInvalidReason } from './validation.js';
@@ -18,10 +18,11 @@ function shortenSha(headSha) {
     return headSha.slice(0, SHORT_SHA_LENGTH);
 }
 async function readRowMetadata(worktreePath, branch) {
-    const [statusSummary, pullRequest, branchCreatedAtMs] = await Promise.all([
+    const [statusSummary, pullRequest, branchCreatedAtMs, headCommit] = await Promise.all([
         readGitStatusSummary(worktreePath),
         readPullRequestInfo(worktreePath, branch),
         readBranchCreatedAtMs(worktreePath, branch),
+        readHeadCommitInfo(worktreePath),
     ]);
     return {
         upstream: statusSummary.upstream,
@@ -29,6 +30,7 @@ async function readRowMetadata(worktreePath, branch) {
         workingTree: statusSummary.workingTree,
         pullRequest,
         branchCreatedAtMs: branchCreatedAtMs ?? undefined,
+        headCommit: headCommit ?? undefined,
     };
 }
 export function toAppRow(mainWorktreePath, worktree, activePath, invalidReason, metadata) {
@@ -56,6 +58,7 @@ export function toAppRow(mainWorktreePath, worktree, activePath, invalidReason,
         workingTree: metadata.workingTree,
         pullRequest: metadata.pullRequest,
         branchCreatedAtMs: metadata.branchCreatedAtMs,
+        headCommit: metadata.headCommit,
         invalidReason: invalidReason ?? undefined,
     };
 }
@@ -70,8 +73,8 @@ async function buildRows(mainWorktreePath, workspaceRoot, activePath, requiredFi
     }));
     return rows;
 }
-async function stopRecordedSession(pgid, port, orphanMatchers) {
-    const stopped = await stopSessionWithFallback({ pgid, port, orphanMatchers }, {
+async function stopRecordedSession(pgid, ports, orphanMatchers) {
+    const stopped = await stopSessionWithFallback({ pgid, ports, orphanMatchers }, {
         killProcessGroup,
         killPortOwner,
         killOrphans,
@@ -81,6 +84,9 @@ async function stopRecordedSession(pgid, port, orphanMatchers) {
         throw new Error(`Failed to stop existing session pgid=${pgid}`);
     }
 }
+function sessionCleanupPorts(active, configuredPorts) {
+    return [...new Set([...(active.ports ?? [active.port]), ...configuredPorts])];
+}
 async function launchDetachedCommand(command, cwd) {
     const { promise, resolve, reject } = Promise.withResolvers();
     let settled = false;
@@ -141,6 +147,7 @@ export async function buildActions(cwd) {
     return createRuntimeStateActions({
         config,
         paths,
+        workspaceRoot,
         adapter: {
             refresh: async () => buildInitialModel(cwd),
             readActive: async () => readSessionRecord(paths, { isSessionAlive: isProcessGroupAlive }),
@@ -153,9 +160,9 @@ export async function buildActions(cwd) {
                 return selected.branch;
             },
             getInvalidReason: async (worktreePath) => getInvalidReason(worktreePath, config.requiredFiles),
-            runSetup: runCommandToLog,
+            runSetup: async (input) => runCommandToLog({ ...input, workspaceRoot }),
             startCommand: startDetachedCommand,
-            stopSession: async (active) => stopRecordedSession(active.pgid, active.port, config.orphanMatchers),
+            stopSession: async (active) => stopRecordedSession(active.pgid, sessionCleanupPorts(active, config.ports), config.orphanMatchers),
             clearSession: async () => clearSessionRecord(paths),
             writeSession: async (record) => writeSessionRecord(paths, record),
             openEditor: async (worktreePath) => {
@@ -179,7 +186,7 @@ export async function buildActions(cwd) {
                     return { kind: 'idle', message: `no pull request found for ${selected.branch}` };
                 }
                 if (pullRequest.kind === 'unavailable') {
-                    return { kind: 'error', message: `pull request metadata is unavailable for ${selected.branch}` };
+                    return { kind: 'idle', message: `pull request metadata unavailable for ${selected.branch}` };
                 }
                 await launchDetachedCommand(getBrowserOpenCommand(pullRequest.url), worktreePath);
                 return { kind: 'idle', message: `opened pull request #${pullRequest.number} for ${selected.branch}` };
@@ -194,7 +201,7 @@ export async function buildActions(cwd) {
                 }
                 const active = await readSessionRecord(paths, { isSessionAlive: isProcessGroupAlive });
                 if (active?.worktreePath === worktreePath) {
-                    await stopRecordedSession(active.pgid, active.port, config.orphanMatchers);
+                    await stopRecordedSession(active.pgid, sessionCleanupPorts(active, config.ports), config.orphanMatchers);
                     await clearSessionRecord(paths);
                 }
                 await execFileAsync('git', ['worktree', 'remove', worktreePath], { cwd: workspaceRoot });

package/dist/core/session-store.d.ts

@@ -5,6 +5,7 @@ export interface SessionRecord {
     pid: number;
     pgid: number;
     port: number;
+    ports?: number[];
     logPath: string;
     startedAt: string;
 }