portless-studio 0.1.0 → 0.1.1

package/dist/server/infrastructure/portless/portless-registry.js

@@ -2,7 +2,10 @@ import * as fs from "node:fs";
 import { err, ok } from "../../../core/result.js";
 import { appError } from "../../application/app-error.js";
 import { addAlias, detectPortless, installPortless, removeAlias, startProxy, stopProxy, } from "./portless-cli.js";
-import { readProxyPid, readProxyStatus, readRoutes } from "./state-files.js";
+import { readProxyPid, readProxyStatus, readRouteEntries, routesFromEntries, } from "./state-files.js";
+/** How long a write waits for a half-written `routes.json` to be whole again. */
+const TORN_RETRIES = 10;
+const TORN_RETRY_MS = 50;
 /** Reads portless state files directly and writes through the portless CLI, which owns the lock. */
 export class PortlessRegistry {
     #stateDir;
@@ -16,6 +19,8 @@ export class PortlessRegistry {
     // Bumped by an install, so a detection that started before it cannot cache a stale answer.
     #detectGeneration = 0;
     #installing = false;
+    /** The entries of the last `routes.json` that parsed, shown while portless rewrites it. */
+    #lastEntries = [];
     /** One per watcher: compares the installation with what that watcher last saw. */
     #installationChecks = new Set();
     constructor(options) {
@@ -29,7 +34,7 @@ export class PortlessRegistry {
     async readSnapshot() {
         const portless = await this.#detect();
         const proxy = readProxyStatus(this.#stateDir);
-        return { proxy, portless, routes: readRoutes(this.#stateDir, proxy), readAt: Date.now() };
+        return { proxy, portless, routes: this.#routes(proxy), readAt: Date.now() };
     }
     watch(onChange) {
         let last = this.#fingerprint();
@@ -103,8 +108,9 @@ export class PortlessRegistry {
     }
     async createAlias(name, port, force) {
         // `portless alias` silently replaces an existing alias, so the conflict check lives here.
+        await this.#waitForWholeRoutesFile();
         const proxy = readProxyStatus(this.#stateDir);
-        const existing = readRoutes(this.#stateDir, proxy).find((route) => route.name === name);
+        const existing = this.#routes(proxy).find((route) => route.name === name);
         if (existing && !force) {
             if (existing.port === port)
                 return ok(undefined);
@@ -149,6 +155,27 @@ export class PortlessRegistry {
     /** The snapshot without its read time, so two reads of the same state compare equal. */
     #fingerprint() {
         const proxy = readProxyStatus(this.#stateDir);
-        return JSON.stringify({ proxy, routes: readRoutes(this.#stateDir, proxy) });
+        return JSON.stringify({ proxy, routes: this.#routes(proxy) });
+    }
+    /**
+     * Routes from `routes.json`. portless rewrites the file in place, so a read can land on an empty
+     * or cut-off file; that read keeps the last entries that parsed, and the next file event or poll
+     * reads it again. A missing file, or one in a format Studio does not know, means no routes.
+     */
+    #routes(proxy) {
+        const read = readRouteEntries(this.#stateDir);
+        if (read.kind === "ok")
+            this.#lastEntries = read.entries;
+        else if (read.kind !== "torn")
+            this.#lastEntries = [];
+        return routesFromEntries(this.#lastEntries, proxy);
+    }
+    /** Gives portless a moment to finish a write, so a name check never runs on a torn file. */
+    async #waitForWholeRoutesFile() {
+        for (let attempt = 0; attempt < TORN_RETRIES; attempt += 1) {
+            if (readRouteEntries(this.#stateDir).kind !== "torn")
+                return;
+            await new Promise((resolve) => setTimeout(resolve, TORN_RETRY_MS));
+        }
     }
 }

package/dist/server/infrastructure/portless/state-files.js

@@ -34,21 +34,29 @@ export function readProxyPid(dir) {
     const pid = Number.parseInt(readText(dir, PID_FILE) ?? "", 10);
     return Number.isInteger(pid) && pid > 0 ? pid : null;
 }
-/** Live routes from `routes.json`. Invalid entries and apps whose process died are left out. */
-export function readRoutes(dir, proxy) {
+export function readRouteEntries(dir) {
     const raw = readText(dir, ROUTES_FILE);
     if (raw === null)
-        return [];
+        return { kind: "missing" };
+    if (raw.trim() === "")
+        return { kind: "torn" };
     let parsed;
     try {
         parsed = JSON.parse(raw);
     }
     catch {
-        return [];
+        return { kind: "torn" };
     }
-    if (!Array.isArray(parsed))
-        return [];
-    return parsed
+    return Array.isArray(parsed) ? { kind: "ok", entries: parsed } : { kind: "unexpected" };
+}
+/** Live routes from `routes.json`. Invalid entries and apps whose process died are left out. */
+export function readRoutes(dir, proxy) {
+    const read = readRouteEntries(dir);
+    return read.kind === "ok" ? routesFromEntries(read.entries, proxy) : [];
+}
+/** The routes in a parsed `routes.json`, without invalid entries and apps whose process died. */
+export function routesFromEntries(entries, proxy) {
+    return entries
         .flatMap((entry) => {
         const route = toRoute(entry, proxy);
         return route ? [route] : [];
@@ -56,6 +64,14 @@ export function readRoutes(dir, proxy) {
         .filter((route) => route.pid === null || isProcessAlive(route.pid))
         .sort((a, b) => a.name.localeCompare(b.name));
 }
+export function inspectRoutesFile(dir) {
+    const read = readRouteEntries(dir);
+    if (read.kind !== "ok")
+        return { state: read.kind, entries: 0, unreadable: 0 };
+    const proxy = { running: false, port: null, https: false, tlds: [DEFAULT_TLD] };
+    const unreadable = read.entries.filter((entry) => toRoute(entry, proxy) === null).length;
+    return { state: "ok", entries: read.entries.length, unreadable };
+}
 /** Signal 0 checks existence without touching the process; EPERM means it exists. */
 export function isProcessAlive(pid) {
     try {

package/dist/server/infrastructure/system/doctor-facts.js

@@ -127,6 +127,7 @@ export async function collectDoctorFacts(options) {
         studioPort: { port: config.port, holder: await portHolder(config.port, options) },
         loginService,
         ...(systemNotifier === undefined ? {} : { systemNotifier }),
+        ...(options.routesFile ? { routesFile: options.routesFile() } : {}),
     };
 }
 /** Paths are built for the platform the facts describe, not the one running the code. */

package/dist/server/infrastructure/system/npm-registry.js

@@ -0,0 +1,20 @@
+/** Public npm metadata of the latest release; Studio sends nothing but this GET. */
+export const LATEST_RELEASE_URL = "https://registry.npmjs.org/portless-studio/latest";
+const TIMEOUT_MS = 3000;
+/** The `version` npm reports as latest, or null on any failure, including the 3 s timeout. */
+export async function fetchLatestVersion(options = {}) {
+    const fetchImpl = options.fetch ?? ((url, init) => fetch(url, init));
+    try {
+        const response = await fetchImpl(options.url ?? LATEST_RELEASE_URL, {
+            signal: AbortSignal.timeout(options.timeoutMs ?? TIMEOUT_MS),
+        });
+        if (!response.ok)
+            return null;
+        const body = await response.json();
+        const version = typeof body === "object" && body !== null ? Reflect.get(body, "version") : undefined;
+        return typeof version === "string" && /^\d+\.\d+\.\d+\S*$/.test(version) ? version : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/server/interface/http/http-server.js

@@ -102,6 +102,11 @@ export function createHttpServer(options) {
             sendJson(res, 200, await options.studio.readSnapshot());
             return;
         }
+        if (pathname === API_PATHS.update && method === "GET") {
+            if (!options.updates)
+                return sendAppError(res, unsupported);
+            return sendJson(res, 200, await options.updates.status());
+        }
         if (pathname === API_PATHS.config && method === "GET") {
             const result = await options.studio.readConfig();
             if (!result.ok)

package/dist/server/interface/http/json-io.js

@@ -16,6 +16,7 @@ const STATUS_BY_CODE = {
     process_not_allowed: 403,
     unsupported: 501,
     command_failed: 502,
+    port_in_use: 409,
     unknown_app: 404,
     path_not_allowed: 403,
     terminal_not_running: 409,

package/dist/server/main.js

@@ -5,20 +5,24 @@ import * as path from "node:path";
 import { createDoctorService } from "./application/doctor.js";
 import { OpenWith } from "./application/open-with.js";
 import { controlProxy } from "./application/proxy-control.js";
+import { confirmProxyStarts } from "./application/proxy-start-check.js";
 import { createAlias, renameAlias } from "./application/route-use-cases.js";
 import { stopProcess } from "./application/stop-process.js";
 import { StudioRuntime } from "./application/studio-runtime.js";
 import { TerminalManager } from "./application/terminals.js";
+import { UpdateChecker, updateChecksAllowed } from "./application/update-check.js";
 import { systemAppCatalog } from "./infrastructure/apps/app-catalog.js";
 import { createDetachedLauncher } from "./infrastructure/apps/detached-launcher.js";
 import { JsonCustomAppStore, JsonRouteProjectStore, openWithPathFor, routeProjectsPathFor, } from "./infrastructure/apps/json-stores.js";
 import { autoNamedPathFor, JsonAutoNamedStore, } from "./infrastructure/config/json-auto-named-store.js";
 import { defaultConfigPath, JsonConfigStore } from "./infrastructure/config/json-config-store.js";
+import { JsonUpdateCache, updateCheckPathFor } from "./infrastructure/config/json-update-cache.js";
 import { proxyStartRecordPathFor, readProxyStartRecord, recordProxyStarts, } from "./infrastructure/config/proxy-start-record.js";
 import { PortlessRegistry } from "./infrastructure/portless/portless-registry.js";
-import { resolveStateDir } from "./infrastructure/portless/state-files.js";
+import { inspectRoutesFile, resolveStateDir } from "./infrastructure/portless/state-files.js";
 import { collectDoctorFacts, proxyPidsAmong } from "./infrastructure/system/doctor-facts.js";
 import { FaviconFetcher } from "./infrastructure/system/favicon-fetcher.js";
+import { fetchLatestVersion } from "./infrastructure/system/npm-registry.js";
 import { OsNotifier } from "./infrastructure/system/os-notifier.js";
 import { ProjectInfoReader } from "./infrastructure/system/project-info.js";
 import { nodeSystemIo } from "./infrastructure/system/system-io.js";
@@ -39,9 +43,11 @@ export function createStudioServices(options = {}) {
         bin: options.portlessBin ?? (process.env.PORTLESS_BIN || "portless"),
         ...(options.npmBin === undefined ? {} : { npmBin: options.npmBin }),
     });
-    // Every proxy Studio starts is written down, so `uninstall` stops only Studio's own.
-    const registry = recordProxyStarts(portless, proxyStartRecordPathFor(configPath));
     const scanner = createPortScanner();
+    const proxyPids = (pids) => proxyPidsAmong(process.platform, nodeSystemIo, pids);
+    // A start counts only once the proxy listens, and every proxy Studio starts is written down,
+    // so `uninstall` stops only Studio's own.
+    const registry = recordProxyStarts(confirmProxyStarts(portless, { scan: () => scanner.scan(), proxyPids }), proxyStartRecordPathFor(configPath));
     const configStore = new JsonConfigStore(configPath);
     const notifier = new OsNotifier({ platform: process.platform });
     const runtime = new StudioRuntime({
@@ -51,7 +57,7 @@ export function createStudioServices(options = {}) {
         projects: new ProjectInfoReader(),
         studioPort: options.studioPort ?? null,
         probe: (port) => probeHttpResponse(port),
-        proxyPids: (pids) => proxyPidsAmong(process.platform, nodeSystemIo, pids),
+        proxyPids,
         autoNamedStore: new JsonAutoNamedStore(autoNamedPathFor(configPath)),
         notifier,
         icons: new FaviconFetcher(),
@@ -97,10 +103,20 @@ export function createStudioServices(options = {}) {
             probe: (port) => probeHttpResponse(port),
             ...(studioService ? { loginService: () => studioService.status() } : {}),
             systemNotifier: () => notifier.availability(),
+            routesFile: () => inspectRoutesFile(stateDir),
         }),
         controlProxy: proxy,
         updateConfig: (config) => runtime.updateConfig(config),
     });
+    const version = options.version;
+    const updates = version === undefined
+        ? undefined
+        : new UpdateChecker({
+            current: version,
+            enabled: async () => updateChecksAllowed(process.env) && (await runtime.settings()).checkForUpdates,
+            fetchLatest: () => fetchLatestVersion(),
+            cache: new JsonUpdateCache(updateCheckPathFor(configPath)),
+        });
     const services = {
         registry,
         scanner,
@@ -117,6 +133,7 @@ export function createStudioServices(options = {}) {
         openWith,
         terminals,
         openUrl: options.openUrl,
+        updates,
     };
     runtimes.set(services, runtime);
     return services;
@@ -130,6 +147,7 @@ export function createUninstallServices(configPath = defaultConfigPath()) {
         recordPath,
         routeProjectsPathFor(configPath),
         openWithPathFor(configPath),
+        updateCheckPathFor(configPath),
     ];
     const processes = new SystemProcessControl({
         platform: process.platform,
@@ -174,6 +192,7 @@ export async function startServer(options) {
         ...(services.openWith ? { openWith: services.openWith } : {}),
         ...(services.terminals ? { terminals: services.terminals } : {}),
         ...(services.openUrl ? { openUrl: services.openUrl } : {}),
+        ...(services.updates ? { updates: services.updates } : {}),
     });
     await new Promise((resolve, reject) => {
         http.server.once("error", reject);