Skip to content

Qwen3.8-Flash-Next on any consumer hardware: one-click install for Windows / Linux. Strata inference engine, OpenAI/Anthropic API on localhost, optional image input.

C++

Host ports: plain message when the main port is taken or reserved; share and tunnel take a free port instead of PORT+1 and PORT+2

Niko1221c7c0e37bc4a6
diff --git a/apps/host/server/index.mjs b/apps/host/server/index.mjs
index 56c7b3c23..e777897d2 100644
--- a/apps/host/server/index.mjs
+++ b/apps/host/server/index.mjs
@@ -72,6 +72,7 @@ import { randomBytes, timingSafeEqual } from 'node:crypto';
import { nativeGateway } from './native-gateway.mjs';
import { proxyCompletion } from './inference.mjs';
import { apiPath } from './api-paths.mjs';
+import { findFreePort, listenProblem } from './ports.mjs';
import { validateChatImages } from './chat-images.mjs';
import { createTimeSkip, measureFolder, timeskipRevisionMessage, imageTypeOf } from './timeskip.mjs';
@@ -908,8 +909,10 @@ const tasks = createTaskService({
const taskTimer = setInterval(() => tasks.tick(), 15000);
taskTimer.unref();
-const localShare = createLocalShare({ handle: openai, hasKey: () => !!store.get().serving?.apiKey, port: Number(process.env.STRATA_SHARE_PORT ?? PORT + 1), changed: () => serving.setSharing(localShare.state()) });
-const tunnelPort = Number(process.env.STRATA_TUNNEL_PORT ?? PORT + 2);
+// The share and tunnel listeners take a free port (the next ones above the host's own) instead of a fixed PORT+1 / PORT+2 that Docker, WSL or Hyper-V may hold or reserve.
+const sharePort = await findFreePort(Number(process.env.STRATA_SHARE_PORT ?? PORT + 1), '0.0.0.0', { skip: [PORT] });
+const localShare = createLocalShare({ handle: openai, hasKey: () => !!store.get().serving?.apiKey, port: sharePort, changed: () => serving.setSharing(localShare.state()) });
+const tunnelPort = await findFreePort(Number(process.env.STRATA_TUNNEL_PORT ?? PORT + 2), '127.0.0.1', { skip: [PORT, sharePort] });
const tunnelOrigin = createLocalShare({ handle: openai, hasKey: () => !!store.get().serving?.apiKey, host: '127.0.0.1', port: tunnelPort });
const connector = createConnectorInstaller({ directory: join(store.HOME, 'engine', 'cloudflare'), componentDirectory: join(componentsDirectory(), 'cloudflared') });
const cloudflare = createCloudflare({ origin: tunnelOrigin, originUrl: `http://127.0.0.1:${tunnelPort}`, hasKey: () => !!store.get().serving?.apiKey, changed: serving.setTunnel, locate: connector.locate, prepareConnector: connector.ensure, connectorInfo: connector.connector, findRunning: findRunningConnector });
@@ -2161,6 +2164,12 @@ async function staticFile(req, res, path) {
/* ------------------------------------------------------------------ start --- */
+server.on('error', error => {
+ if (server.listening) { console.error(`[strata] ${error.message}`); return; }
+ // a taken or Windows-reserved port: one plain sentence instead of a stack trace
+ console.error(`[strata] ${listenProblem(error, PORT, HOST)}`);
+ process.exit(1);
+});
server.listen(PORT, HOST, () => {
if (process.send) process.send({ type: 'strata-ready', port: PORT });
// Engines a lost owner left behind (an earlier crash, an older version): ended after a PID + start time + command-line check.
diff --git a/apps/host/server/local-share.mjs b/apps/host/server/local-share.mjs
index 686f49a64..bcbfc2c4c 100644
--- a/apps/host/server/local-share.mjs
+++ b/apps/host/server/local-share.mjs
@@ -2,6 +2,7 @@
import http from 'node:http';
import os from 'node:os';
import { apiPath } from './api-paths.mjs';
+import { listenProblem } from './ports.mjs';
/** Sharing without a key is allowed (owner decision, 0.2.2): the person is told once, in plain words, and the app keeps offering to make a key. */
export const NO_KEY_WARNING = 'No API key is set, so any device on this network can use your model. Create an API key to protect it.';
export function createLocalShare({ handle, hasKey, changed = () => {}, host = '0.0.0.0', port = 8792 }) {
@@ -18,7 +19,7 @@ export function createLocalShare({ handle, hasKey, changed = () => {}, host = '0
catch { if (!res.headersSent) res.writeHead(500); res.end('Request failed'); }
});
try { await new Promise((resolve,reject) => { listener.once('error',reject); listener.listen(port,host,resolve); }); }
- catch(e) { listener.close(); listener=null; throw e; }
+ catch(e) { listener.close(); listener=null; throw new Error(listenProblem(e, port, host)); }
active=true; changed(); return state();
}
async function stop() {
diff --git a/apps/host/server/ports.mjs b/apps/host/server/ports.mjs
new file mode 100644
index 000000000..363d2406d
--- /dev/null
+++ b/apps/host/server/ports.mjs
@@ -0,0 +1,30 @@
+/** Ports the host listens on: a free one for the helpers, and a plain sentence when the main one cannot be taken. */
+import net from 'node:net';
+
+/** Why a listen failed, in words a person can act on (Windows keeps whole ranges for Hyper-V, WSL and Docker). */
+export function listenProblem(error, port, host = '127.0.0.1') {
+ const code = error?.code;
+ if (code === 'EADDRINUSE') return `Port ${port} is already in use. Strata may already be running; close it or the other program, or start Strata with another port (STRATA_PORT).`;
+ if (code === 'EACCES') return `Windows or a firewall does not let Strata use port ${port}. Hyper-V, WSL and Docker keep ranges of ports for themselves (see "netsh int ipv4 show excludedportrange protocol=tcp"). Start Strata with another port (STRATA_PORT), for example 8801.`;
+ if (code === 'EADDRNOTAVAIL') return `${host} is not an address of this computer, so Strata cannot listen on it. Check STRATA_BIND.`;
+ return `Strata cannot listen on ${host}:${port} (${error?.message ?? code}).`;
+}
+
+function tryListen(port, host) {
+ return new Promise(resolve => {
+ const probe = net.createServer();
+ probe.once('error', () => resolve(null));
+ probe.listen(port, host, () => { const got = probe.address().port; probe.close(() => resolve(got)); });
+ });
+}
+
+/** `preferred` when it can be taken, else the next free port above it (up to `tries` of them), else any free port. Never throws. */
+export async function findFreePort(preferred, host = '127.0.0.1', { skip = [], tries = 20 } = {}) {
+ for (let offset = 0; offset < tries; offset++) {
+ const port = preferred + offset;
+ if (port > 65535 || skip.includes(port)) continue;
+ const got = await tryListen(port, host);
+ if (got) return got;
+ }
+ return (await tryListen(0, host)) ?? preferred;
+}
diff --git a/apps/host/tests/host-ports.test.mjs b/apps/host/tests/host-ports.test.mjs
new file mode 100644
index 000000000..44719a2bc
--- /dev/null
+++ b/apps/host/tests/host-ports.test.mjs
@@ -0,0 +1,42 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import net from 'node:net';
+import { spawn } from 'node:child_process';
+import { mkdtempSync, realpathSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { findFreePort, listenProblem } from '../server/ports.mjs';
+
+const cwd = fileURLToPath(new URL('..', import.meta.url));
+const hold = port => new Promise(resolve => { const s = net.createServer(); s.listen(port, '127.0.0.1', () => resolve(s)); });
+
+test('a taken preferred port gives the next free one, never the taken one', async () => {
+ const first = await hold(0); const taken = first.address().port;
+ try {
+ const got = await findFreePort(taken, '127.0.0.1');
+ assert.notEqual(got, taken);
+ assert.ok(got > 0);
+ assert.notEqual(await findFreePort(got, '127.0.0.1', { skip: [got] }), got);
+ } finally { first.close(); }
+});
+
+test('the plain sentences name the cause and the one next step', () => {
+ const use = listenProblem({ code: 'EADDRINUSE' }, 8791);
+ assert.match(use, /Port 8791 is already in use/); assert.match(use, /STRATA_PORT/);
+ const denied = listenProblem({ code: 'EACCES' }, 8792);
+ assert.match(denied, /Hyper-V, WSL and Docker/); assert.match(denied, /excludedportrange/); assert.match(denied, /STRATA_PORT/);
+ assert.doesNotMatch(denied, /EACCES|permission denied/i);
+});
+
+test('the host on a taken port prints the plain sentence and exits, with no stack trace', async t => {
+ const home = realpathSync(mkdtempSync(join(tmpdir(), 'strata-port-'))); t.after(() => rmSync(home, { recursive: true, force: true }));
+ const blocker = await hold(0); t.after(() => blocker.close());
+ const port = blocker.address().port;
+ const child = spawn(process.execPath, ['server/index.mjs'], { cwd, env: { ...process.env, STRATA_HOME: home, STRATA_PORT: String(port), STRATA_MODELS_DIR: join(home, 'm') } });
+ let err = ''; child.stderr.on('data', d => { err += d; });
+ const code = await new Promise(resolve => { const timer = setTimeout(() => { child.kill(); resolve('timeout'); }, 30000); child.once('exit', c => { clearTimeout(timer); resolve(c); }); });
+ assert.equal(code, 1, err);
+ assert.match(err, new RegExp(`Port ${port} is already in use`));
+ assert.doesNotMatch(err, /at Server\.setupListenHandle/);
+});