server-studio 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Md Mahdi Hasan
+
+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,121 @@
+# Server Studio
+
+A small dashboard for the local dev servers you actually run. Every project gets a card with
+its run command, folder and URL, so starting one is a click instead of a hunt through terminal
+history. It also keeps one permanent port per project, so a saved entry never goes stale.
+
+Node.js is the only requirement. No npm install inside the app, no Electron, no background daemon.
+
+## Install
+
+**macOS**
+
+```bash
+npx server-studio install
+```
+
+That copies the app to `/Applications` and installs the Claude Code skill. Then open it from
+Applications, or:
+
+```bash
+open -a "Server Studio"
+```
+
+**Windows and Linux**
+
+There is no app bundle to install, so run the dashboard directly:
+
+```bash
+npx server-studio start
+```
+
+It serves the same dashboard at `http://localhost:4587` and opens your browser. Add
+`npx server-studio install --no-app` first if you also want the Claude Code skill.
+
+To remove it again:
+
+```bash
+npx server-studio uninstall
+```
+
+Your saved servers are kept. Add `--purge` if you want those deleted too.
+
+| Option | What it does |
+|---|---|
+| `--no-app` | Skip the Mac app, install only the skill |
+| `--no-skill` | Skip the skill, install only the app |
+| `--dry-run` | Print what would happen, change nothing |
+| `--purge` | Uninstall only: also delete your saved server list |
+
+## What's in the box
+
+**The app.** A local dashboard at `127.0.0.1:4587`. Run a server (it opens in a real terminal
+window), stop it, open its URL, reveal its folder, and see at a glance which ports are live.
+
+**The Claude Code skill.** Ask Claude to build you something with a dev server and it registers the
+server for you, picking a free port and baking it into the project config so the port never drifts.
+
+**The Cowork plugin.** The same skill as a `/server-studio` command. Build it with
+`npm run build:plugin`, then open `dist/server-studio.plugin`.
+
+## Platform support
+
+| | macOS | Windows | Linux |
+|---|---|---|---|
+| Dashboard | yes | yes | yes |
+| Installable app | yes | run with `start` | run with `start` |
+| Run in a terminal | Terminal | Command Prompt | first of x-terminal-emulator, gnome-terminal, konsole, xfce4-terminal, xterm |
+| Stop a port | `lsof` + `kill` | `netstat` + `taskkill` | `lsof` + `kill` |
+| Browse for a folder | native dialog | native dialog | needs `zenity`, otherwise type the path |
+
+Windows and Linux support is written but has only been exercised on macOS, so treat the first run
+on those platforms as unproven. Bug reports welcome.
+
+## Your data
+
+Saved servers live in one file:
+
+| macOS | `~/Library/Application Support/Server Studio/data.json` |
+|---|---|
+| Windows | `%APPDATA%\Server Studio\data.json` |
+| Linux | `~/.config/server-studio/data.json` |
+
+It sits outside the app bundle, so installing, updating and uninstalling never touch it. Point
+`SERVER_STUDIO_DATA_DIR` somewhere else to use a different file, which is handy for testing against
+a throwaway list.
+
+## Security
+
+The app runs shell commands you saved, so it is deliberately locked to your own machine:
+
+- It binds to `127.0.0.1` only and is never reachable from the network.
+- Every write requires `Content-Type: application/json`, which blocks form-based CSRF from any
+  site you happen to have open.
+- Requests carrying a foreign `Origin` are rejected, and preflights are refused.
+
+Treat the run command on a card the way you would treat a line you are about to paste into your own
+terminal, because that is exactly what it becomes.
+
+## Development
+
+```bash
+npm run build:plugin   # rebuild dist/server-studio.plugin from skill/
+npm test               # install into a temp folder and check the result
+```
+
+`skill/` is the single source of truth for the skill. The plugin is built from it, so the two
+cannot drift apart.
+
+To run the app against a throwaway server list:
+
+```bash
+SERVER_STUDIO_DATA_DIR=/tmp/ss-test node src/server.js
+```
+
+`src/` holds the dashboard and the per-OS shims in `platform.js`, and is the only copy of that
+code. On macOS the installer copies it into the app bundle, so the bundle never holds a stale
+version.
+
+## License
+
+MIT

package/app/Server Studio.app/Contents/Info.plist

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleName</key>
+  <string>Server Studio</string>
+  <key>CFBundleDisplayName</key>
+  <string>Server Studio</string>
+  <key>CFBundleIdentifier</key>
+  <string>com.mhasan.serverstudio</string>
+  <key>CFBundleVersion</key>
+  <string>1.0</string>
+  <key>CFBundleShortVersionString</key>
+  <string>1.0</string>
+  <key>CFBundlePackageType</key>
+  <string>APPL</string>
+  <key>CFBundleExecutable</key>
+  <string>ServerStudio</string>
+  <key>CFBundleIconFile</key>
+  <string>AppIcon</string>
+  <key>LSMinimumSystemVersion</key>
+  <string>10.13</string>
+  <key>NSHighResolutionCapable</key>
+  <true/>
+</dict>
+</plist>

package/app/Server Studio.app/Contents/MacOS/ServerStudio

@@ -0,0 +1,21 @@
+#!/bin/bash
+# Launcher for Server Studio.app
+HERE="$(cd "$(dirname "$0")" && pwd)"
+RES="$(cd "$HERE/../Resources" && pwd)"
+
+# Make sure common Node install locations are on PATH
+export PATH="/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:$PATH"
+
+NODE="$(command -v node)"
+if [ -z "$NODE" ]; then
+  for p in /opt/homebrew/bin/node /usr/local/bin/node "$HOME"/.nvm/versions/node/*/bin/node; do
+    [ -x "$p" ] && NODE="$p" && break
+  done
+fi
+
+if [ -z "$NODE" ]; then
+  osascript -e 'display dialog "Server Studio needs Node.js.\n\nInstall it from https://nodejs.org then open this app again." with title "Server Studio" buttons {"OK"} default button "OK" with icon caution'
+  exit 1
+fi
+
+exec "$NODE" "$RES/server.js"

package/app/Server Studio.app/Contents/PkgInfo

@@ -0,0 +1 @@
+APPL????

package/bin/cli.js

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+// Server Studio installer. Node built-ins only, no dependencies.
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const ROOT = path.join(__dirname, '..');
+const APP_NAME = 'Server Studio.app';
+const APP_SRC = path.join(ROOT, 'app', APP_NAME);
+const SRC = path.join(ROOT, 'src');
+const MAC = process.platform === 'darwin';
+const APP_DEST = process.env.SERVER_STUDIO_APP_DEST || path.join('/Applications', APP_NAME);
+const SKILL_SRC = path.join(ROOT, 'skill');
+const SKILL_DEST = process.env.SERVER_STUDIO_SKILL_DEST ||
+  path.join(os.homedir(), '.claude', 'skills', 'server-studio');
+
+
+const args = process.argv.slice(2);
+let DATA_DIR;
+const has = f => args.includes(f);
+const cmd = has('-h') || has('--help') ? 'help' : (args.find(a => !a.startsWith('-')) || 'install');
+const DRY = has('--dry-run');
+
+function die(msg) { console.error('error: ' + msg); process.exit(1); }
+function ok(msg) { console.log('  ok  ' + msg); }
+function skip(msg) { console.log('  --  ' + msg); }
+
+function dataDir() {
+  if (process.env.SERVER_STUDIO_DATA_DIR) return process.env.SERVER_STUDIO_DATA_DIR;
+  if (MAC) return path.join(os.homedir(), 'Library', 'Application Support', 'Server Studio');
+  if (process.platform === 'win32') {
+    return path.join(process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming'), 'Server Studio');
+  }
+  return path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'), 'server-studio');
+}
+
+function hasNode() {
+  try { execFileSync('/usr/bin/env', ['which', 'node'], { stdio: 'ignore' }); return true; }
+  catch (e) { return false; }
+}
+
+/* ---------- install ---------- */
+function install() {
+  DATA_DIR = dataDir();
+  if (DRY) {
+    console.log('Dry run, nothing will be written.\n');
+    console.log('  app   -> ' + APP_DEST);
+    console.log('  skill -> ' + SKILL_DEST);
+    console.log('  data  -> ' + path.join(DATA_DIR, 'data.json') + '  (created only if missing)');
+    return;
+  }
+  console.log('Installing Server Studio...\n');
+
+  if (!MAC) {
+    skip('Mac app skipped, this is ' + process.platform + '. Use:  npx server-studio start');
+  } else if (!has('--no-app')) {
+    if (fs.existsSync(APP_DEST)) {
+      fs.rmSync(APP_DEST, { recursive: true, force: true });
+      fs.cpSync(APP_SRC, APP_DEST, { recursive: true });
+      ok('app updated at ' + APP_DEST);
+    } else {
+      fs.cpSync(APP_SRC, APP_DEST, { recursive: true });
+      ok('app installed at ' + APP_DEST);
+    }
+    // cpSync does not preserve the exec bit on the launcher.
+    // src/ is the single source of truth, copied into the bundle at install time.
+    fs.cpSync(SRC, path.join(APP_DEST, 'Contents', 'Resources'), { recursive: true });
+    fs.chmodSync(path.join(APP_DEST, 'Contents', 'MacOS', 'ServerStudio'), 0o755);
+  } else skip('app skipped (--no-app)');
+
+  if (!has('--no-skill')) {
+    fs.mkdirSync(path.dirname(SKILL_DEST), { recursive: true });
+    fs.rmSync(SKILL_DEST, { recursive: true, force: true });
+    fs.cpSync(SKILL_SRC, SKILL_DEST, { recursive: true });
+    ok('Claude Code skill at ' + SKILL_DEST);
+  } else skip('skill skipped (--no-skill)');
+
+  // Your saved servers live outside the app, so installing never touches them.
+  fs.mkdirSync(DATA_DIR, { recursive: true });
+  const dataFile = path.join(DATA_DIR, 'data.json');
+  if (!fs.existsSync(dataFile)) {
+    fs.writeFileSync(dataFile, '[]');
+    ok('created empty server list at ' + dataFile);
+  } else {
+    ok('kept existing server list (' + JSON.parse(fs.readFileSync(dataFile, 'utf8') || '[]').length + ' servers)');
+  }
+
+  if (!hasNode()) {
+    console.log('\nnote: Node.js was not found on PATH. The app needs it to run.');
+  }
+
+  // npx wipes its cache after running, so the plugin is copied somewhere durable
+  // before its path is printed.
+  const pluginSrc = path.join(ROOT, 'dist', 'server-studio.plugin');
+  let pluginFile = null;
+  if (fs.existsSync(pluginSrc)) {
+    pluginFile = path.join(DATA_DIR, 'server-studio.plugin');
+    try { fs.copyFileSync(pluginSrc, pluginFile); }
+    catch (e) { pluginFile = null; }
+  }
+
+  console.log(MAC
+    ? '\nDone. Open it from Applications, or run:  open -a "Server Studio"'
+    : '\nDone. Start it with:  npx server-studio start');
+  if (pluginFile) {
+    console.log('\nUsing Claude Cowork? Install the plugin by opening this file:');
+    console.log('  ' + pluginFile);
+  }
+}
+
+/* ---------- uninstall ---------- */
+function uninstall() {
+  DATA_DIR = dataDir();
+  if (DRY) {
+    console.log('Dry run, nothing will be removed.\n');
+    console.log('  would remove ' + APP_DEST);
+    console.log('  would remove ' + SKILL_DEST);
+    console.log('  would keep   ' + DATA_DIR + (has('--purge') ? '  (--purge: would DELETE)' : ''));
+    return;
+  }
+  console.log('Removing Server Studio...\n');
+
+  if (MAC && fs.existsSync(APP_DEST)) { fs.rmSync(APP_DEST, { recursive: true, force: true }); ok('removed ' + APP_DEST); }
+  else if (MAC) skip('no app at ' + APP_DEST);
+
+  if (fs.existsSync(SKILL_DEST)) { fs.rmSync(SKILL_DEST, { recursive: true, force: true }); ok('removed ' + SKILL_DEST); }
+  else skip('no skill at ' + SKILL_DEST);
+
+  // The server list is the user's own data, so it survives unless asked for explicitly.
+  if (has('--purge')) {
+    if (fs.existsSync(DATA_DIR)) { fs.rmSync(DATA_DIR, { recursive: true, force: true }); ok('deleted saved servers at ' + DATA_DIR); }
+    else skip('no saved servers to delete');
+  } else if (fs.existsSync(DATA_DIR)) {
+    console.log('\nYour saved servers were kept at:\n  ' + DATA_DIR);
+    console.log('Delete them too with:  npx server-studio uninstall --purge');
+  }
+}
+
+function start() {
+  DATA_DIR = dataDir();
+  const { spawn } = require('child_process');
+  const server = path.join(SRC, 'server.js');
+  const child = spawn(process.execPath, [server], { stdio: 'inherit' });
+  child.on('exit', code => process.exit(code || 0));
+  process.on('SIGINT', () => { child.kill('SIGINT'); });
+}
+
+function help() {
+  console.log(`Server Studio
+
+  npx server-studio install      install the app + Claude Code skill
+  npx server-studio start        run the dashboard (works on macOS, Windows and Linux)
+  npx server-studio uninstall    remove them (keeps your saved servers)
+
+Options
+  --no-app        do not install the Mac app (ignored off macOS)
+  --no-skill      do not install the Claude Code skill
+  --purge         uninstall only: also delete your saved server list
+  --dry-run       print what would happen, change nothing
+`);
+}
+
+if (cmd === 'help') help();
+else if (cmd === 'install') install();
+else if (cmd === 'start') start();
+else if (cmd === 'uninstall') uninstall();
+else { console.error('unknown command: ' + cmd + '\n'); help(); process.exit(1); }

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "server-studio",
+  "version": "1.0.0",
+  "description": "A tiny dashboard for your local dev servers. One click to run, stop and open them, with one permanent port per project.",
+  "author": "Md Mahdi Hasan",
+  "license": "MIT",
+  "homepage": "https://github.com/mehdi214designer/server-studio#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mehdi214designer/server-studio.git"
+  },
+  "bugs": {
+    "url": "https://github.com/mehdi214designer/server-studio/issues"
+  },
+  "bin": {
+    "server-studio": "bin/cli.js"
+  },
+  "scripts": {
+    "build:plugin": "node scripts/build-plugin.js",
+    "prepack": "node scripts/build-plugin.js",
+    "test": "node scripts/test.js"
+  },
+  "files": [
+    "bin",
+    "app",
+    "src",
+    "skill",
+    "plugin",
+    "scripts",
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "localhost",
+    "dev-server",
+    "ports",
+    "dashboard",
+    "macos",
+    "windows",
+    "linux",
+    "claude-code",
+    "claude-skill"
+  ],
+  "engines": {
+    "node": ">=18"
+  }
+}

package/plugin/.claude-plugin/plugin.json

@@ -0,0 +1,6 @@
+{
+  "name": "server-studio",
+  "version": "1.0.0",
+  "description": "Save local dev servers into the Server Studio app, with one permanent unique port per project.",
+  "keywords": ["server", "localhost", "dev server", "ports"]
+}

package/plugin/README.md

@@ -0,0 +1,7 @@
+# Server Studio (Cowork plugin)
+
+Adds the `/server-studio` skill, which saves a project's local dev server into the
+Server Studio app so it is one click to run later.
+
+The skill source lives in `skill/` at the repo root. This plugin is built from it by
+`npm run build:plugin`, so the two can never drift apart.

package/scripts/build-plugin.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+// Builds dist/server-studio.plugin from skill/ + plugin/, so the plugin copy of the
+// skill can never drift from the source in skill/.
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const ROOT = path.join(__dirname, '..');
+const DIST = path.join(ROOT, 'dist');
+const OUT = path.join(DIST, 'server-studio.plugin');
+
+const stage = fs.mkdtempSync(path.join(os.tmpdir(), 'ss-plugin-'));
+const skillDir = path.join(stage, 'skills', 'server-studio');
+fs.mkdirSync(skillDir, { recursive: true });
+
+fs.cpSync(path.join(ROOT, 'skill'), skillDir, { recursive: true });
+fs.cpSync(path.join(ROOT, 'plugin'), stage, { recursive: true });
+
+fs.mkdirSync(DIST, { recursive: true });
+fs.rmSync(OUT, { force: true });
+// -r zips the staged tree; the plugin format is a plain zip.
+execFileSync('zip', ['-qr', OUT, '.', '-x', '.DS_Store'], { cwd: stage });
+fs.rmSync(stage, { recursive: true, force: true });
+
+console.log('built ' + path.relative(ROOT, OUT));

package/scripts/test.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+// End to end check: installs into a temp folder and attacks a temp server.
+// Never touches /Applications, ~/.claude or your real server list.
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const http = require('http');
+const { execFileSync, spawn } = require('child_process');
+
+const ROOT = path.join(__dirname, '..');
+const SB = fs.mkdtempSync(path.join(os.tmpdir(), 'ss-test-'));
+const PORT = 4400 + Math.floor(process.pid % 300);
+const env = {
+  ...process.env,
+  SERVER_STUDIO_APP_DEST: path.join(SB, 'Server Studio.app'),
+  SERVER_STUDIO_SKILL_DEST: path.join(SB, 'skill'),
+  SERVER_STUDIO_DATA_DIR: path.join(SB, 'data'),
+};
+
+let failed = 0;
+function check(name, pass, detail) {
+  console.log((pass ? '  pass  ' : '  FAIL  ') + name + (detail && !pass ? '  -> ' + detail : ''));
+  if (!pass) failed++;
+}
+
+function req(opts, body) {
+  return new Promise(resolve => {
+    const r = http.request({ host: '127.0.0.1', port: PORT, ...opts }, res => {
+      let b = ''; res.on('data', c => b += c); res.on('end', () => resolve({ code: res.statusCode, body: b }));
+    });
+    r.on('error', e => resolve({ code: 0, body: String(e) }));
+    if (body) r.write(body);
+    r.end();
+  });
+}
+
+(async () => {
+  console.log('sandbox: ' + SB + '\n');
+
+  // ---- installer ----
+  execFileSync('node', [path.join(ROOT, 'bin', 'cli.js'), 'install'], { env, stdio: 'ignore' });
+  check('app installed', fs.existsSync(path.join(env.SERVER_STUDIO_APP_DEST, 'Contents', 'Resources', 'server.js')));
+  check('shared src copied into bundle', fs.existsSync(path.join(env.SERVER_STUDIO_APP_DEST, 'Contents', 'Resources', 'platform.js')));
+  check('launcher is executable', (fs.statSync(path.join(env.SERVER_STUDIO_APP_DEST, 'Contents', 'MacOS', 'ServerStudio')).mode & 0o111) !== 0);
+  check('skill installed', fs.existsSync(path.join(env.SERVER_STUDIO_SKILL_DEST, 'SKILL.md')));
+  check('empty data file created', fs.readFileSync(path.join(env.SERVER_STUDIO_DATA_DIR, 'data.json'), 'utf8').trim() === '[]');
+  // The path printed for the Cowork plugin must survive npx clearing its cache.
+  check('plugin copied out of the package', fs.existsSync(path.join(env.SERVER_STUDIO_DATA_DIR, 'server-studio.plugin')));
+
+  // Existing data must survive a reinstall.
+  fs.writeFileSync(path.join(env.SERVER_STUDIO_DATA_DIR, 'data.json'), '[{"id":"keep","name":"keep me"}]');
+  execFileSync('node', [path.join(ROOT, 'bin', 'cli.js'), 'install'], { env, stdio: 'ignore' });
+  check('reinstall keeps existing servers',
+    JSON.parse(fs.readFileSync(path.join(env.SERVER_STUDIO_DATA_DIR, 'data.json'), 'utf8'))[0].id === 'keep');
+
+  // ---- running server ----
+  const srv = spawn('node', [path.join(env.SERVER_STUDIO_APP_DEST, 'Contents', 'Resources', 'server.js')],
+    { env: { ...env, PORT: String(PORT) }, stdio: ['ignore', 'pipe', 'pipe'] });
+  const up = await new Promise(res => {
+    const t = setTimeout(() => res(false), 5000);
+    srv.stdout.on('data', d => { if (String(d).includes('running on')) { clearTimeout(t); res(true); } });
+  });
+  check('server started on its own port', up);
+
+  if (up) {
+    const marker = path.join(SB, 'pwned.txt');
+    const payload = JSON.stringify({ command: 'touch ' + marker });
+
+    const a1 = await req({ method: 'POST', path: '/api/run', headers: { 'Content-Type': 'text/plain' } }, payload);
+    check('text/plain CSRF rejected', a1.code === 415, 'got ' + a1.code);
+
+    const a2 = await req({ method: 'POST', path: '/api/run',
+      headers: { 'Content-Type': 'application/json', Origin: 'https://evil.example' } }, payload);
+    check('foreign Origin rejected', a2.code === 403, 'got ' + a2.code);
+
+    const a3 = await req({ method: 'OPTIONS', path: '/api/run', headers: { Origin: 'https://evil.example' } });
+    check('preflight refused', a3.code === 403 || a3.code === 405, 'got ' + a3.code);
+
+    const good = await req({ method: 'POST', path: '/api/servers',
+      headers: { 'Content-Type': 'application/json', Origin: 'http://localhost:' + PORT } }, '[]');
+    check('same-origin write accepted', good.code === 200, 'got ' + good.code);
+
+    await new Promise(r => setTimeout(r, 300));
+    check('no attack executed a command', !fs.existsSync(marker));
+  }
+  srv.kill();
+
+  // ---- uninstall ----
+  execFileSync('node', [path.join(ROOT, 'bin', 'cli.js'), 'uninstall'], { env, stdio: 'ignore' });
+  check('app removed', !fs.existsSync(env.SERVER_STUDIO_APP_DEST));
+  check('skill removed', !fs.existsSync(env.SERVER_STUDIO_SKILL_DEST));
+  check('saved servers kept without --purge', fs.existsSync(path.join(env.SERVER_STUDIO_DATA_DIR, 'data.json')));
+
+  execFileSync('node', [path.join(ROOT, 'bin', 'cli.js'), 'uninstall', '--purge'], { env, stdio: 'ignore' });
+  check('--purge deletes saved servers', !fs.existsSync(env.SERVER_STUDIO_DATA_DIR));
+
+  // ---- platform shims ----
+  // The real Windows and Linux behaviour cannot run here, so this only proves the
+  // module picks the right command and data path for each OS.
+  function loadPlatformAs(name) {
+    const real = process.platform;
+    Object.defineProperty(process, 'platform', { value: name, configurable: true });
+    delete require.cache[require.resolve(path.join(ROOT, 'src', 'platform.js'))];
+    const m = require(path.join(ROOT, 'src', 'platform.js'));
+    Object.defineProperty(process, 'platform', { value: real, configurable: true });
+    return m;
+  }
+  const saved = process.env.SERVER_STUDIO_DATA_DIR;
+  delete process.env.SERVER_STUDIO_DATA_DIR;
+  const win = loadPlatformAs('win32');
+  const lin = loadPlatformAs('linux');
+  const mac = loadPlatformAs('darwin');
+  check('windows data dir uses AppData', /AppData|Roaming|Server Studio/.test(win.dataDir()) && !win.dataDir().includes('Library'));
+  check('linux data dir uses .config', lin.dataDir().includes('.config'));
+  check('mac data dir uses Application Support', mac.dataDir().includes('Application Support'));
+  check('windows terminal is named Command Prompt', win.terminalName() === 'Command Prompt');
+  check('mac terminal is named Terminal', mac.terminalName() === 'Terminal');
+  if (saved) process.env.SERVER_STUDIO_DATA_DIR = saved;
+
+  fs.rmSync(SB, { recursive: true, force: true });
+  console.log('\n' + (failed ? failed + ' failed' : 'all passed'));
+  process.exit(failed ? 1 : 0);
+})();