claude-skills-manager 1.0.1

package/CLAUDE.md

@@ -0,0 +1,117 @@
+# Claude Skills Manager — notes for Claude Code
+
+A local web app for managing the skills in `~/.claude/skills`. A Node HTTP server
+on `127.0.0.1` serves a single page; the page is the whole interface.
+
+If you are reading this inside somebody's own copy, they made it through
+**Modify this app → Set it up**, and they want to change something. Read the
+invariants below before you do — several of them protect a file the user cannot
+afford to lose.
+
+## Run it
+
+```bash
+node server.js              # opens your browser
+SKILLS_NO_OPEN=1 node server.js   # headless; prints the URL instead
+```
+
+There is no build step, no test suite, and **no dependencies** — the whole thing
+is Node's standard library. `npm install` does nothing here.
+
+## The files
+
+```
+server.js            HTTP server, routing, the JSON API
+lib/skills.js        scans both scopes, resolves each skill's effective state
+lib/projects.js      finds project folders, remembers ones added by hand
+lib/settings.js      reads/writes skillOverrides — backups, atomic writes
+lib/frontmatter.js   SKILL.md frontmatter parser
+lib/paths.js         every path the app touches, plus legacy-data migration
+lib/platform.js      every difference between Windows, macOS and Linux
+lib/shortcut.js      desktop shortcuts on the three platforms
+lib/fork.js          making and managing someone's own copy of the app
+lib/app-info.js      what this copy is called, and how it was installed
+public/              the interface: index.html, app.js, styles.css
+tools/make-icon.js   draws assets/icon.{ico,png,icns} from scratch
+bin/                 the CLI entry point
+```
+
+## Invariants
+
+These are the things a reasonable-looking change quietly breaks. Treat them as
+constraints, not preferences.
+
+**Zero runtime dependencies.** Deliberate, not an accident. It means the
+published package is also the source, which is what lets someone fork it with a
+file copy and no toolchain. Do not add one to solve a problem the standard
+library can solve.
+
+**Never write `settings.json` directly.** Go through `lib/settings.js`, which
+copies the old file into `~/.claude/backups/` and then writes atomically via a
+temp file and a rename. If the existing file is invalid JSON it refuses to write
+rather than replacing something it could not read. This is the user's real
+Claude Code configuration; a truncated write costs them their setup.
+
+**Removing a skill moves it, never unlinks it.** Destination is
+`~/.claude/skills-trash/` (or `.claude/skills-trash/` inside a project). The only
+true delete is *Delete forever* in the Removed view, and it says so.
+
+**The API is token-guarded and loopback-only.** The server binds `127.0.0.1` and
+every `/api/` request must carry the per-run token from `server.js`. Do not add a
+route that skips the check, and do not bind to `0.0.0.0` — any page in any
+browser on the machine could then drive it.
+
+**Reveal paths come from an allowlist.** `POST /api/reveal-path` only accepts
+folders the app itself offered. Do not let it open an arbitrary path a request
+names.
+
+**All OS branching lives in `lib/platform.js`.** `lib/shortcut.js` is the one
+exception, because a `.lnk`, an `.app` bundle and a `.desktop` file have nothing
+in common to abstract. Anywhere else, use the helpers.
+
+**Compare paths with `platform.samePath` / `pathKey`, never `.toLowerCase()`.**
+Windows and macOS are case-insensitive; Linux is not, and lowercasing there
+silently merges two genuinely different folders into one.
+
+**The live-instance record is per install.** `lib/paths.js` keys the session file
+by a hash of the install directory. Share it between copies and launching a
+modified copy hands you the original's window instead, discarding every change
+the user made without a word.
+
+**Project settings go in `.claude/settings.local.json`.** The gitignored one, so
+the app never dirties a file the user's repo shares with other people.
+
+## Node version
+
+Node 18+. `server.js` uses global `fetch` and `AbortSignal.timeout`.
+
+## Things worth knowing
+
+- **State lives in `~/.claude/skills-manager/`**, not in the install directory.
+  Under `npx` the install directory is a cache npm replaces on every update.
+- **Effective state is computed, not stored.** A skill's setting comes from
+  `skillOverrides` plus its own frontmatter — `disable-model-invocation: true`
+  rules out *Auto* and *Name only* no matter what the settings file says. See
+  `lib/skills.js`.
+- **The page renders from one `/api/state` payload.** Most actions post a change
+  and get fresh state back, then re-render. Follow that pattern rather than
+  mutating the DOM from a handler.
+- **Undo/redo is client-side history over the same API.** See `pushHistory` and
+  `applyEntry` in `public/app.js`.
+- **The server stops on its own** once no page has checked in for ~2.5 minutes,
+  because a shortcut launch leaves no window to close.
+
+## Testing changes
+
+There is no test suite. What is worth doing by hand after a change:
+
+1. `SKILLS_NO_OPEN=1 node server.js`, then load the printed URL.
+2. Change one skill's setting; confirm a new file appeared in
+   `~/.claude/backups/` and `settings.json` is still valid JSON.
+3. Undo it, and confirm the setting comes back.
+4. Turn Default Claude mode on and off; confirm every skill returns to the
+   setting it had.
+
+**This app edits your real Claude Code configuration.** Testing carelessly has
+consequences — though every write is backed up first, so mistakes are
+recoverable from `~/.claude/backups/`.

package/CONTRIBUTING.md

@@ -0,0 +1,46 @@
+# Contributing
+
+Bug reports and pull requests are welcome.
+
+## Running it
+
+```bash
+git clone https://github.com/npd1987/claude-skills-manager.git
+cd claude-skills-manager
+node server.js
+```
+
+Node 18 or newer. There is nothing to install — see below.
+
+## The one rule
+
+**No dependencies.** The app uses only Node's standard library, and that is a
+feature rather than an oversight: it means the published package *is* the
+source, so anyone can fork it with a plain file copy and no toolchain. A pull
+request that adds a runtime dependency will be asked to solve the problem
+another way, however small the package.
+
+Development-only tooling is a different conversation, but the bar is still high.
+
+## Before opening a pull request
+
+[CLAUDE.md](CLAUDE.md) lists the invariants worth knowing — how settings are
+written, why paths are compared the way they are, where OS-specific code
+belongs. It is written for Claude Code but it is the best short description of
+the codebase for anyone.
+
+There is no test suite. The manual pass at the end of CLAUDE.md is what to run.
+Please say in the pull request which platforms you actually tried it on;
+Windows, macOS and Linux each have their own code paths for opening a browser,
+revealing a folder, and installing a shortcut.
+
+## Reporting a bug
+
+Include your OS, your Node version (`node --version`), and how you installed it
+(`npx`, `npm i -g`, or a clone). Those three decide which code path you were on.
+
+## Changing it just for yourself
+
+You do not need to contribute anything back. **Modify this app → Set it up**
+inside the app gives you your own copy to change however you like, and you can
+point your shortcut at it instead of this one.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 npd1987
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,259 @@
+# Claude Skills Manager
+
+A local interface for the skills in `~/.claude/skills` — see every skill you have
+installed, what state each one is in, and change that state without hand-editing
+`settings.json`.
+
+Windows, macOS and Linux. Free, MIT licensed, and no dependencies: the whole app
+is Node's standard library, down to the icon.
+
+![The skills list, grouped by what each skill can actually do](https://raw.githubusercontent.com/npd1987/claude-skills-manager/main/docs/screenshot-main.png)
+
+## Install
+
+One command, the same on every platform:
+
+```bash
+npx claude-skills-manager
+```
+
+That's the whole thing — it downloads, starts, and opens in your browser. Needs
+[Node.js](https://nodejs.org) 18 or newer, and nothing else.
+
+Launching it again while it's already running reopens the existing tab rather
+than starting a second copy.
+
+**Stopping it.** Use **Quit** in the top right, or just close the tab — the page
+checks in while it's open, and the server shuts itself down about 15 seconds
+after the last one goes away. It never lingers in the background. Reloading is
+safe.
+
+### A shortcut instead of a command
+
+If you would rather launch it from your Start menu, Dock or app launcher,
+install it properly first so it has a permanent home:
+
+```bash
+npm i -g claude-skills-manager
+claude-skills-manager install-shortcut
+```
+
+That writes a Start-menu entry on Windows, an app bundle in `~/Applications` on
+macOS, and a `.desktop` entry on Linux. Add `--desktop` for a desktop copy too,
+and `uninstall-shortcut` removes them again.
+
+### Make it your own
+
+The app can hand you your own copy to change in Claude Code — the sidebar's
+**Modify this app** card walks you through it, including whether your version
+sits alongside this one or replaces it.
+
+![Choosing whether your copy sits alongside this one or replaces it](https://raw.githubusercontent.com/npd1987/claude-skills-manager/main/docs/screenshot-modify.png)
+
+From a terminal, the same thing is:
+
+```bash
+npx claude-skills-manager dev
+```
+
+You get a full working copy plus a `CLAUDE.md` explaining the architecture, so
+Claude Code can start changing it straight away rather than reading its way in.
+See [CONTRIBUTING.md](CONTRIBUTING.md) if you want to send something back.
+
+## Global and project skills
+
+The **Global / Projects** switch at the top of the sidebar chooses between the
+two places skills live. It sits above the filter list because it governs it —
+switching scope re-computes every count below. Skills that ship with Claude Code
+are never listed, because they aren't yours to manage here.
+
+**Global** — `~/.claude/skills`, available in every project. Settings go in
+`~/.claude/settings.json`.
+
+**Projects** — skills inside a single folder's `.claude/skills`, which only
+exist for Claude Code sessions run there. Cards are grouped by folder, and the
+sidebar filters narrow across all folders at once. Settings go in that project's
+`.claude/settings.local.json` — the gitignored file — so this app never dirties a
+file your repo shares with other people.
+
+Two badges only appear on project skills:
+
+- **project only** — the name exists nowhere else
+- **overrides global** — a global skill has the same name, and inside this folder
+  the project one wins
+
+Because project settings sit above global ones, setting a project skill to *Auto*
+sometimes writes an explicit `"on"` rather than removing the entry — otherwise
+the global value would show through. The app handles that for you.
+
+### Which folders it looks in
+
+Every folder you've run a Claude Code session in — it recovers the real paths
+from the session records. A folder needs one session, ever; after that any skill
+you add there shows up on the next Refresh.
+
+For a folder Claude Code has never opened, use **Add folder** on the count line.
+It opens the standard Windows folder picker (a browser can't be given a real
+path by dragging, so a picker is the only reliable way). Added folders are
+remembered in `data/folders.json`.
+
+**Default Claude mode applies to global skills only.** Project skills are left
+alone.
+
+Skills are grouped by how they actually behave:
+
+| Group | Meaning |
+| :--- | :--- |
+| **Auto** | Claude can decide to load the skill on its own, and `/name` works |
+| **Name only** | Claude sees the skill's name but not its full description |
+| **Slash only** | Runs only when you type `/name` — Claude never reaches for it |
+| **Off** | Disabled entirely; the files stay on disk |
+
+## The four settings
+
+The buttons on each card write to `skillOverrides` in `~/.claude/settings.json`.
+They carry the same four names as the sidebar, so a skill's button and its
+section always agree:
+
+| Button | Written as | Notes |
+| :--- | :--- | :--- |
+| **Auto** | *(no entry)* | Claude's default, so this removes the override |
+| **Name only** | `"name-only"` | |
+| **Slash only** | `"user-invocable-only"` | |
+| **Off** | `"off"` | |
+
+Buttons that a skill's own frontmatter rules out are **struck through and
+disabled**, with a tooltip saying why. For a skill with
+`disable-model-invocation: true` that's *Auto* and *Name only* — they'd behave
+identically to *Slash only*, so offering them as real choices would be a lie.
+Such a skill shows **Slash only** as its selected button even when it has no
+override at all, because that is what it actually does.
+
+### Sorting
+
+The **Sort** control sits at the right of the count line: **Name (A–Z)**,
+**Newest installed**, **Oldest installed**, or **Recently changed**. On the All
+skills page it sorts *within* each section, so the grouping still reads first.
+Your choice is remembered between sessions.
+
+Install dates come from when a skill's folder appeared in `~/.claude/skills`, so
+a skill copied in from elsewhere dates from the copy rather than from when it was
+first written. Each card shows its date under the description.
+
+### Descriptions and paths
+
+Every view has a description folded away on the count line — *45 of 45 skills ·
+**What this app does***. Click to expand it; it slides open and holds the
+explanation, when to reach for that setting, and the folders involved
+(**Skills folder** and **Settings file**, each with an *Open* button that reveals
+it in Explorer). The Removed view shows the trash folder instead.
+
+### Cards stay where you clicked them
+
+Changing a setting saves immediately, but the card does **not** jump to its new
+section. It stays put, shows the new setting, and picks up a blue
+**moves to Off** tag telling you where it will land. The sidebar counts update
+straight away, so the new grouping is visible there at once.
+
+Press **Refresh** whenever you want the list itself regrouped. Switching views
+regroups too.
+
+### Undo and redo
+
+**↶ Undo** and **Redo ↷** sit in the top bar — `Ctrl+Z` and `Ctrl+Y` also work.
+Hovering either one tells you exactly what it will do, e.g.
+*Undo: tdd: Slash only → Off*.
+
+They cover setting changes, Default Claude mode, orphan cleanup, and removals —
+undoing a removal puts the folder back *and* restores the setting it had. The
+history survives a page reload and is cleared when you close the tab.
+
+The single exception is **Delete forever** in the Removed view. That one really
+is permanent, and the dialog says so; using it clears any history entries that
+referred to the deleted folder.
+
+### Two reasons a skill is slash-only
+
+The difference matters:
+
+1. **Your setting here** — changeable any time from this app.
+2. **The skill's own frontmatter** — `disable-model-invocation: true` inside its
+   `SKILL.md`. Cards showing a **locked to /** tag are in this category, and
+   their *Auto* and *Name only* buttons are struck through: the skill's author
+   ruled those out, and changing it means editing the `SKILL.md`.
+
+The sidebar counts tell you how many of yours fall into each category.
+
+## Default Claude mode
+
+The sidebar switch turns every skill off in one move, for when you want plain
+out-of-the-box Claude. Your per-skill settings are snapshotted to
+`data/snapshot.json` first, and the panel then reads **Default Claude mode is
+on**.
+
+There are two equally good ways back, and both restore every skill to the exact
+setting it had:
+
+- **Bring my skills back** — the sidebar button.
+- **Undo** — `Ctrl+Z`, or the button in the top bar.
+
+They are the same operation, so they stay in step: undoing the restore puts you
+back in Default Claude mode, snapshot and all, and redo works from either
+direction. Both the settings and the snapshot are written by one request, which
+is what keeps the sidebar switch from ever disagreeing with the skills
+themselves.
+
+## Removing skills
+
+**Remove** moves a skill's folder to `~/.claude/skills-trash/` — it is never
+unlinked. Restore it from **Removed** in the sidebar, or delete it for good from
+there once you're sure.
+
+If you only want Claude to stop using a skill, use **Off** instead. It keeps the
+skill exactly where it is.
+
+## Safety
+
+- Every write to `settings.json` copies the old file to `~/.claude/backups/`
+  first (the last 40 are kept), then writes atomically via a temp file + rename.
+- If `settings.json` ever contains invalid JSON, the app refuses to write and
+  tells you, rather than replacing a file it could not read.
+- The server binds to `127.0.0.1` only and requires a random per-run token, so no
+  other page or process on the machine can drive it.
+
+## Restart Claude Code after changing settings
+
+Claude Code reads `skillOverrides` when a session starts. Changes here apply to
+your **next** session.
+
+## Layout
+
+```
+server.js            HTTP server + JSON API
+bin/                 the command-line entry point
+lib/skills.js        scans both scopes, resolves effective state
+lib/projects.js      finds project folders, remembers added ones
+lib/settings.js      reads/writes skillOverrides, backups, atomic writes
+lib/frontmatter.js   SKILL.md frontmatter parser
+lib/paths.js         every path the app touches
+lib/platform.js      every Windows/macOS/Linux difference
+lib/shortcut.js      desktop shortcuts on the three platforms
+lib/fork.js          making and managing your own copy
+lib/app-info.js      what this copy is called, and how it was installed
+public/              the interface
+tools/make-icon.js   draws assets/icon.{ico,png,icns}
+launch.vbs           windowless launcher used by the Windows shortcut
+install-shortcut.ps1 creates/removes the Start menu shortcut
+```
+
+Your settings and folder list live outside the app, in
+`~/.claude/skills-manager/`, so they survive an update:
+
+```
+snapshot.json        created only while Default Claude mode is on
+folders.json         folders you added by hand
+sessions/            one file per installed copy, recording the live instance
+```
+
+[CLAUDE.md](CLAUDE.md) goes further — the invariants a change must not break,
+and how to test one.

package/Skills.cmd

@@ -0,0 +1,14 @@
+@echo off
+title Claude Skills Manager
+cd /d "%~dp0"
+
+where node >nul 2>nul
+if errorlevel 1 (
+  echo Node.js was not found on your PATH.
+  echo Install it from https://nodejs.org and run this again.
+  pause
+  exit /b 1
+)
+
+node server.js
+pause

package/bin/claude-skills-manager.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+'use strict';
+
+// Subcommands are required lazily: starting the server should not pay to load
+// the shortcut writer, and `--help` should work even on a platform where some
+// other part of the app cannot.
+
+const { NAME, VERSION, PACKAGE_NAME } = require('../lib/app-info');
+
+const HELP = `
+  ${NAME} ${VERSION}
+
+  Usage
+    ${PACKAGE_NAME}                      start it and open the app
+    ${PACKAGE_NAME} dev [folder]         make your own copy to change in Claude Code
+    ${PACKAGE_NAME} install-shortcut     add a desktop/Start-menu shortcut
+    ${PACKAGE_NAME} uninstall-shortcut   remove it again
+
+  Options
+    --desktop      install-shortcut: also put one on the desktop
+    --name <name>  install-shortcut: name it something else, so a copy of the
+                   app can sit alongside the original
+    --help, --version
+
+  Environment
+    SKILLS_NO_OPEN=1   don't open a browser, just print the URL
+`;
+
+function fail(message) {
+  console.error(`\n  ${message}\n`);
+  process.exit(1);
+}
+
+/** Pulls `--flag value` and bare `--flag` out of the remaining arguments. */
+function parseFlags(argv) {
+  const flags = { _: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg.startsWith('--')) {
+      flags._.push(arg);
+      continue;
+    }
+    const key = arg.slice(2);
+    const next = argv[i + 1];
+    if (next && !next.startsWith('--')) {
+      flags[key] = next;
+      i++;
+    } else {
+      flags[key] = true;
+    }
+  }
+  return flags;
+}
+
+async function main() {
+  const [command, ...rest] = process.argv.slice(2);
+  const flags = parseFlags(rest);
+
+  switch (command) {
+    case undefined:
+      return require('../server').start();
+
+    case 'dev':
+    case 'fork': {
+      const fork = require('../lib/fork');
+      const result = await fork.run({ dir: flags._[0], name: flags.name });
+      console.log(fork.describe(result));
+      return;
+    }
+
+    case 'install-shortcut': {
+      const shortcut = require('../lib/shortcut');
+      const created = shortcut.install({ desktop: Boolean(flags.desktop), name: flags.name });
+      for (const line of created) console.log(`  Created ${line}`);
+      console.log(`\n  Launch it by searching for "${flags.name || NAME}".\n`);
+      return;
+    }
+
+    case 'uninstall-shortcut': {
+      const shortcut = require('../lib/shortcut');
+      const removed = shortcut.uninstall({ name: flags.name });
+      if (!removed.length) return console.log('\n  Nothing to remove.\n');
+      for (const line of removed) console.log(`  Removed ${line}`);
+      console.log('');
+      return;
+    }
+
+    case 'help':
+    case '--help':
+    case '-h':
+      return console.log(HELP);
+
+    case 'version':
+    case '--version':
+    case '-v':
+      return console.log(VERSION);
+
+    default:
+      console.log(HELP);
+      fail(`Unknown command: ${command}`);
+  }
+}
+
+main().catch((err) => fail(err && err.message ? err.message : String(err)));

package/install-shortcut.ps1

@@ -0,0 +1,62 @@
+<#
+  Creates a "Claude Skills" shortcut in your Start menu.
+
+    .\install-shortcut.ps1                    # Start menu
+    .\install-shortcut.ps1 -Desktop           # Start menu + Desktop
+    .\install-shortcut.ps1 -Remove            # delete the shortcuts again
+    .\install-shortcut.ps1 -Name "My Skills"  # name it something else, so your
+                                              # own copy can sit beside the
+                                              # original instead of replacing it
+
+  Normally driven by `claude-skills-manager install-shortcut`, which passes
+  -Name for you. It still works on its own.
+
+  The shortcut targets wscript.exe (a real executable), which is what lets
+  Windows pin it to the Start menu and the taskbar.
+#>
+[CmdletBinding()]
+param(
+  [switch]$Desktop,
+  [switch]$Remove,
+  [string]$Name = 'Claude Skills'
+)
+
+$ErrorActionPreference = 'Stop'
+
+$appDir   = $PSScriptRoot
+$startDir = [Environment]::GetFolderPath('Programs')
+$targets  = @(Join-Path $startDir "$Name.lnk")
+
+if ($Desktop -or $Remove) {
+  $targets += Join-Path ([Environment]::GetFolderPath('Desktop')) "$Name.lnk"
+}
+
+if ($Remove) {
+  foreach ($path in $targets) {
+    if (Test-Path $path) { Remove-Item $path -Force; "Removed $path" }
+  }
+  return
+}
+
+$icon = Join-Path $appDir 'assets\icon.ico'
+if (-not (Test-Path $icon)) {
+  & node (Join-Path $appDir 'tools\make-icon.js') | Out-Null
+}
+
+$launcher = Join-Path $appDir 'launch.vbs'
+if (-not (Test-Path $launcher)) { throw "Cannot find $launcher" }
+
+$wscript = Join-Path $env:SystemRoot 'System32\wscript.exe'
+$shell = New-Object -ComObject WScript.Shell
+
+foreach ($path in ($targets | Select-Object -Unique)) {
+  $lnk = $shell.CreateShortcut($path)
+  $lnk.TargetPath       = $wscript
+  $lnk.Arguments        = '"{0}"' -f $launcher
+  $lnk.WorkingDirectory = $appDir
+  $lnk.IconLocation     = "$icon,0"
+  $lnk.Description      = 'See and manage your Claude Code skills'
+  $lnk.WindowStyle      = 7   # minimised; the launcher is windowless anyway
+  $lnk.Save()
+  "Created $path"
+}

package/launch.vbs

@@ -0,0 +1,19 @@
+' Starts Claude Skills with no console window, for the Start menu shortcut.
+' The server opens your browser itself, and quits from the app's Quit button.
+Option Explicit
+
+Dim fso, shell, here
+Set fso = CreateObject("Scripting.FileSystemObject")
+Set shell = CreateObject("WScript.Shell")
+
+here = fso.GetParentFolderName(WScript.ScriptFullName)
+shell.CurrentDirectory = here
+
+' Fail loudly rather than silently doing nothing if Node has gone missing.
+If shell.Run("cmd /c where node", 0, True) <> 0 Then
+  MsgBox "Claude Skills needs Node.js, which isn't on your PATH." & vbCrLf & vbCrLf & _
+         "Install it from https://nodejs.org and try again.", 16, "Claude Skills"
+  WScript.Quit 1
+End If
+
+shell.Run "cmd /c node """ & fso.BuildPath(here, "server.js") & """", 0, False