openwriter 0.10.0 → 0.12.0

package/dist/bin/pad.js

@@ -49,117 +49,162 @@ process.stdin.on('close', () => {
 });
 // Only light imports here — helpers.js uses fs/path/os/crypto (all Node stdlib)
 import { createConnection } from 'net';
+import { existsSync, readFileSync } from 'fs';
+import { dirname, join, resolve } from 'path';
+import { fileURLToPath } from 'url';
 import { readConfig, saveConfig } from '../server/helpers.js';
-const args = process.argv.slice(2);
-// Subcommands (run and exit, don't start server)
-if (args[0] === 'install-skill') {
-    import('../server/install-skill.js').then(m => m.installSkill());
+// ── Worktree-aware re-exec ──────────────────────────────────────────────────
+// The `openwriter` global command is npm-linked to a single repo, but during
+// development we use worktrees for branches. Walking up from cwd to find the
+// nearest openwriter repo lets each worktree's freshly-built dist take effect
+// automatically — no manual `npm link` swap between trees.
+//
+// Detection: walk up from process.cwd() looking for a packages/openwriter
+// package.json named "openwriter". If found AND it's not the same repo as the
+// one we're running from, dynamic-import its dist/bin/pad.js (which runs its
+// own server) and skip our own startup. Outside any openwriter repo (e.g. a
+// book project), we fall through and run our own dist normally.
+function findLocalOpenwriterBin() {
+    let dir = process.cwd();
+    while (true) {
+        const pkgPath = join(dir, 'packages', 'openwriter', 'package.json');
+        if (existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+                if (pkg.name === 'openwriter') {
+                    const bin = join(dir, 'packages', 'openwriter', 'dist', 'bin', 'pad.js');
+                    if (existsSync(bin))
+                        return bin;
+                }
+            }
+            catch { /* keep walking */ }
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
 }
-else if (args[0] === 'plugin') {
-    import('../server/plugin-install.js').then(m => m.handlePluginCommand(args.slice(1)));
+const myBin = resolve(fileURLToPath(import.meta.url));
+const localBin = findLocalOpenwriterBin();
+let handedOff = false;
+if (localBin && resolve(localBin) !== myBin) {
+    console.error(`[OpenWriter] cwd is inside an openwriter repo — running ${localBin}`);
+    await import(localBin);
+    handedOff = true;
 }
-else {
-    let port = 5050;
-    let noOpen = false;
-    let cliApiKey;
-    let cliAvUrl;
-    let plugins = [];
-    for (let i = 0; i < args.length; i++) {
-        if (args[i] === '--port' && args[i + 1]) {
-            port = parseInt(args[i + 1], 10);
-            i++;
-        }
-        if (args[i] === '--no-open') {
-            noOpen = true;
-        }
-        if (args[i] === '--api-key' && args[i + 1]) {
-            cliApiKey = args[i + 1];
-            i++;
-        }
-        if (args[i] === '--av-url' && args[i + 1]) {
-            cliAvUrl = args[i + 1];
-            i++;
-        }
-        if (args[i] === '--plugins' && args[i + 1]) {
-            plugins = args[i + 1].split(',').map((s) => s.trim()).filter(Boolean);
-            i++;
-        }
+if (!handedOff) {
+    const args = process.argv.slice(2);
+    // Subcommands (run and exit, don't start server)
+    if (args[0] === 'install-skill') {
+        import('../server/install-skill.js').then(m => m.installSkill());
     }
-    // Resolve API key: CLI flag → env var → saved config
-    const config = readConfig();
-    // Restore active profile from config
-    const { setActiveProfile } = await import('../server/helpers.js');
-    setActiveProfile(config.activeProfile || 'Default');
-    const avApiKey = cliApiKey || process.env.AV_API_KEY || config.avApiKey || '';
-    const avBackendUrl = cliAvUrl || process.env.AV_BACKEND_URL || config.avBackendUrl;
-    // Persist new values to config so future starts don't need them
-    const updates = {};
-    if (cliApiKey && cliApiKey !== config.avApiKey)
-        updates.avApiKey = cliApiKey;
-    if (cliAvUrl && cliAvUrl !== config.avBackendUrl)
-        updates.avBackendUrl = cliAvUrl;
-    if (Object.keys(updates).length > 0) {
-        saveConfig(updates);
-        console.log('Config saved to ~/.openwriter/config.json');
+    else if (args[0] === 'plugin') {
+        import('../server/plugin-install.js').then(m => m.handlePluginCommand(args.slice(1)));
     }
-    // Set env vars for downstream code (plugins read process.env)
-    if (avApiKey)
-        process.env.AV_API_KEY = avApiKey;
-    if (avBackendUrl)
-        process.env.AV_BACKEND_URL = avBackendUrl;
-    // Port check with health verification — detects orphaned servers
-    async function checkPort() {
-        const taken = await new Promise((resolve) => {
-            const socket = createConnection({ port, host: '127.0.0.1' });
-            socket.once('connect', () => { socket.destroy(); resolve(true); });
-            socket.once('error', () => { resolve(false); });
-        });
-        if (!taken)
-            return 'free';
-        // Port is taken — verify it's a healthy OpenWriter server
-        try {
-            const res = await fetch(`http://127.0.0.1:${port}/api/status`, { signal: AbortSignal.timeout(2000) });
-            return res.ok ? 'healthy' : 'orphaned';
+    else {
+        let port = 5050;
+        let noOpen = false;
+        let cliApiKey;
+        let cliAvUrl;
+        let plugins = [];
+        for (let i = 0; i < args.length; i++) {
+            if (args[i] === '--port' && args[i + 1]) {
+                port = parseInt(args[i + 1], 10);
+                i++;
+            }
+            if (args[i] === '--no-open') {
+                noOpen = true;
+            }
+            if (args[i] === '--api-key' && args[i + 1]) {
+                cliApiKey = args[i + 1];
+                i++;
+            }
+            if (args[i] === '--av-url' && args[i + 1]) {
+                cliAvUrl = args[i + 1];
+                i++;
+            }
+            if (args[i] === '--plugins' && args[i + 1]) {
+                plugins = args[i + 1].split(',').map((s) => s.trim()).filter(Boolean);
+                i++;
+            }
         }
-        catch {
-            return 'orphaned';
+        // Resolve API key: CLI flag → env var → saved config
+        const config = readConfig();
+        // Restore active profile from config
+        const { setActiveProfile } = await import('../server/helpers.js');
+        setActiveProfile(config.activeProfile || 'Default');
+        const avApiKey = cliApiKey || process.env.AV_API_KEY || config.avApiKey || '';
+        const avBackendUrl = cliAvUrl || process.env.AV_BACKEND_URL || config.avBackendUrl;
+        // Persist new values to config so future starts don't need them
+        const updates = {};
+        if (cliApiKey && cliApiKey !== config.avApiKey)
+            updates.avApiKey = cliApiKey;
+        if (cliAvUrl && cliAvUrl !== config.avBackendUrl)
+            updates.avBackendUrl = cliAvUrl;
+        if (Object.keys(updates).length > 0) {
+            saveConfig(updates);
+            console.log('Config saved to ~/.openwriter/config.json');
         }
-    }
-    let portState = await checkPort();
-    // Orphaned server: wait for it to die, then claim primary mode
-    if (portState === 'orphaned') {
-        console.error(`[OpenWriter] Port ${port} held by unresponsive process — waiting for release...`);
-        await new Promise(r => setTimeout(r, 3000));
-        portState = await checkPort();
+        // Set env vars for downstream code (plugins read process.env)
+        if (avApiKey)
+            process.env.AV_API_KEY = avApiKey;
+        if (avBackendUrl)
+            process.env.AV_BACKEND_URL = avBackendUrl;
+        // Port check with health verification — detects orphaned servers
+        async function checkPort() {
+            const taken = await new Promise((resolve) => {
+                const socket = createConnection({ port, host: '127.0.0.1' });
+                socket.once('connect', () => { socket.destroy(); resolve(true); });
+                socket.once('error', () => { resolve(false); });
+            });
+            if (!taken)
+                return 'free';
+            // Port is taken — verify it's a healthy OpenWriter server
+            try {
+                const res = await fetch(`http://127.0.0.1:${port}/api/status`, { signal: AbortSignal.timeout(2000) });
+                return res.ok ? 'healthy' : 'orphaned';
+            }
+            catch {
+                return 'orphaned';
+            }
+        }
+        let portState = await checkPort();
+        // Orphaned server: wait for it to die, then claim primary mode
         if (portState === 'orphaned') {
-            // Still held — wait once more
+            console.error(`[OpenWriter] Port ${port} held by unresponsive process — waiting for release...`);
             await new Promise(r => setTimeout(r, 3000));
             portState = await checkPort();
+            if (portState === 'orphaned') {
+                // Still held — wait once more
+                await new Promise(r => setTimeout(r, 3000));
+                portState = await checkPort();
+            }
+            if (portState !== 'free') {
+                console.error(`[OpenWriter] Port ${port} still unavailable — entering client mode`);
+            }
         }
-        if (portState !== 'free') {
-            console.error(`[OpenWriter] Port ${port} still unavailable — entering client mode`);
+        if (portState === 'healthy') {
+            // Client mode: proxy MCP calls to existing primary server via HTTP
+            console.error(`[OpenWriter] Port ${port} in use by healthy server — entering client mode`);
+            const { startMcpClientServer } = await import('../server/mcp-client.js');
+            startMcpClientServer(port).catch((err) => {
+                console.error('[MCP-Client] Failed to start:', err);
+            });
+        }
+        else {
+            // Primary mode: start MCP stdio FIRST, then lazy-load Express
+            const { load } = await import('../server/state.js');
+            load();
+            const { startMcpServer } = await import('../server/mcp.js');
+            startMcpServer().catch((err) => {
+                console.error('[MCP] Failed to start:', err);
+            });
+            // Deferred: load Express + plugins (heavy deps) after MCP is connecting
+            const { startHttpServer } = await import('../server/index.js');
+            startHttpServer({ port, noOpen, plugins }).catch((err) => {
+                console.error('[HTTP] Failed to start:', err);
+            });
         }
     }
-    if (portState === 'healthy') {
-        // Client mode: proxy MCP calls to existing primary server via HTTP
-        console.error(`[OpenWriter] Port ${port} in use by healthy server — entering client mode`);
-        const { startMcpClientServer } = await import('../server/mcp-client.js');
-        startMcpClientServer(port).catch((err) => {
-            console.error('[MCP-Client] Failed to start:', err);
-        });
-    }
-    else {
-        // Primary mode: start MCP stdio FIRST, then lazy-load Express
-        const { load } = await import('../server/state.js');
-        load();
-        const { startMcpServer } = await import('../server/mcp.js');
-        startMcpServer().catch((err) => {
-            console.error('[MCP] Failed to start:', err);
-        });
-        // Deferred: load Express + plugins (heavy deps) after MCP is connecting
-        const { startHttpServer } = await import('../server/index.js');
-        startHttpServer({ port, noOpen, plugins }).catch((err) => {
-            console.error('[HTTP] Failed to start:', err);
-        });
-    }
-}
+} // end if (!handedOff)