ports-manager 1.0.0 → 1.0.1

package/src/cli.js

@@ -1,278 +1,248 @@
-'use strict';
-
-const fs = require('node:fs');
-const path = require('node:path');
-const { loadConfig, mergeConfig } = require('./config');
-const { detectFolders, classifyProject, scanBackend } = require('./detect');
-const { allocatePorts, buildSpecs } = require('./runtime');
-const { createCorsShim } = require('./cors');
-const { runProcesses } = require('./process-manager');
-const { startProxy } = require('./proxy');
-const { generateIdeFiles, isIdeTerminal } = require('./ide');
-const { launchInBridge, stopBridge } = require('./bridge-client');
-const pkg = require('../package.json');
-
-const HELP = `ports-manager [options]
-
-Detect and run a paired frontend/backend JavaScript project.
-
-  --frontend-dir PATH      Override frontend/client directory
-  --backend-dir PATH       Override backend/server directory
-  --frontend-port PORT     Request frontend port
-  --backend-port PORT      Request backend port
-  --proxy-port PORT        Request same-origin proxy port
-  --range MIN-MAX          Port search range (default 4000-4999)
-  --ban PORTS              Ban comma-separated ports
-  --cors / --no-cors-shim  Enable/disable the CORS preload shim
-  --force-cors             Inject shim even when CORS is heuristically detected
-  --cors-credentials BOOL  Whether shim emits credential support
-  --proxy                  Enable same-origin proxy mode
-  --api-prefix PATH        Backend proxy prefix (default /api)
-  --wait-for-backend[=MS]  Wait before frontend (bare form: 10000ms)
-  --ide-terminals[=MODE]   auto, off, tasks, extension (bare form: auto)
-  --with-keybinding        Generate a user-keybindings reference file
-  --keybinding KEY         Reference shortcut (default ctrl+alt+p)
-  --config PATH            Explicit JSON config
-  --dry-run                Inspect and allocate without writes/processes
-  --stop                   Ask the bridge to stop this workspace's terminals
-  --help                    Show help
-  --version, -v             Show version and author
-`;
-
-function valueFor(argv, index, name) {
-  const argument = argv[index];
-  const equals = argument.indexOf('=');
-  if (equals !== -1) return { value: argument.slice(equals + 1), consumed: 0 };
-  if (index + 1 >= argv.length || argv[index + 1].startsWith('--')) {
-    throw new Error(`${name} requires a value`);
-  }
-  return { value: argv[index + 1], consumed: 1 };
-}
-
-function integer(value, name) {
-  if (!/^\d+$/.test(value)) throw new Error(`${name} must be an integer`);
-  return Number(value);
-}
-
-function boolean(value, name) {
-  if (value === 'true') return true;
-  if (value === 'false') return false;
-  throw new Error(`${name} must be true or false`);
-}
-
-function parseArgs(argv) {
-  const options = { bannedPorts: [] };
-  for (let index = 0; index < argv.length; index += 1) {
-    const argument = argv[index];
-    const name = argument.split('=')[0];
-    if (name === '--help' || name === '-h') options.help = true;
-    else if (name === '--version' || name === '-v') options.version = true;
-    else if (name === '--dry-run') options.dryRun = true;
-    else if (name === '--stop') options.stop = true;
-    else if (name === '--proxy') options.proxy = true;
-    else if (name === '--no-proxy') options.proxy = false;
-    else if (name === '--cors') options.cors = true;
-    else if (name === '--no-cors') options.cors = false;
-    else if (name === '--no-cors-shim') options.cors = false;
-    else if (name === '--force-cors') options.forceCors = true;
-    else if (name === '--with-keybinding') options.withKeybinding = true;
-    else if (name === '--no-cors-credentials') options.corsCredentials = false;
-    else if (name === '--internal-proxy') {
-      options.internalProxy = true;
-    } else if (name === '--ide-terminals') {
-      if (argument.includes('=')) options.ideTerminals = argument.slice(argument.indexOf('=') + 1) || 'auto';
-      else if (argv[index + 1] && !argv[index + 1].startsWith('--') &&
-          ['off', 'auto', 'tasks', 'extension'].includes(argv[index + 1])) {
-        options.ideTerminals = argv[++index];
-      } else options.ideTerminals = 'auto';
-    } else if (name === '--wait-for-backend') {
-      if (argument.includes('=')) options.waitForBackend = integer(argument.split('=').slice(1).join('='), name);
-      else if (argv[index + 1] && /^\d+$/.test(argv[index + 1])) options.waitForBackend = integer(argv[++index], name);
-      else options.waitForBackend = 10000;
-    } else {
-      const mapping = {
-        '--frontend': 'frontend', '--backend': 'backend',
-        '--frontend-dir': 'frontend', '--backend-dir': 'backend', '--config': 'configPath',
-        '--api-prefix': 'apiPrefix', '--keybinding': 'keybinding',
-        '--frontend-port': 'frontendPort', '--backend-port': 'backendPort',
-        '--proxy-port': 'proxyPort', '--cors-credentials': 'corsCredentials',
-        '--port-range': 'portRange', '--range': 'portRange',
-        '--ban-port': 'banPort', '--ban': 'ban',
-        '--proxy-frontend-port': 'proxyFrontendPort', '--proxy-backend-port': 'proxyBackendPort'
-      };
-      const key = mapping[name];
-      if (!key) throw new Error(`unknown option: ${argument}`);
-      const found = valueFor(argv, index, name);
-      index += found.consumed;
-      if (['frontendPort', 'backendPort', 'proxyPort', 'proxyFrontendPort', 'proxyBackendPort'].includes(key)) {
-        options[key] = integer(found.value, name);
-      } else if (key === 'corsCredentials') {
-        options[key] = boolean(found.value, name);
-      } else if (key === 'banPort') {
-        options.bannedPorts.push(integer(found.value, name));
-      } else if (key === 'ban') {
-        const ports = found.value.split(',').map((value) => value.trim()).filter(Boolean);
-        if (!ports.length) throw new Error('--ban requires a comma-separated port list');
-        options.bannedPorts.push(...ports.map((value) => integer(value, name)));
-      } else if (key === 'portRange') {
-        const match = found.value.match(/^(\d+)-(\d+)$/);
-        if (!match) throw new Error('--port-range must be MIN-MAX');
-        options.portRange = [Number(match[1]), Number(match[2])];
-      } else options[key] = found.value;
-    }
-  }
-  if (!options.bannedPorts.length) delete options.bannedPorts;
-  return options;
-}
-
-function proxySpec(root, ports, apiPrefix) {
-  return {
-    name: 'Proxy',
-    cwd: root,
-    command: 'node',
-    args: [
-      path.resolve(__dirname, '../bin/ports-manager.js'), '--internal-proxy',
-      '--proxy-port', String(ports.proxy), '--proxy-frontend-port', String(ports.frontend),
-      '--proxy-backend-port', String(ports.backend), '--api-prefix', apiPrefix
-    ],
-    env: {},
-    color: 'yellow'
-  };
-}
-
-async function runProxyOnly(options) {
-  for (const key of ['proxyPort', 'proxyFrontendPort', 'proxyBackendPort']) {
-    if (!options[key]) throw new Error(`internal proxy missing ${key}`);
-  }
-  const proxy = await startProxy({
-    port: options.proxyPort,
-    frontendPort: options.proxyFrontendPort,
-    backendPort: options.proxyBackendPort,
-    apiPrefix: options.apiPrefix || '/api'
-  });
-  await new Promise((resolve) => {
-    const finish = async () => {
-      await proxy.close();
-      resolve();
-    };
-    process.once('SIGINT', finish);
-    process.once('SIGTERM', finish);
-  });
-}
-
-function printPlan(root, frontend, backend, ports, config, corsEnabled) {
-  console.log(`Root:     ${root}`);
-  console.log(`Backend:  ${backend.framework} / npm run ${backend.script} / ${ports.backend}`);
-  console.log(`Frontend: ${frontend.framework} / npm run ${frontend.script} / ${ports.frontend}`);
-  if (config.proxy) console.log(`Proxy:    http://127.0.0.1:${ports.proxy}${config.apiPrefix}`);
-  console.log(`CORS shim: ${corsEnabled ? 'enabled' : 'skipped'}`);
-}
-
-async function main(argv = process.argv.slice(2), cwd = process.cwd()) {
-  const options = parseArgs(argv);
-  if (options.help) return console.log(HELP);
-  if (options.version) {
-    return console.log(`ports-manager v${pkg.version}\nMuhammad Saad Amin (SENODROOM)`);
-  }
-  if (options.internalProxy) return runProxyOnly(options);
-
-  const root = path.resolve(cwd);
-  const tag = `ports-manager:${root}`;
-  if (options.stop) {
-    await stopBridge(tag);
-    console.log('Requested closure of Ports Manager terminals for this workspace.');
-    return;
-  }
-  const loaded = await loadConfig(root, options.configPath);
-  const config = mergeConfig(loaded.config, options);
-  const folders = detectFolders(root, config);
-  const frontend = classifyProject(folders.frontend, 'frontend');
-  const backend = classifyProject(folders.backend, 'backend');
-  const scan = scanBackend(backend);
-  const corsEnabled = config.cors && (config.forceCors || !scan.corsDetected);
-  if (scan.corsDetected && config.cors && !config.forceCors) {
-    console.log('Existing CORS support detected heuristically; skipping preload shim (use --force-cors to override).');
-  }
-  if (!scan.hasEnvPort) {
-    console.warn('Warning: static scan did not find process.env.PORT in likely backend entry files; runtime behavior may differ.');
-  }
-  if (scan.literals.length) {
-    console.warn(`Warning: possible literal listen port(s) ${scan.literals.join(', ')} found; this heuristic may include inactive code.`);
-  }
-  if (frontend.framework === 'generic') {
-    console.warn('Warning: generic frontend receives PORT and API URL cannot be inferred; configure env values if needed.');
-  }
-
-  const allocated = await allocatePorts(config, config.proxy ? 3 : 2);
-  const ports = { backend: allocated[0], frontend: allocated[1], proxy: allocated[2] };
-  const ideMode = config.ideTerminals;
-  const inIde = isIdeTerminal();
-  let effectiveIdeMode = ideMode;
-  if (ideMode !== 'off' && !inIde) {
-    console.log('IDE terminal mode requested outside a corroborated VS Code/Cursor terminal; using inline mode.');
-    effectiveIdeMode = 'off';
-  }
-  const durableShim = path.join(root, '.vscode', 'ports-manager-cors-preload.cjs');
-  const shimPath = corsEnabled
-    ? (effectiveIdeMode === 'off' ? (options.dryRun ? '<dry-run-cors-shim>' : null) : durableShim)
-    : null;
-  let temporaryShim;
-  if (corsEnabled && effectiveIdeMode === 'off' && !options.dryRun) {
-    temporaryShim = createCorsShim();
-  }
-  const specs = buildSpecs(frontend, backend, ports, config,
-    temporaryShim ? temporaryShim.filename : shimPath);
-  const pSpec = config.proxy ? proxySpec(root, ports, config.apiPrefix) : null;
-  printPlan(root, frontend, backend, ports, config, corsEnabled);
-  if (options.dryRun) {
-    console.log('Dry run: no files written and no processes started.');
-    return;
-  }
-
-  if (effectiveIdeMode === 'extension' || effectiveIdeMode === 'auto') {
-    if (corsEnabled) {
-      fs.mkdirSync(path.dirname(durableShim), { recursive: true });
-      fs.writeFileSync(durableShim, require('./cors').SHIM_SOURCE, 'utf8');
-    }
-    try {
-      await launchInBridge(specs, pSpec, tag);
-      console.log('Started tagged terminals through the Ports Manager bridge.');
-      return;
-    } catch (error) {
-      if (effectiveIdeMode === 'extension') throw error;
-      console.log(`Bridge unavailable (${error.message}); generating VS Code tasks instead.`);
-      effectiveIdeMode = 'tasks';
-    }
-  }
-  if (effectiveIdeMode === 'tasks') {
-    const generated = generateIdeFiles(root, specs, pSpec, {
-      keybinding: config.keybinding,
-      needsShim: corsEnabled,
-      withKeybinding: config.withKeybinding
-    });
-    console.log(`Generated ${generated.tasksFile}. Run “Ports Manager: Run All” from Tasks: Run Task.`);
-    if (generated.keybindingsFile) {
-      console.log(`Suggested shortcut ${config.keybinding} is in ${generated.keybindingsFile}; copy it into Preferences: Open Keyboard Shortcuts (JSON).`);
-      console.log('VS Code/Cursor does not apply workspace keybindings files automatically.');
-    }
-    return;
-  }
-
-  let proxy;
-  try {
-    if (config.proxy) proxy = await startProxy({
-      port: ports.proxy, frontendPort: ports.frontend, backendPort: ports.backend,
-      apiPrefix: config.apiPrefix
-    });
-    const code = await runProcesses(specs, {
-      waitForBackend: config.waitForBackend,
-      backendPort: ports.backend
-    });
-    process.exitCode = code;
-  } finally {
-    if (proxy) await proxy.close();
-    if (temporaryShim) temporaryShim.cleanup();
-  }
-}
-
-module.exports = { HELP, main, parseArgs, proxySpec, runProxyOnly };
+'use strict';
+
+const path = require('node:path');
+const { loadConfig, mergeConfig } = require('./config');
+const { detectFolders, classifyProject, naturalPort } = require('./detect');
+const { allocatePorts, appendNodeRequire, buildSpecs } = require('./runtime');
+const { checkProject, describeFailure, installDependencies, summarize } = require('./preflight');
+const { applyWiring, planWiring, wiringMode } = require('./wiring');
+const { createCorsShim } = require('./cors');
+const { runProcesses } = require('./process-manager');
+const { startProxy } = require('./proxy');
+const leases = require('./leases');
+const pkg = require('../package.json');
+
+const HELP = `ports-manager [options]
+
+Run a paired frontend/backend project on free ports, with the frontend actually
+wired to wherever the backend landed.
+
+  --frontend-dir PATH      Override frontend/client directory
+  --backend-dir PATH       Override backend/server directory
+  --frontend-port PORT     Pin the frontend port
+  --backend-port PORT      Pin the backend port
+  --proxy-port PORT        Pin the same-origin proxy port
+  --range MIN-MAX          Port search range (default 3000-5999)
+  --ban PORTS              Never use these comma-separated ports
+  --proxy / --no-proxy     Force or forbid same-origin proxy mode
+  --api-prefix PATH        Path routed to the backend (default /api)
+  --no-install             Fail instead of installing missing dependencies
+  --no-cors                Do not inject backend CORS origin variables
+  --force-cors             Also preload a response-time CORS shim
+  --no-cors-credentials    Shim omits Access-Control-Allow-Credentials
+  --wait-for-backend[=MS]  Wait for the backend before starting the frontend
+  --config PATH            Explicit JSON config
+  --dry-run                Show the plan without installing or starting anything
+  --help, -h               Show help
+  --version, -v            Show version and author
+`;
+
+function valueFor(argv, index, name) {
+  const argument = argv[index];
+  const equals = argument.indexOf('=');
+  if (equals !== -1) return { value: argument.slice(equals + 1), consumed: 0 };
+  if (index + 1 >= argv.length || argv[index + 1].startsWith('--')) {
+    throw new Error(`${name} requires a value`);
+  }
+  return { value: argv[index + 1], consumed: 1 };
+}
+
+function integer(value, name) {
+  if (!/^\d+$/.test(value)) throw new Error(`${name} must be an integer`);
+  return Number(value);
+}
+
+function boolean(value, name) {
+  if (value === 'true') return true;
+  if (value === 'false') return false;
+  throw new Error(`${name} must be true or false`);
+}
+
+function parseArgs(argv) {
+  const options = { bannedPorts: [] };
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    const name = argument.split('=')[0];
+    if (name === '--help' || name === '-h') options.help = true;
+    else if (name === '--version' || name === '-v') options.version = true;
+    else if (name === '--dry-run') options.dryRun = true;
+    else if (name === '--proxy') options.proxy = true;
+    else if (name === '--no-proxy') options.proxy = false;
+    else if (name === '--cors') options.cors = true;
+    else if (name === '--no-cors' || name === '--no-cors-shim') options.cors = false;
+    else if (name === '--force-cors') options.forceCors = true;
+    else if (name === '--install') options.install = true;
+    else if (name === '--no-install') options.install = false;
+    else if (name === '--no-cors-credentials') options.corsCredentials = false;
+    else if (name === '--wait-for-backend') {
+      if (argument.includes('=')) options.waitForBackend = integer(argument.split('=').slice(1).join('='), name);
+      else if (argv[index + 1] && /^\d+$/.test(argv[index + 1])) options.waitForBackend = integer(argv[++index], name);
+      else options.waitForBackend = 10000;
+    } else {
+      const mapping = {
+        '--frontend': 'frontend', '--backend': 'backend',
+        '--frontend-dir': 'frontend', '--backend-dir': 'backend', '--config': 'configPath',
+        '--api-prefix': 'apiPrefix',
+        '--frontend-port': 'frontendPort', '--backend-port': 'backendPort',
+        '--proxy-port': 'proxyPort', '--cors-credentials': 'corsCredentials',
+        '--port-range': 'portRange', '--range': 'portRange',
+        '--ban-port': 'banPort', '--ban': 'ban'
+      };
+      const key = mapping[name];
+      if (!key) throw new Error(`unknown option: ${argument}`);
+      const found = valueFor(argv, index, name);
+      index += found.consumed;
+      if (['frontendPort', 'backendPort', 'proxyPort'].includes(key)) {
+        options[key] = integer(found.value, name);
+      } else if (key === 'corsCredentials') {
+        options[key] = boolean(found.value, name);
+      } else if (key === 'banPort') {
+        options.bannedPorts.push(integer(found.value, name));
+      } else if (key === 'ban') {
+        const ports = found.value.split(',').map((value) => value.trim()).filter(Boolean);
+        if (!ports.length) throw new Error('--ban requires a comma-separated port list');
+        options.bannedPorts.push(...ports.map((value) => integer(value, name)));
+      } else if (key === 'portRange') {
+        const match = found.value.match(/^(\d+)-(\d+)$/);
+        if (!match) throw new Error('--port-range must be MIN-MAX');
+        options.portRange = [Number(match[1]), Number(match[2])];
+      } else options[key] = found.value;
+    }
+  }
+  if (!options.bannedPorts.length) delete options.bannedPorts;
+  return options;
+}
+
+/** Installs anything missing so we never hand an unrunnable command to the shell. */
+async function preflight(projects, config, logger = console) {
+  const checks = projects.map(checkProject);
+  const broken = checks.filter((check) => !check.ok);
+  if (!broken.length) return checks;
+
+  if (config.install === false) {
+    const detail = broken.map(describeFailure).join('\n');
+    throw new Error(`dependencies are missing and --no-install was given\n${detail}`);
+  }
+  for (const check of broken) {
+    logger.log(`${check.role}: ${summarize(check)}`);
+    const code = await installDependencies(check, logger);
+    if (code !== 0) throw new Error(`${check.packageManager} install failed in ${check.directory}`);
+  }
+  const rechecked = projects.map(checkProject);
+  const stillBroken = rechecked.filter((check) => !check.ok);
+  if (stillBroken.length) {
+    throw new Error(`still missing after install:\n${stillBroken.map(describeFailure).join('\n')}`);
+  }
+  return rechecked;
+}
+
+function describePort(decision) {
+  if (!decision) return '';
+  if (decision.requested) return `${decision.port} (pinned)`;
+  if (!decision.fellBack) return `${decision.port}`;
+  return `${decision.port} (${decision.natural} busy)`;
+}
+
+function printPlan(root, frontend, backend, decisions, wiring, config) {
+  const byName = Object.fromEntries(decisions.map((decision) => [decision.name, decision]));
+  console.log(`Root:      ${root}`);
+  console.log(`Backend:   ${backend.framework} / npm run ${backend.script} / port ${describePort(byName.backend)}`);
+  console.log(`Frontend:  ${frontend.framework} / npm run ${frontend.script} / port ${describePort(byName.frontend)}`);
+  console.log(`Wiring:    ${wiring.describe()}`);
+  console.log(`CORS:      ${wiring.sameOrigin
+    ? 'not needed (same origin)'
+    : (wiring.corsEnvNames.length ? `injecting ${wiring.corsEnvNames.join(', ')}` : 'cross-origin')}${
+    config.forceCors ? ' + preload shim' : ''}`);
+  for (const note of wiring.notes) console.log(`           ${note}`);
+  console.log(`Open:      ${wiring.browserUrl}`);
+}
+
+async function main(argv = process.argv.slice(2), cwd = process.cwd()) {
+  const options = parseArgs(argv);
+  if (options.help) return console.log(HELP);
+  if (options.version) {
+    return console.log(`ports-manager v${pkg.version}\nMuhammad Saad Amin (SENODROOM)`);
+  }
+
+  const root = path.resolve(cwd);
+  const loaded = await loadConfig(root, options.configPath);
+  const config = mergeConfig(loaded.config, options);
+  const folders = detectFolders(root, config);
+  const frontend = classifyProject(folders.frontend, 'frontend');
+  const backend = classifyProject(folders.backend, 'backend');
+
+  if (!options.dryRun) await preflight([frontend, backend], config);
+  else {
+    for (const check of [frontend, backend].map(checkProject).filter((entry) => !entry.ok)) {
+      console.warn(`Would install first — ${describeFailure(check)}`);
+    }
+  }
+
+  const naturalBackendPort = naturalPort(backend);
+  const naturalFrontendPort = naturalPort(frontend);
+  const needsProxy = wiringMode(frontend, config) === 'proxy';
+
+  const requests = [
+    { name: 'backend', requested: config.backendPort, natural: naturalBackendPort },
+    { name: 'frontend', requested: config.frontendPort, natural: naturalFrontendPort }
+  ];
+  if (needsProxy) requests.push({ name: 'proxy', requested: config.proxyPort, natural: undefined });
+
+  const allocation = await allocatePorts(requests, config);
+  const { ports, decisions } = allocation;
+  let leased = false;
+  let cleanupWiring = () => {};
+  let temporaryShim;
+
+  try {
+    const wiring = planWiring({ frontend, backend, ports, config, naturalBackendPort });
+
+    if (config.forceCors && !options.dryRun) {
+      temporaryShim = createCorsShim();
+      wiring.backendEnv.PORTS_MANAGER_CORS_ORIGIN = wiring.browserUrl;
+      wiring.backendEnv.PORTS_MANAGER_CORS_CREDENTIALS = String(config.corsCredentials);
+      wiring.backendEnv.NODE_OPTIONS = appendNodeRequire(process.env.NODE_OPTIONS || '', temporaryShim.filename);
+    }
+
+    printPlan(root, frontend, backend, decisions, wiring, config);
+    if (options.dryRun) {
+      console.log('Dry run: nothing installed, written, or started.');
+      return;
+    }
+
+    cleanupWiring = applyWiring(wiring, frontend, ports, config);
+    const specs = buildSpecs(frontend, backend, ports, config, wiring);
+    leased = leases.acquire(Object.values(ports), root);
+
+    // Hand the ports over to the children only now that everything else is ready.
+    await allocation.release();
+
+    let proxy;
+    try {
+      if (wiring.useProxy) {
+        proxy = await startProxy({
+          port: ports.proxy, frontendPort: ports.frontend, backendPort: ports.backend,
+          apiPrefix: config.apiPrefix
+        });
+      }
+      const code = await runProcesses(specs, {
+        waitForBackend: config.waitForBackend,
+        backendPort: ports.backend,
+        frontendPort: ports.frontend,
+        onReady({ backendUp, frontendUp }) {
+          if (backendUp && frontendUp) console.log(`\nReady: ${wiring.browserUrl} -> ${wiring.describe()}`);
+        }
+      });
+      process.exitCode = code;
+    } finally {
+      if (proxy) await proxy.close();
+    }
+  } finally {
+    await allocation.release();
+    cleanupWiring();
+    if (temporaryShim) temporaryShim.cleanup();
+    if (leased) leases.release();
+  }
+}
+
+module.exports = { HELP, main, parseArgs, preflight, printPlan };

package/src/config.js

@@ -6,24 +6,25 @@ const { cosmiconfig } = require('cosmiconfig');
 
 const DEFAULTS = Object.freeze({
   pairs: [['frontend', 'backend'], ['client', 'server']],
-  portRange: [4000, 4999],
-  bannedPorts: [3000, 5000],
+  // Wide enough to cover the ports MERN projects naturally want (3000, 5000, 5173...)
+  // and to keep finding free ones when several projects run at once.
+  portRange: [3000, 5999],
+  bannedPorts: [],
   cors: true,
   forceCors: false,
   corsCredentials: true,
-  proxy: false,
+  // null = decide automatically (used only when the frontend cannot proxy for itself).
+  proxy: null,
   apiPrefix: '/api',
-  ideTerminals: 'off',
+  install: true,
   waitForBackend: 0,
-  withKeybinding: false,
-  keybinding: 'ctrl+alt+p',
   env: {}
 });
 
 const allowedKeys = new Set([
   'pairs', 'frontend', 'backend', 'frontendPort', 'backendPort', 'proxyPort', 'portRange',
   'bannedPorts', 'cors', 'forceCors', 'corsCredentials', 'proxy', 'apiPrefix',
-  'ideTerminals', 'waitForBackend', 'withKeybinding', 'keybinding', 'env'
+  'install', 'waitForBackend', 'env'
 ]);
 
 function normalizeConfig(input) {
@@ -36,13 +37,6 @@ function normalizeConfig(input) {
   if (config.proxy && typeof config.proxy === 'object' && !Array.isArray(config.proxy)) {
     config.proxy = config.proxy.enabled === true;
   }
-  if (config.ideTerminals && typeof config.ideTerminals === 'object' &&
-      !Array.isArray(config.ideTerminals)) {
-    const ide = config.ideTerminals;
-    config.ideTerminals = ide.mode || 'off';
-    if (ide.withKeybinding !== undefined) config.withKeybinding = ide.withKeybinding;
-    if (ide.keybinding !== undefined) config.keybinding = ide.keybinding;
-  }
   return config;
 }
 
@@ -80,19 +74,18 @@ function validateConfig(config) {
     if (!Array.isArray(config.bannedPorts)) throw new Error('bannedPorts must be an array');
     config.bannedPorts.forEach((port, index) => assertPort(port, `bannedPorts[${index}]`));
   }
-  for (const key of ['cors', 'forceCors', 'corsCredentials', 'proxy', 'withKeybinding']) {
+  for (const key of ['cors', 'forceCors', 'corsCredentials', 'install']) {
     if (config[key] !== undefined && typeof config[key] !== 'boolean') {
       throw new Error(`${key} must be boolean`);
     }
   }
+  if (config.proxy !== undefined && config.proxy !== null && typeof config.proxy !== 'boolean') {
+    throw new Error('proxy must be boolean or null');
+  }
   if (config.apiPrefix !== undefined &&
       (typeof config.apiPrefix !== 'string' || !config.apiPrefix.startsWith('/'))) {
     throw new Error('apiPrefix must be a string beginning with /');
   }
-  if (config.ideTerminals !== undefined &&
-      !['off', 'auto', 'tasks', 'extension'].includes(config.ideTerminals)) {
-    throw new Error('ideTerminals must be off, auto, tasks, or extension');
-  }
   if (config.waitForBackend !== undefined &&
       (!Number.isInteger(config.waitForBackend) || config.waitForBackend < 0)) {
     throw new Error('waitForBackend must be a non-negative integer (milliseconds)');
@@ -142,7 +135,7 @@ function mergeConfig(fileConfig, cliConfig) {
     if (allowedKeys.has(key) && value !== undefined) result[key] = value;
   }
   result.bannedPorts = [...new Set([
-    3000, 5000, ...(fileConfig.bannedPorts || []), ...(cliConfig.bannedPorts || [])
+    ...(fileConfig.bannedPorts || []), ...(cliConfig.bannedPorts || [])
   ])];
   validateConfig(result);
   return result;