vimd 0.1.6 → 0.1.8

package/dist/cli/commands/dev.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/dev.ts"],"names":[],"mappings":"AAWA,UAAU,UAAU;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,wBAAsB,UAAU,CAC9B,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,UAAU,GAClB,OAAO,CAAC,IAAI,CAAC,CAwGf"}
+{"version":3,"file":"dev.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/dev.ts"],"names":[],"mappings":"AAYA,UAAU,UAAU;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,wBAAsB,UAAU,CAC9B,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,UAAU,GAClB,OAAO,CAAC,IAAI,CAAC,CA+If"}

package/dist/cli/commands/dev.js

@@ -6,6 +6,7 @@ import { LiveServer } from '../../core/server.js';
 import { PandocDetector } from '../../core/pandoc-detector.js';
 import { Logger } from '../../utils/logger.js';
 import { ProcessManager } from '../../utils/process-manager.js';
+import { SessionManager } from '../../utils/session-manager.js';
 import * as path from 'path';
 import fs from 'fs-extra';
 export async function devCommand(filePath, options) {
@@ -23,44 +24,73 @@ export async function devCommand(filePath, options) {
         if (options.open !== undefined) {
             config.open = options.open;
         }
+        let port = config.port;
+        // 2. Clean dead sessions first
+        const deadCleaned = await SessionManager.cleanDeadSessions();
+        if (deadCleaned > 0) {
+            Logger.info(`Cleaned ${deadCleaned} stale session(s)`);
+        }
+        // 3. Check and cleanup previous session on same port
+        const cleanup = await SessionManager.cleanupSessionOnPort(port);
+        if (cleanup.killed) {
+            Logger.info(`Stopped previous session on port ${port}`);
+        }
+        if (cleanup.htmlRemoved) {
+            Logger.info('Removed previous preview file');
+        }
+        // 4. Check if port is available (might be used by other app)
+        if (!(await SessionManager.isPortAvailable(port))) {
+            const newPort = await SessionManager.findAvailablePort(port + 1);
+            Logger.warn(`Port ${port} is in use by another application`);
+            Logger.info(`Using port ${newPort} instead`);
+            port = newPort;
+        }
         Logger.info(`Theme: ${config.theme}`);
-        Logger.info(`Port: ${config.port}`);
-        // 2. Check pandoc installation
+        Logger.info(`Port: ${port}`);
+        // 5. Check pandoc installation
         PandocDetector.ensureInstalled();
-        // 3. Check file exists
+        // 6. Check file exists
         const absolutePath = path.resolve(filePath);
         if (!(await fs.pathExists(absolutePath))) {
             Logger.error(`File not found: ${filePath}`);
             process.exit(1);
         }
-        // 4. Prepare output HTML in source directory
+        // 7. Prepare output HTML in source directory
         const sourceDir = path.dirname(absolutePath);
         const basename = path.basename(filePath, path.extname(filePath));
         const htmlFileName = `vimd-preview-${basename}.html`;
         const htmlPath = path.join(sourceDir, htmlFileName);
-        // 5. Prepare converter
+        // 8. Prepare converter
         const converter = new MarkdownConverter({
             theme: config.theme,
             pandocOptions: config.pandoc,
             customCSS: config.css,
             template: config.template,
         });
-        // 6. Initial conversion
+        // 9. Initial conversion
         Logger.info('Converting markdown...');
         const html = await converter.convertWithTemplate(absolutePath);
         await converter.writeHTML(html, htmlPath);
         Logger.success('Conversion complete');
-        // 7. Start live server from source directory
+        // 10. Start live server from source directory
         const server = new LiveServer({
-            port: config.port,
+            port: port,
             host: config.host,
             open: config.open,
             root: sourceDir,
         });
         await server.start(htmlPath);
+        // 11. Save session
+        await SessionManager.saveSession({
+            pid: process.pid,
+            port: port,
+            htmlPath: htmlPath,
+            sourcePath: absolutePath,
+            startedAt: new Date().toISOString(),
+        });
         Logger.info(`Watching: ${filePath}`);
         Logger.info('Press Ctrl+C to stop');
-        // 8. Start file watching
+        // 12. Start file watching
         const watcher = new FileWatcher(absolutePath, config.watch);
         watcher.onChange(async (changedPath) => {
             Logger.info('File changed, reconverting...');
@@ -77,7 +107,7 @@ export async function devCommand(filePath, options) {
             }
         });
         watcher.start();
-        // 9. Register cleanup - remove generated HTML file
+        // 13. Register cleanup - remove generated HTML file and session
         ProcessManager.onExit(async () => {
             Logger.info('Shutting down...');
             await watcher.stop();
@@ -90,6 +120,8 @@ export async function devCommand(filePath, options) {
             catch {
                 // Ignore errors when removing file
             }
+            // Remove session from registry
+            await SessionManager.removeSession(port);
             Logger.info('Cleanup complete');
         });
     }

package/dist/themes/styles/dark.css

@@ -1,54 +1,524 @@
-/* Dark Theme - VS Code inspired */
+/*
+ * GitHub Dark Theme for vimd
+ * Based on github-markdown-css by Sindre Sorhus
+ * https://github.com/sindresorhus/github-markdown-css
+ * MIT License
+ */
+
+/* Full page dark background */
+html {
+  background-color: #0d1117;
+}
+
+/* Main body styles */
 body {
-  font-family: 'Fira Code', Consolas, Monaco, monospace;
-  line-height: 1.6;
-  color: #d4d4d4;
-  background: #1e1e1e;
-  max-width: 900px;
+  color-scheme: dark;
+  -ms-text-size-adjust: 100%;
+  -webkit-text-size-adjust: 100%;
   margin: 0 auto;
   padding: 2rem;
+  max-width: 980px;
+  color: #f0f6fc;
+  background-color: #0d1117;
+  font-family: -apple-system,BlinkMacSystemFont,"Segoe UI","Noto Sans",Helvetica,Arial,sans-serif,"Apple Color Emoji","Segoe UI Emoji";
+  font-size: 16px;
+  line-height: 1.5;
+  word-wrap: break-word;
 }
 
-h1, h2, h3, h4, h5, h6 {
-  color: #569cd6;
-  margin-top: 1.5em;
-  margin-bottom: 0.5em;
-}
-
-a {
-  color: #569cd6;
+/* Links */
+body a {
+  background-color: transparent;
+  color: #4493f8;
   text-decoration: none;
 }
 
-a:hover {
+body a:hover {
   text-decoration: underline;
 }
 
-code {
-  background: #252526;
-  color: #ce9178;
-  padding: 0.2em 0.4em;
-  border-radius: 3px;
-  font-family: 'Fira Code', monospace;
+/* Strong / Bold */
+body b,
+body strong {
+  font-weight: 600;
 }
 
-pre {
-  background: #252526;
-  padding: 1em;
-  border-radius: 5px;
-  overflow-x: auto;
-  border: 1px solid #333;
+/* Headings */
+body h1,
+body h2,
+body h3,
+body h4,
+body h5,
+body h6 {
+  margin-top: 1.5rem;
+  margin-bottom: 1rem;
+  font-weight: 600;
+  line-height: 1.25;
+}
+
+body h1 {
+  margin: .67em 0;
+  font-weight: 600;
+  padding-bottom: .3em;
+  font-size: 2em;
+  border-bottom: 1px solid #3d444db3;
+}
+
+body h2 {
+  font-weight: 600;
+  padding-bottom: .3em;
+  font-size: 1.5em;
+  border-bottom: 1px solid #3d444db3;
+}
+
+body h3 {
+  font-weight: 600;
+  font-size: 1.25em;
+}
+
+body h4 {
+  font-weight: 600;
+  font-size: 1em;
+}
+
+body h5 {
+  font-weight: 600;
+  font-size: .875em;
+}
+
+body h6 {
+  font-weight: 600;
+  font-size: .85em;
+  color: #9198a1;
+}
+
+/* Paragraphs */
+body p {
+  margin-top: 0;
+  margin-bottom: 10px;
+}
+
+/* Lists */
+body ul,
+body ol {
+  margin-top: 0;
+  margin-bottom: 0;
+  padding-left: 2em;
+}
+
+body li+li {
+  margin-top: .25em;
 }
 
-pre code {
-  background: none;
-  color: #d4d4d4;
+/* Blockquote */
+body blockquote {
+  margin: 0;
+  padding: 0 1em;
+  color: #9198a1;
+  border-left: .25em solid #3d444d;
+}
+
+/* Horizontal Rule */
+body hr {
+  box-sizing: content-box;
+  overflow: hidden;
+  background: transparent;
+  border-bottom: 1px solid #3d444db3;
+  height: .25em;
   padding: 0;
+  margin: 1.5rem 0;
+  background-color: #3d444d;
+  border: 0;
+}
+
+/* Images */
+body img {
+  border-style: none;
+  max-width: 100%;
+  box-sizing: content-box;
+}
+
+/* Tables */
+body table {
+  border-spacing: 0;
+  border-collapse: collapse;
+  display: block;
+  width: max-content;
+  max-width: 100%;
+  overflow: auto;
+}
+
+body table th {
+  font-weight: 600;
+}
+
+body table th,
+body table td {
+  padding: 6px 13px;
+  border: 1px solid #3d444d;
+}
+
+body table tr {
+  background-color: #0d1117;
+  border-top: 1px solid #3d444db3;
+}
+
+body table tr:nth-child(2n) {
+  background-color: #151b23;
+}
+
+/* Inline Code */
+body code,
+body tt {
+  padding: .2em .4em;
+  margin: 0;
+  font-size: 85%;
+  white-space: break-spaces;
+  background-color: #656c7633;
+  border-radius: 6px;
+  font-family: ui-monospace, SFMono-Regular, SF Mono, Menlo, Consolas, Liberation Mono, monospace;
+}
+
+/* Code Blocks */
+body pre {
+  margin-top: 0;
+  margin-bottom: 0;
+  font-family: ui-monospace, SFMono-Regular, SF Mono, Menlo, Consolas, Liberation Mono, monospace;
+  font-size: 12px;
+  word-wrap: normal;
+}
+
+body pre code {
+  font-size: 100%;
+}
+
+body pre>code {
+  padding: 0;
+  margin: 0;
+  word-break: normal;
+  white-space: pre;
+  background: transparent;
+  border: 0;
+}
+
+body .highlight pre,
+body pre {
+  padding: 1rem;
+  overflow: auto;
+  font-size: 85%;
+  line-height: 1.45;
+  color: #f0f6fc;
+  background-color: #151b23;
+  border-radius: 6px;
+}
+
+body pre code,
+body pre tt {
+  display: inline;
+  max-width: auto;
+  padding: 0;
+  margin: 0;
+  overflow: visible;
+  line-height: inherit;
+  word-wrap: normal;
+  background-color: transparent;
+  border: 0;
+}
+
+/* Keyboard */
+body kbd {
+  display: inline-block;
+  padding: 0.25rem;
+  font: 11px ui-monospace, SFMono-Regular, SF Mono, Menlo, Consolas, Liberation Mono, monospace;
+  line-height: 10px;
+  color: #f0f6fc;
+  vertical-align: middle;
+  background-color: #151b23;
+  border: solid 1px #3d444db3;
+  border-bottom-color: #3d444db3;
+  border-radius: 6px;
+  box-shadow: inset 0 -1px 0 #3d444db3;
+}
+
+/* Mark / Highlight */
+body mark {
+  background-color: #bb800926;
+  color: #f0f6fc;
+}
+
+/* Definition Lists */
+body dl {
+  padding: 0;
+}
+
+body dl dt {
+  padding: 0;
+  margin-top: 1rem;
+  font-size: 1em;
+  font-style: italic;
+  font-weight: 600;
+}
+
+body dl dd {
+  padding: 0 1rem;
+  margin-bottom: 1rem;
+}
+
+/* Table of Contents (pandoc) */
+nav#TOC {
+  background-color: #151b23;
+  border: 1px solid #3d444d;
+  border-radius: 6px;
+  padding: 1rem 1.5rem;
+  margin-bottom: 1.5rem;
+}
+
+nav#TOC > ul {
+  margin: 0;
+  padding-left: 0;
+  list-style: none;
+}
+
+nav#TOC ul {
+  padding-left: 1.5em;
+}
+
+nav#TOC li {
+  margin: 0.4em 0;
+}
+
+nav#TOC a {
+  color: #4493f8;
+}
+
+nav#TOC a:hover {
+  color: #58a6ff;
+}
+
+/* Pandoc Syntax Highlighting - GitHub Dark Colors */
+div.sourceCode {
+  background-color: #151b23;
+  border-radius: 6px;
+  overflow: auto;
+}
+
+pre.sourceCode {
+  margin: 0;
+  padding: 1rem;
+}
+
+code.sourceCode {
+  background: transparent;
+  color: #f0f6fc;
+}
+
+/* Comments */
+code.sourceCode span.co,
+.sourceCode .co {
+  color: #9198a1;
+}
+
+/* Constants */
+code.sourceCode span.cn,
+code.sourceCode span.c1,
+code.sourceCode span.dv,
+code.sourceCode span.bn,
+code.sourceCode span.fl,
+.sourceCode .cn,
+.sourceCode .c1,
+.sourceCode .dv,
+.sourceCode .bn,
+.sourceCode .fl {
+  color: #79c0ff;
+}
+
+/* Strings */
+code.sourceCode span.st,
+code.sourceCode span.ch,
+code.sourceCode span.vs,
+.sourceCode .st,
+.sourceCode .ch,
+.sourceCode .vs {
+  color: #a5d6ff;
+}
+
+/* Keywords */
+code.sourceCode span.kw,
+code.sourceCode span.cf,
+.sourceCode .kw,
+.sourceCode .cf {
+  color: #ff7b72;
+}
+
+/* Functions */
+code.sourceCode span.fu,
+code.sourceCode span.bu,
+.sourceCode .fu,
+.sourceCode .bu {
+  color: #d2a8ff;
+}
+
+/* Variables */
+code.sourceCode span.va,
+.sourceCode .va {
+  color: #ffa657;
+}
+
+/* Data Types */
+code.sourceCode span.dt,
+.sourceCode .dt {
+  color: #79c0ff;
+}
+
+/* Operators */
+code.sourceCode span.op,
+.sourceCode .op {
+  color: #f0f6fc;
+}
+
+/* Attributes / Decorators */
+code.sourceCode span.at,
+.sourceCode .at {
+  color: #7ee787;
+}
+
+/* Preprocessor */
+code.sourceCode span.pp,
+.sourceCode .pp {
+  color: #ff7b72;
+}
+
+/* Import */
+code.sourceCode span.im,
+.sourceCode .im {
+  color: #ff7b72;
+}
+
+/* Special characters */
+code.sourceCode span.sc,
+.sourceCode .sc {
+  color: #a5d6ff;
+}
+
+/* Regular expressions */
+code.sourceCode span.ss,
+.sourceCode .ss {
+  color: #a5d6ff;
+}
+
+/* Annotations */
+code.sourceCode span.an,
+.sourceCode .an {
+  color: #9198a1;
+}
+
+/* Documentation */
+code.sourceCode span.do,
+.sourceCode .do {
+  color: #9198a1;
+}
+
+/* Errors */
+code.sourceCode span.er,
+code.sourceCode span.al,
+.sourceCode .er,
+.sourceCode .al {
+  color: #f85149;
+}
+
+/* Warnings */
+code.sourceCode span.wa,
+.sourceCode .wa {
+  color: #d29922;
+}
+
+/* Information */
+code.sourceCode span.in,
+.sourceCode .in {
+  color: #9198a1;
+}
+
+/* GitHub .pl-* classes (for compatibility) */
+body .pl-c {
+  color: #9198a1;
+}
+
+body .pl-c1,
+body .pl-s .pl-v {
+  color: #79c0ff;
+}
+
+body .pl-e,
+body .pl-en {
+  color: #d2a8ff;
+}
+
+body .pl-smi,
+body .pl-s .pl-s1 {
+  color: #f0f6fc;
+}
+
+body .pl-ent {
+  color: #7ee787;
+}
+
+body .pl-k {
+  color: #ff7b72;
+}
+
+body .pl-s,
+body .pl-pds,
+body .pl-s .pl-pse .pl-s1,
+body .pl-sr,
+body .pl-sr .pl-cce,
+body .pl-sr .pl-sre,
+body .pl-sr .pl-sra {
+  color: #a5d6ff;
+}
+
+body .pl-v,
+body .pl-smw {
+  color: #ffa657;
+}
+
+body .pl-bu {
+  color: #f85149;
+}
+
+/* Selection */
+::selection {
+  background-color: #264f78;
+  color: #ffffff;
+}
+
+/* Scrollbar (WebKit) */
+::-webkit-scrollbar {
+  width: 10px;
+  height: 10px;
+}
+
+::-webkit-scrollbar-track {
+  background: #0d1117;
+}
+
+::-webkit-scrollbar-thumb {
+  background: #3d444d;
+  border-radius: 5px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+  background: #4f5761;
+}
+
+/* Focus states */
+body a:focus {
+  outline: 2px solid #1f6feb;
+  outline-offset: -2px;
 }
 
-blockquote {
-  border-left: 4px solid #569cd6;
-  padding-left: 1em;
-  color: #b5b5b5;
-  margin-left: 0;
+/* Responsive */
+@media (max-width: 768px) {
+  body {
+    padding: 1rem;
+  }
 }

package/dist/utils/session-manager.d.ts

@@ -0,0 +1,65 @@
+export interface VimdSession {
+    pid: number;
+    port: number;
+    htmlPath: string;
+    sourcePath: string;
+    startedAt: string;
+}
+export interface VimdSessions {
+    [port: string]: VimdSession;
+}
+export interface CleanupResult {
+    killed: boolean;
+    htmlRemoved: boolean;
+    previousPort?: number;
+    previousSource?: string;
+}
+export declare class SessionManager {
+    private static readonly SESSIONS_DIR;
+    private static readonly SESSIONS_FILE;
+    /**
+     * Load all sessions from file
+     */
+    static loadSessions(): Promise<VimdSessions>;
+    /**
+     * Save sessions to file
+     */
+    static saveSessions(sessions: VimdSessions): Promise<void>;
+    /**
+     * Get session for specific port
+     */
+    static getSession(port: number): Promise<VimdSession | null>;
+    /**
+     * Save session for specific port
+     */
+    static saveSession(session: VimdSession): Promise<void>;
+    /**
+     * Remove session for specific port
+     */
+    static removeSession(port: number): Promise<void>;
+    /**
+     * Check if a process is alive
+     */
+    static isProcessAlive(pid: number): boolean;
+    /**
+     * Kill a process safely
+     */
+    static killProcess(pid: number): Promise<boolean>;
+    /**
+     * Clean up dead sessions (PIDs that no longer exist)
+     */
+    static cleanDeadSessions(): Promise<number>;
+    /**
+     * Clean up previous session on the same port
+     */
+    static cleanupSessionOnPort(port: number): Promise<CleanupResult>;
+    /**
+     * Check if a port is available
+     */
+    static isPortAvailable(port: number): Promise<boolean>;
+    /**
+     * Find an available port starting from startPort
+     */
+    static findAvailablePort(startPort: number): Promise<number>;
+}
+//# sourceMappingURL=session-manager.d.ts.map

package/dist/utils/session-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-manager.d.ts","sourceRoot":"","sources":["../../src/utils/session-manager.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,YAAY;IAC3B,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;CAC7B;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,OAAO,CAAC;IAChB,WAAW,EAAE,OAAO,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,YAAY,CAAkC;IACtE,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,aAAa,CAGnC;IAEF;;OAEG;WACU,YAAY,IAAI,OAAO,CAAC,YAAY,CAAC;IAWlD;;OAEG;WACU,YAAY,CAAC,QAAQ,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAKhE;;OAEG;WACU,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;IAKlE;;OAEG;WACU,WAAW,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAM7D;;OAEG;WACU,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAMvD;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAS3C;;OAEG;WACU,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAgBvD;;OAEG;WACU,iBAAiB,IAAI,OAAO,CAAC,MAAM,CAAC;IA0BjD;;OAEG;WACU,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC;IAmCvE;;OAEG;IACH,MAAM,CAAC,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAYtD;;OAEG;WACU,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAcnE"}

package/dist/utils/session-manager.js

@@ -0,0 +1,168 @@
+// src/utils/session-manager.ts
+import fs from 'fs-extra';
+import * as path from 'path';
+import * as os from 'os';
+import * as net from 'net';
+export class SessionManager {
+    /**
+     * Load all sessions from file
+     */
+    static async loadSessions() {
+        try {
+            if (await fs.pathExists(this.SESSIONS_FILE)) {
+                return await fs.readJson(this.SESSIONS_FILE);
+            }
+        }
+        catch {
+            // Corrupted file, start fresh
+        }
+        return {};
+    }
+    /**
+     * Save sessions to file
+     */
+    static async saveSessions(sessions) {
+        await fs.ensureDir(this.SESSIONS_DIR);
+        await fs.writeJson(this.SESSIONS_FILE, sessions, { spaces: 2 });
+    }
+    /**
+     * Get session for specific port
+     */
+    static async getSession(port) {
+        const sessions = await this.loadSessions();
+        return sessions[port.toString()] || null;
+    }
+    /**
+     * Save session for specific port
+     */
+    static async saveSession(session) {
+        const sessions = await this.loadSessions();
+        sessions[session.port.toString()] = session;
+        await this.saveSessions(sessions);
+    }
+    /**
+     * Remove session for specific port
+     */
+    static async removeSession(port) {
+        const sessions = await this.loadSessions();
+        delete sessions[port.toString()];
+        await this.saveSessions(sessions);
+    }
+    /**
+     * Check if a process is alive
+     */
+    static isProcessAlive(pid) {
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Kill a process safely
+     */
+    static async killProcess(pid) {
+        try {
+            process.kill(pid, 'SIGTERM');
+            // Wait a bit for graceful shutdown
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            // Force kill if still alive
+            if (this.isProcessAlive(pid)) {
+                process.kill(pid, 'SIGKILL');
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Clean up dead sessions (PIDs that no longer exist)
+     */
+    static async cleanDeadSessions() {
+        const sessions = await this.loadSessions();
+        let cleaned = 0;
+        for (const [port, session] of Object.entries(sessions)) {
+            if (!this.isProcessAlive(session.pid)) {
+                // Process is dead, clean up HTML if exists
+                try {
+                    if (await fs.pathExists(session.htmlPath)) {
+                        await fs.remove(session.htmlPath);
+                    }
+                }
+                catch {
+                    // Ignore removal errors
+                }
+                delete sessions[port];
+                cleaned++;
+            }
+        }
+        if (cleaned > 0) {
+            await this.saveSessions(sessions);
+        }
+        return cleaned;
+    }
+    /**
+     * Clean up previous session on the same port
+     */
+    static async cleanupSessionOnPort(port) {
+        const session = await this.getSession(port);
+        if (!session) {
+            return { killed: false, htmlRemoved: false };
+        }
+        const result = {
+            killed: false,
+            htmlRemoved: false,
+            previousPort: port,
+            previousSource: session.sourcePath,
+        };
+        // Kill process if alive
+        if (this.isProcessAlive(session.pid)) {
+            result.killed = await this.killProcess(session.pid);
+        }
+        // Remove HTML file
+        try {
+            if (await fs.pathExists(session.htmlPath)) {
+                await fs.remove(session.htmlPath);
+                result.htmlRemoved = true;
+            }
+        }
+        catch {
+            // Ignore removal errors
+        }
+        // Remove session from registry
+        await this.removeSession(port);
+        return result;
+    }
+    /**
+     * Check if a port is available
+     */
+    static isPortAvailable(port) {
+        return new Promise((resolve) => {
+            const server = net.createServer();
+            server.once('error', () => resolve(false));
+            server.once('listening', () => {
+                server.close();
+                resolve(true);
+            });
+            server.listen(port, '127.0.0.1');
+        });
+    }
+    /**
+     * Find an available port starting from startPort
+     */
+    static async findAvailablePort(startPort) {
+        const MAX_ATTEMPTS = 10;
+        for (let i = 0; i < MAX_ATTEMPTS; i++) {
+            const port = startPort + i;
+            if (await this.isPortAvailable(port)) {
+                return port;
+            }
+        }
+        throw new Error(`No available port found (tried ${startPort}-${startPort + MAX_ATTEMPTS - 1})`);
+    }
+}
+SessionManager.SESSIONS_DIR = path.join(os.tmpdir(), 'vimd');
+SessionManager.SESSIONS_FILE = path.join(SessionManager.SESSIONS_DIR, 'sessions.json');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vimd",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Real-time Markdown preview tool with pandoc (view markdown)",
   "type": "module",
   "keywords": [