stikfix 1.3.2 → 1.6.0

package/dist/host/src/index.js

@@ -12,135 +12,174 @@
 import { writeFileSync, readFileSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { parseArgs } from 'node:util';
+import { pathToFileURL } from 'node:url';
 import { resolveConfig, resolveConfigValues, ensureNotesDir, writeTokenFile } from './config.js';
 import { createHostServer } from './server.js';
 import { bindServer, BIND_HOST } from './bind.js';
 import { probeExistingHost } from './probe.js';
 import { startTray } from './tray.js';
-// ---------------------------------------------------------------------------
-// CLI parsing (preserve Phase 1 stub options block — HOST-13)
-// ---------------------------------------------------------------------------
-const { values: rawValues } = parseArgs({
-    options: {
-        root: { type: 'string' },
-        origin: { type: 'string', multiple: true },
-        name: { type: 'string' },
-        'notes-dir': { type: 'string' },
-        port: { type: 'string' },
-        token: { type: 'string' },
-    },
-    strict: false,
-});
-// Apply three-tier env resolution (flag > STIKFIX_* > npm_config_*) so that
-// `npm run host -- --root <dir>` works in Windows PowerShell, where npm 11.x
-// intercepts unknown flags and re-exposes them as npm_config_<key> env vars.
-const values = resolveConfigValues(rawValues);
-if (!values['root']) {
-    console.error('stikfix-host: --root is required');
-    process.exit(1);
-}
-// ---------------------------------------------------------------------------
-// Config resolution + filesystem setup
-// ---------------------------------------------------------------------------
-const cfg = resolveConfig(values);
-ensureNotesDir(cfg.notesDir);
-// ---------------------------------------------------------------------------
-// FIX-SI: Single-instance guard — BEFORE any file mutation
-// ---------------------------------------------------------------------------
-const portFilePath = join(cfg.root, '.stikfix-port');
-if (existsSync(portFilePath)) {
-    const portStr = readFileSync(portFilePath, 'utf8').trim();
-    const existingPort = Number(portStr);
-    if (Number.isInteger(existingPort) && existingPort > 0 && existingPort <= 65535) {
-        const live = await probeExistingHost(cfg.root, existingPort);
-        if (live !== null) {
-            console.log(`stikfix-host: already running for ${cfg.root} on port ${live.port} — not starting a second instance.`);
-            process.exit(0);
+/**
+ * Start the HTTP host. Extracted from the former top-level module body so the
+ * single-executable dispatcher (exe-main.ts) can call it as `serve`, while
+ * `node dist/host/src/index.js` keeps running it via the direct-entry guard at
+ * the bottom of this file. Behavior is byte-for-byte identical to the previous
+ * top-level code — the only change is that argv is passed in (defaulting to
+ * process.argv.slice(2)) instead of being read from the global process.argv.
+ */
+export async function startHttpHost(argv = process.argv.slice(2)) {
+    // -------------------------------------------------------------------------
+    // CLI parsing (preserve Phase 1 stub options block — HOST-13)
+    // -------------------------------------------------------------------------
+    const { values: rawValues } = parseArgs({
+        args: argv,
+        options: {
+            root: { type: 'string' },
+            origin: { type: 'string', multiple: true },
+            name: { type: 'string' },
+            'notes-dir': { type: 'string' },
+            port: { type: 'string' },
+            token: { type: 'string' },
+            'git-sync': { type: 'boolean' },
+        },
+        strict: false,
+    });
+    // Apply three-tier env resolution (flag > STIKFIX_* > npm_config_*) so that
+    // `npm run host -- --root <dir>` works in Windows PowerShell, where npm 11.x
+    // intercepts unknown flags and re-exposes them as npm_config_<key> env vars.
+    const values = resolveConfigValues(rawValues);
+    if (!values['root']) {
+        console.error('stikfix-host: --root is required');
+        process.exit(1);
+    }
+    // -------------------------------------------------------------------------
+    // Config resolution + filesystem setup
+    // -------------------------------------------------------------------------
+    const cfg = resolveConfig(values);
+    ensureNotesDir(cfg.notesDir);
+    // -------------------------------------------------------------------------
+    // FIX-SI: Single-instance guard — BEFORE any file mutation
+    // -------------------------------------------------------------------------
+    const portFilePath = join(cfg.root, '.stikfix-port');
+    if (existsSync(portFilePath)) {
+        const portStr = readFileSync(portFilePath, 'utf8').trim();
+        const existingPort = Number(portStr);
+        if (Number.isInteger(existingPort) && existingPort > 0 && existingPort <= 65535) {
+            const live = await probeExistingHost(cfg.root, existingPort);
+            if (live !== null) {
+                console.log(`stikfix-host: already running for ${cfg.root} on port ${live.port} — not starting a second instance.`);
+                process.exit(0);
+            }
+            // else: stale port file — continue with normal startup
         }
-        // else: stale port file — continue with normal startup
     }
-}
-// ---------------------------------------------------------------------------
-// FIX-TP: Token persistence — reuse existing token if no explicit token given
-// ---------------------------------------------------------------------------
-// An "explicit" token is one supplied via --token / STIKFIX_TOKEN / npm_config_token.
-// resolveConfig already resolved these; if none was supplied, randomUUID() was called.
-// We detect the "no explicit token" case by checking the raw resolved values BEFORE
-// randomUUID was applied.
-const rawToken = values['token'] ??
-    (process.env['STIKFIX_TOKEN']) ??
-    (process.env['npm_config_token']);
-const tokenFilePath = join(cfg.root, '.stikfix-token');
-let finalToken = cfg.token;
-if (!rawToken) {
-    // No explicit token provided — try to reuse existing token file
-    if (existsSync(tokenFilePath)) {
-        const existing = readFileSync(tokenFilePath, 'utf8').trim();
-        if (existing.length > 0) {
-            finalToken = existing;
+    // -------------------------------------------------------------------------
+    // FIX-TP: Token persistence — reuse existing token if no explicit token given
+    // -------------------------------------------------------------------------
+    // An "explicit" token is one supplied via --token / STIKFIX_TOKEN / npm_config_token.
+    // resolveConfig already resolved these; if none was supplied, randomUUID() was called.
+    // We detect the "no explicit token" case by checking the raw resolved values BEFORE
+    // randomUUID was applied.
+    const rawToken = values['token'] ??
+        (process.env['STIKFIX_TOKEN']) ??
+        (process.env['npm_config_token']);
+    const tokenFilePath = join(cfg.root, '.stikfix-token');
+    let finalToken = cfg.token;
+    if (!rawToken) {
+        // No explicit token provided — try to reuse existing token file
+        if (existsSync(tokenFilePath)) {
+            const existing = readFileSync(tokenFilePath, 'utf8').trim();
+            if (existing.length > 0) {
+                finalToken = existing;
+            }
+            // else: empty file — keep freshly generated UUID from resolveConfig
+        }
+        // else: no existing file — keep freshly generated UUID from resolveConfig
+    }
+    // Write the final token (idempotent — fixes perms to 0o600 via writeTokenFile)
+    writeTokenFile(cfg.root, finalToken);
+    // -------------------------------------------------------------------------
+    // Port discovery — bind-or-fail loop on 127.0.0.1 (Pattern 1 / D-08)
+    // -------------------------------------------------------------------------
+    const server = createHostServer({ ...cfg, token: finalToken });
+    const boundPort = await bindServer(server, cfg.port);
+    // Safety assertion: binding must be 127.0.0.1 (T-02-bind)
+    const addr = server.address();
+    if (addr.address !== BIND_HOST) {
+        throw new Error(`FATAL: server bound to ${addr.address} instead of ${BIND_HOST}`);
+    }
+    // Publish bound port to disk so the native host can read it without a port scan
+    // (RESEARCH Open Question 2 / A5). Mode 0o600 alongside existing token file.
+    writeFileSync(join(cfg.root, '.stikfix-port'), String(boundPort), { encoding: 'utf8', mode: 0o600 });
+    // Startup JSON line — read by smoke test via readline (Pattern 12)
+    console.log(JSON.stringify({
+        app: 'stikfix',
+        name: cfg.name,
+        root: cfg.root,
+        port: boundPort,
+        token: finalToken,
+        notesDir: cfg.notesDir,
+        origins: cfg.origins,
+    }));
+    // -------------------------------------------------------------------------
+    // Windows system-tray indicator (best-effort, cosmetic, win32-only)
+    // -------------------------------------------------------------------------
+    // Only reached on genuine startup — the single-instance guard above exits(0)
+    // before here, so a second instance never spawns a duplicate tray.
+    const tray = startTray({
+        port: boundPort,
+        root: cfg.root,
+        name: cfg.name,
+        notesDir: cfg.notesDir,
+        hostPid: process.pid,
+    });
+    // Kill the tray child when the host shuts down so a dead host has no tray.
+    // (No prior signal handling existed here; these are additive.)
+    let shuttingDown = false;
+    function shutdown(signal) {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        try {
+            tray?.kill();
         }
-        // else: empty file — keep freshly generated UUID from resolveConfig
+        catch { /* best-effort */ }
+        server.close(() => process.exit(0));
+        // Fallback: exit even if server.close hangs on lingering connections.
+        setTimeout(() => process.exit(0), 1000).unref();
+        void signal;
     }
-    // else: no existing file — keep freshly generated UUID from resolveConfig
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+    // Belt-and-suspenders: also reap the tray on plain process exit.
+    process.on('exit', () => { try {
+        tray?.kill();
+    }
+    catch { /* best-effort */ } });
+    // Server runs indefinitely (Pitfall 2 — no process.exit here)
 }
-// Write the final token (idempotent — fixes perms to 0o600 via writeTokenFile)
-writeTokenFile(cfg.root, finalToken);
-// ---------------------------------------------------------------------------
-// Port discovery — bind-or-fail loop on 127.0.0.1 (Pattern 1 / D-08)
-// ---------------------------------------------------------------------------
-const server = createHostServer({ ...cfg, token: finalToken });
-const boundPort = await bindServer(server, cfg.port);
-// Safety assertion: binding must be 127.0.0.1 (T-02-bind)
-const addr = server.address();
-if (addr.address !== BIND_HOST) {
-    throw new Error(`FATAL: server bound to ${addr.address} instead of ${BIND_HOST}`);
+function isBundled() {
+    try {
+        return typeof __STIKFIX_BUNDLED__ !== 'undefined' && __STIKFIX_BUNDLED__ === true;
+    }
+    catch {
+        return false;
+    }
 }
-// Publish bound port to disk so the native host can read it without a port scan
-// (RESEARCH Open Question 2 / A5). Mode 0o600 alongside existing token file.
-writeFileSync(join(cfg.root, '.stikfix-port'), String(boundPort), { encoding: 'utf8', mode: 0o600 });
-// Startup JSON line — read by smoke test via readline (Pattern 12)
-console.log(JSON.stringify({
-    app: 'stikfix',
-    name: cfg.name,
-    root: cfg.root,
-    port: boundPort,
-    token: finalToken,
-    notesDir: cfg.notesDir,
-    origins: cfg.origins,
-}));
-// ---------------------------------------------------------------------------
-// Windows system-tray indicator (best-effort, cosmetic, win32-only)
-// ---------------------------------------------------------------------------
-// Only reached on genuine startup — the single-instance guard above exits(0)
-// before here, so a second instance never spawns a duplicate tray.
-const tray = startTray({
-    port: boundPort,
-    root: cfg.root,
-    name: cfg.name,
-    notesDir: cfg.notesDir,
-    hostPid: process.pid,
-});
-// Kill the tray child when the host shuts down so a dead host has no tray.
-// (No prior signal handling existed here; these are additive.)
-let shuttingDown = false;
-function shutdown(signal) {
-    if (shuttingDown)
-        return;
-    shuttingDown = true;
+function isDirectEntry() {
+    // In the single-executable bundle, exe-main.ts dispatches explicitly — this
+    // guard must never fire there (it would double-start the host).
+    if (isBundled())
+        return false;
     try {
-        tray?.kill();
+        return import.meta.url === pathToFileURL(process.argv[1] ?? '').href;
+    }
+    catch {
+        return false;
     }
-    catch { /* best-effort */ }
-    server.close(() => process.exit(0));
-    // Fallback: exit even if server.close hangs on lingering connections.
-    setTimeout(() => process.exit(0), 1000).unref();
-    void signal;
 }
-process.on('SIGINT', () => shutdown('SIGINT'));
-process.on('SIGTERM', () => shutdown('SIGTERM'));
-// Belt-and-suspenders: also reap the tray on plain process exit.
-process.on('exit', () => { try {
-    tray?.kill();
+if (isDirectEntry()) {
+    startHttpHost().catch((err) => {
+        console.error(err instanceof Error ? (err.stack ?? err.message) : String(err));
+        process.exit(1);
+    });
 }
-catch { /* best-effort */ } });
-// Server runs indefinitely (Pitfall 2 — no process.exit here)

package/dist/host/src/native-host.js

@@ -78,11 +78,19 @@ export function handleStartHost(cfg, root, spawnFn = spawn, out) {
     }
     const nodePath = typeof cfg.nodePath === 'string' && cfg.nodePath.length > 0 ? cfg.nodePath : process.execPath;
     const hostEntry = resolveHostEntry(cfg);
+    // Standalone-exe install path: when config points at a single-executable host,
+    // spawn `<exe> serve --root <root>` (the exe self-detects the subcommand).
+    // Otherwise keep the exact prior behavior: `node <hostEntry> --root <root>`.
+    const hostExe = typeof cfg.hostExe === 'string' && cfg.hostExe.length > 0 ? cfg.hostExe : undefined;
+    const spawnCmd = hostExe ?? nodePath;
+    const spawnArgs = hostExe
+        ? ['serve', '--root', resolvedRoot]
+        : [hostEntry, '--root', resolvedRoot];
     // CRITICAL (T-09-07): the native host MUST NOT bind/listen itself. It only
     // spawns a SEPARATE, detached process that is the HTTP host. Detached +
     // stdio:'ignore' + unref() so the child outlives this one-shot native process.
     try {
-        const child = spawnFn(nodePath, [hostEntry, '--root', resolvedRoot], {
+        const child = spawnFn(spawnCmd, spawnArgs, {
             detached: true,
             stdio: 'ignore',
             windowsHide: true,
@@ -239,12 +247,31 @@ export function main() {
         process.exit(0);
     });
 }
-// Run only when invoked as the entry point (esbuild CJS bundle), never on import.
-// In the esbuild CJS bundle (stikfix-native.cjs), `require`/`module` are CJS
-// scope locals and `require.main === module` is true when run directly. The
-// node:test compile path emits ESM where these are undefined at runtime — the
-// `typeof` guards keep main() from running on import there.
-if (typeof require !== 'undefined' &&
+/**
+ * Async-friendly entry alias for the SEA dispatcher (exe-main.ts). The native
+ * message loop is event-driven, so this resolves immediately after wiring up the
+ * stdin listener; the process stays alive until stdin closes (Chrome closes the
+ * pipe) or a handler calls process.exit. Delegates to main() so the direct
+ * require.main path below is unchanged.
+ */
+export async function runNativeHost() {
+    main();
+}
+function bundledInExe() {
+    try {
+        return typeof __STIKFIX_BUNDLED__ !== 'undefined' && __STIKFIX_BUNDLED__ === true;
+    }
+    catch {
+        return false;
+    }
+}
+// Run only when invoked as the entry point (standalone stikfix-native.cjs),
+// never on import. In that esbuild CJS bundle `require`/`module` are CJS scope
+// locals and `require.main === module` is true when run directly. The node:test
+// compile path emits ESM where these are undefined at runtime — the `typeof`
+// guards keep main() from running on import there.
+if (!bundledInExe() &&
+    typeof require !== 'undefined' &&
     typeof module !== 'undefined' &&
     require.main === module) {
     main();

package/dist/host/src/server.js

@@ -16,6 +16,7 @@ import { withSerialLock, getNextSerial } from './serial.js';
 import { writeNote } from './write-note.js';
 import { listAnnotations, editNote, deleteNote } from './read-note.js';
 import { validateChosenFolder } from './validate-folder.js';
+import { isGitRepo, getLastGitSyncStatus, gitSyncNote } from './git-sync.js';
 // ---------------------------------------------------------------------------
 // Per-request notes-dir resolution (D-04 — targetDir support)
 // ---------------------------------------------------------------------------
@@ -81,7 +82,7 @@ function setPreflightHeaders(req, res) {
 // ---------------------------------------------------------------------------
 // Route handlers
 // ---------------------------------------------------------------------------
-function handleStatus(req, res, cfg) {
+async function handleStatus(req, res, cfg) {
     setCorsHeaders(req, res);
     const body = JSON.stringify({
         app: 'stikfix',
@@ -90,6 +91,10 @@ function handleStatus(req, res, cfg) {
         root: cfg.root,
         notesDir: cfg.notesDir,
         origins: cfg.origins,
+        // git-sync surface (shared contract): is cfg.root a git work tree, and the
+        // result of the most recent git-sync attempt (null if none yet).
+        gitRepo: await isGitRepo(cfg.root),
+        gitSyncStatus: getLastGitSyncStatus(),
     });
     res.writeHead(200, { 'Content-Type': 'application/json' });
     res.end(body);
@@ -162,12 +167,21 @@ async function handleAnnotation(req, res, cfg) {
     //    Writes are confined to <notesDir> (= cfg.notesDir OR <validated targetDir>/notes).
     //    targetDir is NOT persisted into the note frontmatter (routing-only field).
     try {
+        let serialNum = 0;
         const { file, serial } = await withSerialLock(async () => {
-            const serialNum = getNextSerial(notesDir);
+            serialNum = getNextSerial(notesDir);
             return writeNote(notesDir, payload, serialNum);
         });
         res.writeHead(200, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ ok: true, file, serial }));
+        // git-sync (opt-in) — AFTER the 200 is sent, outside withSerialLock, and
+        // fire-and-forget so Send stays instant. Runs iff the CLI/machine default
+        // (cfg.gitSync) OR the per-send flag (payload.gitSync) is true. Its own queue
+        // serializes concurrent notes; .catch-guarded so it can never crash the host.
+        const doSync = cfg.gitSync === true || payload.gitSync === true;
+        if (doSync) {
+            void gitSyncNote({ root: cfg.root, notesDir, serial: serialNum }).catch(() => { });
+        }
     }
     catch (e) {
         // CR-02: propagate statusCode from write-phase errors (e.g. bad screenshot → 400)
@@ -384,7 +398,13 @@ export function createHostServer(cfg) {
             return;
         }
         if (method === 'GET' && path === '/status') {
-            handleStatus(req, res, cfg);
+            handleStatus(req, res, cfg).catch((e) => {
+                if (!res.headersSent) {
+                    setCorsHeaders(req, res);
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ ok: false, error: String(e) }));
+                }
+            });
             return;
         }
         if (method === 'POST' && path === '/annotation') {

package/dist/host/stikfix-init.cjs

@@ -30,6 +30,8 @@ var REG_CHROME_KEY = `HKCU\\Software\\Google\\Chrome\\NativeMessagingHosts\\${NA
 var REG_EDGE_KEY = `HKCU\\Software\\Microsoft\\Edge\\NativeMessagingHosts\\${NATIVE_HOST_NAME}`;
 var REG_FIREFOX_KEY = `HKCU\\Software\\Mozilla\\NativeMessagingHosts\\${NATIVE_HOST_NAME}`;
 var DEFAULT_GECKO_ID = "stikfix@stikfix.com";
+var CONFIG_DIR = (home) => (0, import_node_path2.join)(home, ".config", "stikfix");
+var CONFIG_PATH = (home) => (0, import_node_path2.join)(CONFIG_DIR(home), "config.json");
 var LAUNCHER_BATCH_FILENAME = "stikfix-host.bat";
 var LAUNCHER_VBS_FILENAME = "stikfix-host.vbs";
 var LAUNCHER_LNK_FILENAME = "Stikfix Host.lnk";
@@ -176,14 +178,17 @@ function createLauncherFiles(opts) {
   const hostEntry = opts.hostEntryPath;
   const rootArg = opts.root;
   const portArg = opts.port !== void 0 ? ` --port ${opts.port}` : "";
+  const useExe = typeof opts.hostExe === "string" && opts.hostExe.length > 0;
+  const hostExe = opts.hostExe ?? "";
   if (plat === "win32") {
+    const batchLaunch = useExe ? `"${hostExe}" serve --root "${rootArg}"${portArg}` : `"${nodeCmd}" "${hostEntry}" --root "${rootArg}"${portArg}`;
     const batchContent = [
       "@echo off",
       `rem Stikfix HTTP host launcher \u2014 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;
@@ -191,17 +196,20 @@ function createLauncherFiles(opts) {
     written.push(batchPath);
     const vq = (s) => s.replace(/"/g, '""');
     const vbsHostEntry = vq(hostEntry);
+    const vbsHostExe = vq(hostExe);
     const vbsRoot = vq(rootArg);
     const vbsPortArg = opts.port !== void 0 ? ` --port ${opts.port}` : "";
+    const vbsRunLine = useExe ? `sh.Run "cmd /c """ & 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."',
@@ -218,21 +226,22 @@ function createLauncherFiles(opts) {
     (0, import_node_fs.writeFileSync)(vbsPath, vbsContent, { encoding: "utf8" });
     written.push(vbsPath);
     if (paths.shortcut) {
-      const lnkPath = paths.shortcut;
+      const guessedLnkPath = paths.shortcut;
       const iconPath = opts.iconPath ?? "";
-      const safeLnkPath = lnkPath.replace(/'/g, "''");
+      const safeLnkFileName = LAUNCHER_LNK_FILENAME.replace(/'/g, "''");
       const safeIconPath = iconPath.replace(/'/g, "''");
       const wscriptPath = (0, import_node_path2.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}');$s.TargetPath = '${safeWscript}';$s.Arguments = '"${safeVbsPath}"';$s.Description = 'Start the Stikfix HTTP backend host';` + (safeIconPath ? `$s.IconLocation = '${safeIconPath},0';` : "") + `$s.Save()`;
+      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();Write-Output $lnkPath`;
       try {
-        (0, import_node_child_process.execFileSync)(
+        const stdout = (0, import_node_child_process.execFileSync)(
           "powershell.exe",
           ["-NoProfile", "-NonInteractive", "-Command", psScript],
-          { timeout: 15e3, stdio: "ignore" }
+          { timeout: 15e3, encoding: "utf8" }
         );
-        written.push(lnkPath);
+        const resolvedLnkPath = stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).pop() ?? guessedLnkPath;
+        written.push(resolvedLnkPath);
       } catch (err) {
         warnings.push(
           `Desktop shortcut creation failed (non-fatal): ${String(err.message)}. The batch file at ${batchPath} can be used directly.`
@@ -245,7 +254,7 @@ function createLauncherFiles(opts) {
       `# Stikfix HTTP host launcher \u2014 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;
     (0, import_node_fs.writeFileSync)(commandPath, commandContent, { encoding: "utf8", mode: 493 });
@@ -256,7 +265,7 @@ 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;
     (0, import_node_fs.writeFileSync)(shPath, shContent, { encoding: "utf8" });
@@ -321,8 +330,8 @@ function registerNativeHost(opts) {
   const home = opts.home ?? (0, import_node_os.homedir)();
   const browser = opts.browser ?? "chrome";
   const manifestPath = nativeManifestPath(plat, home, browser);
-  const wrapperPath = writeNativeWrapper(opts.hostBinPath, plat, home, browser);
-  const manifest = buildManifest(opts.extensionId, wrapperPath, browser);
+  const manifestTarget = opts.directPath ? (0, import_node_path2.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) => {
@@ -373,6 +382,34 @@ function unregisterNativeHost(opts = {}) {
     }
   }
 }
+function teardownHost(opts = {}) {
+  const plat = opts.plat ?? process.platform;
+  const home = opts.home ?? (0, import_node_os.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 {
+    (0, import_node_fs.rmSync)(result.configPath, { force: true });
+    result.configRemoved = true;
+  } catch {
+    result.configRemoved = false;
+  }
+  return result;
+}
 
 // host/src/extension-id.ts
 var import_node_crypto2 = require("node:crypto");
@@ -430,8 +467,8 @@ function resolveStartupChoice(forceOn, forceOff, isTTY) {
   }
   return false;
 }
-var CONFIG_DIR = (0, import_node_path3.join)((0, import_node_os2.homedir)(), ".config", "stikfix");
-var CONFIG_PATH = (0, import_node_path3.join)(CONFIG_DIR, "config.json");
+var CONFIG_DIR2 = (0, import_node_path3.join)((0, import_node_os2.homedir)(), ".config", "stikfix");
+var CONFIG_PATH2 = (0, import_node_path3.join)(CONFIG_DIR2, "config.json");
 if (subcommand === "init") {
   const rawRoot = values["root"];
   const rawExtId = values["extension-id"];
@@ -449,9 +486,9 @@ if (subcommand === "init") {
   const name = (0, import_node_path3.basename)(root);
   const notesDir = (0, import_node_path3.join)(root, "notes");
   const hostEntryPath = (0, import_node_path3.resolve)((0, import_node_path3.join)(__dirname, "src", "index.js"));
-  (0, import_node_fs2.mkdirSync)(CONFIG_DIR, { recursive: true });
+  (0, import_node_fs2.mkdirSync)(CONFIG_DIR2, { recursive: true });
   const config = { root, name, notesDir, hostEntry: hostEntryPath, nodePath: process.execPath };
-  (0, import_node_fs2.writeFileSync)(CONFIG_PATH, JSON.stringify(config, null, 2), { encoding: "utf8", mode: 384 });
+  (0, import_node_fs2.writeFileSync)(CONFIG_PATH2, JSON.stringify(config, null, 2), { encoding: "utf8", mode: 384 });
   const hostBinPath = (0, import_node_path3.resolve)((0, import_node_path3.join)(__dirname, "stikfix-native.cjs"));
   try {
     registerNativeHost({ extensionId, hostBinPath, browser });
@@ -540,9 +577,9 @@ if (subcommand === "init") {
   console.log("");
   console.log("  2. Start the backend \u2014 double-click the desktop launcher:");
   if (process.platform === "win32") {
-    const lnkPath = (0, import_node_path3.join)((0, import_node_os2.homedir)(), "Desktop", "Stikfix Host.lnk");
+    const lnkPath = launcherResult.written.find((p) => p.endsWith(".lnk")) ?? "";
     const batchPath = launcherResult.written.find((p) => p.endsWith(".bat")) ?? "";
-    if ((0, import_node_fs2.existsSync)(lnkPath)) {
+    if (lnkPath && (0, import_node_fs2.existsSync)(lnkPath)) {
       console.log('       Desktop shortcut: "Stikfix Host" (icon on your Desktop)');
     } else if (batchPath) {
       console.log("       Batch file: " + batchPath);
@@ -567,17 +604,13 @@ if (subcommand === "init") {
   console.log("  npx --yes stikfix@latest init --root " + root);
 } else if (subcommand === "uninstall") {
   const browser = resolveBrowser(values["browser"]);
-  try {
-    unregisterNativeHost({ browser });
-  } catch (err) {
-    console.error("stikfix uninstall: error removing native-host manifest:", String(err));
+  const teardown = teardownHost({ browser });
+  if (teardown.manifestError) {
+    console.error("stikfix uninstall: error removing native-host manifest:", teardown.manifestError);
   }
-  try {
-    unregisterStartup();
-  } catch (err) {
-    console.error("stikfix uninstall: error removing startup entry:", String(err));
+  if (teardown.startupError) {
+    console.error("stikfix uninstall: error removing startup entry:", teardown.startupError);
   }
-  (0, import_node_fs2.rmSync)(CONFIG_PATH, { force: true });
   console.log("stikfix: native host unregistered.");
   console.log("  manifest removed");
   console.log("  launcher files removed");