@tnldotdev/tnl 0.1.0-rc.13 → 0.1.0-rc.17

package/dist/next.js

@@ -0,0 +1,85 @@
+import { canonicalLoopbackTarget, readDevelopmentContext, registerLocalTarget, requestTunnelAssignment, runtimePayload, } from "./internal/dev.js";
+const developmentServerPhase = "phase-development-server";
+const runtimeEnvironmentName = "TNL_PROJECT_RUNTIME";
+/** Adds tnl project metadata and safe `tnl dev` routing to a Next.js development server. */
+export function withTnl(config = {}, ...extra) {
+    if (extra.length !== 0) {
+        throw new Error("withTnl() does not accept tunnel options; use project configuration");
+    }
+    return async function tnlNextConfig(phase, context) {
+        const resolved = typeof config === "function" ? await config(phase, context) : await config;
+        const nextConfig = resolved ?? {};
+        if (phase !== developmentServerPhase) {
+            return nextConfig;
+        }
+        const development = readDevelopmentContext();
+        if (development.bootstrap === null) {
+            if (development.localProject === null) {
+                return nextConfig;
+            }
+            return injectRuntime(nextConfig, runtimePayload(development.localProject, false));
+        }
+        const allowedDevOrigins = nextConfig.allowedDevOrigins ?? [];
+        if (!Array.isArray(allowedDevOrigins)) {
+            throw new Error("Next.js allowedDevOrigins must be an array when used with tnl");
+        }
+        const target = nextTarget(process.env);
+        const assignment = await requestTunnelAssignment("next", development.bootstrap);
+        await registerLocalTarget(assignment, target);
+        return injectRuntime({
+            ...nextConfig,
+            allowedDevOrigins: unique([...allowedDevOrigins, assignment.hostname]),
+        }, runtimePayload(assignment.project, true));
+    };
+}
+function injectRuntime(config, payload) {
+    return {
+        ...config,
+        env: {
+            ...config.env,
+            [runtimeEnvironmentName]: payload,
+        },
+    };
+}
+function nextTarget(environment) {
+    // Next 16.3.4 binds and sets this origin before loading next.config, so it is authoritative.
+    const value = environment.__NEXT_PRIVATE_ORIGIN;
+    if (value === undefined) {
+        throw new Error("Next.js did not report its bound development listener to tnl dev");
+    }
+    let origin;
+    try {
+        origin = new URL(value);
+        if (origin.protocol !== "http:" ||
+            origin.username !== "" ||
+            origin.password !== "" ||
+            origin.pathname !== "/" ||
+            origin.search !== "" ||
+            origin.hash !== "" ||
+            origin.port === "") {
+            throw new Error("invalid origin");
+        }
+    }
+    catch (error) {
+        throw new Error("Next.js reported an invalid development listener", { cause: error });
+    }
+    const port = parsePort(origin.port, "Next.js listener");
+    const reportedPort = environment.PORT;
+    if (reportedPort !== undefined && parsePort(reportedPort, "PORT") !== port) {
+        throw new Error("Next.js reported inconsistent development listener ports");
+    }
+    return canonicalLoopbackTarget(origin.hostname, port);
+}
+function parsePort(value, source) {
+    if (!/^[0-9]+$/.test(value)) {
+        throw new Error(`${source} must be a port between 1 and 65535`);
+    }
+    const port = Number(value);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new Error(`${source} must be a port between 1 and 65535`);
+    }
+    return port;
+}
+function unique(values) {
+    return [...new Set(values)];
+}

package/dist/vite.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "vite";
+/** Adds tnl project metadata and safe `tnl dev` routing to a Vite development server. */
+export default function tnl(...arguments_: never[]): Plugin;

package/dist/vite.js

@@ -0,0 +1,98 @@
+import { canonicalLoopbackTarget, readDevelopmentContext, registerLocalTarget, requestTunnelAssignment, runtimePayload, } from "./internal/dev.js";
+const runtimeDefineName = "process.env.TNL_PROJECT_RUNTIME";
+/** Adds tnl project metadata and safe `tnl dev` routing to a Vite development server. */
+export default function tnl(...arguments_) {
+    if (arguments_.length !== 0) {
+        throw new Error("tnl() does not accept tunnel options; use project configuration");
+    }
+    let assignment = null;
+    let localPortRegistered = false;
+    return {
+        name: "tnl",
+        enforce: "post",
+        apply: "serve",
+        async config(userConfig = {}, configEnvironment) {
+            assignment = null;
+            localPortRegistered = false;
+            if (configEnvironment.command !== "serve" || configEnvironment.isPreview === true) {
+                return undefined;
+            }
+            const development = readDevelopmentContext();
+            if (development.bootstrap === null) {
+                if (development.localProject === null) {
+                    return undefined;
+                }
+                return runtimeDefine(runtimePayload(development.localProject, false));
+            }
+            const server = userConfig.server ?? {};
+            validateAllowedHosts(server.allowedHosts);
+            assignment = await requestTunnelAssignment("vite", development.bootstrap);
+            const result = {
+                ...runtimeDefine(runtimePayload(assignment.project, true)),
+                server: {
+                    allowedHosts: addAllowedHost(server.allowedHosts, assignment.hostname),
+                },
+            };
+            if (development.bootstrap.port === undefined) {
+                return result;
+            }
+            return {
+                ...result,
+                server: {
+                    ...result.server,
+                    port: development.bootstrap.port,
+                    // Let Vite report a fallback listener so tnl can reject it with the target diagnostic.
+                    strictPort: false,
+                },
+            };
+        },
+        configureServer(server) {
+            const configured = assignment;
+            if (configured === null) {
+                return;
+            }
+            if (server.httpServer === null) {
+                throw new Error("Vite middleware mode cannot register a listening target with tnl dev");
+            }
+            const originalListen = server.listen.bind(server);
+            server.listen = async (port, isRestart) => {
+                const listening = await originalListen(port, isRestart);
+                if (localPortRegistered) {
+                    return listening;
+                }
+                const address = server.httpServer?.address();
+                if (address === null || address === undefined || typeof address === "string") {
+                    await server.close();
+                    throw new Error("Vite did not report its listening port to tnl dev");
+                }
+                try {
+                    await registerLocalTarget(configured, canonicalLoopbackTarget(address.address, address.port));
+                    localPortRegistered = true;
+                }
+                catch (error) {
+                    await server.close();
+                    throw error;
+                }
+                return listening;
+            };
+        },
+    };
+}
+function runtimeDefine(payload) {
+    return {
+        define: {
+            [runtimeDefineName]: JSON.stringify(payload),
+        },
+    };
+}
+function addAllowedHost(allowedHosts, hostname) {
+    if (allowedHosts === true) {
+        return true;
+    }
+    return [...new Set([...(allowedHosts ?? []), hostname])];
+}
+function validateAllowedHosts(value) {
+    if (value !== undefined && value !== true && !Array.isArray(value)) {
+        throw new Error("Vite server.allowedHosts must be an array or true when used with tnl");
+    }
+}

package/lib/config.d.ts

@@ -0,0 +1,69 @@
+export interface TNL {
+  server?: string;
+  team?: string;
+  tunnel?: {
+    host?: string;
+    subdomain?: string;
+    public?: boolean;
+    ephemeral?: boolean;
+    /**
+     * @maxItems 63
+     */
+    allowIP?: string[];
+  };
+  publish?: Publish;
+  dev?: Dev;
+  services?: {
+    [k: string]: {
+      directory?: string;
+      server?: string;
+      team?: string;
+      tunnel?: {
+        host?: string;
+        subdomain?: string;
+        public?: boolean;
+        ephemeral?: boolean;
+        /**
+         * @maxItems 63
+         */
+        allowIP?: string[];
+      };
+      publish?: Publish;
+      dev?: Dev;
+    };
+  };
+}
+export interface Publish {
+  target?: string | number;
+}
+export interface Dev {
+  /**
+   * @minItems 1
+   */
+  command?: [string, ...string[]];
+  port?: number;
+  startupTimeout?: string;
+}
+
+/** Details about the Git worktree or project directory containing tnl.config.ts. */
+export interface TnlWorktree {
+  readonly isGit: boolean;
+  /** DNS-safe name keyed to this worktree and client state directory. */
+  readonly label: string;
+  readonly name: string;
+  readonly root: string;
+}
+
+/** Values available to a tnl.config.ts configuration factory. */
+export interface TnlConfigContext {
+  readonly cwd: string;
+  readonly env: Readonly<Record<string, string>>;
+  readonly worktree: TnlWorktree;
+}
+
+export type TnlConfigFactory = (context: TnlConfigContext) => TNL | Promise<TNL>;
+
+export type TnlConfigInput = TNL | TnlConfigFactory;
+
+/** Provides type checking for an implicit-version-1 tnl.config.ts configuration. */
+export declare function defineConfig<const Config extends TnlConfigInput>(config: Config): Config;

package/lib/config.mjs

@@ -0,0 +1,3 @@
+export function defineConfig(config) {
+  return config;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tnldotdev/tnl",
-  "version": "0.1.0-rc.13",
-  "description": "The tnl client for project-local development workflows.",
+  "version": "0.1.0-rc.17",
+  "description": "The tnl client and framework integrations for project-local development.",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -13,22 +13,70 @@
   },
   "files": [
     "bin",
-    "lib"
+    "dist",
+    "lib",
+    "NOTICE",
+    "THIRD_PARTY_LICENSES.txt"
   ],
   "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./config": {
+      "types": "./lib/config.d.ts",
+      "import": "./lib/config.mjs"
+    },
+    "./next": {
+      "types": "./dist/next.d.ts",
+      "import": "./dist/next.js",
+      "default": "./dist/next.js"
+    },
+    "./vite": {
+      "types": "./dist/vite.d.ts",
+      "import": "./dist/vite.js",
+      "default": "./dist/vite.js"
+    }
+  },
   "publishConfig": {
     "access": "public"
   },
+  "scripts": {
+    "build": "pnpm run clean && tsc --project tsconfig.json",
+    "clean": "node ../../scripts/clean-package.mjs",
+    "prepack": "pnpm run build"
+  },
+  "devDependencies": {
+    "next": "16.3.4",
+    "react": "19.2.8",
+    "react-dom": "19.2.8",
+    "vite": "8.2.2"
+  },
+  "peerDependencies": {
+    "next": ">=16.3.4",
+    "vite": ">=6.0.9"
+  },
+  "peerDependenciesMeta": {
+    "next": {
+      "optional": true
+    },
+    "vite": {
+      "optional": true
+    }
+  },
   "engines": {
-    "node": ">=22.15"
+    "node": ">=22.18"
   },
   "optionalDependencies": {
-    "@tnldotdev/tnl-darwin-arm64": "0.1.0-rc.13",
-    "@tnldotdev/tnl-darwin-x64": "0.1.0-rc.13",
-    "@tnldotdev/tnl-linux-arm64": "0.1.0-rc.13",
-    "@tnldotdev/tnl-linux-x64": "0.1.0-rc.13"
+    "@tnldotdev/tnl-darwin-arm64": "0.1.0-rc.17",
+    "@tnldotdev/tnl-darwin-x64": "0.1.0-rc.17",
+    "@tnldotdev/tnl-linux-arm64": "0.1.0-rc.17",
+    "@tnldotdev/tnl-linux-x64": "0.1.0-rc.17"
   },
   "tnl": {
-    "commit": "5ea468a77835db128d4ff826c126dc234595704a"
+    "commit": "bd70c08fe7c09aef1153e1afbbb25161d519a7ec"
   }
 }