@lark-apaas/fullstack-cli 1.1.60 → 1.1.61-alpha.20260818172555

package/templates/scripts/dev.js

@@ -3,12 +3,15 @@
 
 const fs = require('fs');
 const path = require('path');
-const { spawn, execSync } = require('child_process');
+const { spawn, execSync, execFileSync } = require('child_process');
 const readline = require('readline');
 
 // ── Project root ──────────────────────────────────────────────────────────────
 const PROJECT_ROOT = path.resolve(__dirname, '..');
 process.chdir(PROJECT_ROOT);
+// Runtime scripts may be image-owned and therefore live outside the workspace.
+// Keep the project identity explicit for validation and all supervised children.
+process.env.MIAODA_WORKSPACE_ROOT ||= PROJECT_ROOT;
 
 // ── Load .env ─────────────────────────────────────────────────────────────────
 function loadEnv() {
@@ -31,13 +34,73 @@ loadEnv();
 
 // ── Configuration ─────────────────────────────────────────────────────────────
 const LOG_DIR = process.env.LOG_DIR || 'logs';
-const MAX_RESTART_COUNT = process.env.MAX_RESTART_COUNT != null && process.env.MAX_RESTART_COUNT !== ''
-  ? parseInt(process.env.MAX_RESTART_COUNT, 10)
-  : Infinity;
+const MAX_RESTART_COUNT =
+  process.env.MAX_RESTART_COUNT != null && process.env.MAX_RESTART_COUNT !== ''
+    ? parseInt(process.env.MAX_RESTART_COUNT, 10)
+    : Infinity;
 const RESTART_DELAY = parseInt(process.env.RESTART_DELAY, 10) || 2;
 const MAX_DELAY = 8;
 const SERVER_PORT = process.env.SERVER_PORT || '3000';
 const CLIENT_DEV_PORT = process.env.CLIENT_DEV_PORT || '8080';
+const CACHE_HANDOFF_EXIT_CODE = 75;
+const NEST_ORCHESTRATOR_OWNER_FILE = path.resolve(
+  process.env.MIAODA_NEST_ORCHESTRATOR_OWNER_FILE ||
+    '/tmp/event/MIAODA_NEST_ORCHESTRATOR_OWNER.json'
+);
+let CACHE_BOOTSTRAP_ENABLED =
+  process.env.MIAODA_CACHE_BOOTSTRAP_ENABLED === 'true';
+let STARTUP_EXPERIMENT_ENABLED =
+  process.env.MIAODA_STARTUP_EXPERIMENT_ENABLED === 'true';
+const CACHE_RUNTIME_SCRIPTS_ROOT = path.resolve(
+  process.env.MIAODA_CACHE_RUNTIME_SCRIPTS_ROOT ||
+    path.join(PROJECT_ROOT, 'scripts')
+);
+
+function readExternalNestOrchestratorOwner() {
+  try {
+    const owner = JSON.parse(
+      fs.readFileSync(NEST_ORCHESTRATOR_OWNER_FILE, 'utf8')
+    );
+    const pid = Number(owner.pid);
+    if (
+      owner.schemaVersion !== 1 ||
+      owner.mode !== (process.env.MIAODA_NEST_START_MODE || 'workspace') ||
+      !Number.isSafeInteger(pid) ||
+      pid <= 1 ||
+      pid === process.pid
+    ) {
+      return undefined;
+    }
+    process.kill(pid, 0);
+    return { pid, mode: owner.mode };
+  } catch {
+    return undefined;
+  }
+}
+
+function dependencyHandoffAlreadyCompleted() {
+  if (!fs.existsSync(path.join(PROJECT_ROOT, 'node_modules'))) return false;
+  try {
+    const cacheRoot = path.resolve(
+      process.env.MIAODA_CACHE_ROOT ||
+        path.join(PROJECT_ROOT, '.miaoda-cache', 'current')
+    );
+    const readyFile = path.resolve(
+      process.env.MIAODA_DEPENDENCY_READY_FILE ||
+        path.join(PROJECT_ROOT, '.miaoda-runtime', 'dependencies-ready.json')
+    );
+    const generation = JSON.parse(
+      fs.readFileSync(path.join(cacheRoot, 'generation.json'), 'utf8')
+    );
+    const ready = JSON.parse(fs.readFileSync(readyFile, 'utf8'));
+    return (
+      /^[a-f0-9]{64}$/.test(generation.generationId || '') &&
+      ready.generationId === generation.generationId
+    );
+  } catch {
+    return false;
+  }
+}
 
 fs.mkdirSync(LOG_DIR, { recursive: true });
 
@@ -50,11 +113,16 @@ const devLogFd = fs.openSync(devLogPath, 'a');
 function timestamp() {
   const now = new Date();
   return (
-    now.getFullYear() + '-' +
-    String(now.getMonth() + 1).padStart(2, '0') + '-' +
-    String(now.getDate()).padStart(2, '0') + ' ' +
-    String(now.getHours()).padStart(2, '0') + ':' +
-    String(now.getMinutes()).padStart(2, '0') + ':' +
+    now.getFullYear() +
+    '-' +
+    String(now.getMonth() + 1).padStart(2, '0') +
+    '-' +
+    String(now.getDate()).padStart(2, '0') +
+    ' ' +
+    String(now.getHours()).padStart(2, '0') +
+    ':' +
+    String(now.getMinutes()).padStart(2, '0') +
+    ':' +
     String(now.getSeconds()).padStart(2, '0')
   );
 }
@@ -68,21 +136,33 @@ const STDOUT_MAX_INFLIGHT = 1000;
 function writeOutput(msg) {
   // File first and synchronously — read-logs reads this file; it must never be gated
   // by the terminal consumer.
-  try { fs.writeSync(devStdLogFd, msg); } catch {}
+  try {
+    fs.writeSync(devStdLogFd, msg);
+  } catch {}
   // stdout mirror via async fs.write: if process.stdout is a pty/pipe whose consumer
   // stalls, the block happens on the libuv threadpool, NOT the event loop — so the
   // synchronous log-FILE writes above (and subsequent readline callbacks) keep running.
   // Drop overflow when too many writes are already pending (best-effort mirror).
-  if (_stdoutInFlight >= STDOUT_MAX_INFLIGHT) { return; }
+  if (_stdoutInFlight >= STDOUT_MAX_INFLIGHT) {
+    return;
+  }
   _stdoutInFlight++;
-  try { fs.write(1, msg, () => { _stdoutInFlight--; }); } catch { _stdoutInFlight--; }
+  try {
+    fs.write(1, msg, () => {
+      _stdoutInFlight--;
+    });
+  } catch {
+    _stdoutInFlight--;
+  }
 }
 
 /** Structured event log → terminal + dev.std.log + dev.log */
 function logEvent(level, name, message) {
   const msg = `[${timestamp()}] [${level}] [${name}] ${message}\n`;
   writeOutput(msg);
-  try { fs.writeSync(devLogFd, msg); } catch {}
+  try {
+    fs.writeSync(devLogFd, msg);
+  } catch {}
 }
 
 // ── Process group management ──────────────────────────────────────────────────
@@ -94,11 +174,16 @@ function killProcessGroup(pid, signal) {
 
 function killOrphansByPort(port) {
   try {
-    const pids = execSync(`lsof -ti :${port}`, { encoding: 'utf8', timeout: 5000 }).trim();
+    const pids = execSync(`lsof -ti :${port}`, {
+      encoding: 'utf8',
+      timeout: 5000,
+    }).trim();
     if (pids) {
       const pidList = pids.split('\n').filter(Boolean);
       for (const p of pidList) {
-        try { process.kill(parseInt(p, 10), 'SIGKILL'); } catch {}
+        try {
+          process.kill(parseInt(p, 10), 'SIGKILL');
+        } catch {}
       }
       return pidList;
     }
@@ -111,16 +196,23 @@ let stopping = false;
 const managedProcesses = []; // { name, pid, child }
 
 function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+  return new Promise(resolve => setTimeout(resolve, ms));
 }
 
 /**
  * Start and supervise a process with auto-restart and log piping.
  * Returns a promise that resolves when the process loop ends.
  */
-function startProcess({ name, command, args, cleanupPort }) {
+function startProcess({
+  name,
+  command,
+  args,
+  cleanupPort,
+  stopRestartOnExitCodes = [],
+}) {
   const logFilePath = path.join(LOG_DIR, `${name}.std.log`);
   const logFd = fs.openSync(logFilePath, 'a');
+  const logicalLogFds = new Map();
 
   const entry = { name, pid: null, child: null };
   managedProcesses.push(entry);
@@ -141,14 +233,39 @@ function startProcess({ name, command, args, cleanupPort }) {
       entry.child = child;
 
       const startTime = Date.now();
-      logEvent('INFO', name, `Process started (PGID: ${child.pid}): ${command} ${args.join(' ')}`);
+      logEvent(
+        'INFO',
+        name,
+        `Process started (PGID: ${child.pid}): ${command} ${args.join(' ')}`
+      );
 
       // Pipe stdout and stderr through readline for timestamped logging
-      const pipeLines = (stream) => {
-        const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
-        rl.on('line', (line) => {
-          const msg = `[${timestamp()}] [${name}] ${line}\n`;
-          try { fs.writeSync(logFd, msg); } catch {}
+      const pipeLines = stream => {
+        const rl = readline.createInterface({
+          input: stream,
+          crlfDelay: Infinity,
+        });
+        rl.on('line', line => {
+          const tagged = /^MIAODA_LOG\t(client|server)\t(.*)$/.exec(line);
+          const logicalName = tagged?.[1] || name;
+          const logicalLine = tagged?.[2] ?? line;
+          const msg = `[${timestamp()}] [${logicalName}] ${logicalLine}\n`;
+          try {
+            fs.writeSync(logFd, msg);
+          } catch {}
+          if (tagged) {
+            try {
+              let logicalFd = logicalLogFds.get(logicalName);
+              if (logicalFd === undefined) {
+                logicalFd = fs.openSync(
+                  path.join(LOG_DIR, `${logicalName}.std.log`),
+                  'a'
+                );
+                logicalLogFds.set(logicalName, logicalFd);
+              }
+              fs.writeSync(logicalFd, msg);
+            } catch {}
+          }
           writeOutput(msg);
         });
       };
@@ -159,15 +276,16 @@ function startProcess({ name, command, args, cleanupPort }) {
       // NOTE: must use 'exit', not 'close'. With shell:true, grandchild processes
       // (e.g. nest's server) inherit stdout pipes. 'close' won't fire until ALL
       // pipe holders exit, causing dev.js to hang when npm/nest dies but server survives.
-      const exitCode = await new Promise((resolve) => {
-        child.on('exit', (code) => resolve(code ?? 1));
+      const exitCode = await new Promise(resolve => {
+        child.on('exit', code => resolve(code ?? 1));
         child.on('error', () => resolve(1));
       });
+      const completedHandoff = stopRestartOnExitCodes.includes(exitCode);
 
       // Kill the entire process group
       if (entry.pid) {
         killProcessGroup(entry.pid, 'SIGTERM');
-        await sleep(2000);
+        await sleep(completedHandoff ? 100 : 2000);
         killProcessGroup(entry.pid, 'SIGKILL');
       }
       entry.pid = null;
@@ -177,31 +295,74 @@ function startProcess({ name, command, args, cleanupPort }) {
       if (cleanupPort) {
         const orphans = killOrphansByPort(cleanupPort);
         if (orphans.length > 0) {
-          logEvent('WARN', name, `Killed orphan processes on port ${cleanupPort}: ${orphans.join(' ')}`);
+          logEvent(
+            'WARN',
+            name,
+            `Killed orphan processes on port ${cleanupPort}: ${orphans.join(' ')}`
+          );
           await sleep(500);
         }
       }
 
       if (stopping) break;
 
+      if (completedHandoff) {
+        logEvent(
+          'INFO',
+          name,
+          `Process completed one-way handoff with code ${exitCode}`
+        );
+        try {
+          fs.closeSync(logFd);
+        } catch {}
+        for (const logicalFd of logicalLogFds.values()) {
+          try {
+            fs.closeSync(logicalFd);
+          } catch {}
+        }
+        return exitCode;
+      }
+
       const runDuration = (Date.now() - startTime) / 1000;
       if (runDuration >= 60) {
         restartCount = 0;
-        logEvent('INFO', name, `Ran for ${Math.round(runDuration)}s, resetting restart counter`);
+        logEvent(
+          'INFO',
+          name,
+          `Ran for ${Math.round(runDuration)}s, resetting restart counter`
+        );
       } else {
         restartCount++;
       }
       if (restartCount >= MAX_RESTART_COUNT) {
-        logEvent('ERROR', name, `Max restart count (${MAX_RESTART_COUNT}) reached, giving up`);
+        logEvent(
+          'ERROR',
+          name,
+          `Max restart count (${MAX_RESTART_COUNT}) reached, giving up`
+        );
         break;
       }
 
-      const delay = Math.min(RESTART_DELAY * (1 << Math.max(0, restartCount - 1)), MAX_DELAY);
-      logEvent('WARN', name, `Process exited with code ${exitCode}, restarting (${restartCount}/${MAX_RESTART_COUNT}) in ${delay}s...`);
+      const delay = Math.min(
+        RESTART_DELAY * (1 << Math.max(0, restartCount - 1)),
+        MAX_DELAY
+      );
+      logEvent(
+        'WARN',
+        name,
+        `Process exited with code ${exitCode}, restarting (${restartCount}/${MAX_RESTART_COUNT}) in ${delay}s...`
+      );
       await sleep(delay * 1000);
     }
 
-    try { fs.closeSync(logFd); } catch {}
+    try {
+      fs.closeSync(logFd);
+    } catch {}
+    for (const logicalFd of logicalLogFds.values()) {
+      try {
+        fs.closeSync(logicalFd);
+      } catch {}
+    }
   };
 
   return run();
@@ -231,7 +392,11 @@ async function cleanup() {
   // Force kill any remaining
   for (const entry of managedProcesses) {
     if (entry.pid) {
-      logEvent('WARN', 'main', `Force killing process group (PGID: ${entry.pid})`);
+      logEvent(
+        'WARN',
+        'main',
+        `Force killing process group (PGID: ${entry.pid})`
+      );
       killProcessGroup(entry.pid, 'SIGKILL');
     }
   }
@@ -242,8 +407,12 @@ async function cleanup() {
 
   logEvent('INFO', 'main', 'All processes stopped');
 
-  try { fs.closeSync(devStdLogFd); } catch {}
-  try { fs.closeSync(devLogFd); } catch {}
+  try {
+    fs.closeSync(devStdLogFd);
+  } catch {}
+  try {
+    fs.closeSync(devLogFd);
+  } catch {}
 
   process.exit(0);
 }
@@ -261,48 +430,253 @@ function cleanStaleDist() {
   }
 }
 
+async function followExternalNestOrchestratorOrStartLocal(
+  serverStartupRuntimeScript
+) {
+  const owner = readExternalNestOrchestratorOwner();
+  if (!owner) {
+    return startProcess({
+      name: 'server',
+      command: process.execPath,
+      args: [serverStartupRuntimeScript],
+      cleanupPort: SERVER_PORT,
+    });
+  }
+
+  logEvent(
+    'INFO',
+    'server',
+    `Following image-owned Nest orchestrator pid=${owner.pid} mode=${owner.mode}`
+  );
+  while (!stopping) {
+    try {
+      process.kill(owner.pid, 0);
+      await sleep(200);
+    } catch {
+      break;
+    }
+  }
+  if (stopping) return 0;
+
+  // If the image-owned orchestrator exits, resume the normal supervised
+  // workspace service. By this point node_modules is expected to be ready; if
+  // it is not, server-startup-runtime keeps the original bounded wait.
+  logEvent(
+    'WARN',
+    'server',
+    `Image-owned Nest orchestrator pid=${owner.pid} exited; starting local supervisor`
+  );
+  return startProcess({
+    name: 'server',
+    command: process.execPath,
+    args: [serverStartupRuntimeScript],
+    cleanupPort: SERVER_PORT,
+  });
+}
+
 // ── Main ──────────────────────────────────────────────────────────────────────
 async function main() {
   logEvent('INFO', 'main', '========== Dev session started ==========');
 
-  cleanStaleDist();
+  if (process.env.MIAODA_HMR_ROUTING_MODE === 'same-origin') {
+    delete process.env.MIAODA_WS_HOST;
+    logEvent(
+      'INFO',
+      'main',
+      'Using same-origin HMR routing; ignored the dedicated MIAODA_WS_HOST'
+    );
+  }
 
-  // Initialize action plugins
-  writeOutput('\n🔌 Initializing action plugins...\n');
-  try {
-    execSync('fullstack-cli action-plugin init', { cwd: PROJECT_ROOT, stdio: 'inherit' });
-    writeOutput('✅ Action plugins initialized\n\n');
-  } catch {
-    writeOutput('⚠️  Action plugin initialization failed, continuing anyway...\n\n');
+  const coordinatorRuntimeScript = path.join(
+    CACHE_RUNTIME_SCRIPTS_ROOT,
+    'cache-runtime-coordinator.mjs'
+  );
+  const serverStartupRuntimeScript = path.join(
+    CACHE_RUNTIME_SCRIPTS_ROOT,
+    'server-startup-runtime.mjs'
+  );
+  const workspaceClientRuntimeScript = path.join(
+    CACHE_RUNTIME_SCRIPTS_ROOT,
+    'workspace-client-runtime.mjs'
+  );
+  if (
+    CACHE_BOOTSTRAP_ENABLED &&
+    !STARTUP_EXPERIMENT_ENABLED &&
+    dependencyHandoffAlreadyCompleted()
+  ) {
+    CACHE_BOOTSTRAP_ENABLED = false;
+    process.env.MIAODA_CACHE_BOOTSTRAP_ENABLED = 'false';
+    logEvent(
+      'INFO',
+      'main',
+      'Dependency handoff already completed; starting original services directly'
+    );
+  }
+  if (STARTUP_EXPERIMENT_ENABLED) {
+    try {
+      for (const requiredPath of [
+        serverStartupRuntimeScript,
+        workspaceClientRuntimeScript,
+      ]) {
+        if (!fs.existsSync(requiredPath)) {
+          throw new Error(
+            `MIAODA_STARTUP_EXPERIMENT_INPUT_MISSING: ${requiredPath}`
+          );
+        }
+      }
+    } catch (error) {
+      STARTUP_EXPERIMENT_ENABLED = false;
+      process.env.MIAODA_STARTUP_EXPERIMENT_ENABLED = 'false';
+      logEvent(
+        'WARN',
+        'main',
+        `Startup experiment unavailable; using original services: ${error.message}`
+      );
+    }
+  }
+  if (CACHE_BOOTSTRAP_ENABLED && !STARTUP_EXPERIMENT_ENABLED) {
+    process.env.MIAODA_CACHE_VALIDATION_RECEIPT_FILE ||= path.join(
+      PROJECT_ROOT,
+      '.miaoda-runtime',
+      'cache-validation-receipt.json'
+    );
+    try {
+      for (const requiredPath of [coordinatorRuntimeScript]) {
+        if (!fs.existsSync(requiredPath)) {
+          throw new Error(
+            `MIAODA_CACHE_BOOTSTRAP_INPUT_MISSING: ${requiredPath}`
+          );
+        }
+      }
+      execFileSync(
+        process.execPath,
+        [coordinatorRuntimeScript, '--validate-only'],
+        {
+          cwd: PROJECT_ROOT,
+          env: { ...process.env },
+          stdio: ['ignore', 'pipe', 'pipe'],
+        }
+      );
+    } catch (error) {
+      CACHE_BOOTSTRAP_ENABLED = false;
+      const reason = error?.stderr?.toString().trim() || error.message;
+      logEvent(
+        'WARN',
+        'main',
+        `Cache generation preflight rejected; using dependency-backed startup: ${reason}`
+      );
+    }
   }
 
-  // Start server and client
-  const serverPromise = startProcess({
-    name: 'server',
-    command: 'npm',
-    args: ['run', 'dev:server'],
-    cleanupPort: SERVER_PORT,
-  });
+  cleanStaleDist();
 
-  const clientPromise = startProcess({
-    name: 'client',
-    command: 'npm',
-    args: ['run', 'dev:client'],
-    cleanupPort: CLIENT_DEV_PORT,
-  });
+  const initializeActionPlugins = () => {
+    writeOutput('\n🔌 Initializing action plugins...\n');
+    try {
+      execSync('fullstack-cli action-plugin init', {
+        cwd: PROJECT_ROOT,
+        stdio: 'inherit',
+      });
+      writeOutput('✅ Action plugins initialized\n\n');
+    } catch {
+      writeOutput(
+        '⚠️  Action plugin initialization failed, continuing anyway...\n\n'
+      );
+    }
+  };
+
+  // The transition runtime resolves Action Plugin dependencies from the sealed
+  // dependency cache. Running the project CLI here would reintroduce a project
+  // node_modules dependency before restoration completes.
+  if (!CACHE_BOOTSTRAP_ENABLED && !STARTUP_EXPERIMENT_ENABLED) {
+    initializeActionPlugins();
+  } else if (!STARTUP_EXPERIMENT_ENABLED) {
+    logEvent(
+      'INFO',
+      'main',
+      'Skipped dynamic Action Plugin initialization in cache-only mode'
+    );
+  }
 
   writeOutput(`📋 Dev processes running. Press Ctrl+C to stop.\n`);
   writeOutput(`📄 Logs: ${devStdLogPath}\n\n`);
 
-  // Wait for both (they loop until stopping or max restarts)
-  await Promise.all([serverPromise, clientPromise]);
+  if (STARTUP_EXPERIMENT_ENABLED) {
+    logEvent(
+      'INFO',
+      'main',
+      `Starting normal workspace Vite with Nest mode ${
+        process.env.MIAODA_NEST_START_MODE || 'workspace'
+      }`
+    );
+    const serverPromise =
+      (process.env.MIAODA_NEST_START_MODE || 'workspace') ===
+      'bundle-handoff'
+        ? followExternalNestOrchestratorOrStartLocal(
+            serverStartupRuntimeScript
+          )
+        : startProcess({
+            name: 'server',
+            command: process.execPath,
+            args: [serverStartupRuntimeScript],
+            cleanupPort: SERVER_PORT,
+          });
+    const clientPromise = startProcess({
+      name: 'client',
+      command: process.execPath,
+      args: [workspaceClientRuntimeScript],
+      cleanupPort: CLIENT_DEV_PORT,
+    });
+    await Promise.all([serverPromise, clientPromise]);
+  } else if (CACHE_BOOTSTRAP_ENABLED) {
+    const exitCode = await startProcess({
+      name: 'coordinator',
+      command: process.execPath,
+      args: [coordinatorRuntimeScript],
+      stopRestartOnExitCodes: [CACHE_HANDOFF_EXIT_CODE],
+    });
+    if (exitCode === CACHE_HANDOFF_EXIT_CODE && !stopping) {
+      CACHE_BOOTSTRAP_ENABLED = false;
+      process.env.MIAODA_CACHE_BOOTSTRAP_ENABLED = 'false';
+      process.env.NODE_PATH = '';
+      logEvent(
+        'INFO',
+        'main',
+        'Dependencies restored; cache runtime retired before original services start'
+      );
+      initializeActionPlugins();
+    }
+  }
+
+  if (
+    !STARTUP_EXPERIMENT_ENABLED &&
+    !CACHE_BOOTSTRAP_ENABLED &&
+    !stopping
+  ) {
+    // Feature-off and post-cache handoff keep the original process boundary
+    // and exact npm commands. Failures therefore surface through the original
+    // Preview starting/failed/retry UI instead of a cached-page fallback.
+    const serverPromise = startProcess({
+      name: 'server',
+      command: 'npm',
+      args: ['run', 'dev:server'],
+      cleanupPort: SERVER_PORT,
+    });
+    const clientPromise = startProcess({
+      name: 'client',
+      command: 'npm',
+      args: ['run', 'dev:client'],
+      cleanupPort: CLIENT_DEV_PORT,
+    });
+    await Promise.all([serverPromise, clientPromise]);
+  }
 
   if (!cleanupDone) {
     await cleanup();
   }
 }
 
-main().catch((err) => {
+main().catch(err => {
   console.error('Fatal error:', err);
   process.exit(1);
 });

package/templates/scripts/dev.sh

@@ -7,6 +7,8 @@
 # 显式想跑本地路径可用 `npm run dev:local`（绕过 SANDBOX_ID 判断）。
 set -euo pipefail
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+export MIAODA_CACHE_RUNTIME_SCRIPTS_ROOT="${MIAODA_CACHE_RUNTIME_SCRIPTS_ROOT:-$SCRIPT_DIR}"
+export MIAODA_WORKSPACE_ROOT="${MIAODA_WORKSPACE_ROOT:-$(cd "$SCRIPT_DIR/.." && pwd)}"
 
 if [ -n "${SANDBOX_ID:-}" ]; then
   exec node "$SCRIPT_DIR/dev.js" "$@"