portless-studio 0.1.0 → 0.1.2

package/dist/server/main.js

@@ -2,33 +2,48 @@ import { randomBytes } from "node:crypto";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { stopContainer } from "./application/container-source.js";
 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 { publicUrls, SHORT_URL_PORT, ShortUrls } from "./application/short-urls.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 { collectDoctorFacts, proxyPidsAmong } from "./infrastructure/system/doctor-facts.js";
+import { inspectRoutesFile, resolveStateDir } from "./infrastructure/portless/state-files.js";
+import { DockerContainers } from "./infrastructure/system/docker-containers.js";
+import { collectDoctorFacts, proxyPidsAmong, reachesPortless, testBind, } 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 { startForwarder } from "./infrastructure/system/port-forwarder.js";
 import { ProjectInfoReader } from "./infrastructure/system/project-info.js";
 import { nodeSystemIo } from "./infrastructure/system/system-io.js";
 import { createPortScanner, listPortsFor, probeHttpResponse, } from "./infrastructure/system/system-port-scanner.js";
 import { SystemProcessControl } from "./infrastructure/system/system-process-control.js";
-import { createTerminalSpawner, detectTerminalMode, nodeTerminalFolders, } from "./infrastructure/terminal/terminal-spawner.js";
+import { systemProcessTree } from "./infrastructure/terminal/process-tree.js";
+import { createTerminalSpawner, detectTerminalMode, interactiveShellName, nodeTerminalFolders, } from "./infrastructure/terminal/terminal-spawner.js";
 import { createHttpServer } from "./interface/http/http-server.js";
 export { defaultConfigPath } from "./infrastructure/config/json-config-store.js";
 /** Only this machine can connect; see docs/architecture.md, Security. */
 const LOOPBACK = "127.0.0.1";
+/** `PORTLESS_STUDIO_SHORT_URL_PORT`, when it is a valid port; port 80 otherwise. */
+export function shortUrlPortFrom(env) {
+    const raw = env.PORTLESS_STUDIO_SHORT_URL_PORT;
+    const port = raw === undefined ? Number.NaN : Number(raw);
+    return Number.isInteger(port) && port >= 1 && port <= 65535 ? port : SHORT_URL_PORT;
+}
 // Lets startServer reuse the runtime behind services built here, so both share one scan cache.
 const runtimes = new WeakMap();
 export function createStudioServices(options = {}) {
@@ -39,11 +54,20 @@ 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);
+    const shortUrls = new ShortUrls({
+        forwarding: { listen: (port, target) => startForwarder({ port, targetPort: target }) },
+        port: options.shortUrlPort ?? shortUrlPortFrom(process.env),
+        log: (line) => console.log(line),
+        reachesProxy: (port) => reachesPortless(port),
+    });
+    // A start counts only once the proxy listens, and every proxy Studio starts is written down,
+    // so `uninstall` stops only Studio's own. Route URLs drop the port while Studio forwards it.
+    const registry = publicUrls(recordProxyStarts(confirmProxyStarts(portless, { scan: () => scanner.scan(), proxyPids }), proxyStartRecordPathFor(configPath)), () => shortUrls.publicPort());
     const configStore = new JsonConfigStore(configPath);
     const notifier = new OsNotifier({ platform: process.platform });
+    const containers = new DockerContainers();
     const runtime = new StudioRuntime({
         registry,
         scanner,
@@ -51,11 +75,13 @@ 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(),
         routeProjectStore: new JsonRouteProjectStore(routeProjectsPathFor(configPath)),
+        containers,
+        shortUrls,
     });
     const openWith = new OpenWith({
         catalog: systemAppCatalog(),
@@ -66,6 +92,8 @@ export function createStudioServices(options = {}) {
     const terminals = new TerminalManager({
         spawner: lazySpawner(),
         folders: nodeTerminalFolders(),
+        processTree: systemProcessTree(),
+        homeDir: os.homedir(),
         workspace: {
             openableFolders: () => runtime.openableFolders(),
             snapshot: () => runtime.readSnapshot(),
@@ -97,10 +125,24 @@ export function createStudioServices(options = {}) {
             probe: (port) => probeHttpResponse(port),
             ...(studioService ? { loginService: () => studioService.status() } : {}),
             systemNotifier: () => notifier.availability(),
+            routesFile: () => inspectRoutesFile(stateDir),
+            docker: () => containers.read(),
+            lowPort: testBind,
+            shortUrls: (config) => shortUrls.inspect(config),
         }),
         controlProxy: proxy,
         updateConfig: (config) => runtime.updateConfig(config),
+        syncShortUrls: (config) => shortUrls.sync(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,
@@ -113,10 +155,13 @@ export function createStudioServices(options = {}) {
             stoppablePids: () => runtime.stoppablePids(),
             selfPid: process.pid,
         }),
+        stopContainer: (name) => stopContainer(name, containers),
         studioService,
         openWith,
         terminals,
         openUrl: options.openUrl,
+        updates,
+        shortUrls,
     };
     runtimes.set(services, runtime);
     return services;
@@ -130,6 +175,7 @@ export function createUninstallServices(configPath = defaultConfigPath()) {
         recordPath,
         routeProjectsPathFor(configPath),
         openWithPathFor(configPath),
+        updateCheckPathFor(configPath),
     ];
     const processes = new SystemProcessControl({
         platform: process.platform,
@@ -160,6 +206,7 @@ export async function startServer(options) {
             scanner: services.scanner,
             configStore: services.configStore,
             projects: new ProjectInfoReader(),
+            ...(services.shortUrls ? { shortUrls: services.shortUrls } : {}),
         });
     const token = randomBytes(32).toString("base64url");
     const http = createHttpServer({
@@ -170,10 +217,12 @@ export async function startServer(options) {
         doctor: services.doctor,
         controlProxy: services.controlProxy,
         stopProcess: services.stopProcess,
+        stopContainer: services.stopContainer,
         ...(services.studioService ? { studioService: services.studioService } : {}),
         ...(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);
@@ -185,6 +234,8 @@ export async function startServer(options) {
     const { port } = http.server.address();
     studio.setStudioPort(port);
     studio.start();
+    // The short-URL forwarder settles before anyone prints or registers a URL.
+    await studio.ready();
     return {
         url: `http://${LOOPBACK}:${port}`,
         port,
@@ -195,8 +246,10 @@ export async function startServer(options) {
             studio.stop();
             services.terminals?.closeAll();
             http.closeStreams();
-            http.server.close(() => resolve());
-            http.server.closeAllConnections();
+            void (services.shortUrls?.close() ?? Promise.resolve()).finally(() => {
+                http.server.close(() => resolve());
+                http.server.closeAllConnections();
+            });
         }),
     };
 }
@@ -211,6 +264,7 @@ function lazySpawner() {
         get mode() {
             return mode;
         },
+        shellName: interactiveShellName(),
         spawn: async (request) => {
             real ??= detectTerminalMode(process.platform).then((detected) => createTerminalSpawner({ mode: detected }));
             const spawner = await real;