@ohzw/worktree-command-tui 0.1.1 → 0.1.3

package/dist/core/init.js

@@ -1,18 +1,11 @@
-import { access, readFile, writeFile } from 'node:fs/promises';
+import { access, readFile } from 'node:fs/promises';
 import { constants } from 'node:fs';
 import path from 'node:path';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
-import { CONFIG_FILE_NAME, CONFIG_FILE_NAMES } from './config.js';
+import { createDefaultToolConfig, renderConfigJsonc, writeToolConfigForRepo } from './config-lifecycle.js';
 const execFileAsync = promisify(execFile);
-function isSafeNamespace(value) {
-    return /^[A-Za-z0-9._-]+$/u.test(value);
-}
-function toSafeNamespace(value) {
-    const replaced = value.replace(/[^A-Za-z0-9._-]+/gu, '-');
-    const trimmed = replaced.replace(/^-+/, '').replace(/-+$/, '');
-    return trimmed.length > 0 && isSafeNamespace(trimmed) ? trimmed : 'worktree-command-tui';
-}
+export { renderConfigJsonc };
 async function resolveRepositoryRoot(cwd) {
     const { stdout } = await execFileAsync('git', ['rev-parse', '--show-toplevel'], { cwd });
     return stdout.trim();
@@ -85,56 +78,15 @@ function selectDefaultScript(scripts) {
 export async function buildDefaultConfig(repoRoot) {
     const packageJson = await readPackageJson(repoRoot);
     const packageManager = await detectPackageManager(repoRoot, packageJson);
-    const command = [packageManager, 'run', selectDefaultScript(packageJson?.scripts)];
-    const namespaceSeed = packageJson?.name ?? path.basename(repoRoot);
-    return {
-        namespace: toSafeNamespace(namespaceSeed),
-        command,
-        port: 3000,
-        requiredFiles: ['package.json'],
-        orphanMatchers: [],
-    };
-}
-export function renderConfigJsonc(config) {
-    return `{
-  // Session namespace used for git-common-dir state files and logs.
-  // Keep this filesystem-safe: letters, numbers, dots, underscores, and hyphens only.
-  "namespace": ${JSON.stringify(config.namespace)},
-
-  // Command launched in the selected worktree.
-  // Use argv form so spaces and shell metacharacters are passed safely.
-  "command": ${JSON.stringify(config.command)},
-
-  // TCP port owned by the command, used when stopping stale/orphaned processes.
-  "port": ${JSON.stringify(config.port)},
-
-  // Files that must exist in a worktree before the command can be started there.
-  "requiredFiles": ${JSON.stringify(config.requiredFiles)},
-
-  // Extra process command-line substrings treated as orphans for cleanup.
-  // Example: ["node --watch", "vite --host 0.0.0.0"]
-  "orphanMatchers": ${JSON.stringify(config.orphanMatchers)},
-}
-`;
-}
-async function findExistingConfigPath(workspaceRoot) {
-    for (const fileName of CONFIG_FILE_NAMES) {
-        const configPath = path.join(workspaceRoot, fileName);
-        if (await fileExists(configPath)) {
-            return configPath;
-        }
-    }
-    return null;
+    return createDefaultToolConfig({
+        namespaceSeed: packageJson?.name ?? path.basename(repoRoot),
+        packageManager,
+        script: selectDefaultScript(packageJson?.scripts),
+    });
 }
 export async function runInit(options) {
-    const configPath = path.join(options.workspaceRoot, CONFIG_FILE_NAME);
-    const existingConfigPath = await findExistingConfigPath(options.workspaceRoot);
-    if (!options.force && existingConfigPath) {
-        throw new Error(`Config file already exists: ${existingConfigPath}`);
-    }
     const config = await buildDefaultConfig(options.workspaceRoot);
-    await writeFile(configPath, renderConfigJsonc(config), 'utf8');
-    return { path: configPath, config };
+    return writeToolConfigForRepo({ ...options, config }, fileExists);
 }
 export async function createConfigForRepo(options) {
     const workspaceRoot = await resolveRepositoryRoot(options.cwd);

package/dist/core/log-reader.d.ts

@@ -0,0 +1,7 @@
+export interface LogEntry {
+    name: string;
+    path: string;
+    content: string;
+}
+export declare function tailLogContent(content: string): string;
+export declare function readLogs(logsDir: string, activeLogPath: string | null): Promise<LogEntry[]>;

package/dist/core/log-reader.js

@@ -0,0 +1,59 @@
+import path from 'node:path';
+import { open, readdir, stat } from 'node:fs/promises';
+const MAX_LOG_BYTES = 16 * 1024;
+const MAX_LOG_LINES = 120;
+const MAX_LOG_FILES = 100;
+export function tailLogContent(content) {
+    const byteTrimmed = content.length > MAX_LOG_BYTES ? content.slice(-MAX_LOG_BYTES) : content;
+    const lines = byteTrimmed.replace(/\r\n/g, '\n').split('\n');
+    const tailLines = lines.length > MAX_LOG_LINES ? lines.slice(-MAX_LOG_LINES) : lines;
+    return tailLines.join('\n').trimEnd();
+}
+async function readLogTail(filePath) {
+    const stats = await stat(filePath);
+    const bytesToRead = Math.min(stats.size, MAX_LOG_BYTES);
+    const buffer = Buffer.alloc(bytesToRead);
+    const file = await open(filePath, 'r');
+    try {
+        await file.read(buffer, 0, bytesToRead, Math.max(0, stats.size - bytesToRead));
+    }
+    finally {
+        await file.close();
+    }
+    return buffer.toString('utf8');
+}
+export async function readLogs(logsDir, activeLogPath) {
+    try {
+        const entries = (await readdir(logsDir, { withFileTypes: true }))
+            .filter(entry => entry.isFile() && entry.name.endsWith('.log'))
+            .slice(0, MAX_LOG_FILES)
+            .map(entry => ({ name: entry.name, path: path.join(logsDir, entry.name) }));
+        if (entries.length === 0) {
+            return [];
+        }
+        let selectedEntries = entries;
+        if (activeLogPath !== null) {
+            const activeEntry = entries.find(entry => entry.path === activeLogPath);
+            selectedEntries = activeEntry ? [activeEntry] : [];
+            if (selectedEntries.length === 0) {
+                return [];
+            }
+        }
+        else {
+            const withStats = await Promise.all(entries.map(async (entry) => ({
+                ...entry,
+                mtimeMs: (await stat(entry.path)).mtimeMs,
+            })));
+            withStats.sort((a, b) => b.mtimeMs - a.mtimeMs || a.name.localeCompare(b.name));
+            selectedEntries = [withStats[0]];
+        }
+        return await Promise.all(selectedEntries.map(async (entry) => ({
+            name: entry.name,
+            path: entry.path,
+            content: tailLogContent(await readLogTail(entry.path)),
+        })));
+    }
+    catch {
+        return [];
+    }
+}

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

@@ -1,4 +1,4 @@
 export declare function isProcessGroupAlive(pgid: number): Promise<boolean>;
 export declare function killProcessGroup(pgid: number, signal?: NodeJS.Signals): Promise<void>;
-export declare function killPortOwner(port: number): Promise<void>;
-export declare function killOrphans(matcher: string): Promise<void>;
+export declare function killPortOwner(port: number, pgid: number): Promise<void>;
+export declare function killOrphans(matcher: string, pgid: number): Promise<void>;

package/dist/core/posix-process.js

@@ -1,6 +1,16 @@
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 const execFileAsync = promisify(execFile);
+async function readProcessGroupId(pid) {
+    try {
+        const { stdout } = await execFileAsync('ps', ['-o', 'pgid=', '-p', pid]);
+        const pgid = Number(stdout.trim());
+        return Number.isInteger(pgid) ? pgid : null;
+    }
+    catch {
+        return null;
+    }
+}
 export async function isProcessGroupAlive(pgid) {
     try {
         process.kill(-pgid, 0);
@@ -11,6 +21,9 @@ export async function isProcessGroupAlive(pgid) {
     }
 }
 export async function killProcessGroup(pgid, signal = 'SIGTERM') {
+    if (pgid <= 1) {
+        return;
+    }
     try {
         process.kill(-pgid, signal);
     }
@@ -18,23 +31,25 @@ export async function killProcessGroup(pgid, signal = 'SIGTERM') {
         // Process group already gone.
     }
 }
-export async function killPortOwner(port) {
+export async function killPortOwner(port, pgid) {
     try {
         const { stdout } = await execFileAsync('lsof', ['-nP', `-iTCP:${port}`, '-sTCP:LISTEN', '-t']);
         for (const pid of stdout
             .split('\n')
             .map(line => line.trim())
             .filter(Boolean)) {
-            await execFileAsync('kill', [pid]);
+            if (await readProcessGroupId(pid) === pgid) {
+                await execFileAsync('kill', [pid]);
+            }
         }
     }
     catch {
         // Port not owned or lsof found nothing.
     }
 }
-export async function killOrphans(matcher) {
+export async function killOrphans(matcher, pgid) {
     try {
-        await execFileAsync('pkill', ['-f', matcher]);
+        await execFileAsync('pkill', ['-g', String(pgid), '-f', matcher]);
     }
     catch {
         // No matching orphan process.

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

@@ -1,7 +1,7 @@
 export interface CleanupDeps {
     killProcessGroup: (pgid: number, signal?: NodeJS.Signals) => Promise<void>;
-    killPortOwner: (port: number) => Promise<void>;
-    killOrphans: (matcher: string) => Promise<void>;
+    killPortOwner: (port: number, pgid: number) => Promise<void>;
+    killOrphans: (matcher: string, pgid: number) => Promise<void>;
     isSessionAlive: (pgid: number) => Promise<boolean>;
 }
 export declare function stopSessionWithFallback(input: {

package/dist/core/process-control.js

@@ -1,11 +1,14 @@
 export async function stopSessionWithFallback(input, deps) {
+    if (input.pgid <= 1) {
+        return false;
+    }
     await deps.killProcessGroup(input.pgid, 'SIGTERM');
     if (!(await deps.isSessionAlive(input.pgid))) {
         return true;
     }
-    await deps.killPortOwner(input.port);
+    await deps.killPortOwner(input.port, input.pgid);
     for (const matcher of input.orphanMatchers) {
-        await deps.killOrphans(matcher);
+        await deps.killOrphans(matcher, input.pgid);
     }
     if (!(await deps.isSessionAlive(input.pgid))) {
         return true;

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

@@ -0,0 +1,42 @@
+import type { ToolConfig } from './config.js';
+import type { AppActions, AppLogEntry, AppModel, AppStatus } from './runtime.js';
+import type { SessionPaths, SessionRecord } from './session-store.js';
+export interface StartedCommand {
+    pid: number;
+    pgid: number;
+    logPath: string;
+}
+export interface RuntimeStateAdapter {
+    refresh: () => Promise<AppModel>;
+    readActive: () => Promise<SessionRecord | null>;
+    readLogs: (logPath: string | null) => Promise<AppLogEntry[]>;
+    readWorktreeBranch: (worktreePath: string) => Promise<string>;
+    getInvalidReason: (worktreePath: string) => Promise<string | null>;
+    runSetup: (input: {
+        command: string[];
+        cwd: string;
+        logsDir: string;
+        logFileBase: string;
+    }) => Promise<{
+        logPath: string;
+    }>;
+    startCommand: (input: {
+        command: string[];
+        cwd: string;
+        logsDir: string;
+        logFileBase: string;
+    }) => Promise<StartedCommand>;
+    stopSession: (active: SessionRecord) => Promise<void>;
+    clearSession: () => Promise<void>;
+    writeSession: (record: SessionRecord) => Promise<void>;
+    openEditor: (worktreePath: string) => Promise<AppStatus>;
+    openPullRequest: (worktreePath: string) => Promise<AppStatus>;
+    deleteWorktree: (worktreePath: string) => Promise<AppStatus>;
+    nowIso: () => string;
+}
+export interface RuntimeStateOptions {
+    config: ToolConfig;
+    paths: SessionPaths;
+    adapter: RuntimeStateAdapter;
+}
+export declare function createRuntimeStateActions({ config, paths, adapter }: RuntimeStateOptions): AppActions;

package/dist/core/runtime-state.js

@@ -0,0 +1,125 @@
+import path from 'node:path';
+function toLogFileBase(branch) {
+    return branch.replace(/[\\/]/g, '-');
+}
+export function createRuntimeStateActions({ config, paths, adapter }) {
+    const refreshLogs = async () => {
+        const active = await adapter.readActive();
+        return {
+            logs: await adapter.readLogs(active?.logPath ?? null),
+            activePath: active?.worktreePath ?? null,
+            activeBranch: active?.branch ?? null,
+        };
+    };
+    const refreshWithStatus = async (run, preserveRunningStatus) => {
+        const status = await run();
+        const model = await adapter.refresh();
+        if (preserveRunningStatus && model.activePath !== null && status.kind === 'idle') {
+            return {
+                ...model,
+                status: { kind: 'running', message: status.message },
+            };
+        }
+        return {
+            ...model,
+            status,
+        };
+    };
+    const stop = async () => {
+        const active = await adapter.readActive();
+        if (active) {
+            await adapter.stopSession(active);
+            await adapter.clearSession();
+        }
+        const model = await adapter.refresh();
+        return {
+            ...model,
+            activePath: null,
+            activeBranch: null,
+            status: { kind: 'idle', message: active ? 'stopped' : 'already stopped' },
+        };
+    };
+    const setup = async (worktreePath) => {
+        const setupCommand = config.setupCommand;
+        if (setupCommand === undefined) {
+            const model = await adapter.refresh();
+            return {
+                ...model,
+                status: { kind: 'idle', message: 'setup command is not configured' },
+            };
+        }
+        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),
+            };
+        }
+        const model = await adapter.refresh();
+        return {
+            ...model,
+            status: { kind: model.activePath === null ? 'idle' : 'running', message: `setup complete for ${branch}` },
+            logs: await adapter.readLogs(setupLogPath),
+        };
+    };
+    const start = async (worktreePath) => {
+        const current = await adapter.readActive();
+        if (current?.worktreePath === worktreePath) {
+            const model = await adapter.refresh();
+            return {
+                ...model,
+                activePath: current.worktreePath,
+                activeBranch: current.branch,
+                status: { kind: 'idle', message: 'already active' },
+            };
+        }
+        const invalidReason = await adapter.getInvalidReason(worktreePath);
+        if (invalidReason) {
+            throw new Error(invalidReason);
+        }
+        if (current) {
+            await adapter.stopSession(current);
+            await adapter.clearSession();
+        }
+        const branch = await adapter.readWorktreeBranch(worktreePath);
+        const started = await adapter.startCommand({
+            command: config.command,
+            cwd: worktreePath,
+            logsDir: paths.logsDir,
+            logFileBase: toLogFileBase(branch),
+        });
+        await adapter.writeSession({
+            namespace: config.namespace,
+            worktreePath,
+            branch,
+            pid: started.pid,
+            pgid: started.pgid,
+            port: config.port,
+            logPath: started.logPath,
+            startedAt: adapter.nowIso(),
+        });
+        const model = await adapter.refresh();
+        return {
+            ...model,
+            activePath: worktreePath,
+            activeBranch: branch,
+            status: { kind: 'running', message: `started ${branch}` },
+        };
+    };
+    const openEditor = async (worktreePath) => refreshWithStatus(() => adapter.openEditor(worktreePath), true);
+    const openPullRequest = async (worktreePath) => refreshWithStatus(() => adapter.openPullRequest(worktreePath), true);
+    const deleteWorktree = async (worktreePath) => refreshWithStatus(() => adapter.deleteWorktree(worktreePath), false);
+    return { setup, start, stop, refresh: adapter.refresh, refreshLogs, openEditor, openPullRequest, deleteWorktree };
+}

package/dist/core/runtime.d.ts

@@ -1,29 +1,8 @@
 import { type WorktreeRow } from './git-worktrees.js';
+import { type UpstreamInfo, type WorkingTreeInfo } 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';
-export interface UpstreamInfo {
-    branch: string;
-    ahead: number;
-    behind: number;
-}
-export interface WorkingTreeInfo {
-    staged: number;
-    unstaged: number;
-    untracked: number;
-    conflicts: number;
-}
-export type PullRequestInfo = {
-    kind: 'found';
-    number: number;
-    title: string;
-    url: string;
-    state: 'OPEN' | 'CLOSED' | 'MERGED';
-    isDraft: boolean;
-    baseBranch: string;
-} | {
-    kind: 'none';
-} | {
-    kind: 'unavailable';
-};
 export interface AppRow {
     path: string;
     shortPath: string;
@@ -34,17 +13,14 @@ export interface AppRow {
     upstreamUnavailable?: boolean;
     workingTree?: WorkingTreeInfo;
     pullRequest?: PullRequestInfo;
+    branchCreatedAtMs?: number;
     invalidReason?: string;
 }
 export interface AppStatus {
-    kind: 'idle' | 'starting' | 'running' | 'stopping' | 'error';
+    kind: 'idle' | 'setting-up' | 'starting' | 'running' | 'stopping' | 'error';
     message: string;
 }
-export interface AppLogEntry {
-    name: string;
-    path: string;
-    content: string;
-}
+export type AppLogEntry = LogEntry;
 export interface AppModel {
     repoName: string;
     namespace: string;
@@ -52,21 +28,25 @@ export interface AppModel {
     activePath: string | null;
     activeBranch: string | null;
     status: AppStatus;
+    setupAvailable: boolean;
+    editorAvailable: boolean;
+    logs: AppLogEntry[];
+}
+export interface AppLogRefresh {
     logs: AppLogEntry[];
+    activePath: string | null;
+    activeBranch: string | null;
 }
 export interface AppActions {
+    setup: (worktreePath: string) => Promise<AppModel>;
     start: (worktreePath: string) => Promise<AppModel>;
     stop: () => Promise<AppModel>;
     refresh: () => Promise<AppModel>;
-    refreshLogs: () => Promise<AppLogEntry[]>;
-}
-interface GitStatusSummary {
-    upstream?: UpstreamInfo;
-    upstreamUnavailable: boolean;
-    workingTree?: WorkingTreeInfo;
+    refreshLogs: () => Promise<AppLogRefresh>;
+    openEditor: (worktreePath: string) => Promise<AppModel>;
+    openPullRequest: (worktreePath: string) => Promise<AppModel>;
+    deleteWorktree: (worktreePath: string) => Promise<AppModel>;
 }
-export declare function parseGitStatusSummary(output: string): GitStatusSummary;
-export declare function toAppRow(mainWorktreePath: string, worktree: WorktreeRow, activePath: string | null, invalidReason: string | null, metadata: Pick<AppRow, 'upstream' | 'upstreamUnavailable' | 'workingTree' | 'pullRequest'>): AppRow;
+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 buildInitialModel(cwd: string): Promise<AppModel>;
 export declare function buildActions(cwd: string): Promise<AppActions>;
-export {};