@tnldotdev/tnl 0.1.0-rc.15 → 0.1.0-rc.20

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/lib/launcher.mjs

@@ -2,16 +2,17 @@ import { constants, accessSync, readFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
 import process from "node:process";
+import { nativeTargets } from "./native-targets.mjs";
 
 const require = createRequire(import.meta.url);
 const launcherManifest = new URL("../package.json", import.meta.url);
 
-const nativePackages = new Map([
-  ["darwin-arm64", "@tnldotdev/tnl-darwin-arm64"],
-  ["darwin-x64", "@tnldotdev/tnl-darwin-x64"],
-  ["linux-arm64", "@tnldotdev/tnl-linux-arm64"],
-  ["linux-x64", "@tnldotdev/tnl-linux-x64"],
-]);
+const nativePackages = new Map(
+  nativeTargets.map(({ platform, architecture, packageName }) => [
+    `${platform}-${architecture}`,
+    packageName,
+  ]),
+);
 
 export function nativePackageName(platform, architecture) {
   const packageName = nativePackages.get(`${platform}-${architecture}`);

package/lib/native-targets.mjs

@@ -0,0 +1,12 @@
+/** Internal distribution catalog shared by the launcher and release scripts.
+ * Node architecture names belong here; Go artifact paths and versions do not.
+ * Entries retain native publish order. This module is not a public package export.
+ */
+export const nativeTargets = Object.freeze(
+  [
+    { platform: "darwin", architecture: "arm64", packageName: "@tnldotdev/tnl-darwin-arm64" },
+    { platform: "darwin", architecture: "x64", packageName: "@tnldotdev/tnl-darwin-x64" },
+    { platform: "linux", architecture: "arm64", packageName: "@tnldotdev/tnl-linux-arm64" },
+    { platform: "linux", architecture: "x64", packageName: "@tnldotdev/tnl-linux-x64" },
+  ].map((target) => Object.freeze(target)),
+);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tnldotdev/tnl",
-  "version": "0.1.0-rc.15",
-  "description": "The tnl client for project-local development workflows.",
+  "version": "0.1.0-rc.20",
+  "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.15",
-    "@tnldotdev/tnl-darwin-x64": "0.1.0-rc.15",
-    "@tnldotdev/tnl-linux-arm64": "0.1.0-rc.15",
-    "@tnldotdev/tnl-linux-x64": "0.1.0-rc.15"
+    "@tnldotdev/tnl-darwin-arm64": "0.1.0-rc.20",
+    "@tnldotdev/tnl-darwin-x64": "0.1.0-rc.20",
+    "@tnldotdev/tnl-linux-arm64": "0.1.0-rc.20",
+    "@tnldotdev/tnl-linux-x64": "0.1.0-rc.20"
   },
   "tnl": {
-    "commit": "6c007d4dc631cced3042a3490c4c785f15c1548e"
+    "commit": "a2073944387d90f6b7a83ec28a409964b06a28a7"
   }
 }