@happier-dev/stack 0.1.0 → 0.2.0

package/scripts/tailscale.mjs

@@ -1,15 +1,19 @@
 import './utils/env/env.mjs';
 import { parseArgs } from './utils/cli/args.mjs';
-import { run, runCapture } from './utils/proc/proc.mjs';
+import { run } from './utils/proc/proc.mjs';
 import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
 import { isSandboxed, sandboxAllowsGlobalSideEffects } from './utils/env/sandbox.mjs';
 import { getInternalServerUrl } from './utils/server/urls.mjs';
 import { getStackName, resolveStackEnvPath } from './utils/paths/paths.mjs';
-import { resolveCommandPath } from './utils/proc/commands.mjs';
-import { constants } from 'node:fs';
-import { access } from 'node:fs/promises';
 import { banner, bullets, cmd as cmdFmt, kv, ok, sectionTitle } from './utils/ui/layout.mjs';
 import { cyan, dim, green } from './utils/ui/ansi.mjs';
+import {
+  extractTailscaleServeHttpsUrl,
+  runTailscaleServeEnable as runSharedTailscaleServeEnable,
+  runTailscaleServeReset as runSharedTailscaleServeReset,
+  runTailscaleServeStatus as runSharedTailscaleServeStatus,
+  tailscaleServeHttpsUrlForInternalServerUrlFromStatus,
+} from '@happier-dev/cli-common/tailscale';
 
 /**
  * Manage Tailscale Serve for exposing the local UI/API over HTTPS (secure context).
@@ -36,55 +40,15 @@ function getServeConfig(internalServerUrl) {
   return { upstream, servePath };
 }
 
-function extractHttpsUrl(serveStatusText) {
-  const line = serveStatusText
-    .split('\n')
-    .map((l) => l.trim())
-    .find((l) => l.toLowerCase().includes('https://'));
-  if (!line) return null;
-  const m = line.match(/https:\/\/\S+/i);
-  if (!m) return null;
-  // Avoid trailing slash for base URLs (some consumers treat it as a path prefix).
-  return m[0].replace(/\/+$/, '');
-}
-
-function tailscaleStatusMatchesInternalServerUrl(status, internalServerUrl) {
-  const raw = (internalServerUrl ?? '').trim();
-  if (!raw) return true;
-
-  // Fast path.
-  if (status.includes(raw)) return true;
-
-  // Tailscale typically prints proxy targets like:
-  //   |-- / proxy http://127.0.0.1:3005
-  let port = '';
-  try {
-    port = new URL(raw).port;
-  } catch {
-    port = '';
-  }
-  if (!port) return false;
-
-  const re = new RegExp(String.raw`\\bproxy\\s+https?:\\/\\/(?:127\\.0\\.0\\.1|localhost|0\\.0\\.0\\.0):${port}\\b`, 'i');
-  return re.test(status);
-}
-
 export async function tailscaleServeHttpsUrlForInternalServerUrl(internalServerUrl) {
   try {
     const status = await tailscaleServeStatus();
-    const https = extractHttpsUrl(status);
-    if (!https) return null;
-    return tailscaleStatusMatchesInternalServerUrl(status, internalServerUrl) ? https : null;
+    return tailscaleServeHttpsUrlForInternalServerUrlFromStatus(status, internalServerUrl);
   } catch {
     return null;
   }
 }
 
-function extractServeEnableUrl(text) {
-  const m = String(text ?? '').match(/https:\/\/login\.tailscale\.com\/f\/serve\?node=\S+/i);
-  return m ? m[0] : null;
-}
-
 function assertTailscaleAllowed(action) {
   if (isSandboxed() && !sandboxAllowsGlobalSideEffects()) {
     throw new Error(
@@ -120,68 +84,16 @@ function tailscaleUserResetTimeoutMs() {
   return parseTimeoutMs(process.env.HAPPIER_STACK_TAILSCALE_RESET_TIMEOUT_MS, 15000);
 }
 
-function tailscaleEnv() {
-  // LaunchAgents inherit `XPC_SERVICE_NAME`, which can confuse some CLI tools.
-  // In practice, we’ve seen Tailscale commands like `tailscale version` hang under
-  // this env. Strip it for any tailscale subprocesses.
-  const env = { ...process.env };
-  delete env.XPC_SERVICE_NAME;
-  return env;
-}
-
-async function isExecutable(path) {
-  try {
-    await access(path, constants.X_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function resolveTailscaleCmd() {
-  // Allow explicit override (useful for LaunchAgents where aliases don't exist).
-  if (process.env.HAPPIER_STACK_TAILSCALE_BIN?.trim()) {
-    return process.env.HAPPIER_STACK_TAILSCALE_BIN.trim();
-  }
-
-  // Try PATH first (without executing `tailscale`, which can hang in some environments).
-  try {
-    const found = await resolveCommandPath('tailscale', { env: tailscaleEnv(), timeoutMs: tailscaleProbeTimeoutMs() });
-    if (found) {
-      return found;
-    }
-  } catch {
-    // ignore and fall back
-  }
-
-  // Common macOS app install paths.
-  //
-  // IMPORTANT:
-  // Prefer the lowercase `tailscale` CLI inside the app bundle. The capitalized
-  // `Tailscale` binary can behave differently under LaunchAgents (XPC env),
-  // potentially hanging instead of printing a version and exiting.
-  const appCliPath = '/Applications/Tailscale.app/Contents/MacOS/tailscale';
-  if (await isExecutable(appCliPath)) {
-    return appCliPath;
-  }
-
-  const appPath = '/Applications/Tailscale.app/Contents/MacOS/Tailscale';
-  if (await isExecutable(appPath)) {
-    return appPath;
-  }
-
-  throw new Error(
-    `[local] tailscale CLI not found.\n` +
-    `- Install Tailscale, or\n` +
-    `- Put 'tailscale' on PATH, or\n` +
-    `- Set HAPPIER_STACK_TAILSCALE_BIN="${appCliPath}"`
-  );
-}
-
-export async function tailscaleServeHttpsUrl() {
+export async function tailscaleServeHttpsUrl({ internalServerUrl } = {}) {
   try {
     const status = await tailscaleServeStatus();
-    return extractHttpsUrl(status);
+    const comparableInternalServerUrl =
+      String(internalServerUrl ?? '').trim() ||
+      getInternalServerUrl({ env: process.env, defaultPort: 3005 }).internalServerUrl;
+    return (
+      tailscaleServeHttpsUrlForInternalServerUrlFromStatus(status, comparableInternalServerUrl) ??
+      extractTailscaleServeHttpsUrl(status)
+    );
   } catch {
     return null;
   }
@@ -189,53 +101,43 @@ export async function tailscaleServeHttpsUrl() {
 
 export async function tailscaleServeStatus() {
   assertTailscaleAllowed('status');
-  const cmd = await resolveTailscaleCmd();
-  return await runCapture(cmd, ['serve', 'status'], { env: tailscaleEnv(), timeoutMs: tailscaleProbeTimeoutMs() });
+  return await runSharedTailscaleServeStatus({
+    env: process.env,
+    timeoutMs: tailscaleProbeTimeoutMs(),
+  });
 }
 
 export async function tailscaleServeEnable({ internalServerUrl, timeoutMs } = {}) {
   assertTailscaleAllowed('enable');
-  const cmd = await resolveTailscaleCmd();
   const { upstream, servePath } = getServeConfig(internalServerUrl);
-  const args = ['serve', '--bg'];
-  if (servePath && servePath !== '/' && servePath !== '') {
-    args.push(`--set-path=${servePath}`);
-  }
-  args.push(upstream);
-  const env = tailscaleEnv();
-  const timeout = Number.isFinite(timeoutMs) ? (timeoutMs > 0 ? timeoutMs : 0) : tailscaleUserEnableTimeoutMs();
+  const result = await runSharedTailscaleServeEnable({
+    env: process.env,
+    servePath,
+    timeoutMs: Number.isFinite(timeoutMs) ? timeoutMs : tailscaleUserEnableTimeoutMs(),
+    upstreamUrl: upstream,
+  });
 
-  try {
-    // `tailscale serve --bg` can hang in some environments (and should never block stack startup).
-    // Use a short, best-effort timeout; if it prints an enable URL, open it and return a helpful result.
-    await runCapture(cmd, args, { env, timeoutMs: timeout });
-  } catch (e) {
-    const out = e && typeof e === 'object' && 'out' in e ? e.out : '';
-    const err = e && typeof e === 'object' && 'err' in e ? e.err : '';
-    const msg = e instanceof Error ? e.message : String(e);
-    const combined = `${out ?? ''}\n${err ?? ''}\n${msg ?? ''}`.trim();
-    const enableUrl = extractServeEnableUrl(combined);
-    if (enableUrl) {
-      // User-initiated action (CLI / menubar): open the enable page.
-      try {
-        await run('open', [enableUrl]);
-      } catch {
-        // ignore (headless / restricted environment)
-      }
-      return { status: combined || String(e), httpsUrl: null, enableUrl };
+  if (result.approvalUrl) {
+    try {
+      await run('open', [result.approvalUrl]);
+    } catch {
+      // ignore (headless / restricted environment)
     }
-    throw e;
   }
 
-  const status = await runCapture(cmd, ['serve', 'status'], { env, timeoutMs: tailscaleProbeTimeoutMs() }).catch(() => '');
-  return { status, httpsUrl: status ? extractHttpsUrl(status) : null };
+  return {
+    enableUrl: result.approvalUrl,
+    httpsUrl: result.httpsUrl,
+    status: result.rawStatus,
+  };
 }
 
 export async function tailscaleServeReset({ timeoutMs } = {}) {
   assertTailscaleAllowed('reset');
-  const cmd = await resolveTailscaleCmd();
-  const timeout = Number.isFinite(timeoutMs) ? (timeoutMs > 0 ? timeoutMs : 0) : tailscaleUserResetTimeoutMs();
-  await run(cmd, ['serve', 'reset'], { env: tailscaleEnv(), timeoutMs: timeout });
+  await runSharedTailscaleServeReset({
+    env: process.env,
+    timeoutMs: Number.isFinite(timeoutMs) ? timeoutMs : tailscaleUserResetTimeoutMs(),
+  });
 }
 
 export async function maybeEnableTailscaleServe({ internalServerUrl }) {
@@ -424,15 +326,17 @@ async function main() {
     case 'status': {
       const status = await tailscaleServeStatus();
       if (json) {
-        printResult({ json, data: { status, httpsUrl: extractHttpsUrl(status) } });
+        printResult({
+          json,
+          data: { status, httpsUrl: await tailscaleServeHttpsUrl({ internalServerUrl }) },
+        });
       } else {
         process.stdout.write(status);
       }
       return;
     }
     case 'url': {
-      const status = await tailscaleServeStatus();
-      const url = extractHttpsUrl(status);
+      const url = await tailscaleServeHttpsUrl({ internalServerUrl });
       if (!url) {
         throw new Error('[tailscale] no https:// URL found in `tailscale serve status` output');
       }

package/scripts/tailscale_cmd_output.test.mjs

@@ -65,7 +65,7 @@ test('tailscale enable output includes stack context + upstream', async () => {
       cwd: repoRoot,
       env: {
         ...process.env,
-        HAPPIER_STACK_TAILSCALE_BIN: tailscaleBin,
+        HAPPIER_TAILSCALE_BIN: tailscaleBin,
         HAPPIER_STACK_SERVER_PORT: String(internalPort),
         HAPPIER_STACK_STACK: 'repo-test-1234',
         HAPPIER_STACK_ENV_FILE: envPath,
@@ -86,3 +86,51 @@ test('tailscale enable output includes stack context + upstream', async () => {
   }
 });
 
+test('tailscale url returns the relay-comparable ts.net URL when multiple serve entries exist', async () => {
+  const scriptsDir = dirname(fileURLToPath(import.meta.url));
+  const packageRoot = dirname(scriptsDir);
+  const repoRoot = dirname(dirname(packageRoot));
+
+  const tmp = mkdtempSync(join(tmpdir(), 'happier-tailscale-url-test-'));
+  try {
+    const binDir = join(tmp, 'bin');
+    mkdirSync(binDir, { recursive: true });
+    const tailscaleBin = join(binDir, 'tailscale');
+    const relayPort = 35555;
+    const otherUrl = 'https://other-service.ts.net';
+    const relayUrl = 'https://relay-service.ts.net';
+
+    writeFileSync(
+      tailscaleBin,
+      [
+        '#!/usr/bin/env node',
+        'const args = process.argv.slice(2);',
+        "if (args[0] === 'serve' && args[1] === 'status') {",
+        `  process.stdout.write('${otherUrl}\\n');`,
+        '  process.stdout.write("|-- / proxy http://127.0.0.1:8080\\n");',
+        `  process.stdout.write('${relayUrl}\\n');`,
+        `  process.stdout.write('|-- / proxy http://127.0.0.1:${relayPort}\\n');`,
+        '  process.exit(0);',
+        '}',
+        'process.exit(0);',
+        '',
+      ].join('\n')
+    );
+    chmodSync(tailscaleBin, 0o755);
+
+    const res = await runNode([join(packageRoot, 'scripts', 'tailscale.mjs'), 'url'], {
+      cwd: repoRoot,
+      env: {
+        ...process.env,
+        HAPPIER_TAILSCALE_BIN: tailscaleBin,
+        HAPPIER_STACK_SERVER_PORT: String(relayPort),
+        HAPPIER_STACK_SANDBOX_ALLOW_GLOBAL: '1',
+      },
+    });
+
+    assert.equal(res.code, 0, `expected exit 0, got ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`);
+    assert.equal(stripAnsi(res.stdout).trim(), relayUrl);
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});

package/scripts/tauri_dev.mjs

@@ -0,0 +1,291 @@
+import './utils/env/env.mjs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import * as os from 'node:os';
+import { dirname, join } from 'node:path';
+import { existsSync } from 'node:fs';
+
+import { getComponentDir, getRootDir } from './utils/paths/paths.mjs';
+import { printResult, wantsHelp, wantsJson } from './utils/cli/cli.mjs';
+import { ensureWorkspacePackagesBuiltForComponent, pmExecBin } from './utils/proc/pm.mjs';
+import { spawnProc } from './utils/proc/proc.mjs';
+import { getStackRuntimeStatePath, readStackRuntimeStateFile } from './utils/stack/runtime_state.mjs';
+import { sanitizeDnsLabel } from './utils/net/dns.mjs';
+import { buildStackTauriDevConfig, resolveStackTauriDevUrl } from './utils/tauri/dev_runtime.mjs';
+import { waitForExpoMetroRunning } from './utils/expo/expo.mjs';
+import {
+  assertCargoAvailableForTauri,
+  buildStackTauriDevProcessInvocation,
+  buildTauriRuntimeEnv,
+} from './utils/dev/tauri_dev.mjs';
+
+function buildDefaultStackTauriEnv(env, stackName) {
+  const nextEnv = { ...env };
+  const normalizedStack = sanitizeDnsLabel(String(stackName ?? '').trim());
+  if (!normalizedStack) {
+    return nextEnv;
+  }
+
+  if (!String(nextEnv.HAPPIER_STACK_TAURI_IDENTIFIER ?? '').trim()) {
+    nextEnv.HAPPIER_STACK_TAURI_IDENTIFIER = `com.happier.stack.${normalizedStack}`;
+  }
+  if (!String(nextEnv.HAPPIER_STACK_TAURI_PRODUCT_NAME ?? '').trim()) {
+    nextEnv.HAPPIER_STACK_TAURI_PRODUCT_NAME = `Happier (${normalizedStack})`;
+  }
+  return nextEnv;
+}
+
+async function readJsonFile(path) {
+  return JSON.parse(await readFile(path, 'utf-8'));
+}
+
+function wantsTauriWaitForExpo(env = process.env) {
+  const raw = String(env?.HAPPIER_STACK_TAURI_WAIT_FOR_EXPO ?? '').trim();
+  if (raw) return raw !== '0';
+  return true;
+}
+
+function parsePortFromUrl(rawUrl, fallbackPort) {
+  try {
+    const url = new URL(String(rawUrl ?? '').trim());
+    const p = Number(url.port || fallbackPort);
+    return Number.isFinite(p) && p > 0 ? Math.floor(p) : fallbackPort;
+  } catch {
+    return fallbackPort;
+  }
+}
+
+function resolveTauriUiDirForDev({ rootDir, env = process.env } = {}) {
+  const inputEnv = env && typeof env === 'object' ? env : process.env;
+  const primary = getComponentDir(rootDir, 'happier-ui', inputEnv);
+  if (existsSync(join(primary, 'src-tauri', 'tauri.conf.json'))) {
+    return primary;
+  }
+
+  const fallbackRepoDir = String(
+    inputEnv.HAPPIER_STACK_CLI_ROOT_DIR ??
+      inputEnv.HAPPIER_STACK_INVOKED_CWD ??
+      ''
+  ).trim();
+  if (!fallbackRepoDir) {
+    return primary;
+  }
+
+  const fallback = getComponentDir(rootDir, 'happier-ui', {
+    ...inputEnv,
+    HAPPIER_STACK_REPO_DIR: fallbackRepoDir,
+  });
+  if (existsSync(join(fallback, 'src-tauri', 'tauri.conf.json'))) {
+    return fallback;
+  }
+
+  return primary;
+}
+
+function assertTauriUiDirForDev(uiDir) {
+  const dir = String(uiDir ?? '').trim();
+  const tauriDir = join(dir, 'src-tauri');
+  const required = [
+    join(tauriDir, 'tauri.conf.json'),
+    join(tauriDir, 'tauri.publicdev.conf.json'),
+    join(tauriDir, 'Cargo.toml'),
+  ];
+  if (required.every((p) => existsSync(p))) {
+    return {
+      tauriDir,
+      configPath: required[0],
+      publicDevConfigPath: required[1],
+      cargoManifestPath: required[2],
+    };
+  }
+
+  throw new Error(
+    [
+      '[tauri-dev] expected a Happier repo checkout containing apps/ui/src-tauri, but required files were missing.',
+      `Resolved UI dir: ${dir || '(empty)'}.`,
+      'Fix: run the command from your repo checkout (or set HAPPIER_STACK_REPO_DIR to it) and retry.',
+    ].join(' ')
+  );
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+  const json = wantsJson(argv);
+  if (wantsHelp(argv)) {
+    printResult({
+      json,
+      data: { usage: 'node ./apps/stack/scripts/tauri_dev.mjs [--json]', json: true },
+      text: [
+        '[tauri-dev] usage:',
+        '  node ./apps/stack/scripts/tauri_dev.mjs',
+        '',
+        'notes:',
+        '  - Reuses the existing Expo dev server instead of starting a second one.',
+        '  - Builds the bundled hsetup sidecar once before launching Tauri.',
+        '  - When stack env is present, derives a stack-scoped dev URL and Tauri identifier.',
+      ].join('\n'),
+    });
+    return;
+  }
+
+  const rootDir = getRootDir(import.meta.url);
+  const envWithStackDefaults = buildDefaultStackTauriEnv(process.env, process.env.HAPPIER_STACK_STACK);
+  const uiDir = resolveTauriUiDirForDev({ rootDir, env: envWithStackDefaults });
+  const uiLayout = assertTauriUiDirForDev(uiDir);
+  const repoRootDir = dirname(dirname(uiDir));
+  const stackName = String(envWithStackDefaults.HAPPIER_STACK_STACK ?? '').trim();
+  const runtimeState = stackName
+    ? await readStackRuntimeStateFile(getStackRuntimeStatePath(stackName))
+    : null;
+  const devUrl = resolveStackTauriDevUrl({
+    runtimeState,
+    defaultPort: Number(process.env.HAPPIER_STACK_TAURI_DEV_PORT ?? 8081),
+  });
+  const resolveUserHomeDir = () => {
+    try {
+      return String(os.userInfo()?.homedir ?? os.homedir() ?? '').trim();
+    } catch {
+      return String(os.homedir() ?? '').trim();
+    }
+  };
+  const runtimeEnv = buildTauriRuntimeEnv({
+    env: envWithStackDefaults,
+    resolveUserHomeDir,
+  });
+  assertCargoAvailableForTauri({ env: runtimeEnv, resolveUserHomeDir });
+  if (String(runtimeEnv.HAPPIER_STACK_TUI ?? '').trim() === '1') {
+    const pathEntries = String(runtimeEnv.PATH ?? '')
+      .split(process.platform === 'win32' ? ';' : ':')
+      .map((entry) => String(entry ?? '').trim())
+      .filter(Boolean);
+    const pathHead = pathEntries.slice(0, 4).join(process.platform === 'win32' ? ';' : ':');
+    // eslint-disable-next-line no-console
+    console.log(
+      `[tauri-dev] env preflight: HOME=${String(runtimeEnv.HOME ?? '')} CARGO=${String(runtimeEnv.CARGO ?? '')} PATH=${pathHead}${pathEntries.length > 4 ? ':…' : ''}`
+    );
+  }
+
+  const baseConfig = await readJsonFile(uiLayout.configPath);
+  const overlayConfig = await readJsonFile(uiLayout.publicDevConfigPath);
+  const mergedConfig = buildStackTauriDevConfig({
+    baseConfig,
+    overlayConfig,
+    devUrl,
+    env: envWithStackDefaults,
+  });
+
+  // Best-effort: refresh the stack-scoped dev config under the stack storage dir.
+  // Some workflows (or older stack tooling) may still refer to this path; keeping it current prevents
+  // drift like stale `externalBin` entries causing hard-to-debug native build failures.
+  if (!json && stackName) {
+    try {
+      const stackBaseDir = getDefaultAutostartPaths(envWithStackDefaults).baseDir;
+      const stackConfigPath = join(stackBaseDir, 'tauri.dev.stack.json');
+      const stackDevConfig = buildStackTauriDevConfig({
+        baseConfig,
+        overlayConfig,
+        devUrl,
+        env: envWithStackDefaults,
+      });
+      stackDevConfig.build = {
+        ...(stackDevConfig.build ?? {}),
+        beforeDevCommand: null,
+        beforeBuildCommand: null,
+      };
+      if (stackDevConfig.bundle && typeof stackDevConfig.bundle === 'object') {
+        stackDevConfig.bundle = {
+          ...stackDevConfig.bundle,
+          createUpdaterArtifacts: false,
+        };
+      }
+      await mkdir(dirname(stackConfigPath), { recursive: true }).catch(() => {});
+      await writeFile(stackConfigPath, JSON.stringify(stackDevConfig, null, 2), 'utf-8');
+    } catch {
+      // ignore (non-fatal)
+    }
+  }
+  const configPath = uiLayout.publicDevConfigPath;
+  const configOverride = {
+    identifier: mergedConfig.identifier,
+    productName: mergedConfig.productName,
+    ...(mergedConfig.app?.windows?.length ? { app: { windows: mergedConfig.app.windows } } : {}),
+    ...(mergedConfig.bundle && typeof mergedConfig.bundle === 'object'
+      ? { bundle: { createUpdaterArtifacts: mergedConfig.bundle.createUpdaterArtifacts ?? false } }
+      : {}),
+    build: {
+      beforeDevCommand: '',
+      devUrl,
+    },
+  };
+
+  if (json) {
+    const tauriInvocation = buildStackTauriDevProcessInvocation({
+      rootDir,
+      repoRootDir,
+      uiDir,
+      env: runtimeEnv,
+      configPath,
+      configOverride,
+      resolveUserHomeDir,
+    });
+    printResult({
+      json,
+      data: {
+        ok: true,
+        devUrl,
+        uiDir,
+        configPath,
+        stackName: stackName || null,
+        identifier: mergedConfig.identifier ?? null,
+        tauri: {
+          command: tauriInvocation.command,
+          args: tauriInvocation.args,
+          cwd: tauriInvocation.cwd,
+        },
+      },
+    });
+    return;
+  }
+
+  if (wantsTauriWaitForExpo(envWithStackDefaults)) {
+    const defaultPort = Number(envWithStackDefaults.HAPPIER_STACK_TAURI_DEV_PORT ?? 8081);
+    const expoPort = parsePortFromUrl(devUrl, Number.isFinite(defaultPort) && defaultPort > 0 ? defaultPort : 8081);
+    const metro = await waitForExpoMetroRunning({ port: expoPort, env: envWithStackDefaults });
+    if (!metro.ok) {
+      throw new Error(
+        [
+          `[tauri-dev] Expo dev server was not reachable on port ${expoPort}.`,
+          'Start the UI dev server first (`yarn ui`, `yarn --cwd apps/ui start`, or `yarn tui:with-tauri`) and retry.',
+        ].join(' ')
+      );
+    }
+  }
+
+  await ensureWorkspacePackagesBuiltForComponent(uiDir, { quiet: false, env: envWithStackDefaults });
+  await pmExecBin({
+    dir: uiDir,
+    bin: 'tauri:prepare:sidecar',
+    env: envWithStackDefaults,
+  });
+
+  const tauriInvocation = buildStackTauriDevProcessInvocation({
+    rootDir,
+    repoRootDir,
+    uiDir,
+    env: runtimeEnv,
+    configPath,
+    configOverride,
+    resolveUserHomeDir,
+  });
+  spawnProc('tauri', tauriInvocation.command, tauriInvocation.args, {
+    ...(tauriInvocation.env ?? runtimeEnv),
+    CI: 'false',
+  }, {
+    cwd: tauriInvocation.cwd,
+    ...(tauriInvocation.windowsVerbatimArguments ? { windowsVerbatimArguments: tauriInvocation.windowsVerbatimArguments } : {}),
+  });
+}
+
+main().catch((error) => {
+  console.error(`[tauri-dev] failed: ${error instanceof Error ? error.message : String(error)}`);
+  process.exitCode = 1;
+});