openwriter 0.5.5 → 0.6.1

package/dist/server/helpers.js

@@ -2,51 +2,78 @@
  * Shared constants and utility functions for OpenWriter server.
  * Both state.ts and documents.ts import from here to avoid duplication.
  */
-import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from 'fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, readdirSync, statSync, rmSync } from 'fs';
 import { join, isAbsolute, basename, dirname, resolve, sep } from 'path';
 import { homedir } from 'os';
 import { randomUUID } from 'crypto';
-export const DATA_DIR = join(homedir(), '.openwriter');
-export const VERSIONS_DIR = join(DATA_DIR, '.versions');
-export const WORKSPACES_DIR = join(DATA_DIR, '_workspaces');
-export const CONFIG_FILE = join(DATA_DIR, 'config.json');
+export const ROOT_DIR = join(homedir(), '.openwriter');
 export const TEMP_PREFIX = '_untitled-';
+// ---- Profile state ----
+let activeProfile = 'Default';
+export function getActiveProfile() {
+    return activeProfile;
+}
+export function setActiveProfile(name) {
+    activeProfile = name;
+}
+// ---- Profile-aware path getters ----
+export function getDataDir() {
+    return join(ROOT_DIR, 'profiles', activeProfile);
+}
+export function getVersionsDir() {
+    return join(getDataDir(), '.versions');
+}
+export function getWorkspacesDir() {
+    return join(getDataDir(), '_workspaces');
+}
+export function getConfigFile() {
+    return join(ROOT_DIR, 'config.json');
+}
+// ---- Directory bootstrapping ----
 export function ensureDataDir() {
-    if (!existsSync(DATA_DIR)) {
-        // One-time migration: rename ~/.superwriter/ → ~/.openwriter/
+    // Ensure ROOT_DIR exists (with legacy migration)
+    if (!existsSync(ROOT_DIR)) {
         const legacyDir = join(homedir(), '.superwriter');
         if (existsSync(legacyDir)) {
-            renameSync(legacyDir, DATA_DIR);
+            renameSync(legacyDir, ROOT_DIR);
         }
         else {
-            mkdirSync(DATA_DIR, { recursive: true });
+            mkdirSync(ROOT_DIR, { recursive: true });
         }
     }
+    // Migrate flat files into profiles/Default/ if needed
+    migrateToProfiles();
+    // Ensure active profile directory exists
+    const dataDir = getDataDir();
+    if (!existsSync(dataDir))
+        mkdirSync(dataDir, { recursive: true });
 }
 export function ensureWorkspacesDir() {
     ensureDataDir();
-    if (!existsSync(WORKSPACES_DIR))
-        mkdirSync(WORKSPACES_DIR, { recursive: true });
+    const wsDir = getWorkspacesDir();
+    if (!existsSync(wsDir))
+        mkdirSync(wsDir, { recursive: true });
 }
 export function sanitizeFilename(name) {
     return name.replace(/[<>:"/\\|?*]/g, '-').trim() || 'Untitled';
 }
 export function filePathForTitle(title) {
-    return join(DATA_DIR, `${sanitizeFilename(title)}.md`);
+    return join(getDataDir(), `${sanitizeFilename(title)}.md`);
 }
 export function tempFilePath() {
-    return join(DATA_DIR, `${TEMP_PREFIX}${randomUUID()}.md`);
+    return join(getDataDir(), `${TEMP_PREFIX}${randomUUID()}.md`);
 }
 // ---- Path resolution for external documents ----
 /** Resolve a filename to a full path. Basenames resolve to DATA_DIR; absolute paths pass through. */
 export function resolveDocPath(filename) {
+    const dataDir = getDataDir();
     // External docs use absolute paths as identifiers — pass through
     if (isAbsolute(filename))
         return filename;
     // Internal docs must resolve within DATA_DIR — block path traversal
-    const resolved = resolve(DATA_DIR, filename);
-    const dataDir = resolve(DATA_DIR);
-    if (resolved !== dataDir && !resolved.startsWith(dataDir + sep)) {
+    const resolved = resolve(dataDir, filename);
+    const dataDirResolved = resolve(dataDir);
+    if (resolved !== dataDirResolved && !resolved.startsWith(dataDirResolved + sep)) {
         throw new Error(`Path traversal blocked: ${filename}`);
     }
     return resolved;
@@ -55,7 +82,7 @@ export function resolveDocPath(filename) {
 export function isExternalDoc(filename) {
     if (isAbsolute(filename) || /[/\\]/.test(filename)) {
         const resolved = isAbsolute(filename) ? filename : filename;
-        return !resolved.startsWith(DATA_DIR);
+        return !resolved.startsWith(getDataDir());
     }
     return false;
 }
@@ -83,10 +110,11 @@ export function generateNodeId() {
 export const LEAF_BLOCK_TYPES = new Set(['paragraph', 'heading', 'codeBlock', 'horizontalRule', 'table', 'image']);
 export function readConfig() {
     ensureDataDir();
-    if (!existsSync(CONFIG_FILE))
+    const configFile = getConfigFile();
+    if (!existsSync(configFile))
         return {};
     try {
-        return JSON.parse(readFileSync(CONFIG_FILE, 'utf-8'));
+        return JSON.parse(readFileSync(configFile, 'utf-8'));
     }
     catch {
         return {};
@@ -96,5 +124,132 @@ export function saveConfig(updates) {
     ensureDataDir();
     const current = readConfig();
     const merged = { ...current, ...updates };
-    atomicWriteFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2));
+    atomicWriteFileSync(getConfigFile(), JSON.stringify(merged, null, 2));
+}
+// ---- Profile CRUD ----
+export function listProfiles() {
+    const config = readConfig();
+    return config.profiles || ['Default'];
+}
+export function createProfile(name) {
+    if (!name.trim())
+        throw new Error('Profile name cannot be empty');
+    const config = readConfig();
+    const profiles = config.profiles || ['Default'];
+    if (profiles.includes(name))
+        throw new Error(`Profile "${name}" already exists`);
+    // Create profile directory
+    const profileDir = join(ROOT_DIR, 'profiles', name);
+    mkdirSync(profileDir, { recursive: true });
+    // Update config
+    profiles.push(name);
+    saveConfig({ profiles });
+}
+export function deleteProfile(name) {
+    if (name === 'Default')
+        throw new Error('Cannot delete the Default profile');
+    if (name === activeProfile)
+        throw new Error('Cannot delete the active profile');
+    const config = readConfig();
+    const profiles = config.profiles || ['Default'];
+    const idx = profiles.indexOf(name);
+    if (idx === -1)
+        throw new Error(`Profile "${name}" not found`);
+    // Move directory to .trash-{name}/ (soft delete)
+    const profileDir = join(ROOT_DIR, 'profiles', name);
+    const trashDir = join(ROOT_DIR, 'profiles', `.trash-${name}`);
+    if (existsSync(profileDir)) {
+        // If a trash dir already exists for this name, remove the old trash first
+        if (existsSync(trashDir)) {
+            rmSync(trashDir, { recursive: true, force: true });
+        }
+        renameSync(profileDir, trashDir);
+    }
+    profiles.splice(idx, 1);
+    saveConfig({ profiles });
+}
+export function listTrashedProfiles() {
+    const profilesDir = join(ROOT_DIR, 'profiles');
+    if (!existsSync(profilesDir))
+        return [];
+    try {
+        return readdirSync(profilesDir)
+            .filter(name => name.startsWith('.trash-') && statSync(join(profilesDir, name)).isDirectory())
+            .map(name => name.slice('.trash-'.length));
+    }
+    catch {
+        return [];
+    }
+}
+export function restoreProfile(name) {
+    const trashDir = join(ROOT_DIR, 'profiles', `.trash-${name}`);
+    if (!existsSync(trashDir))
+        throw new Error(`No trashed profile "${name}" found`);
+    const profileDir = join(ROOT_DIR, 'profiles', name);
+    if (existsSync(profileDir))
+        throw new Error(`A profile named "${name}" already exists`);
+    renameSync(trashDir, profileDir);
+    // Add back to config
+    const config = readConfig();
+    const profiles = config.profiles || ['Default'];
+    if (!profiles.includes(name)) {
+        profiles.push(name);
+        saveConfig({ profiles });
+    }
+}
+// ---- Migration: flat files → profiles/Default/ ----
+function migrateToProfiles() {
+    const profilesDir = join(ROOT_DIR, 'profiles');
+    if (existsSync(profilesDir))
+        return; // Already migrated
+    // Create profiles/Default/
+    const defaultDir = join(profilesDir, 'Default');
+    mkdirSync(defaultDir, { recursive: true });
+    // Items to move from ROOT_DIR → profiles/Default/
+    const dirsToMove = ['_workspaces', '_images', '.versions', '_marks'];
+    const filesToMove = ['_doc-order.json', 'external-docs.json'];
+    for (const dir of dirsToMove) {
+        const src = join(ROOT_DIR, dir);
+        if (existsSync(src)) {
+            renameSync(src, join(defaultDir, dir));
+        }
+    }
+    for (const file of filesToMove) {
+        const src = join(ROOT_DIR, file);
+        if (existsSync(src)) {
+            renameSync(src, join(defaultDir, file));
+        }
+    }
+    // Move .git and .gitignore
+    for (const name of ['.git', '.gitignore']) {
+        const src = join(ROOT_DIR, name);
+        if (existsSync(src)) {
+            renameSync(src, join(defaultDir, name));
+        }
+    }
+    // Move all .md files
+    try {
+        const entries = readdirSync(ROOT_DIR);
+        for (const entry of entries) {
+            if (entry.endsWith('.md')) {
+                const src = join(ROOT_DIR, entry);
+                if (statSync(src).isFile()) {
+                    renameSync(src, join(defaultDir, entry));
+                }
+            }
+        }
+    }
+    catch { /* best effort */ }
+    // Update config
+    const configFile = getConfigFile();
+    let config = {};
+    if (existsSync(configFile)) {
+        try {
+            config = JSON.parse(readFileSync(configFile, 'utf-8'));
+        }
+        catch { /* */ }
+    }
+    config.activeProfile = 'Default';
+    config.profiles = ['Default'];
+    atomicWriteFileSync(configFile, JSON.stringify(config, null, 2));
 }

package/dist/server/image-upload.js

@@ -7,18 +7,19 @@ import multer from 'multer';
 import { existsSync, mkdirSync } from 'fs';
 import { join, extname } from 'path';
 import { randomUUID } from 'crypto';
-import { DATA_DIR, ensureDataDir } from './helpers.js';
+import { getDataDir, ensureDataDir } from './helpers.js';
 import express from 'express';
-const IMAGES_DIR = join(DATA_DIR, '_images');
+function getImagesDir() { return join(getDataDir(), '_images'); }
 function ensureImagesDir() {
     ensureDataDir();
-    if (!existsSync(IMAGES_DIR))
-        mkdirSync(IMAGES_DIR, { recursive: true });
+    const dir = getImagesDir();
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
 }
 const storage = multer.diskStorage({
     destination: (_req, _file, cb) => {
         ensureImagesDir();
-        cb(null, IMAGES_DIR);
+        cb(null, getImagesDir());
     },
     filename: (_req, file, cb) => {
         const ext = extname(file.originalname) || '.png';
@@ -39,9 +40,11 @@ const upload = multer({
 });
 export function createImageRouter() {
     const router = Router();
-    // Static serving for images
+    // Dynamic static serving — resolves active profile's images dir per request
     ensureImagesDir();
-    router.use('/_images', express.static(IMAGES_DIR));
+    router.use('/_images', (req, res, next) => {
+        express.static(getImagesDir())(req, res, next);
+    });
     // Upload endpoint
     router.post('/api/upload-image', upload.single('image'), (req, res) => {
         if (!req.file) {

package/dist/server/index.js

@@ -11,19 +11,23 @@ import { setupWebSocket, broadcastAgentStatus, broadcastDocumentSwitched, broadc
 import { TOOL_REGISTRY } from './mcp.js';
 import { z } from 'zod';
 import { zodToJsonSchema } from 'zod-to-json-schema';
-import { save, getDocument, getTitle, getFilePath, getDocId, getMetadata, getStatus, updateDocument, setMetadata, applyTextEdits, isAgentLocked, getPendingDocInfo, getDocTagsByFilename, addDocTag, removeDocTag, markAllNodesAsPending, updatePendingCacheForActiveDoc } from './state.js';
-import { listDocuments, switchDocument, createDocument, deleteDocument, duplicateDocument, reloadDocument, updateDocumentTitle, openFile, reorderDocs, searchDocuments, listArchivedDocuments, archiveDocument, unarchiveDocument } from './documents.js';
+import { save, cancelDebouncedSave, load, getDocument, getTitle, getFilePath, getDocId, getMetadata, getStatus, updateDocument, setMetadata, applyTextEdits, isAgentLocked, getPendingDocInfo, getDocTagsByFilename, addDocTag, removeDocTag, markAllNodesAsPending, updatePendingCacheForActiveDoc, clearAllCaches } from './state.js';
+import { listDocuments, switchDocument, createDocument, deleteDocument, duplicateDocument, reloadDocument, updateDocumentTitle, openFile, reorderDocs, searchDocuments, listArchivedDocuments, archiveDocument, unarchiveDocument, getActiveFilename } from './documents.js';
 import { createWorkspaceRouter } from './workspace-routes.js';
 import { createLinkRouter } from './link-routes.js';
 import { createTweetRouter } from './tweet-routes.js';
 import { markdownToTiptap } from './markdown.js';
 import { importGoogleDoc } from './gdoc-import.js';
 import { createVersionRouter } from './version-routes.js';
+import { clearVersionsCache } from './versions.js';
 import { createSyncRouter } from './sync-routes.js';
 import { removeDocFromAllWorkspaces } from './workspaces.js';
-import { resolveDocPath } from './helpers.js';
+import { resolveDocPath, getActiveProfile, setActiveProfile, listProfiles, createProfile, deleteProfile, listTrashedProfiles, restoreProfile, saveConfig, readConfig } from './helpers.js';
 import { createImageRouter } from './image-upload.js';
 import { createExportRouter } from './export-routes.js';
+import { createConnectionRouter } from './connection-routes.js';
+import { createSchedulerRouter } from './scheduler-routes.js';
+import { platformFetch, isAuthenticated } from './connections.js';
 import { PluginManager } from './plugin-manager.js';
 import { checkForUpdate } from './update-check.js';
 import { addMark, getMarks, resolveMarks } from './marks.js';
@@ -81,6 +85,40 @@ export async function startHttpServer(options = {}) {
     app.use(createSyncRouter(broadcastSyncStatus));
     // Mount export routes
     app.use(createExportRouter());
+    // Mount connection CRUD + profile binding routes
+    app.use(createConnectionRouter());
+    // Mount scheduler proxy routes
+    app.use(createSchedulerRouter());
+    // Newsletter analytics proxy routes
+    app.get('/api/publications', async (req, res) => {
+        try {
+            if (!isAuthenticated()) {
+                res.status(401).json({ error: 'Not authenticated' });
+                return;
+            }
+            const qs = req.query.documentId ? `?documentId=${encodeURIComponent(req.query.documentId)}` : '';
+            const resp = await platformFetch(`/publications${qs}`);
+            const data = await resp.json();
+            res.status(resp.status).json(data);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.get('/api/publications/:id/stats', async (req, res) => {
+        try {
+            if (!isAuthenticated()) {
+                res.status(401).json({ error: 'Not authenticated' });
+                return;
+            }
+            const resp = await platformFetch(`/publications/${req.params.id}/stats`);
+            const data = await resp.json();
+            res.status(resp.status).json(data);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
     // Mount version history routes
     app.use(createVersionRouter({
         getDocId,
@@ -136,6 +174,26 @@ export async function startHttpServer(options = {}) {
     app.get('/api/documents', (_req, res) => {
         res.json(listDocuments());
     });
+    app.get('/api/documents/:filename/text', (req, res) => {
+        try {
+            const filepath = resolveDocPath(req.params.filename);
+            const raw = readFileSync(filepath, 'utf-8');
+            // Parse YAML frontmatter
+            const fmMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+            const text = fmMatch ? fmMatch[2].trim() : raw.trim();
+            let meta = {};
+            if (fmMatch) {
+                try {
+                    meta = JSON.parse(fmMatch[1]);
+                }
+                catch { }
+            }
+            res.json({ text, meta });
+        }
+        catch (err) {
+            res.status(404).json({ error: 'Document not found' });
+        }
+    });
     app.put('/api/documents/reorder', (req, res) => {
         try {
             const { order } = req.body;
@@ -209,10 +267,32 @@ export async function startHttpServer(options = {}) {
             res.status(400).json({ error: err.message });
         }
     });
+    // Sync browser editor content to server state — guarantees server has latest before MCP calls.
+    // Used by compose modals that need to read server state via MCP tools.
+    app.post('/api/documents/sync-content', (req, res) => {
+        try {
+            const { document: doc, filename } = req.body;
+            if (!doc || !filename) {
+                res.status(400).json({ error: 'document and filename required' });
+                return;
+            }
+            if (filename === getActiveFilename()) {
+                updateDocument(doc);
+                save();
+            }
+            res.json({ ok: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
     app.post('/api/documents/switch', (req, res) => {
         try {
+            const alreadyActive = req.body.filename === getActiveFilename();
             const result = switchDocument(req.body.filename);
-            broadcastDocumentSwitched(result.document, result.title, result.filename);
+            if (!alreadyActive) {
+                broadcastDocumentSwitched(result.document, result.title, result.filename);
+            }
             res.json(result);
         }
         catch (err) {
@@ -400,6 +480,83 @@ export async function startHttpServer(options = {}) {
             res.status(500).json({ error: err.message });
         }
     });
+    // ---- Profile management ----
+    app.get('/api/profiles', (_req, res) => {
+        res.json({ profiles: listProfiles(), active: getActiveProfile() });
+    });
+    app.post('/api/profiles', (req, res) => {
+        try {
+            const { name } = req.body;
+            if (!name?.trim()) {
+                res.status(400).json({ error: 'name is required' });
+                return;
+            }
+            createProfile(name.trim());
+            res.json({ success: true });
+        }
+        catch (err) {
+            res.status(400).json({ error: err.message });
+        }
+    });
+    app.post('/api/profiles/switch', async (req, res) => {
+        try {
+            const { name } = req.body;
+            if (!name?.trim()) {
+                res.status(400).json({ error: 'name is required' });
+                return;
+            }
+            const profiles = listProfiles();
+            if (!profiles.includes(name)) {
+                res.status(404).json({ error: `Profile "${name}" not found` });
+                return;
+            }
+            // Flush current doc
+            cancelDebouncedSave();
+            save();
+            // Switch profile
+            setActiveProfile(name);
+            saveConfig({ activeProfile: name });
+            // Clear caches and reload
+            clearAllCaches();
+            clearVersionsCache();
+            load();
+            // Broadcast fresh state
+            broadcastDocumentSwitched(getDocument(), getTitle(), getFilePath().split(/[/\\]/).pop() || '', getMetadata());
+            broadcastDocumentsChanged();
+            broadcastWorkspacesChanged();
+            broadcastPendingDocsChanged();
+            res.json({ success: true, active: name });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    app.delete('/api/profiles/:name', (req, res) => {
+        try {
+            deleteProfile(req.params.name);
+            res.json({ success: true });
+        }
+        catch (err) {
+            res.status(400).json({ error: err.message });
+        }
+    });
+    app.get('/api/profiles/trash', (_req, res) => {
+        res.json({ profiles: listTrashedProfiles() });
+    });
+    app.post('/api/profiles/restore', (req, res) => {
+        try {
+            const { name } = req.body;
+            if (!name?.trim()) {
+                res.status(400).json({ error: 'name is required' });
+                return;
+            }
+            restoreProfile(name.trim());
+            res.json({ success: true });
+        }
+        catch (err) {
+            res.status(400).json({ error: err.message });
+        }
+    });
     // Google Doc import
     app.post('/api/import/gdoc', (req, res) => {
         try {
@@ -422,7 +579,7 @@ export async function startHttpServer(options = {}) {
             console.error(`[Plugin] ${result.error}`);
     }
     // Auto-enable from saved config.json
-    const savedConfig = (await import('./helpers.js')).readConfig();
+    const savedConfig = readConfig();
     for (const [name, state] of Object.entries(savedConfig.plugins || {})) {
         if (state.enabled && !((options.plugins || []).includes(name))) {
             const result = await pluginManager.enable(name);

package/dist/server/install-skill.js

@@ -1,19 +1,136 @@
 import fs from 'fs';
 import path from 'path';
 import os from 'os';
+import { execSync } from 'child_process';
 import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
+function log(msg) {
+    console.error(msg);
+}
+function isGloballyInstalled() {
+    try {
+        const result = execSync('openwriter --version', {
+            stdio: ['pipe', 'pipe', 'pipe'],
+            timeout: 10000,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function installGlobally() {
+    log('\n② Installing openwriter globally...');
+    // Try without sudo first (works on Windows, nvm, Homebrew, volta, etc.)
+    try {
+        execSync('npm install -g openwriter', { stdio: 'inherit', timeout: 120000 });
+        log('  ✓ Installed globally');
+        return true;
+    }
+    catch {
+        // Likely permission error on macOS/Linux system Node
+    }
+    // Try with sudo on non-Windows
+    if (process.platform !== 'win32') {
+        log('  Retrying with sudo...');
+        try {
+            execSync('sudo npm install -g openwriter', { stdio: 'inherit', timeout: 120000 });
+            log('  ✓ Installed globally (sudo)');
+            return true;
+        }
+        catch {
+            // sudo failed too
+        }
+    }
+    log('  ✗ Could not install globally. Run manually:');
+    log('    npm install -g openwriter');
+    return false;
+}
+function isMcpConfigured() {
+    const claudeJson = path.join(os.homedir(), '.claude.json');
+    if (!fs.existsSync(claudeJson))
+        return false;
+    try {
+        const content = JSON.parse(fs.readFileSync(claudeJson, 'utf-8'));
+        return !!content?.mcpServers?.openwriter;
+    }
+    catch {
+        return false;
+    }
+}
+function configureMcp() {
+    log('\n③ Configuring MCP server for Claude Code...');
+    // Try using claude CLI
+    try {
+        execSync('claude mcp add -s user openwriter -- openwriter --no-open', {
+            stdio: 'inherit',
+            timeout: 15000,
+        });
+        log('  ✓ MCP server configured');
+        return true;
+    }
+    catch {
+        // claude CLI not available or failed
+    }
+    // Fallback: edit ~/.claude.json directly
+    log('  claude CLI not found — writing config directly...');
+    const claudeJson = path.join(os.homedir(), '.claude.json');
+    try {
+        let config = {};
+        if (fs.existsSync(claudeJson)) {
+            config = JSON.parse(fs.readFileSync(claudeJson, 'utf-8'));
+        }
+        if (!config.mcpServers)
+            config.mcpServers = {};
+        // Add openwriter as first entry (Claude Code loads sequentially)
+        const existing = config.mcpServers;
+        config.mcpServers = {
+            openwriter: { command: 'openwriter', args: ['--no-open'] },
+            ...existing,
+        };
+        fs.writeFileSync(claudeJson, JSON.stringify(config, null, 2), 'utf-8');
+        log(`  ✓ MCP server added to ${claudeJson}`);
+        return true;
+    }
+    catch (err) {
+        log(`  ✗ Could not configure MCP server. Add manually:`);
+        log('    claude mcp add -s user openwriter -- openwriter --no-open');
+        return false;
+    }
+}
 export function installSkill() {
+    // Step 1: Copy SKILL.md
+    log('① Installing OpenWriter skill...');
     const source = path.join(__dirname, '../../skill/SKILL.md');
     const targetDir = path.join(os.homedir(), '.claude', 'skills', 'openwriter');
     const target = path.join(targetDir, 'SKILL.md');
     if (!fs.existsSync(source)) {
-        console.error(`Error: SKILL.md not found at ${source}`);
+        log(`  Error: SKILL.md not found at ${source}`);
         process.exit(1);
     }
     fs.mkdirSync(targetDir, { recursive: true });
     fs.copyFileSync(source, target);
-    console.error(`Installed OpenWriter skill to ${target}`);
+    log(`  ✓ Skill installed to ${target}`);
+    // Step 2: Global install (skip if already installed)
+    const alreadyInstalled = isGloballyInstalled();
+    if (alreadyInstalled) {
+        log('\n② openwriter already installed globally — skipping');
+    }
+    else {
+        if (!installGlobally()) {
+            process.exit(1);
+        }
+    }
+    // Step 3: Configure MCP server (skip if already configured)
+    if (isMcpConfigured()) {
+        log('\n③ MCP server already configured — skipping');
+    }
+    else {
+        configureMcp();
+    }
+    // Done
+    log('\n✓ OpenWriter is ready!');
+    log('  Restart Claude Code, then type /openwriter to start writing.\n');
     process.exit(0);
 }