stikfix 1.5.0 → 1.6.1

package/README.md

@@ -8,6 +8,7 @@
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](./LICENSE)
 [![npm](https://img.shields.io/npm/v/stikfix.svg)](https://www.npmjs.com/package/stikfix)
+[![GitHub Release](https://img.shields.io/github/v/release/omernesh/stikfix?label=Windows%20installer)](https://github.com/omernesh/stikfix/releases/latest)
 [![Chrome MV3](https://img.shields.io/badge/Chrome-MV3-blue.svg)](#load-the-extension)
 
 </div>
@@ -33,7 +34,26 @@ No cloud. No accounts. No sign-up. Everything stays on `127.0.0.1` — **your co
 
 ## Quick start
 
-### 1. Install the host (one command)
+### Windows: one-click installer (recommended)
+
+1. Download **`stikfix-setup-1.6.0.exe`** from the [latest release](https://github.com/omernesh/stikfix/releases/latest).
+2. Run it. It needs **administrator rights** — it writes a browser policy so the extension can install itself.
+3. Pick a setup type:
+   - **Complete** — installs the host, force-installs the extension into every Chromium browser it finds (Chrome/Edge/Brave), sets the host to run on Windows login, and adds a desktop shortcut. Fully automatic — no terminal.
+   - **Custom** — pick components (the host; which browsers get the extension) and tasks (run-on-startup, desktop shortcut) individually, and choose your notes folder.
+4. The wizard finishes with a **post-install health check** that verifies the host binds, native messaging is registered, the browser force-install policy is set, and the notes folder is writable.
+5. Open Chrome/Edge/Brave — the extension is already there, next time the browser starts. You'll see **"Installed by your organization"** next to it; that's expected and correct for a self-hosted extension. It's force-installed via enterprise policy (`ExtensionInstallForcelist`) pointed at a self-hosted update manifest, not a Chrome Web Store listing.
+6. Open your app, click **Enter Review Mode**, and start dropping notes.
+
+The installer ships **`stikfix-host.exe`**, a self-contained binary — no Node.js needs to be installed on the machine. Re-run the health check anytime with `stikfix-host.exe doctor`, or the **"Stikfix Health Check"** shortcut it adds to the Start menu. To remove everything — host, browser policy entry, startup entry, native-messaging registration — use Windows **Add or remove programs**.
+
+For advanced use or troubleshooting, the same binary takes subcommands directly: `stikfix-host.exe serve --root <dir>`, `stikfix-host.exe doctor` (prints the health checklist), `stikfix-host.exe register` / `stikfix-host.exe uninstall`.
+
+### Developer path (macOS, Linux, or from source on Windows)
+
+Everything the Windows installer automates above, you can also do by hand — this is the path for macOS/Linux, or for building and loading the extension from source.
+
+#### 1. Install the host (one command)
 
 ```bash
 npx stikfix init --root /path/to/your/project
@@ -48,9 +68,9 @@ This turnkey installer:
 
 > **Keep it current:** re-run `npx --yes stikfix@latest init --root /path/to/your/project` anytime to update the host.
 
-### 2. Load the extension
+#### 2. Load the extension
 
-For v1.0 the extension is loaded **unpacked** (a Chrome Web Store listing is coming next):
+On the developer path the extension is loaded **unpacked** (a Chrome Web Store listing is coming next — the Windows installer above already force-installs it automatically, so unpacked loading isn't needed there):
 
 1. Open `chrome://extensions` (or `edge://extensions`).
 2. Turn on **Developer mode**.
@@ -58,15 +78,15 @@ For v1.0 the extension is loaded **unpacked** (a Chrome Web Store listing is com
 
 The loaded ID matches what the installer printed — nothing to type. (Building `.output/chrome-mv3/` from source is covered under [Development](#development).)
 
-### 3. Start the backend
+#### 3. Start the backend
 
 Double-click the **Stikfix Host** launcher on your Desktop. That's it — no commands, and double-clicking again is safe (it won't launch a second copy). The host listens on a port in the `39240–39260` range; the extension discovers it automatically.
 
-### 4. Pair in one click
+#### 4. Pair in one click
 
 Open the stikfix popup in your toolbar and hit **Pair with host**. The token is handed over automatically through the OS native-messaging channel — you never see it, never paste it. Pair once and it stays paired, even after restarts.
 
-### 5. Drop a note
+#### 5. Drop a note
 
 Open your app, click **Enter Review Mode**, and start dropping notes. The first note on a new site opens an **OS folder picker** so you can choose where that origin's notes live; it's remembered after that. When you're ready, tell your AI agent **"read my notes."**
 
@@ -80,7 +100,7 @@ Open your app, click **Enter Review Mode**, and start dropping notes. The first
 - **Notes panel** — a chip-toggled list of every note: counts by status, filter chips, text search, and click-to-jump that scrolls right to the pin. Flip **All pages** to browse every note across the project, not just the current page.
 - **Live updates** — while Review Mode is on, pins and the panel refresh on their own (~4s, only when the tab is visible) as the agent writes replies and resolves notes. No manual reload.
 - **Per-origin project routing** — the first note on a new site opens an OS folder picker; after that, every tab routes to the right project's `notes/` folder automatically. No per-note picking.
-- **Cross-browser host** — one `npx stikfix init` registers Chrome and Edge in a single pass.
+- **Cross-browser host** — one `npx stikfix init` registers Chrome and Edge in a single pass. On Windows, the one-click installer does this (and the browser-side install) for you.
 - **The `review-notes` AI skill** — the portable agent half of the loop (see below).
 
 ## How notes reach your AI

package/dist/host/src/bootstrap/register.js

@@ -268,15 +268,22 @@ export function createLauncherFiles(opts) {
     const hostEntry = opts.hostEntryPath;
     const rootArg = opts.root;
     const portArg = opts.port !== undefined ? ` --port ${opts.port}` : '';
+    // Standalone-exe launcher: run `"<exe>" serve --root ...` instead of
+    // `"node" "<hostEntry>" --root ...`. Absent → exact prior node behavior.
+    const useExe = typeof opts.hostExe === 'string' && opts.hostExe.length > 0;
+    const hostExe = opts.hostExe ?? '';
     if (plat === 'win32') {
         // Write batch file — plain text, no exec required
+        const batchLaunch = useExe
+            ? `"${hostExe}" serve --root "${rootArg}"${portArg}`
+            : `"${nodeCmd}" "${hostEntry}" --root "${rootArg}"${portArg}`;
         const batchContent = [
             '@echo off',
             `rem Stikfix HTTP host launcher — double-click to start the backend`,
             `rem Generated by: npx stikfix init`,
             `rem Root: ${rootArg}`,
             ``,
-            `"${nodeCmd}" "${hostEntry}" --root "${rootArg}"${portArg}`,
+            batchLaunch,
             `if %ERRORLEVEL% NEQ 0 pause`,
         ].join('\r\n');
         const batchPath = paths.launcher;
@@ -287,17 +294,33 @@ export function createLauncherFiles(opts) {
         // VBS string-literal escaping: a literal " is doubled ("").
         const vq = (s) => s.replace(/"/g, '""');
         const vbsHostEntry = vq(hostEntry);
+        const vbsHostExe = vq(hostExe);
         const vbsRoot = vq(rootArg);
         const vbsPortArg = opts.port !== undefined ? ` --port ${opts.port}` : '';
+        // The hidden-launch line (window style 0).
+        //
+        // exe mode runs the ABSOLUTE exe path DIRECTLY via sh.Run — NOT through
+        // `cmd /c`. Reason: `cmd /c "<quoted exe>" ... "<quoted root>"` starts and
+        // ends with a quote, so cmd.exe strips the outer pair (documented in
+        // `cmd /?`) and mangles the spaced "C:\Program Files\..." path → the host
+        // never starts. WScript.Shell.Run parses the quoted exe path correctly, so
+        // no cmd wrapper (and no PATH lookup) is needed for an absolute exe.
+        //
+        // node mode keeps `cmd /c` so a relative `node` on PATH resolves; that line
+        // begins with `node` (not a quote), so cmd's outer-quote strip never fires.
+        const vbsRunLine = useExe
+            ? `sh.Run """" & hostExe & """ serve --root """ & root & """${vbsPortArg}", 0, False`
+            : `sh.Run "cmd /c node """ & hostEntry & """ --root """ & root & """${vbsPortArg}", 0, False`;
         const vbsContent = [
             'Option Explicit',
-            'Dim sh, fso, hostEntry, root, portFile, msg, port, f',
+            'Dim sh, fso, hostEntry, hostExe, root, portFile, msg, port, f',
             'Set sh = CreateObject("WScript.Shell")',
             'Set fso = CreateObject("Scripting.FileSystemObject")',
             `hostEntry = "${vbsHostEntry}"`,
+            `hostExe = "${vbsHostExe}"`,
             `root = "${vbsRoot}"`,
             "' Launch the host hidden (window style 0), do not wait",
-            `sh.Run "cmd /c node """ & hostEntry & """ --root """ & root & """${vbsPortArg}", 0, False`,
+            vbsRunLine,
             "' Give it a moment to bind and write the port file",
             'WScript.Sleep 1800',
             'msg = "Stikfix host is running." & vbCrLf & vbCrLf & "You can start dropping notes."',
@@ -319,34 +342,56 @@ export function createLauncherFiles(opts) {
         // execFile (not exec) — no shell spawned, no injection vector.
         // If this fails for any reason, fall through to the warning (batch file is the fallback).
         if (paths.shortcut) {
-            const lnkPath = paths.shortcut;
+            // paths.shortcut (from getLauncherPaths) is a HARDCODED GUESS —
+            // join(home, 'Desktop', ...) — which is wrong when Windows OneDrive
+            // "Known Folder Move" (or a custom Shell-Folder registry override)
+            // redirects the Desktop elsewhere. Resolve the REAL current Desktop
+            // folder at shortcut-creation time via PowerShell's
+            // [Environment]::GetFolderPath('Desktop'), which honors that
+            // redirection, and build the .lnk path from that instead. The guess is
+            // kept only as the non-fatal fallback message below.
+            const guessedLnkPath = paths.shortcut;
             const iconPath = opts.iconPath ?? '';
             // Build PowerShell script as a single string — paths passed as PS variables
             // set from the -Command string. No shell metacharacter interpolation from
             // external data; all values are constants determined at registration time.
             // PowerShell single-quote escaping: replace ' with '' in path strings.
-            const safeLnkPath = lnkPath.replace(/'/g, "''");
+            const safeLnkFileName = LAUNCHER_LNK_FILENAME.replace(/'/g, "''");
             const safeIconPath = iconPath.replace(/'/g, "''");
             const wscriptPath = join(process.env['SystemRoot'] ?? 'C:\\Windows', 'System32', 'wscript.exe');
             const safeWscript = wscriptPath.replace(/'/g, "''");
             const safeVbsPath = vbsPath.replace(/'/g, "''");
-            const psScript = `$ws = New-Object -ComObject WScript.Shell;` +
-                `$s = $ws.CreateShortcut('${safeLnkPath}');` +
+            // $desktop resolves the REAL Desktop (OneDrive KFM / Shell-Folder aware);
+            // the script prints the final .lnk path on stdout so Node can capture the
+            // ACTUAL path created instead of trusting the hardcoded guess.
+            const psScript = `$desktop = [Environment]::GetFolderPath('Desktop');` +
+                `$lnkPath = Join-Path $desktop '${safeLnkFileName}';` +
+                `$ws = New-Object -ComObject WScript.Shell;` +
+                `$s = $ws.CreateShortcut($lnkPath);` +
                 `$s.TargetPath = '${safeWscript}';` +
                 `$s.Arguments = '"${safeVbsPath}"';` +
                 `$s.Description = 'Start the Stikfix HTTP backend host';` +
                 (safeIconPath ? `$s.IconLocation = '${safeIconPath},0';` : '') +
-                `$s.Save()`;
+                `$s.Save();` +
+                `Write-Output $lnkPath`;
             // execFileSync — NEVER exec; arg array is static with respect to user input.
             // Synchronous so init reports the shortcut accurately (the async variant
             // raced existsSync in the CLI and printed a false "skipped" message).
             try {
-                execFileSync('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', psScript], { timeout: 15_000, stdio: 'ignore' });
+                const stdout = execFileSync('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', psScript], { timeout: 15_000, encoding: 'utf8' });
+                // The resolved .lnk path is the last non-empty stdout line. Fall back to
+                // the hardcoded guess only if PowerShell somehow printed nothing.
+                const resolvedLnkPath = stdout
+                    .split(/\r?\n/)
+                    .map((line) => line.trim())
+                    .filter(Boolean)
+                    .pop() ?? guessedLnkPath;
                 // Only record the shortcut once it actually exists on disk.
-                written.push(lnkPath);
+                written.push(resolvedLnkPath);
             }
             catch (err) {
-                // Non-fatal: batch file is the acceptable fallback
+                // Non-fatal: batch file is the acceptable fallback. The shortcut was not
+                // created at guessedLnkPath (or anywhere else), matching prior behavior.
                 warnings.push(`Desktop shortcut creation failed (non-fatal): ${String(err.message)}. ` +
                     `The batch file at ${batchPath} can be used directly.`);
             }
@@ -359,7 +404,9 @@ export function createLauncherFiles(opts) {
             `# Stikfix HTTP host launcher — double-click in Finder or drag to Dock`,
             `# Generated by: npx stikfix init`,
             ``,
-            `exec "${nodeCmd}" "${hostEntry}" --root "${rootArg}"${portArg}`,
+            useExe
+                ? `exec "${hostExe}" serve --root "${rootArg}"${portArg}`
+                : `exec "${nodeCmd}" "${hostEntry}" --root "${rootArg}"${portArg}`,
         ].join('\n');
         const commandPath = paths.launcher;
         writeFileSync(commandPath, commandContent, { encoding: 'utf8', mode: 0o755 });
@@ -372,7 +419,9 @@ export function createLauncherFiles(opts) {
             `# Stikfix HTTP host launcher`,
             `# Generated by: npx stikfix init`,
             ``,
-            `exec "${nodeCmd}" "${hostEntry}" --root "${rootArg}"${portArg}`,
+            useExe
+                ? `exec "${hostExe}" serve --root "${rootArg}"${portArg}`
+                : `exec "${nodeCmd}" "${hostEntry}" --root "${rootArg}"${portArg}`,
         ].join('\n');
         const shPath = paths.launcher;
         writeFileSync(shPath, shContent, { encoding: 'utf8' });
@@ -479,10 +528,14 @@ export function registerNativeHost(opts) {
     const home = opts.home ?? homedir();
     const browser = opts.browser ?? 'chrome';
     const manifestPath = nativeManifestPath(plat, home, browser);
-    // Chrome's CreateProcess (and Firefox on Windows) cannot run a .cjs directly —
-    // point the manifest at a per-OS wrapper that runs `node <abs cjs>` instead.
-    const wrapperPath = writeNativeWrapper(opts.hostBinPath, plat, home, browser);
-    const manifest = buildManifest(opts.extensionId, wrapperPath, browser);
+    // Default (npx/node install): Chrome's CreateProcess (and Firefox on Windows)
+    // cannot run a .cjs directly — point the manifest at a per-OS wrapper that
+    // runs `node <abs cjs>`. Standalone-exe install (directPath): the exe self-
+    // detects native mode, so point the manifest straight at it — no wrapper.
+    const manifestTarget = opts.directPath
+        ? resolve(opts.hostBinPath)
+        : writeNativeWrapper(opts.hostBinPath, plat, home, browser);
+    const manifest = buildManifest(opts.extensionId, manifestTarget, browser);
     writeManifest(manifest, manifestPath);
     if (plat === 'win32') {
         const execReg = opts.execReg ?? ((args) => {
@@ -613,5 +666,51 @@ export function enumerateArtifacts(opts = {}) {
         : [];
     return { paths, registryKeys };
 }
+/**
+ * Shared uninstall teardown used by BOTH `bin/stikfix.ts uninstall` and the
+ * standalone exe's `stikfix-host uninstall` subcommand, so the two entry
+ * points stay behaviorally equivalent and neither duplicates the removal
+ * logic inline:
+ *   - remove the native-messaging manifest + HKCU registry keys, launcher
+ *     files, and Desktop shortcut (via unregisterNativeHost)
+ *   - remove the Windows startup (HKCU Run) autoload entry (via unregisterStartup)
+ *   - remove the stikfix config.json
+ *
+ * Idempotent: every step tolerates an already-absent file/key — matches the
+ * existing idempotent contracts of unregisterNativeHost/unregisterStartup.
+ * No console output here — callers own their own user-facing messages/format
+ * (bin/stikfix.ts prints plain text lines; the exe prints JSON).
+ */
+export function teardownHost(opts = {}) {
+    const plat = opts.plat ?? process.platform;
+    const home = opts.home ?? homedir();
+    const browser = opts.browser ?? 'chrome';
+    const result = {
+        manifestRemoved: true,
+        configPath: CONFIG_PATH(home),
+        configRemoved: false,
+    };
+    try {
+        unregisterNativeHost({ plat, home, browser });
+    }
+    catch (err) {
+        result.manifestRemoved = false;
+        result.manifestError = err instanceof Error ? err.message : String(err);
+    }
+    try {
+        unregisterStartup({ plat, home });
+    }
+    catch (err) {
+        result.startupError = err instanceof Error ? err.message : String(err);
+    }
+    try {
+        rmSync(result.configPath, { force: true });
+        result.configRemoved = true;
+    }
+    catch {
+        result.configRemoved = false;
+    }
+    return result;
+}
 // Re-export isInsideDir for consumers that need path validation
 export { isInsideDir };

package/dist/host/src/config.js

@@ -13,13 +13,29 @@ import { resolve, join, basename, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { randomUUID } from 'node:crypto';
 import { isInsideDir } from './security.js';
-// ---------------------------------------------------------------------------
-// VERSION — read from package.json at runtime (Pattern 11)
-// dist/host/src/config.js → ../../../package.json
-// ---------------------------------------------------------------------------
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const _pkg = JSON.parse(readFileSync(join(__dirname, '../../../package.json'), 'utf8'));
-export const VERSION = _pkg.version;
+function resolveVersion() {
+    // 1. SEA exe: the bundle has no package.json at a stable relative path, so the
+    //    version is inlined at build time. `typeof` guards against ReferenceError
+    //    in builds where the constant was never defined.
+    try {
+        if (typeof __STIKFIX_VERSION__ === 'string' && __STIKFIX_VERSION__.length > 0) {
+            return __STIKFIX_VERSION__;
+        }
+    }
+    catch {
+        // Not defined in this build — fall through to the on-disk read.
+    }
+    // 2. Normal tsc/node build: dist/host/src/config.js → ../../../package.json.
+    try {
+        const dir = dirname(fileURLToPath(import.meta.url));
+        const pkg = JSON.parse(readFileSync(join(dir, '../../../package.json'), 'utf8'));
+        return pkg.version;
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+export const VERSION = resolveVersion();
 // ---------------------------------------------------------------------------
 // resolveConfigValues — three-tier env resolution (exported for testing)
 // ---------------------------------------------------------------------------