Open History to see the last commit
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)
25}
26
27export function getPnpmCommand(platform = process.platform) {
28 return platform === 'win32' ? 'pnpm.cmd' : 'pnpm'
29}
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 )
43}
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 )
53}
54
55function isLikelyPhysicalInterface(name) {
56 return /\b(wi-?fi|wireless|wlan|ethernet)\b|^(en|eth)\d+/iu.test(name)
57}
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 )
63}
64
65function enumerateIpv4Candidates(interfaces) {
66 return Object.entries(interfaces).flatMap(([interfaceName, items]) =>
67 (items ?? []).map((info) => ({
68 ...info,
69 interfaceName,
70 })),
71 )
72}
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
82}
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]
95}
96
97export function pickLanAddress(interfaces = networkInterfaces()) {
98 return pickLanAddressInfo(interfaces)?.address
99}
100
101function isPublicMobileEnvKey(key) {
102 return (
103 key.startsWith('EXPO_PUBLIC_') || key === 'REACT_NATIVE_PACKAGER_HOSTNAME'
104 )
105}
106
107function shouldStripFromExpoEnv(key, loadedEnvKeys) {
108 return (
109 key.startsWith('OPENAI_') ||
110 (loadedEnvKeys.has(key) && !isPublicMobileEnvKey(key))
111 )
112}
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 }
137}
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 }
185}
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 }
217}
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`)
235}
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 }
254}
255
256function printConfig(config) {
257 console.log(JSON.stringify(createPrintableConfig(config), null, 2))
258}
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)
271}
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')
285}
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))
346}
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()
363}
364
365const entryPath = process.argv[1] ? path.resolve(process.argv[1]) : ''
366if (entryPath === fileURLToPath(import.meta.url)) {
367 main()
368}