omnikey-cli 1.0.11 → 1.0.12

package/README.md

@@ -2,9 +2,9 @@
 
 A command-line tool for onboarding users to the Omnikey open-source app and configuring their OPENAI_API_KEY.
 
-## About OmnikeyAI (macOS)
+## About OmnikeyAI
 
-OmnikeyAI is a productivity tool for macOS that helps you quickly rewrite selected text using OpenAI. The CLI allows you to configure and run the backend daemon on your local macOS and manage your OpenAI API key with ease. Once set up, you can select any text on your Mac in any app and trigger rewrite commands directly from your desktop.
+OmnikeyAI is a productivity tool that helps you quickly rewrite selected text using OpenAI. The CLI allows you to configure and run the backend daemon on your local machine and manage your OpenAI API key with ease.
 
 - For more details about the app and its features, see the [main README](https://github.com/GurinderRawala/OmniKey-AI).
 - Download the latest macOS app here: [Download OmniKeyAI for macOS](https://omnikeyai-saas-fmytqc3dra-uc.a.run.app/macos/download)
@@ -13,7 +13,7 @@ OmnikeyAI is a productivity tool for macOS that helps you quickly rewrite select
 
 - `omnikey onboard`: Interactive onboarding to set up your OPENAI_API_KEY.
 - Accepts the `--open-ai-key` parameter for non-interactive setup.
-- Configure and run the backend daemon for the macOS app.
+- Configure and run the backend daemon — persisted across reboots on both macOS and Windows.
 
 ## Usage
 
@@ -21,28 +21,42 @@ OmnikeyAI is a productivity tool for macOS that helps you quickly rewrite select
 # Install CLI globally (from this directory)
 npm install -g omnikey-cli
 
-# Onboard interactively (will prompt for OpenAI key and self-hosting)
+# Onboard interactively (will prompt for OpenAI key)
 omnikey onboard
 
 # Or onboard non-interactively
 omnikey onboard --open-ai-key YOUR_KEY
 
-# Running the daemon will set up a launchd agent and keep the backend server running across system restarts
+# Start the daemon (auto-restarts on reboot)
 omnikey daemon --port 7071
 
 # Kill the daemon
-omnikey kill-daemon --port 7071
+omnikey kill-daemon
 
-# Remove the config directory and SQLite database (and launchd agent)
+# Remove the config directory and SQLite database (and persistence agent)
 omnikey remove-config
 
-# check daemon status if it is running
+# Check daemon status
 omnikey status
 
-# check daemon logs 
+# Check daemon logs
 omnikey logs --lines 100
 ```
 
+## Platform notes
+
+### macOS
+
+The daemon is registered as a **launchd agent** (`~/Library/LaunchAgents/com.omnikey.daemon.plist`) so it auto-restarts after login and on crashes.
+
+### Windows
+
+The daemon is registered as a **Windows Task Scheduler** task (`OmnikeyDaemon`) that runs at every logon. A wrapper script (`~/.omnikey/start-daemon.cmd`) is generated to set the required environment variables before launching the Node.js backend.
+
+> **Note:** `schtasks` is a built-in Windows command — no third-party tools or administrator rights are required for user-level scheduled tasks.
+
+Commands that query process state use `netstat` (instead of `lsof`) on Windows, and process termination uses `taskkill` (instead of `SIGTERM`).
+
 ## Development
 
 - Built with Node.js and TypeScript.

package/backend-dist/agentPrompts.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AGENT_SYSTEM_PROMPT = void 0;
-exports.AGENT_SYSTEM_PROMPT = `
+exports.AGENT_SYSTEM_PROMPT_WINDOWS = exports.AGENT_SYSTEM_PROMPT_MACOS = void 0;
+exports.AGENT_SYSTEM_PROMPT_MACOS = `
 You are an AI agent that can both reason about the user's situation and design shell scripts that the user will run on their own machine.
 
 This agent is invoked when the user includes @omniAgent and there may also be stored custom task instructions for the current task.
@@ -62,3 +62,63 @@ The user will run the script and share the output with you.
 - Do not emit any text before or after the <final_answer> block; the entire response must be inside the <final_answer> tags.
 </final_answer_block>
 `;
+exports.AGENT_SYSTEM_PROMPT_WINDOWS = `
+You are an AI agent that can both reason about the user's situation and design shell scripts that the user will run on their own machine.
+
+This agent is invoked when the user includes @omniAgent and there may also be stored custom task instructions for the current task.
+Your job is to:
+- Read and respect the stored task instructions (how to behave, what to focus on, output style) when they are provided.
+- Carefully consider the current user input (what they typed when running @omniAgent).
+- Decide whether additional machine-level information is needed, and if so, generate an appropriate shell script to gather it.
+- Use the results of any previously run scripts plus the instructions and input to produce a complete, helpful final answer.
+
+General guidelines:
+- Only create commands that are safe and read-only, focusing on inspection, diagnostics, and information gathering.
+- Do not generate any commands that install software, modify user data, or change system settings.
+- Never ask the user to run commands with elevated privileges (Run as Administrator).
+- Ensure that all commands provided are compatible with Windows PowerShell; avoid any macOS or Linux-specific commands.
+- Scripts must be self-contained and ready to run as-is, without the user needing to edit them.
+
+The user will run the script and share the output with you.
+
+<instruction_handling>
+- Treat stored task instructions (if present) as authoritative for how to prioritize, what to examine, and how to format your answer, as long as they do not conflict with system rules or safety guidelines.
+- Treat the current user input as the immediate goal or question you must solve, applying the stored instructions to that specific situation.
+- If there is a conflict, follow: system rules first, then stored instructions, then ad-hoc guidance in the current input.
+</instruction_handling>
+
+<interaction_rules>
+- When you need to execute ANY shell command, respond with a single <shell_script> block that contains the FULL script to run.
+- Within that script, include all steps needed to carry out the current diagnostic or information-gathering task as completely as possible (for example, collect all relevant logs, inspect all relevant services, perform all necessary checks), rather than issuing minimal or placeholder commands.
+- Prefer one comprehensive script over multiple small scripts; only wait for another round of output if you genuinely need the previous results to decide on the next actions.
+- If further machine-level investigation is unnecessary, skip the shell script and respond directly with a <final_answer>.
+- Every response MUST be exactly one of:
+  - A single <shell_script>...</shell_script> block, and nothing else; or
+  - A single <final_answer>...</final_answer> block, and nothing else.
+- Never send plain text or explanation outside of these tags. If you are not emitting a <shell_script>, you MUST emit a <final_answer>.
+- When you are completely finished and ready to present the result back to the user, respond with a single <final_answer> block.
+- Do NOT include reasoning, commentary, or any other tags outside of <shell_script>...</shell_script> or <final_answer>...</final_answer>.
+- Never wrap your entire response in other XML or JSON structures.
+</interaction_rules>
+
+<shell_script_block>
+- Always emit exactly this structure when you want to run commands:
+
+  <shell_script>
+  # your commands here
+  </shell_script>
+
+- Use a single, self-contained PowerShell script per turn; do not send multiple <shell_script> blocks in one response.
+- Inside the script, group related commands logically and add brief inline comments ONLY when they clarify non-obvious steps.
+- Prefer safe, idempotent commands. Never use elevated privileges.
+- Use PowerShell cmdlets and syntax (e.g. Get-ChildItem, Select-Object, Where-Object) rather than cmd.exe or bash equivalents.
+</shell_script_block>
+
+<final_answer_block>
+- When you have gathered enough information and completed the requested work, respond once with:
+  <final_answer>
+  ...user-facing result here (clear summary, key findings, concrete recommendations or next steps, formatted according to any stored instructions)...
+  </final_answer>
+- Do not emit any text before or after the <final_answer> block; the entire response must be inside the <final_answer> tags.
+</final_answer_block>
+`;

package/backend-dist/agentServer.js

@@ -53,7 +53,7 @@ const openai = new openai_1.default({
 });
 const sessionMessages = new Map();
 const MAX_TURNS = 10;
-async function getOrCreateSession(sessionId, subscription, log) {
+async function getOrCreateSession(sessionId, subscription, platform, log) {
     const existing = sessionMessages.get(sessionId);
     if (existing) {
         log.debug('Reusing existing agent session', {
@@ -63,6 +63,7 @@ async function getOrCreateSession(sessionId, subscription, log) {
         });
         return existing;
     }
+    const systemPrompt = platform === 'windows' ? agentPrompts_1.AGENT_SYSTEM_PROMPT_WINDOWS : agentPrompts_1.AGENT_SYSTEM_PROMPT_MACOS;
     // use these instructions as user instructions
     const prompt = await (0, featureRoutes_1.getPromptForCommand)(log, 'task', subscription).catch((err) => {
         log.error('Failed to get system prompt for new agent session', { error: err });
@@ -73,7 +74,7 @@ async function getOrCreateSession(sessionId, subscription, log) {
         history: [
             {
                 role: 'system',
-                content: agentPrompts_1.AGENT_SYSTEM_PROMPT,
+                content: systemPrompt,
             },
             ...(prompt
                 ? [
@@ -163,7 +164,7 @@ async function authenticateFromAuthHeader(authHeader, log) {
     }
 }
 async function runAgentTurn(sessionId, subscription, clientMessage, send, log) {
-    const session = await getOrCreateSession(sessionId, subscription, log);
+    const session = await getOrCreateSession(sessionId, subscription, clientMessage.platform, log);
     // Count this call as one agent iteration.
     session.turns += 1;
     log.info('Starting agent turn', {

package/backend-dist/index.js

@@ -51,8 +51,8 @@ app.get('/macos/appcast', (req, res) => {
     const appcastUrl = `${baseUrl}/macos/appcast`;
     // These should match the values embedded into the macOS app
     // Info.plist in macOS/build_release_dmg.sh.
-    const bundleVersion = '12';
-    const shortVersion = '1.0.11';
+    const bundleVersion = '13';
+    const shortVersion = '1.0.12';
     const xml = `<?xml version="1.0" encoding="utf-8"?>
 <rss version="2.0"
      xmlns:sparkle="http://www.andymatuschak.org/xml-namespaces/sparkle"
@@ -77,6 +77,42 @@ app.get('/macos/appcast', (req, res) => {
     res.set('Content-Type', 'application/xml; charset=utf-8');
     res.send(xml);
 });
+// ── Windows distribution endpoints ───────────────────────────────────────────
+// These should match the values in windows/OmniKey.Windows.csproj
+// <Version> and windows/build_release_zip.ps1 $APP_VERSION.
+const WIN_VERSION = '1.0';
+const WIN_ZIP_FILENAME = 'OmniKeyAI-windows-x64.zip';
+const WIN_ZIP_PATH = path_1.default.join(process.cwd(), 'windows', WIN_ZIP_FILENAME);
+// Serves the pre-built ZIP produced by windows/build_release_zip.ps1.
+app.get('/windows/download', (_req, res) => {
+    res.download(WIN_ZIP_PATH, WIN_ZIP_FILENAME, (err) => {
+        if (err) {
+            logger_1.logger.error('Failed to send Windows ZIP for download.', { error: err });
+            if (!res.headersSent) {
+                res.status(500).send('Unable to download file.');
+            }
+        }
+    });
+});
+// JSON update-check endpoint consumed by UpdateChecker.cs on the Windows client.
+// Returns the latest version + download URL so the client can decide whether
+// to prompt the user for an update.
+app.get('/windows/update', (req, res) => {
+    const baseUrl = `${req.protocol}://${req.get('host')}`;
+    let fileSize = 0;
+    try {
+        fileSize = fs_1.default.statSync(WIN_ZIP_PATH).size;
+    }
+    catch (error) {
+        logger_1.logger.error('Failed to stat Windows ZIP for update endpoint.', { error });
+    }
+    res.json({
+        version: WIN_VERSION,
+        downloadUrl: `${baseUrl}/windows/download`,
+        fileSize,
+        releaseNotes: '',
+    });
+});
 app.get('/health', (_req, res) => {
     res.json({ status: 'ok' });
 });

package/dist/daemon.js

@@ -7,33 +7,20 @@ exports.startDaemon = startDaemon;
 const child_process_1 = require("child_process");
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
-const os_1 = __importDefault(require("os"));
 const child_process_2 = require("child_process");
+const utils_1 = require("./utils");
 /**
  * Start the Omnikey API backend as a daemon on the specified port.
- * Also creates and registers a launchd agent for persistence on macOS.
+ * On macOS: creates and registers a launchd agent for persistence.
+ * On Windows: creates a wrapper script and registers a Windows Task Scheduler task.
  * @param port The port to run the backend on
  */
 function startDaemon(port = 7071) {
-    // Only use ~/.omnikey/config.json for environment variables
-    // Path to the backend entry point (now from backend-dist)
     const backendPath = path_1.default.resolve(__dirname, '../backend-dist/index.js');
-    // Read and update environment variables from ~/.omnikey/config.json
-    const homeDir = process.env.HOME || process.env.USERPROFILE || os_1.default.homedir();
-    const configDir = path_1.default.join(homeDir, '.omnikey');
-    const configPath = path_1.default.join(configDir, 'config.json');
-    let configVars = {};
-    if (fs_1.default.existsSync(configPath)) {
-        try {
-            configVars = JSON.parse(fs_1.default.readFileSync(configPath, 'utf-8'));
-        }
-        catch (e) {
-            console.error('Failed to parse config.json:', e);
-        }
-    }
-    // Ensure both OMNIKEY_PORT and PORT are set for compatibility
+    const configDir = (0, utils_1.getConfigDir)();
+    const configPath = (0, utils_1.getConfigPath)();
+    const configVars = (0, utils_1.readConfig)();
     configVars.OMNIKEY_PORT = port;
-    // Write the updated configVars back to config.json
     try {
         fs_1.default.mkdirSync(configDir, { recursive: true });
         fs_1.default.writeFileSync(configPath, JSON.stringify(configVars, null, 2), 'utf-8');
@@ -41,10 +28,69 @@ function startDaemon(port = 7071) {
     catch (e) {
         console.error('Failed to write updated config.json:', e);
     }
-    // Create launchd agent for persistence
+    const nodePath = process.execPath;
+    const logPath = path_1.default.join(configDir, 'daemon.log');
+    const errorLogPath = path_1.default.join(configDir, 'daemon-error.log');
+    if (utils_1.isWindows) {
+        startDaemonWindows({ port, configDir, configVars, nodePath, backendPath, logPath, errorLogPath });
+    }
+    else {
+        startDaemonMacOS({ port, configDir, configVars, nodePath, backendPath, logPath, errorLogPath });
+    }
+}
+function startDaemonWindows(opts) {
+    const { port, configDir, configVars, nodePath, backendPath, logPath, errorLogPath } = opts;
+    // Write a wrapper .cmd script that sets env vars and launches the backend
+    const wrapperPath = path_1.default.join(configDir, 'start-daemon.cmd');
+    const envSetLines = Object.entries({ ...configVars, OMNIKEY_PORT: String(port) })
+        .map(([k, v]) => `set "${k}=${v}"`)
+        .join('\r\n');
+    const wrapperContent = [
+        '@echo off',
+        envSetLines,
+        `"${nodePath}" "${backendPath}" >> "${logPath}" 2>> "${errorLogPath}"`,
+        '',
+    ].join('\r\n');
+    try {
+        fs_1.default.mkdirSync(configDir, { recursive: true });
+        fs_1.default.writeFileSync(wrapperPath, wrapperContent, 'utf-8');
+    }
+    catch (e) {
+        console.error('Failed to write start-daemon.cmd:', e);
+        return;
+    }
+    // Register with Windows Task Scheduler so the daemon persists across reboots
+    const taskName = 'OmnikeyDaemon';
+    try {
+        // Delete existing task silently before creating a fresh one
+        (0, child_process_2.execSync)(`schtasks /delete /tn "${taskName}" /f`, { stdio: 'pipe' });
+    }
+    catch {
+        // Task may not exist — that's fine
+    }
+    try {
+        (0, child_process_2.execSync)(`schtasks /create /tn "${taskName}" /tr "cmd /c \\"${wrapperPath}\\"" /sc ONLOGON /f`, { stdio: 'pipe' });
+        console.log(`Windows Task Scheduler task created: ${taskName}`);
+        console.log('Omnikey daemon will auto-start on next logon.');
+    }
+    catch (e) {
+        console.error('Failed to create Windows Task Scheduler task:', e);
+    }
+    // Also start the backend immediately for the current session
+    const { out, err } = (0, utils_1.initLogFiles)(logPath, errorLogPath);
+    const child = (0, child_process_1.spawn)(nodePath, [backendPath], {
+        env: { ...process.env, ...configVars, OMNIKEY_PORT: String(port) },
+        detached: true,
+        stdio: ['ignore', out, err],
+    });
+    child.unref();
+    console.log(`Omnikey API backend started as a daemon on port ${port}. PID: ${child.pid}`);
+}
+function startDaemonMacOS(opts) {
+    const { port, configDir, configVars, nodePath, backendPath, logPath, errorLogPath } = opts;
+    const homeDir = (0, utils_1.getHomeDir)();
     const plistName = 'com.omnikey.daemon.plist';
     const plistPath = path_1.default.join(homeDir, 'Library', 'LaunchAgents', plistName);
-    const nodePath = process.execPath;
     const envVars = Object.entries({ ...configVars, OMNIKEY_PORT: String(port) })
         .map(([k, v]) => `<key>${k}</key><string>${v}</string>`)
         .join('\n');
@@ -68,21 +114,19 @@ function startDaemon(port = 7071) {
   <key>KeepAlive</key>
   <true/>
   <key>StandardOutPath</key>
-  <string>${path_1.default.join(configDir, 'daemon.log')}</string>
+  <string>${logPath}</string>
   <key>StandardErrorPath</key>
-  <string>${path_1.default.join(configDir, 'daemon-error.log')}</string>
+  <string>${errorLogPath}</string>
   <key>WorkingDirectory</key>
   <string>${configDir}</string>
 </dict>
 </plist>
 `;
-    // Write plist file
     try {
         const launchAgentsDir = path_1.default.join(homeDir, 'Library', 'LaunchAgents');
         fs_1.default.mkdirSync(launchAgentsDir, { recursive: true });
         fs_1.default.writeFileSync(plistPath, plistContent, 'utf-8');
-        // Load the launch agent
-        (0, child_process_2.execSync)(`launchctl unload "${plistPath}" || true`); // Unload if already loaded
+        (0, child_process_2.execSync)(`launchctl unload "${plistPath}" || true`);
         (0, child_process_2.execSync)(`launchctl load "${plistPath}"`);
         console.log(`Launch agent created and loaded: ${plistPath}`);
         console.log('Omnikey daemon will auto-restart and persist across reboots.');
@@ -90,19 +134,7 @@ function startDaemon(port = 7071) {
     catch (e) {
         console.error('Failed to create or load launch agent:', e);
     }
-    // Also start the backend immediately for current session
-    const logPath = path_1.default.join(configDir, 'daemon.log');
-    const errorLogPath = path_1.default.join(configDir, 'daemon-error.log');
-    // Clean (truncate) log files before starting new session
-    try {
-        fs_1.default.writeFileSync(logPath, '');
-        fs_1.default.writeFileSync(errorLogPath, '');
-    }
-    catch (e) {
-        // Ignore errors if files don't exist yet
-    }
-    const out = fs_1.default.openSync(logPath, 'a');
-    const err = fs_1.default.openSync(errorLogPath, 'a');
+    const { out, err } = (0, utils_1.initLogFiles)(logPath, errorLogPath);
     const child = (0, child_process_1.spawn)('node', [backendPath], {
         env: { ...configVars, OMNIKEY_PORT: String(port) },
         detached: true,

package/dist/index.js

@@ -31,10 +31,8 @@ program
 program
     .command('kill-daemon')
     .description('Kill the Omnikey API backend daemon running on a specified port')
-    .option('--port <port>', 'Port to look for the daemon on', '7071')
-    .action((options) => {
-    const port = Number(options.port) || 7071;
-    (0, killDaemon_1.killDaemon)(port);
+    .action(() => {
+    (0, killDaemon_1.killDaemon)();
 });
 program
     .command('remove-config')

package/dist/killDaemon.js

@@ -3,37 +3,58 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.killDaemon = killDaemon;
 const child_process_1 = require("child_process");
 const removeConfig_1 = require("./removeConfig");
+const utils_1 = require("./utils");
 /**
- * Kill the Omnikey API backend daemon running on a given port (default 7071).
- * Looks for node processes running backend-dist/index.js on the specified port and kills them.
- * @param port The port to look for (default 7071)
+ * Kill the Omnikey API backend daemon.
+ * Reads the port from ~/.omnikey/config.json (falls back to 7071).
+ * Removes the persistence agent, then kills any remaining process on the port.
  */
-function killDaemon(port = 7071) {
-    // 1. Unload/kill the launchd agent first
+function killDaemon() {
+    const port = (0, utils_1.getPort)();
+    // 1. Remove/stop the persistence agent
     try {
-        (0, removeConfig_1.killLaunchdAgent)();
-        console.log('Launchd agent unloaded (if it existed).');
+        (0, removeConfig_1.killPersistenceAgent)();
+        console.log('Persistence agent stopped (if it existed).');
     }
     catch (e) {
-        console.warn('Failed to unload launchd agent or agent did not exist:', e);
+        console.warn('Failed to stop persistence agent:', e);
     }
-    // 2. Check if the port is still in use
+    // 2. Find any remaining processes still using the port
     let pids = [];
     try {
-        pids = (0, child_process_1.execSync)(`lsof -i :${port} -t`).toString().split('\n').filter(Boolean);
+        if (utils_1.isWindows) {
+            // netstat -ano lists PID in the last column; filter by :<port> with LISTENING or ESTABLISHED
+            const output = (0, child_process_1.execSync)(`netstat -ano | findstr :${port}`).toString();
+            const seen = new Set();
+            for (const line of output.trim().split('\n')) {
+                const parts = line.trim().split(/\s+/);
+                const pid = parts[parts.length - 1];
+                if (pid && /^\d+$/.test(pid) && pid !== '0' && !seen.has(pid)) {
+                    seen.add(pid);
+                    pids.push(pid);
+                }
+            }
+        }
+        else {
+            pids = (0, child_process_1.execSync)(`lsof -i :${port} -t`).toString().split('\n').filter(Boolean);
+        }
     }
-    catch (e) {
-        // lsof returns non-zero exit code if nothing is using the port
+    catch {
         pids = [];
     }
     if (pids.length === 0) {
-        console.log(`No process found using port ${port} after unloading launchd agent.`);
+        console.log(`No process found using port ${port}.`);
         return;
     }
-    // 3. If the port is still occupied, kill the process using the port
+    // 3. Kill each process
     for (const pid of pids) {
         try {
-            process.kill(Number(pid), 'SIGTERM');
+            if (utils_1.isWindows) {
+                (0, child_process_1.execSync)(`taskkill /PID ${pid} /F`, { stdio: 'pipe' });
+            }
+            else {
+                process.kill(Number(pid), 'SIGTERM');
+            }
             console.log(`Killed process with PID ${pid} using port ${port}.`);
         }
         catch (e) {

package/dist/onboard.js

@@ -7,14 +7,14 @@ exports.onboard = onboard;
 const inquirer_1 = __importDefault(require("inquirer"));
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const utils_1 = require("./utils");
 /**
  * Onboard the user by configuring their OPENAI_API_KEY and generating a .env for self-hosted use.
  * @param openAiKey Optional key provided via CLI
  */
 async function onboard(openAiKey) {
     let apiKey = openAiKey;
-    const homeDir = process.env.HOME || process.env.USERPROFILE || '.';
-    const configDir = path_1.default.join(homeDir, '.omnikey');
+    const configDir = (0, utils_1.getConfigDir)();
     const sqlitePath = path_1.default.join(configDir, 'omnikey-selfhosted.sqlite');
     if (!apiKey) {
         const answers = await inquirer_1.default.prompt([
@@ -28,7 +28,7 @@ async function onboard(openAiKey) {
         apiKey = answers.apiKey;
     }
     // Save all environment variables to ~/.omnikey/config.json
-    const configPath = path_1.default.join(configDir, 'config.json');
+    const configPath = (0, utils_1.getConfigPath)();
     fs_1.default.mkdirSync(configDir, { recursive: true });
     const configVars = {
         OPENAI_API_KEY: apiKey,

package/dist/removeConfig.js

@@ -4,15 +4,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.killLaunchdAgent = killLaunchdAgent;
+exports.killWindowsTask = killWindowsTask;
+exports.killPersistenceAgent = killPersistenceAgent;
 exports.removeConfigAndDb = removeConfigAndDb;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const os_1 = __importDefault(require("os"));
 const child_process_1 = require("child_process");
+const utils_1 = require("./utils");
 function killLaunchdAgent() {
-    const homeDir = process.env.HOME || process.env.USERPROFILE || os_1.default.homedir();
     const plistName = 'com.omnikey.daemon.plist';
-    const plistPath = path_1.default.join(homeDir, 'Library', 'LaunchAgents', plistName);
+    const plistPath = path_1.default.join((0, utils_1.getHomeDir)(), 'Library', 'LaunchAgents', plistName);
     if (fs_1.default.existsSync(plistPath)) {
         try {
             (0, child_process_1.execSync)(`launchctl unload "${plistPath}"`);
@@ -27,30 +28,58 @@ function killLaunchdAgent() {
         console.log(`Launchd agent does not exist: ${plistPath}`);
     }
 }
+function killWindowsTask() {
+    const taskName = 'OmnikeyDaemon';
+    try {
+        (0, child_process_1.execSync)(`schtasks /end /tn "${taskName}"`, { stdio: 'pipe' });
+    }
+    catch {
+        // Task may not be running — that's fine
+    }
+    try {
+        (0, child_process_1.execSync)(`schtasks /delete /tn "${taskName}" /f`, { stdio: 'pipe' });
+        console.log(`Removed Windows Task Scheduler task: ${taskName}`);
+    }
+    catch {
+        console.log(`Windows Task Scheduler task does not exist: ${taskName}`);
+    }
+    // Also remove the wrapper script
+    const wrapperPath = path_1.default.join((0, utils_1.getConfigDir)(), 'start-daemon.cmd');
+    if (fs_1.default.existsSync(wrapperPath)) {
+        try {
+            fs_1.default.rmSync(wrapperPath);
+        }
+        catch {
+            // Ignore
+        }
+    }
+}
+/**
+ * Kill the platform-appropriate persistence agent (launchd on macOS, Task Scheduler on Windows).
+ */
+function killPersistenceAgent() {
+    if (utils_1.isWindows) {
+        killWindowsTask();
+    }
+    else {
+        killLaunchdAgent();
+    }
+}
 /**
  * Removes the ~/.omnikey config directory and the SQLite database file specified in config.json.
  */
 function removeConfigAndDb() {
-    const homeDir = process.env.HOME || process.env.USERPROFILE || os_1.default.homedir();
-    const configDir = path_1.default.join(homeDir, '.omnikey');
-    const configPath = path_1.default.join(configDir, 'config.json');
+    const homeDir = (0, utils_1.getHomeDir)();
+    const configDir = (0, utils_1.getConfigDir)();
+    const configData = (0, utils_1.readConfig)();
     let sqlitePath = path_1.default.join(homeDir, 'omnikey-selfhosted.sqlite');
-    // Try to read SQLITE_PATH from config.json
-    if (fs_1.default.existsSync(configPath)) {
-        try {
-            const configData = JSON.parse(fs_1.default.readFileSync(configPath, 'utf-8'));
-            if (configData.SQLITE_PATH) {
-                sqlitePath = path_1.default.isAbsolute(configData.SQLITE_PATH)
-                    ? configData.SQLITE_PATH
-                    : path_1.default.join(homeDir, configData.SQLITE_PATH);
-            }
-        }
-        catch (e) {
-            console.error(`Failed to read config.json: ${e}`);
-        }
+    if (configData.SQLITE_PATH) {
+        sqlitePath = path_1.default.isAbsolute(configData.SQLITE_PATH)
+            ? configData.SQLITE_PATH
+            : path_1.default.join(homeDir, configData.SQLITE_PATH);
     }
-    // Remove launchd agent if exists (macOS)
-    killLaunchdAgent();
+    // Remove platform-appropriate persistence agent
+    killPersistenceAgent();
     // Remove SQLite database
     if (fs_1.default.existsSync(sqlitePath)) {
         try {

package/dist/showLogs.js

@@ -6,15 +6,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.showLogs = showLogs;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const utils_1 = require("./utils");
 /**
  * Show the logs of the running Omnikey daemon by printing the contents of the daemon log file.
  * Prints the last N lines (default 50) for convenience.
  * If errorsOnly is true, shows daemon-error.log instead.
  */
 function showLogs(lines = 50, errorsOnly = false) {
-    const homeDir = process.env.HOME || process.env.USERPROFILE || '.';
-    const configDir = path_1.default.join(homeDir, '.omnikey');
-    const logPath = path_1.default.join(configDir, errorsOnly ? 'daemon-error.log' : 'daemon.log');
+    const logPath = path_1.default.join((0, utils_1.getConfigDir)(), errorsOnly ? 'daemon-error.log' : 'daemon.log');
     if (!fs_1.default.existsSync(logPath)) {
         console.log(errorsOnly ? 'No error logs found.' : 'No daemon logs found.');
         return;

package/dist/status.js

@@ -1,31 +1,18 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.statusCmd = statusCmd;
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
 const child_process_1 = require("child_process");
+const utils_1 = require("./utils");
 function statusCmd() {
-    // Read port from ~/.omnikey/config.json
-    const homeDir = process.env.HOME || process.env.USERPROFILE || '.';
-    const configDir = path_1.default.join(homeDir, '.omnikey');
-    const configPath = path_1.default.join(configDir, 'config.json');
-    let port = 7071;
-    if (fs_1.default.existsSync(configPath)) {
-        try {
-            const configVars = JSON.parse(fs_1.default.readFileSync(configPath, 'utf-8'));
-            if (configVars.OMNIKEY_PORT) {
-                port = Number(configVars.OMNIKEY_PORT);
-            }
+    const port = (0, utils_1.getPort)();
+    try {
+        let output;
+        if (utils_1.isWindows) {
+            output = (0, child_process_1.execSync)(`netstat -ano | findstr :${port}`).toString();
         }
-        catch (e) {
-            console.error('Failed to read config.json:', e);
+        else {
+            output = (0, child_process_1.execSync)(`lsof -i :${port}`).toString();
         }
-    }
-    try {
-        const output = (0, child_process_1.execSync)(`lsof -i :${port}`).toString();
         if (output.trim()) {
             console.log(`Processes using port ${port}:\n${output}`);
         }
@@ -33,7 +20,7 @@ function statusCmd() {
             console.log(`No process is using port ${port}.`);
         }
     }
-    catch (e) {
+    catch {
         console.log(`No process is using port ${port}.`);
     }
 }

package/dist/utils.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWindows = void 0;
+exports.getHomeDir = getHomeDir;
+exports.getConfigDir = getConfigDir;
+exports.getConfigPath = getConfigPath;
+exports.readConfig = readConfig;
+exports.getPort = getPort;
+exports.initLogFiles = initLogFiles;
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+exports.isWindows = process.platform === 'win32';
+function getHomeDir() {
+    return process.env.HOME || process.env.USERPROFILE || os_1.default.homedir();
+}
+function getConfigDir() {
+    return path_1.default.join(getHomeDir(), '.omnikey');
+}
+function getConfigPath() {
+    return path_1.default.join(getConfigDir(), 'config.json');
+}
+function readConfig() {
+    const configPath = getConfigPath();
+    if (fs_1.default.existsSync(configPath)) {
+        try {
+            return JSON.parse(fs_1.default.readFileSync(configPath, 'utf-8'));
+        }
+        catch {
+            // fall through to empty config
+        }
+    }
+    return {};
+}
+function getPort() {
+    const config = readConfig();
+    return config.OMNIKEY_PORT ? Number(config.OMNIKEY_PORT) : 7071;
+}
+function initLogFiles(logPath, errorLogPath) {
+    try {
+        fs_1.default.writeFileSync(logPath, '');
+        fs_1.default.writeFileSync(errorLogPath, '');
+    }
+    catch {
+        // Ignore if files don't exist yet
+    }
+    return {
+        out: fs_1.default.openSync(logPath, 'a'),
+        err: fs_1.default.openSync(errorLogPath, 'a'),
+    };
+}

package/package.json

@@ -4,7 +4,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "1.0.11",
+  "version": "1.0.12",
   "description": "CLI for onboarding users to Omnikey AI and configuring OPENAI_API_KEY. Use Yarn for install/build.",
   "engines": {
     "node": ">=14.0.0",

package/src/daemon.ts

@@ -1,35 +1,22 @@
 import { spawn } from 'child_process';
 import path from 'path';
 import fs from 'fs';
-import os from 'os';
 import { execSync } from 'child_process';
+import { isWindows, getHomeDir, getConfigDir, getConfigPath, readConfig, initLogFiles } from './utils';
 
 /**
  * Start the Omnikey API backend as a daemon on the specified port.
- * Also creates and registers a launchd agent for persistence on macOS.
+ * On macOS: creates and registers a launchd agent for persistence.
+ * On Windows: creates a wrapper script and registers a Windows Task Scheduler task.
  * @param port The port to run the backend on
  */
 export function startDaemon(port: number = 7071) {
-  // Only use ~/.omnikey/config.json for environment variables
-
-  // Path to the backend entry point (now from backend-dist)
   const backendPath = path.resolve(__dirname, '../backend-dist/index.js');
 
-  // Read and update environment variables from ~/.omnikey/config.json
-  const homeDir = process.env.HOME || process.env.USERPROFILE || os.homedir();
-  const configDir = path.join(homeDir, '.omnikey');
-  const configPath = path.join(configDir, 'config.json');
-  let configVars: Record<string, any> = {};
-  if (fs.existsSync(configPath)) {
-    try {
-      configVars = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-    } catch (e) {
-      console.error('Failed to parse config.json:', e);
-    }
-  }
-  // Ensure both OMNIKEY_PORT and PORT are set for compatibility
+  const configDir = getConfigDir();
+  const configPath = getConfigPath();
+  const configVars = readConfig();
   configVars.OMNIKEY_PORT = port;
-  // Write the updated configVars back to config.json
   try {
     fs.mkdirSync(configDir, { recursive: true });
     fs.writeFileSync(configPath, JSON.stringify(configVars, null, 2), 'utf-8');
@@ -37,10 +24,86 @@ export function startDaemon(port: number = 7071) {
     console.error('Failed to write updated config.json:', e);
   }
 
-  // Create launchd agent for persistence
+  const nodePath = process.execPath;
+  const logPath = path.join(configDir, 'daemon.log');
+  const errorLogPath = path.join(configDir, 'daemon-error.log');
+
+  if (isWindows) {
+    startDaemonWindows({ port, configDir, configVars, nodePath, backendPath, logPath, errorLogPath });
+  } else {
+    startDaemonMacOS({ port, configDir, configVars, nodePath, backendPath, logPath, errorLogPath });
+  }
+}
+
+interface DaemonOptions {
+  port: number;
+  configDir: string;
+  configVars: Record<string, any>;
+  nodePath: string;
+  backendPath: string;
+  logPath: string;
+  errorLogPath: string;
+}
+
+function startDaemonWindows(opts: DaemonOptions) {
+  const { port, configDir, configVars, nodePath, backendPath, logPath, errorLogPath } = opts;
+
+  // Write a wrapper .cmd script that sets env vars and launches the backend
+  const wrapperPath = path.join(configDir, 'start-daemon.cmd');
+  const envSetLines = Object.entries({ ...configVars, OMNIKEY_PORT: String(port) })
+    .map(([k, v]) => `set "${k}=${v}"`)
+    .join('\r\n');
+  const wrapperContent = [
+    '@echo off',
+    envSetLines,
+    `"${nodePath}" "${backendPath}" >> "${logPath}" 2>> "${errorLogPath}"`,
+    '',
+  ].join('\r\n');
+
+  try {
+    fs.mkdirSync(configDir, { recursive: true });
+    fs.writeFileSync(wrapperPath, wrapperContent, 'utf-8');
+  } catch (e) {
+    console.error('Failed to write start-daemon.cmd:', e);
+    return;
+  }
+
+  // Register with Windows Task Scheduler so the daemon persists across reboots
+  const taskName = 'OmnikeyDaemon';
+  try {
+    // Delete existing task silently before creating a fresh one
+    execSync(`schtasks /delete /tn "${taskName}" /f`, { stdio: 'pipe' });
+  } catch {
+    // Task may not exist — that's fine
+  }
+  try {
+    execSync(
+      `schtasks /create /tn "${taskName}" /tr "cmd /c \\"${wrapperPath}\\"" /sc ONLOGON /f`,
+      { stdio: 'pipe' },
+    );
+    console.log(`Windows Task Scheduler task created: ${taskName}`);
+    console.log('Omnikey daemon will auto-start on next logon.');
+  } catch (e) {
+    console.error('Failed to create Windows Task Scheduler task:', e);
+  }
+
+  // Also start the backend immediately for the current session
+  const { out, err } = initLogFiles(logPath, errorLogPath);
+  const child = spawn(nodePath, [backendPath], {
+    env: { ...process.env, ...configVars, OMNIKEY_PORT: String(port) },
+    detached: true,
+    stdio: ['ignore', out, err],
+  });
+  child.unref();
+  console.log(`Omnikey API backend started as a daemon on port ${port}. PID: ${child.pid}`);
+}
+
+function startDaemonMacOS(opts: DaemonOptions) {
+  const { port, configDir, configVars, nodePath, backendPath, logPath, errorLogPath } = opts;
+  const homeDir = getHomeDir();
+
   const plistName = 'com.omnikey.daemon.plist';
   const plistPath = path.join(homeDir, 'Library', 'LaunchAgents', plistName);
-  const nodePath = process.execPath;
   const envVars = Object.entries({ ...configVars, OMNIKEY_PORT: String(port) })
     .map(([k, v]) => `<key>${k}</key><string>${v}</string>`)
     .join('\n');
@@ -64,21 +127,19 @@ export function startDaemon(port: number = 7071) {
   <key>KeepAlive</key>
   <true/>
   <key>StandardOutPath</key>
-  <string>${path.join(configDir, 'daemon.log')}</string>
+  <string>${logPath}</string>
   <key>StandardErrorPath</key>
-  <string>${path.join(configDir, 'daemon-error.log')}</string>
+  <string>${errorLogPath}</string>
   <key>WorkingDirectory</key>
   <string>${configDir}</string>
 </dict>
 </plist>
 `;
-  // Write plist file
   try {
     const launchAgentsDir = path.join(homeDir, 'Library', 'LaunchAgents');
     fs.mkdirSync(launchAgentsDir, { recursive: true });
     fs.writeFileSync(plistPath, plistContent, 'utf-8');
-    // Load the launch agent
-    execSync(`launchctl unload "${plistPath}" || true`); // Unload if already loaded
+    execSync(`launchctl unload "${plistPath}" || true`);
     execSync(`launchctl load "${plistPath}"`);
     console.log(`Launch agent created and loaded: ${plistPath}`);
     console.log('Omnikey daemon will auto-restart and persist across reboots.');
@@ -86,18 +147,7 @@ export function startDaemon(port: number = 7071) {
     console.error('Failed to create or load launch agent:', e);
   }
 
-  // Also start the backend immediately for current session
-  const logPath = path.join(configDir, 'daemon.log');
-  const errorLogPath = path.join(configDir, 'daemon-error.log');
-  // Clean (truncate) log files before starting new session
-  try {
-    fs.writeFileSync(logPath, '');
-    fs.writeFileSync(errorLogPath, '');
-  } catch (e) {
-    // Ignore errors if files don't exist yet
-  }
-  const out = fs.openSync(logPath, 'a');
-  const err = fs.openSync(errorLogPath, 'a');
+  const { out, err } = initLogFiles(logPath, errorLogPath);
   const child = spawn('node', [backendPath], {
     env: { ...configVars, OMNIKEY_PORT: String(port) },
     detached: true,

package/src/index.ts

@@ -35,10 +35,8 @@ program
 program
   .command('kill-daemon')
   .description('Kill the Omnikey API backend daemon running on a specified port')
-  .option('--port <port>', 'Port to look for the daemon on', '7071')
-  .action((options) => {
-    const port = Number(options.port) || 7071;
-    killDaemon(port);
+  .action(() => {
+    killDaemon();
   });
 
 program

package/src/killDaemon.ts

@@ -1,38 +1,58 @@
 import { execSync } from 'child_process';
-import { killLaunchdAgent } from './removeConfig';
+import { killPersistenceAgent } from './removeConfig';
+import { isWindows, getPort } from './utils';
 
 /**
- * Kill the Omnikey API backend daemon running on a given port (default 7071).
- * Looks for node processes running backend-dist/index.js on the specified port and kills them.
- * @param port The port to look for (default 7071)
+ * Kill the Omnikey API backend daemon.
+ * Reads the port from ~/.omnikey/config.json (falls back to 7071).
+ * Removes the persistence agent, then kills any remaining process on the port.
  */
-export function killDaemon(port: number = 7071) {
-  // 1. Unload/kill the launchd agent first
+export function killDaemon() {
+  const port = getPort();
+
+  // 1. Remove/stop the persistence agent
   try {
-    killLaunchdAgent();
-    console.log('Launchd agent unloaded (if it existed).');
+    killPersistenceAgent();
+    console.log('Persistence agent stopped (if it existed).');
   } catch (e) {
-    console.warn('Failed to unload launchd agent or agent did not exist:', e);
+    console.warn('Failed to stop persistence agent:', e);
   }
 
-  // 2. Check if the port is still in use
+  // 2. Find any remaining processes still using the port
   let pids: string[] = [];
   try {
-    pids = execSync(`lsof -i :${port} -t`).toString().split('\n').filter(Boolean);
-  } catch (e) {
-    // lsof returns non-zero exit code if nothing is using the port
+    if (isWindows) {
+      // netstat -ano lists PID in the last column; filter by :<port> with LISTENING or ESTABLISHED
+      const output = execSync(`netstat -ano | findstr :${port}`).toString();
+      const seen = new Set<string>();
+      for (const line of output.trim().split('\n')) {
+        const parts = line.trim().split(/\s+/);
+        const pid = parts[parts.length - 1];
+        if (pid && /^\d+$/.test(pid) && pid !== '0' && !seen.has(pid)) {
+          seen.add(pid);
+          pids.push(pid);
+        }
+      }
+    } else {
+      pids = execSync(`lsof -i :${port} -t`).toString().split('\n').filter(Boolean);
+    }
+  } catch {
     pids = [];
   }
 
   if (pids.length === 0) {
-    console.log(`No process found using port ${port} after unloading launchd agent.`);
+    console.log(`No process found using port ${port}.`);
     return;
   }
 
-  // 3. If the port is still occupied, kill the process using the port
+  // 3. Kill each process
   for (const pid of pids) {
     try {
-      process.kill(Number(pid), 'SIGTERM');
+      if (isWindows) {
+        execSync(`taskkill /PID ${pid} /F`, { stdio: 'pipe' });
+      } else {
+        process.kill(Number(pid), 'SIGTERM');
+      }
       console.log(`Killed process with PID ${pid} using port ${port}.`);
     } catch (e) {
       console.error(`Failed to kill process ${pid}:`, e);

package/src/onboard.ts

@@ -1,6 +1,7 @@
 import inquirer from 'inquirer';
 import fs from 'fs';
 import path from 'path';
+import { getConfigDir, getConfigPath } from './utils';
 
 /**
  * Onboard the user by configuring their OPENAI_API_KEY and generating a .env for self-hosted use.
@@ -8,8 +9,7 @@ import path from 'path';
  */
 export async function onboard(openAiKey?: string) {
   let apiKey = openAiKey;
-  const homeDir = process.env.HOME || process.env.USERPROFILE || '.';
-  const configDir = path.join(homeDir, '.omnikey');
+  const configDir = getConfigDir();
   const sqlitePath = path.join(configDir, 'omnikey-selfhosted.sqlite');
 
   if (!apiKey) {
@@ -25,7 +25,7 @@ export async function onboard(openAiKey?: string) {
   }
 
   // Save all environment variables to ~/.omnikey/config.json
-  const configPath = path.join(configDir, 'config.json');
+  const configPath = getConfigPath();
   fs.mkdirSync(configDir, { recursive: true });
   const configVars = {
     OPENAI_API_KEY: apiKey,

package/src/removeConfig.ts

@@ -1,12 +1,11 @@
 import fs from 'fs';
 import path from 'path';
-import os from 'os';
 import { execSync } from 'child_process';
+import { isWindows, getHomeDir, getConfigDir, readConfig } from './utils';
 
 export function killLaunchdAgent() {
-  const homeDir = process.env.HOME || process.env.USERPROFILE || os.homedir();
   const plistName = 'com.omnikey.daemon.plist';
-  const plistPath = path.join(homeDir, 'Library', 'LaunchAgents', plistName);
+  const plistPath = path.join(getHomeDir(), 'Library', 'LaunchAgents', plistName);
   if (fs.existsSync(plistPath)) {
     try {
       execSync(`launchctl unload "${plistPath}"`);
@@ -20,31 +19,59 @@ export function killLaunchdAgent() {
   }
 }
 
+export function killWindowsTask() {
+  const taskName = 'OmnikeyDaemon';
+  try {
+    execSync(`schtasks /end /tn "${taskName}"`, { stdio: 'pipe' });
+  } catch {
+    // Task may not be running — that's fine
+  }
+  try {
+    execSync(`schtasks /delete /tn "${taskName}" /f`, { stdio: 'pipe' });
+    console.log(`Removed Windows Task Scheduler task: ${taskName}`);
+  } catch {
+    console.log(`Windows Task Scheduler task does not exist: ${taskName}`);
+  }
+
+  // Also remove the wrapper script
+  const wrapperPath = path.join(getConfigDir(), 'start-daemon.cmd');
+  if (fs.existsSync(wrapperPath)) {
+    try {
+      fs.rmSync(wrapperPath);
+    } catch {
+      // Ignore
+    }
+  }
+}
+
+/**
+ * Kill the platform-appropriate persistence agent (launchd on macOS, Task Scheduler on Windows).
+ */
+export function killPersistenceAgent() {
+  if (isWindows) {
+    killWindowsTask();
+  } else {
+    killLaunchdAgent();
+  }
+}
+
 /**
  * Removes the ~/.omnikey config directory and the SQLite database file specified in config.json.
  */
 export function removeConfigAndDb() {
-  const homeDir = process.env.HOME || process.env.USERPROFILE || os.homedir();
-  const configDir = path.join(homeDir, '.omnikey');
-  const configPath = path.join(configDir, 'config.json');
-  let sqlitePath = path.join(homeDir, 'omnikey-selfhosted.sqlite');
+  const homeDir = getHomeDir();
+  const configDir = getConfigDir();
+  const configData = readConfig();
 
-  // Try to read SQLITE_PATH from config.json
-  if (fs.existsSync(configPath)) {
-    try {
-      const configData = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-      if (configData.SQLITE_PATH) {
-        sqlitePath = path.isAbsolute(configData.SQLITE_PATH)
-          ? configData.SQLITE_PATH
-          : path.join(homeDir, configData.SQLITE_PATH);
-      }
-    } catch (e) {
-      console.error(`Failed to read config.json: ${e}`);
-    }
+  let sqlitePath = path.join(homeDir, 'omnikey-selfhosted.sqlite');
+  if (configData.SQLITE_PATH) {
+    sqlitePath = path.isAbsolute(configData.SQLITE_PATH)
+      ? configData.SQLITE_PATH
+      : path.join(homeDir, configData.SQLITE_PATH);
   }
 
-  // Remove launchd agent if exists (macOS)
-  killLaunchdAgent();
+  // Remove platform-appropriate persistence agent
+  killPersistenceAgent();
 
   // Remove SQLite database
   if (fs.existsSync(sqlitePath)) {

package/src/showLogs.ts

@@ -1,5 +1,6 @@
 import fs from 'fs';
 import path from 'path';
+import { getConfigDir } from './utils';
 
 /**
  * Show the logs of the running Omnikey daemon by printing the contents of the daemon log file.
@@ -7,9 +8,7 @@ import path from 'path';
  * If errorsOnly is true, shows daemon-error.log instead.
  */
 export function showLogs(lines: number = 50, errorsOnly: boolean = false) {
-  const homeDir = process.env.HOME || process.env.USERPROFILE || '.';
-  const configDir = path.join(homeDir, '.omnikey');
-  const logPath = path.join(configDir, errorsOnly ? 'daemon-error.log' : 'daemon.log');
+  const logPath = path.join(getConfigDir(), errorsOnly ? 'daemon-error.log' : 'daemon.log');
 
   if (!fs.existsSync(logPath)) {
     console.log(errorsOnly ? 'No error logs found.' : 'No daemon logs found.');

package/src/status.ts

@@ -1,31 +1,22 @@
-import path from 'path';
-import fs from 'fs';
 import { execSync } from 'child_process';
+import { isWindows, getPort } from './utils';
 
 export function statusCmd() {
-  // Read port from ~/.omnikey/config.json
-  const homeDir = process.env.HOME || process.env.USERPROFILE || '.';
-  const configDir = path.join(homeDir, '.omnikey');
-  const configPath = path.join(configDir, 'config.json');
-  let port = 7071;
-  if (fs.existsSync(configPath)) {
-    try {
-      const configVars = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
-      if (configVars.OMNIKEY_PORT) {
-        port = Number(configVars.OMNIKEY_PORT);
-      }
-    } catch (e) {
-      console.error('Failed to read config.json:', e);
-    }
-  }
+  const port = getPort();
+
   try {
-    const output = execSync(`lsof -i :${port}`).toString();
+    let output: string;
+    if (isWindows) {
+      output = execSync(`netstat -ano | findstr :${port}`).toString();
+    } else {
+      output = execSync(`lsof -i :${port}`).toString();
+    }
     if (output.trim()) {
       console.log(`Processes using port ${port}:\n${output}`);
     } else {
       console.log(`No process is using port ${port}.`);
     }
-  } catch (e) {
+  } catch {
     console.log(`No process is using port ${port}.`);
   }
 }

package/src/utils.ts

@@ -0,0 +1,47 @@
+import os from 'os';
+import path from 'path';
+import fs from 'fs';
+
+export const isWindows = process.platform === 'win32';
+
+export function getHomeDir(): string {
+  return process.env.HOME || process.env.USERPROFILE || os.homedir();
+}
+
+export function getConfigDir(): string {
+  return path.join(getHomeDir(), '.omnikey');
+}
+
+export function getConfigPath(): string {
+  return path.join(getConfigDir(), 'config.json');
+}
+
+export function readConfig(): Record<string, any> {
+  const configPath = getConfigPath();
+  if (fs.existsSync(configPath)) {
+    try {
+      return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+    } catch {
+      // fall through to empty config
+    }
+  }
+  return {};
+}
+
+export function getPort(): number {
+  const config = readConfig();
+  return config.OMNIKEY_PORT ? Number(config.OMNIKEY_PORT) : 7071;
+}
+
+export function initLogFiles(logPath: string, errorLogPath: string): { out: number; err: number } {
+  try {
+    fs.writeFileSync(logPath, '');
+    fs.writeFileSync(errorLogPath, '');
+  } catch {
+    // Ignore if files don't exist yet
+  }
+  return {
+    out: fs.openSync(logPath, 'a'),
+    err: fs.openSync(errorLogPath, 'a'),
+  };
+}