Skip to content
Source
Sign inSign up
TanStack/ai
Open History to see the last commit

dev.mjs

368 lines9.0 KB

1import { spawn } from 'node:child_process'
2import { fileURLToPath } from 'node:url'
3import { networkInterfaces } from 'node:os'
4import path from 'node:path'
5import { config as loadDotenv } from 'dotenv'
6​
7const BACKEND_PORT = 8787
8const EXAMPLE_DIR = path.resolve(fileURLToPath(new URL('..', import.meta.url)))
9const DEFAULT_ENV_FILE = path.join(EXAMPLE_DIR, '.env')
10const loadedEnvKeysByEnv = new WeakMap()
11​
12export function loadEnvFileIntoEnv(
13 envFile = DEFAULT_ENV_FILE,
14 env = process.env,
15) {
16 const result = loadDotenv({
17 path: envFile,
18 processEnv: env,
19 quiet: true,
20 })
21​
22 loadedEnvKeysByEnv.set(env, Object.keys(result.parsed ?? {}))
23​
24 return Boolean(result.parsed)
26​
27export function getPnpmCommand(platform = process.platform) {
28 return platform === 'win32' ? 'pnpm.cmd' : 'pnpm'
30​
31function isPrivateIpv4(address) {
32 const parts = address.split('.').map((part) => Number.parseInt(part, 10))
33 if (parts.length !== 4 || parts.some((part) => Number.isNaN(part))) {
34 return false
35 }
36​
37 const [first, second] = parts
38 return (
39 first === 10 ||
40 (first === 172 && second >= 16 && second <= 31) ||
41 (first === 192 && second === 168)
42 )
44​
45function isUsableIpv4(info) {
46 return (
47 info?.family === 'IPv4' &&
48 !info.internal &&
49 typeof info.address === 'string' &&
50 !info.address.startsWith('127.') &&
51 !info.address.startsWith('169.254.')
52 )
54​
55function isLikelyPhysicalInterface(name) {
56 return /\b(wi-?fi|wireless|wlan|ethernet)\b|^(en|eth)\d+/iu.test(name)
58​
59function isLikelyVirtualInterface(name) {
60 return /vEthernet|WSL|Hyper-V|Docker|Default Switch|VirtualBox|VMware|VPN|Tailscale|ZeroTier|WireGuard|loopback|\blo\b|bridge|\bbr-|tunnel|\btun|tap/iu.test(
61 name,
62 )
64​
65function enumerateIpv4Candidates(interfaces) {
66 return Object.entries(interfaces).flatMap(([interfaceName, items]) =>
67 (items ?? []).map((info) => ({
68 ...info,
69 interfaceName,
70 })),
71 )
73​
74function scoreLanCandidate(candidate) {
75 let score = 0
76​
77 if (isPrivateIpv4(candidate.address)) score += 100
78 if (isLikelyPhysicalInterface(candidate.interfaceName)) score += 50
79 if (isLikelyVirtualInterface(candidate.interfaceName)) score -= 100
80​
81 return score
83​
84export function pickLanAddressInfo(interfaces = networkInterfaces()) {
85 const usable = enumerateIpv4Candidates(interfaces).filter(isUsableIpv4)
86 const ranked = usable
87 .map((candidate, index) => ({
88 ...candidate,
89 index,
90 score: scoreLanCandidate(candidate),
91 }))
92 .sort((left, right) => right.score - left.score || left.index - right.index)
93​
94 return ranked[0]
96​
97export function pickLanAddress(interfaces = networkInterfaces()) {
98 return pickLanAddressInfo(interfaces)?.address
100​
101function isPublicMobileEnvKey(key) {
102 return (
103 key.startsWith('EXPO_PUBLIC_') || key === 'REACT_NATIVE_PACKAGER_HOSTNAME'
104 )
106​
107function shouldStripFromExpoEnv(key, loadedEnvKeys) {
108 return (
109 key.startsWith('OPENAI_') ||
110 (loadedEnvKeys.has(key) && !isPublicMobileEnvKey(key))
111 )
113​
114function createExpoEnv({
115 baseUrl,
116 env,
117 hasProvidedPackagerHostname,
118 packagerHostname,
119}) {
120 const loadedEnvKeys = new Set(loadedEnvKeysByEnv.get(env) ?? [])
121 const expoEnv = { ...env }
122​
123 for (const key of Object.keys(expoEnv)) {
124 if (shouldStripFromExpoEnv(key, loadedEnvKeys)) {
125 delete expoEnv[key]
126 }
127 }
128​
129 return {
130 ...expoEnv,
131 EXPO_NO_DOTENV: '1',
132 EXPO_PUBLIC_TANSTACK_AI_BASE_URL: baseUrl,
133 ...(hasProvidedPackagerHostname
134 ? { REACT_NATIVE_PACKAGER_HOSTNAME: packagerHostname }
135 : {}),
136 }
138​
139export function createDevConfig({
140 env = process.env,
141 networkInterfaces: interfaces = networkInterfaces(),
142 platform = process.platform,
143} = {}) {
144 const providedBaseUrl = env.EXPO_PUBLIC_TANSTACK_AI_BASE_URL
145 const providedPackagerHostname = env.REACT_NATIVE_PACKAGER_HOSTNAME
146 const hasProvidedPackagerHostname = Object.hasOwn(
147 env,
148 'REACT_NATIVE_PACKAGER_HOSTNAME',
149 )
150 const port = env.PORT ?? String(BACKEND_PORT)
151 const lanAddressInfo = pickLanAddressInfo(interfaces)
152 const lanAddress = lanAddressInfo?.address
153 const baseUrl =
154 providedBaseUrl ??
155 (lanAddress ? `http://${lanAddress}:${port}` : `http://127.0.0.1:${port}`)
156 const packagerHostname = hasProvidedPackagerHostname
157 ? providedPackagerHostname
158 : undefined
159 const metroHostSource = hasProvidedPackagerHostname ? 'environment' : 'expo'
160 const serverEnv = {
161 ...env,
162 PORT: port,
163 }
164 const expoEnv = createExpoEnv({
165 baseUrl,
166 env,
167 hasProvidedPackagerHostname,
168 packagerHostname,
169 })
170​
171 return {
172 baseUrl,
173 lanAddress,
174 lanInterfaceName: lanAddressInfo?.interfaceName,
175 metroHostSource,
176 packagerHostname,
177 port,
178 pnpmCommand: getPnpmCommand(platform),
179 serverOpenAIKeyLoaded: Boolean(serverEnv.OPENAI_API_KEY),
180 usedProvidedBaseUrl: Boolean(providedBaseUrl),
181 usedProvidedPackagerHostname: hasProvidedPackagerHostname,
182 serverEnv,
183 expoEnv,
184 }
186​
187export function createSpawnConfig({
188 command,
189 args,
190 cwd,
191 env,
192 platform = process.platform,
193 stdio = 'inherit',
194}) {
195 if (platform === 'win32') {
196 return {
197 command: env?.ComSpec ?? 'cmd.exe',
198 args: ['/d', '/s', '/c', command, ...args],
199 options: {
200 cwd,
201 env,
202 stdio,
203 windowsHide: false,
204 },
205 }
206 }
207​
208 return {
209 command,
210 args,
211 options: {
212 cwd,
213 env,
214 stdio,
215 },
216 }
218​
219function printHelp() {
220 console.log(`TanStack AI React Native dev runner
221​
222Usage:
223 pnpm dev Start Hono and Expo in LAN mode
224 node scripts/dev.mjs Start Hono and Expo in LAN mode
225 node scripts/dev.mjs --print-config
226 node scripts/dev.mjs --help
227​
228Environment:
229 EXPO_PUBLIC_TANSTACK_AI_BASE_URL
230 Optional backend URL override for Expo, for example http://192.168.1.10:8787.
231 REACT_NATIVE_PACKAGER_HOSTNAME
232 Optional Metro host override for unusual network cases. Expo manages Metro
233 host detection by default.
234`)
236​
237export function createPrintableConfig(config) {
238 return {
239 baseUrl: config.baseUrl,
240 lanAddress: config.lanAddress,
241 lanInterfaceName: config.lanInterfaceName,
242 metroHost:
243 config.metroHostSource === 'environment'
244 ? config.packagerHostname
245 : 'Expo-managed',
246 metroHostSource: config.metroHostSource,
247 packagerHostname: config.packagerHostname ?? null,
248 port: config.port,
249 pnpmCommand: config.pnpmCommand,
250 serverOpenAIKeyLoaded: config.serverOpenAIKeyLoaded,
251 usedProvidedBaseUrl: config.usedProvidedBaseUrl,
252 usedProvidedPackagerHostname: config.usedProvidedPackagerHostname,
253 }
255​
256function printConfig(config) {
257 console.log(JSON.stringify(createPrintableConfig(config), null, 2))
259​
260export function spawnProcess(command, args, env, { platform, stdio } = {}) {
261 const spawnConfig = createSpawnConfig({
262 command,
263 args,
264 cwd: EXAMPLE_DIR,
265 env,
266 platform,
267 stdio,
268 })
269​
270 return spawn(spawnConfig.command, spawnConfig.args, spawnConfig.options)
272​
273function killProcess(child) {
274 if (child.exitCode !== null || child.signalCode !== null) return
275 if (!child.pid) return
276​
277 if (process.platform === 'win32') {
278 spawn('taskkill', ['/pid', String(child.pid), '/t', '/f'], {
279 stdio: 'ignore',
280 })
281 return
282 }
283​
284 child.kill('SIGTERM')
286​
287function startDev() {
288 loadEnvFileIntoEnv()
289 const config = createDevConfig()
290​
291 console.log(
292 `Using EXPO_PUBLIC_TANSTACK_AI_BASE_URL=${config.baseUrl}${
293 config.usedProvidedBaseUrl ? ' (from environment)' : ''
294 }`,
295 )
296 console.log(
297 config.usedProvidedPackagerHostname
298 ? `Using REACT_NATIVE_PACKAGER_HOSTNAME=${config.packagerHostname} (from environment)`
299 : 'Using Expo-managed Metro host detection',
300 )
301​
302 if (!config.lanAddress && !config.usedProvidedBaseUrl) {
303 console.warn(
304 'No non-internal IPv4 address was detected. Set EXPO_PUBLIC_TANSTACK_AI_BASE_URL manually if your phone cannot reach the backend.',
305 )
306 }
307​
308 const children = [
309 spawnProcess(config.pnpmCommand, ['dev:server'], config.serverEnv),
310 spawnProcess(
311 config.pnpmCommand,
312 ['exec', 'expo', 'start', '--lan', '--clear'],
313 config.expoEnv,
314 ),
315 ]
316​
317 let shuttingDown = false
318​
319 function shutdown(exitCode = 0) {
320 if (shuttingDown) return
321 shuttingDown = true
322 for (const child of children) {
323 killProcess(child)
324 }
325 process.exitCode = exitCode
326 }
327​
328 for (const child of children) {
329 child.on('error', (error) => {
330 console.error(error)
331 shutdown(1)
332 })
333​
334 child.on('exit', (code, signal) => {
335 if (shuttingDown) return
336 if (code === 0 || signal) {
337 shutdown(0)
338 } else {
339 shutdown(code ?? 1)
340 }
341 })
342 }
343​
344 process.on('SIGINT', () => shutdown(0))
345 process.on('SIGTERM', () => shutdown(0))
347​
348function main() {
349 const args = new Set(process.argv.slice(2))
350​
351 if (args.has('--help') || args.has('-h')) {
352 printHelp()
353 return
354 }
355​
356 if (args.has('--print-config')) {
357 loadEnvFileIntoEnv()
358 printConfig(createDevConfig())
359 return
360 }
361​
362 startDev()
364​
365const entryPath = process.argv[1] ? path.resolve(process.argv[1]) : ''
366if (entryPath === fileURLToPath(import.meta.url)) {
367 main()