@stacksjs/ts-cloud 0.7.3 → 0.7.5

package/dist/drivers/aws/driver.d.ts

@@ -2,6 +2,14 @@ import type { CloudDriver, ComputeStackOutputs, ComputeTarget, FindComputeTarget
 export interface AwsDriverOptions {
     region?: string;
 }
+/**
+ * Local-state pin (parity with the Hetzner driver's shared-box support): a
+ * project riding an instance whose tags belong to another project records
+ * `{ "instanceId": "i-..." }` in `.ts-cloud/state/<stack>.json`, and target
+ * lookups trust that record when the tag scan finds nothing. Exported for
+ * tests.
+ */
+export declare function readPinnedInstanceId(stackName: string): string | null;
 export declare class AwsDriver implements CloudDriver {
     readonly name: "aws";
     readonly usesCloudFormation = true;
@@ -26,6 +34,7 @@ export declare class AwsDriver implements CloudDriver {
     getComputeOutputs(options: ProvisionComputeOptions): Promise<ComputeStackOutputs>;
     uploadRelease(options: UploadReleaseOptions): Promise<UploadReleaseResult>;
     findComputeTargets(options: FindComputeTargetsOptions): Promise<ComputeTarget[]>;
+    private reservationsToTargets;
     /**
      * SSM AWS-RunShellScript executes the joined commands with `/bin/sh` (dash on
      * Ubuntu), which rejects bash-only syntax like `set -o pipefail`. Our deploy

package/dist/drivers/hetzner/provision.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Idempotent find-or-create provisioning helpers on top of the Hetzner client.
+ *
+ * These are the building blocks for "deploy X onto a Hetzner box" scripts:
+ * each helper reuses an existing resource when one matches (by name, or by
+ * key body for SSH keys) and creates it otherwise, so re-running a deploy
+ * converges instead of failing on duplicates.
+ */
+import type { CreateServerOptions, HetznerClient, HetznerFirewallRule, HetznerServer } from './client';
+export interface EnsuredResource {
+    id: number;
+    name: string;
+    created: boolean;
+}
+export interface EnsureSshKeyOptions {
+    /** Name used if the key needs to be registered. */
+    name: string;
+    /** OpenSSH public key (`<type> <base64> [comment]`). */
+    publicKey: string;
+    labels?: Record<string, string>;
+}
+/**
+ * Register an SSH public key, reusing any already-registered key with the
+ * same body (comment/whitespace differences ignored) regardless of its name.
+ */
+export declare function ensureSshKey(client: HetznerClient, options: EnsureSshKeyOptions): Promise<EnsuredResource>;
+export interface EnsureFirewallOptions {
+    name: string;
+    rules: HetznerFirewallRule[];
+    labels?: Record<string, string>;
+}
+/**
+ * Find a firewall by name and sync its rules to the given set, or create it.
+ * Rules are replaced in-place on reuse so the firewall always matches the
+ * declared config.
+ */
+export declare function ensureFirewall(client: HetznerClient, options: EnsureFirewallOptions): Promise<EnsuredResource>;
+export interface EnsureServerOptions extends CreateServerOptions {
+    /** Wait until the (created or reused) server reaches `running`. @default true */
+    waitForRunning?: boolean;
+}
+export interface EnsuredServer {
+    server: HetznerServer;
+    created: boolean;
+}
+/**
+ * Find a server by name or create it, waiting until it is running by default.
+ * Creation options (`userData`, `sshKeys`, `firewalls`, ...) only apply when
+ * the server does not exist yet — an existing server is reused as-is.
+ */
+export declare function ensureServer(client: HetznerClient, options: EnsureServerOptions): Promise<EnsuredServer>;
+/** The public IPv4 of a server, throwing when it has none. */
+export declare function serverPublicIpv4(server: HetznerServer): string;

package/dist/drivers/index.d.ts

@@ -2,8 +2,12 @@ export * from './factory';
 export { AwsDriver } from './aws/driver';
 export { HetznerDriver } from './hetzner/driver';
 export { isBoxMode, LocalBoxDriver } from './local-box/driver';
-export { HetznerClient, resolveHetznerApiToken } from './hetzner/client';
+export { HetznerClient, normalizeSshPublicKey, resolveHetznerApiToken } from './hetzner/client';
 export { generateUbuntuAppCloudInit, wrapCloudInitUserData } from './hetzner/cloud-init';
+export { ensureFirewall, ensureServer, ensureSshKey, serverPublicIpv4 } from './hetzner/provision';
+export type { EnsuredResource, EnsuredServer, EnsureFirewallOptions, EnsureServerOptions, EnsureSshKeyOptions, } from './hetzner/provision';
+export { buildSshArgs, scpUpload, sshExec, sshExecOrThrow, waitForCloudInit, waitForSsh } from './shared/remote-exec';
+export type { RemoteExecOptions, RemoteExecResult, WaitOptions } from './shared/remote-exec';
 export { buildAwsArtifactFetch, buildLocalArtifactFetch, buildSiteDeployScript, buildStaticSiteDeployScript, resolveExecStart, } from './shared/deploy-script';
 export { deployAllComputeSites, deploySiteRelease, reloadRpxGateway } from './shared/compute-deploy';
 export { buildRpxConfig, buildRpxLbConfig, buildRpxProvisionScript, deriveRouteId, normalizeRoutePath, renderRpxLauncher, DEFAULT_RPX_CERTS_DIR, RPX_DIR, RPX_LAUNCHER_PATH, RPX_SERVICE_NAME, } from './shared/rpx-gateway';

package/dist/drivers/shared/remote-exec.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Minimal SSH/scp helpers for driving a freshly-provisioned box from a deploy
+ * script, plus wait loops for the boot milestones every provider shares
+ * (sshd accepting connections, cloud-init finished).
+ *
+ * Uses the system `ssh`/`scp` binaries via Bun.spawn — no keys or agents are
+ * managed here; pass `identityFile` or rely on the ambient SSH config.
+ */
+export interface RemoteExecOptions {
+    /** SSH user. @default 'root' */
+    user?: string;
+    /** Private key passed as `ssh -i`. Omit to use the ambient SSH config/agent. */
+    identityFile?: string;
+    /** SSH `ConnectTimeout` in seconds. @default 10 */
+    connectTimeoutSec?: number;
+}
+export interface RemoteExecResult {
+    code: number;
+    stdout: string;
+    stderr: string;
+}
+/**
+ * The ssh/scp CLI arguments implied by {@link RemoteExecOptions}. Host key
+ * checking is disabled because these helpers target freshly-created servers
+ * whose host keys cannot be known in advance.
+ */
+export declare function buildSshArgs(options?: RemoteExecOptions): string[];
+/** Run a command on the host over SSH, capturing exit code and output. */
+export declare function sshExec(host: string, command: string, options?: RemoteExecOptions): Promise<RemoteExecResult>;
+/** Like {@link sshExec}, but throws on non-zero exit and returns stdout. */
+export declare function sshExecOrThrow(host: string, command: string, options?: RemoteExecOptions): Promise<string>;
+/** Copy local files into a directory on the host via scp. */
+export declare function scpUpload(host: string, localPaths: string[], remoteDir: string, options?: RemoteExecOptions): Promise<void>;
+export interface WaitOptions extends RemoteExecOptions {
+    /** Give up after this long. */
+    timeoutMs?: number;
+    /** Delay between attempts. @default 5000 */
+    pollIntervalMs?: number;
+}
+/** Poll until sshd accepts the connection (box booted + key authorized). */
+export declare function waitForSsh(host: string, options?: WaitOptions): Promise<void>;
+/**
+ * Poll `cloud-init status` until it reports done. Throws when cloud-init
+ * reports an error so a broken first boot fails the deploy instead of
+ * surfacing later as missing packages.
+ */
+export declare function waitForCloudInit(host: string, options?: WaitOptions): Promise<void>;

package/dist/index.js

@@ -84592,12 +84592,12 @@ import { existsSync as existsSync26, statSync as statSync6 } from "node:fs";
 import { readFile as readFile2, writeFile as writeFile6 } from "node:fs/promises";
 import { mkdtempSync as mkdtempSync6 } from "node:fs";
 import { tmpdir as tmpdir7 } from "node:os";
-import { dirname as dirname9, extname as extname3, join as join23, normalize } from "node:path";
+import { dirname as dirname9, extname as extname3, join as join25, normalize } from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
 
 // src/deploy/dashboard-data-server.ts
 import { existsSync as existsSync24, readFileSync as readFileSync18 } from "node:fs";
-import { join as join21 } from "node:path";
+import { join as join23 } from "node:path";
 
 // src/drivers/factory.ts
 await init_dist2();
@@ -84606,6 +84606,7 @@ await init_dist2();
 init_cloudformation();
 await init_dist2();
 import { readFileSync as readFileSync15 } from "node:fs";
+import { join as join18 } from "node:path";
 init_s3();
 
 // src/drivers/shared/package-manager.ts
@@ -85716,6 +85717,16 @@ function resolveAwsImageId(config6) {
 }
 
 // src/drivers/aws/driver.ts
+function readPinnedInstanceId(stackName) {
+  try {
+    const raw = readFileSync15(join18(process.cwd(), ".ts-cloud/state", `${stackName}.json`), "utf8");
+    const state = JSON.parse(raw);
+    return typeof state.instanceId === "string" && state.instanceId.length > 0 ? state.instanceId : null;
+  } catch {
+    return null;
+  }
+}
+
 class AwsDriver {
   name = "aws";
   usesCloudFormation = true;
@@ -85893,8 +85904,33 @@ class AwsDriver {
       { Name: "instance-state-name", Values: ["running", "pending"] }
     ];
     const result = await ec22.describeInstances({ Filters: filters });
+    const targets = this.reservationsToTargets(result.Reservations);
+    if (targets.length > 0 || (options.role || "app") !== "app")
+      return targets;
+    const stackName = options.stackName ?? `${options.slug}-${options.environment}`;
+    let pinnedId = readPinnedInstanceId(stackName);
+    if (!pinnedId) {
+      try {
+        pinnedId = (await new CloudFormationClient(region).getStackOutputs(stackName)).appInstanceId ?? null;
+      } catch {
+        pinnedId = null;
+      }
+    }
+    if (!pinnedId)
+      return [];
+    try {
+      const pinned = await ec22.describeInstances({
+        InstanceIds: [pinnedId],
+        Filters: [{ Name: "instance-state-name", Values: ["running", "pending"] }]
+      });
+      return this.reservationsToTargets(pinned.Reservations);
+    } catch {
+      return [];
+    }
+  }
+  reservationsToTargets(reservations) {
     const targets = [];
-    for (const reservation of result.Reservations || []) {
+    for (const reservation of reservations || []) {
       for (const instance of reservation.Instances || []) {
         if (!instance.InstanceId)
           continue;
@@ -85987,7 +86023,7 @@ class AwsDriver {
 await init_dist2();
 import { existsSync as existsSync20, readFileSync as readFileSync16 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
 import { execSync as execSync3 } from "node:child_process";
 
 // src/drivers/hetzner/client.ts
@@ -86291,6 +86327,17 @@ function buildRpxConfigInternal(sites, options, appBoxes) {
     }
     domains.add(site.domain);
   }
+  if (options.proxy.autoWww !== false) {
+    for (const domain of [...domains]) {
+      if (domain.split(".").length !== 2)
+        continue;
+      const wwwDomain = `www.${domain}`;
+      if (domains.has(wwwDomain))
+        continue;
+      proxies.push({ to: wwwDomain, redirect: { to: `https://${domain}` }, id: deriveRouteId(wwwDomain) });
+      domains.add(wwwDomain);
+    }
+  }
   proxies.sort((a, b) => {
     if (a.to !== b.to)
       return a.to.localeCompare(b.to);
@@ -86607,10 +86654,10 @@ function matchesTsCloudLabels(labels, slug, environment, role = "app") {
 
 // src/drivers/hetzner/state.ts
 import { mkdir as mkdir4, readFile, writeFile as writeFile4 } from "node:fs/promises";
-import { join as join18 } from "node:path";
+import { join as join19 } from "node:path";
 var STATE_DIR = ".ts-cloud/state";
 function driverStatePath(stackName) {
-  return join18(process.cwd(), STATE_DIR, `${stackName}.json`);
+  return join19(process.cwd(), STATE_DIR, `${stackName}.json`);
 }
 async function readDriverState(stackName) {
   try {
@@ -86622,7 +86669,7 @@ async function readDriverState(stackName) {
 }
 async function writeDriverState(stackName, state) {
   const path = driverStatePath(stackName);
-  await mkdir4(join18(process.cwd(), STATE_DIR), { recursive: true });
+  await mkdir4(join19(process.cwd(), STATE_DIR), { recursive: true });
   await writeFile4(path, `${JSON.stringify(state, null, 2)}
 `, "utf8");
 }
@@ -86630,7 +86677,7 @@ async function writeDriverState(stackName, state) {
 // src/drivers/hetzner/driver.ts
 var SSH_MAX_BUFFER = 1024 * 1024 * 256;
 function expandHome(path) {
-  return path.startsWith("~/") ? join19(homedir8(), path.slice(2)) : path;
+  return path.startsWith("~/") ? join20(homedir8(), path.slice(2)) : path;
 }
 
 class HetznerDriver {
@@ -87195,7 +87242,8 @@ class HetznerDriver {
     const targets = await this.findComputeTargets({
       slug: options.config.project.slug,
       environment: options.environment,
-      role: "app"
+      role: "app",
+      stackName: resolveProjectStackName(options.config, options.environment)
     });
     const first = targets[0];
     return {
@@ -87209,7 +87257,8 @@ class HetznerDriver {
     const targets = options.targets?.length ? options.targets : await this.findComputeTargets({
       slug: options.config.project.slug,
       environment: options.environment,
-      role: "app"
+      role: "app",
+      stackName: resolveProjectStackName(options.config, options.environment)
     });
     if (targets.length === 0) {
       throw new Error("No Hetzner compute targets found for release upload");
@@ -87237,6 +87286,20 @@ class HetznerDriver {
     const exact = servers.filter((server) => matchesTsCloudLabels(server.labels, options.slug, options.environment, role));
     if (exact.length > 0)
       return exact.map(toTarget);
+    if (role === "app") {
+      const state = await readDriverState(options.stackName ?? `${options.slug}-${options.environment}`);
+      const pinnedIds = [state?.serverId, ...state?.appServerIds ?? []].filter((id) => typeof id === "number");
+      if (pinnedIds.length > 0) {
+        const pinned = [];
+        for (const id of pinnedIds) {
+          const server = servers.find((candidate) => candidate.id === id) ?? await this.tryGetServer(id);
+          if (server && server.status !== "off")
+            pinned.push(server);
+        }
+        if (pinned.length > 0)
+          return pinned.map(toTarget);
+      }
+    }
     if (role === "app") {
       const candidates = servers.filter((server) => server.status !== "off" && server.labels?.[`${TS_CLOUD_LABEL_PREFIX}/managed-by`] === "ts-cloud" && server.labels?.[`${TS_CLOUD_LABEL_PREFIX}/environment`] === options.environment && server.labels?.[`${TS_CLOUD_LABEL_PREFIX}/role`] === "app");
       if (candidates.length === 1)
@@ -87719,10 +87782,10 @@ import { execSync as execSync5 } from "node:child_process";
 import { randomBytes as randomBytes6 } from "node:crypto";
 import { chmodSync, existsSync as existsSync21, mkdirSync as mkdirSync9, readFileSync as readFileSync17, writeFileSync as writeFileSync12 } from "node:fs";
 import { tmpdir as tmpdir6 } from "node:os";
-import { dirname as dirname8, isAbsolute as isAbsolute5, join as join20 } from "node:path";
+import { dirname as dirname8, isAbsolute as isAbsolute5, join as join21 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 var MANAGEMENT_DASHBOARD_SITE = "dashboard";
-var DASHBOARD_CREDENTIALS_FILE = join20(".ts-cloud", "dashboard-credentials.json");
+var DASHBOARD_CREDENTIALS_FILE = join21(".ts-cloud", "dashboard-credentials.json");
 function generatePassword() {
   return randomBytes6(24).toString("base64url");
 }
@@ -87732,7 +87795,7 @@ function resolveDashboardAuth(cwd, username, logger4) {
     return { password: explicit, source: "env" };
   if (truthy(process.env.TS_CLOUD_UI_PUBLIC))
     return { password: undefined, source: "public" };
-  const file = join20(cwd, DASHBOARD_CREDENTIALS_FILE);
+  const file = join21(cwd, DASHBOARD_CREDENTIALS_FILE);
   try {
     if (existsSync21(file)) {
       const saved = JSON.parse(readFileSync17(file, "utf8"));
@@ -87757,18 +87820,18 @@ function truthy(v) {
   return v != null && v !== "" && v !== "0" && v.toLowerCase() !== "false";
 }
 function resolveUiSource(cwd) {
-  if (existsSync21(join20(cwd, "packages", "ui", "pages")) || existsSync21(join20(cwd, "packages", "ui", "package.json"))) {
+  if (existsSync21(join21(cwd, "packages", "ui", "pages")) || existsSync21(join21(cwd, "packages", "ui", "package.json"))) {
     return { uiRoot: "packages/ui/dist", build: "cd packages/ui && bun install && bun run build" };
   }
   const here = dirname8(fileURLToPath4(import.meta.url));
   const candidates = [
-    join20(here, "ui"),
-    join20(here, "..", "ui"),
-    join20(here, "..", "..", "ui"),
-    join20(here, "..", "dist", "ui")
+    join21(here, "ui"),
+    join21(here, "..", "ui"),
+    join21(here, "..", "..", "ui"),
+    join21(here, "..", "dist", "ui")
   ];
   for (const dir of candidates) {
-    if (existsSync21(join20(dir, "index.html")) || existsSync21(join20(dir, "serverless.html")))
+    if (existsSync21(join21(dir, "index.html")) || existsSync21(join21(dir, "serverless.html")))
       return { uiRoot: dir, build: false };
   }
   return null;
@@ -87821,12 +87884,12 @@ function buildManagementDashboardArtifact(site, options) {
       logger4.info(`Management dashboard: building UI (${site.build})`);
       execSync5(site.build, { cwd, stdio: "inherit" });
     }
-    const root = isAbsolute5(site.root) ? site.root : join20(cwd, site.root);
+    const root = isAbsolute5(site.root) ? site.root : join21(cwd, site.root);
     if (!existsSync21(root)) {
       logger4.warn(`Management dashboard: build output not found at ${root} — skipping dashboard artifact.`);
       return null;
     }
-    const tarball = join20(tmpdir6(), `${options.slug}-${MANAGEMENT_DASHBOARD_SITE}-${options.sha}.tar.gz`);
+    const tarball = join21(tmpdir6(), `${options.slug}-${MANAGEMENT_DASHBOARD_SITE}-${options.sha}.tar.gz`);
     execSync5(`tar czf "${tarball}" -C "${root}" .`, { stdio: "inherit" });
     return tarball;
   } catch (error2) {
@@ -88355,10 +88418,11 @@ async function deploySiteRelease(driver, options, logger4 = noopLogger2) {
   const targets = await driver.findComputeTargets({
     slug,
     environment,
-    role: "app"
+    role: "app",
+    stackName
   });
   if (targets.length === 0) {
-    const hint = driver.name === "aws" ? `Stack '${stackName}' has no EC2 instances tagged Project=${slug} Environment=${environment} Role=app.` : `No Hetzner servers labeled ts-cloud/project=${slug} ts-cloud/environment=${environment} ts-cloud/role=app.`;
+    const hint = driver.name === "aws" ? `Stack '${stackName}' has no EC2 instances tagged Project=${slug} Environment=${environment} Role=app, and .ts-cloud/state/${stackName}.json pins no live instance. For a shared box, record its instanceId there.` : `No Hetzner servers labeled ts-cloud/project=${slug} ts-cloud/environment=${environment} ts-cloud/role=app, and .ts-cloud/state/${stackName}.json pins no live server. For a shared box, record its serverId there.`;
     return { success: false, error: hint };
   }
   if (isPhpSite(site)) {
@@ -88588,7 +88652,8 @@ async function reloadRpxGateway(options) {
   const targets = await driver.findComputeTargets({
     slug: config6.project.slug,
     environment,
-    role: "app"
+    role: "app",
+    stackName: resolveProjectStackName(config6, environment)
   });
   if (targets.length === 0) {
     logger4.warn("rpx gateway: no compute targets found — skipping gateway reload.");
@@ -88877,7 +88942,7 @@ function configuredRegion(config6) {
   return config6.project.region ?? "us-east-1";
 }
 function loadLocalState(config6, environment) {
-  const statePath = join21(process.cwd(), ".ts-cloud", "state", `${config6.project.slug}-${environment}.json`);
+  const statePath = join23(process.cwd(), ".ts-cloud", "state", `${config6.project.slug}-${environment}.json`);
   if (!existsSync24(statePath))
     return null;
   try {
@@ -90838,10 +90903,10 @@ function selectedEnvironment(config6, requested) {
 }
 async function loadLocalEnv(cwd) {
   const candidates = [
-    join23(here, "..", "..", "..", "..", ".env"),
-    join23(cwd, ".env"),
-    join23(cwd, ".env.local"),
-    join23(cwd, ".env.production")
+    join25(here, "..", "..", "..", "..", ".env"),
+    join25(cwd, ".env"),
+    join25(cwd, ".env.local"),
+    join25(cwd, ".env.production")
   ];
   for (const file of candidates) {
     if (!existsSync26(file))
@@ -90865,10 +90930,10 @@ async function loadLocalEnv(cwd) {
 }
 function resolveCloudConfigPath(cwd) {
   const candidates = [
-    join23(cwd, "config", "cloud.ts"),
-    join23(cwd, "config", "cloud.js"),
-    join23(cwd, "cloud.config.ts"),
-    join23(cwd, "cloud.config.js")
+    join25(cwd, "config", "cloud.ts"),
+    join25(cwd, "config", "cloud.js"),
+    join25(cwd, "cloud.config.ts"),
+    join25(cwd, "cloud.config.js")
   ];
   return candidates.find((file) => existsSync26(file)) ?? null;
 }
@@ -90908,15 +90973,15 @@ async function resolveLiveDashboardData(config6, environment) {
 }
 function resolveUiSourceDir(cwd) {
   const candidates = [
-    join23(cwd, "packages", "ui"),
-    join23(here, "..", "..", "..", "ui"),
-    join23(here, "..", "..", "ui"),
-    join23(here, "..", "ui-src"),
-    join23(here, "..", "..", "ui-src"),
-    join23(here, "..", "..", "dist", "ui-src")
+    join25(cwd, "packages", "ui"),
+    join25(here, "..", "..", "..", "ui"),
+    join25(here, "..", "..", "ui"),
+    join25(here, "..", "ui-src"),
+    join25(here, "..", "..", "ui-src"),
+    join25(here, "..", "..", "dist", "ui-src")
   ];
   for (const dir of candidates) {
-    if (existsSync26(join23(dir, "pages")) && existsSync26(join23(dir, "package.json")))
+    if (existsSync26(join25(dir, "pages")) && existsSync26(join25(dir, "package.json")))
       return dir;
   }
   return null;
@@ -90926,8 +90991,8 @@ async function buildLiveUi(cwd, data) {
   if (!uiDir)
     return null;
   try {
-    const outDir = mkdtempSync6(join23(tmpdir7(), "ts-cloud-dashboard-"));
-    const localStx = join23(uiDir, "node_modules", ".bin", "stx");
+    const outDir = mkdtempSync6(join25(tmpdir7(), "ts-cloud-dashboard-"));
+    const localStx = join25(uiDir, "node_modules", ".bin", "stx");
     const cmd = existsSync26(localStx) ? [localStx, "build", "--pages", "pages", "--out", outDir, "--no-sitemap", "--no-cache"] : ["bunx", "--bun", "@stacksjs/stx", "build", "--pages", "pages", "--out", outDir, "--no-sitemap", "--no-cache"];
     const proc = Bun.spawn(cmd, {
       cwd: uiDir,
@@ -91067,13 +91132,13 @@ function staticPath(uiRoot, pathname) {
   const normalized = normalize(wanted);
   if (normalized.startsWith("..") || normalized.includes("/../"))
     return null;
-  const base = join23(uiRoot, normalized);
+  const base = join25(uiRoot, normalized);
   if (existsSync26(base) && !statSync6(base).isDirectory())
     return base;
   if (!extname3(base) && existsSync26(`${base}.html`))
     return `${base}.html`;
-  if (!extname3(base) && existsSync26(join23(base, "index.html")))
-    return join23(base, "index.html");
+  if (!extname3(base) && existsSync26(join25(base, "index.html")))
+    return join25(base, "index.html");
   return null;
 }
 async function serveStatic(uiRoot, pathname) {