sparkecoder 0.1.6 → 0.1.8

package/dist/server/index.d.ts

@@ -19,6 +19,7 @@ declare function startServer(options?: ServerOptions): Promise<{
     port: number;
     host: string;
     webPort: number | undefined;
+    webStarted: boolean | undefined;
 }>;
 declare function stopServer(): void;
 

package/dist/server/index.js

@@ -1131,7 +1131,8 @@ async function runBackground(command, workingDirectory, options) {
     cwd: workingDirectory,
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     sessionId: options.sessionId,
-    background: true
+    background: true,
+    name: options.name
   }, workingDirectory);
   const logFile = join2(logDir, "output.log");
   const wrappedCommand = `(${command}) 2>&1 | tee -a ${shellEscape(logFile)}`;
@@ -3954,7 +3955,10 @@ terminals2.post(
       return c.json({ error: "tmux is not installed. Background terminals require tmux." }, 400);
     }
     const workingDirectory = body.cwd || session.workingDirectory;
-    const result = await runBackground(body.command, workingDirectory, { sessionId });
+    const result = await runBackground(body.command, workingDirectory, {
+      sessionId,
+      name: body.name
+    });
     return c.json({
       id: result.id,
       name: body.name || null,
@@ -3978,7 +3982,7 @@ terminals2.get("/:sessionId/terminals", async (c) => {
       const running = await isRunning(meta.id);
       return {
         id: meta.id,
-        name: null,
+        name: meta.name || null,
         command: meta.command,
         cwd: meta.cwd,
         status: running ? "running" : "stopped",
@@ -4062,10 +4066,17 @@ terminals2.post(
   "/:sessionId/terminals/:terminalId/write",
   zValidator4("json", writeSchema),
   async (c) => {
-    return c.json({
-      error: "stdin writing not supported in tmux mode. Use tmux send-keys directly if needed.",
-      hint: 'tmux send-keys -t spark_{terminalId} "your input"'
-    }, 501);
+    const terminalId = c.req.param("terminalId");
+    const body = c.req.valid("json");
+    const isRunning2 = await isRunning(terminalId);
+    if (!isRunning2) {
+      return c.json({ error: "Terminal is not running" }, 400);
+    }
+    const success = await sendInput(terminalId, body.input, { pressEnter: false });
+    if (!success) {
+      return c.json({ error: "Failed to write to terminal" }, 500);
+    }
+    return c.json({ success: true, written: body.input.length });
   }
 );
 terminals2.post("/:sessionId/terminals/kill-all", async (c) => {
@@ -4074,12 +4085,12 @@ terminals2.post("/:sessionId/terminals/kill-all", async (c) => {
   if (!session) {
     return c.json({ error: "Session not found" }, 404);
   }
-  const terminalIds = await listSessions();
+  const sessionTerminals = await listSessionTerminals(sessionId, session.workingDirectory);
   let killed = 0;
-  for (const id of terminalIds) {
-    const meta = await getMeta(id, session.workingDirectory);
-    if (meta && meta.sessionId === sessionId) {
-      const success = await killTerminal(id);
+  for (const terminal of sessionTerminals) {
+    const isRunning2 = await isRunning(terminal.id);
+    if (isRunning2) {
+      const success = await killTerminal(terminal.id);
       if (success) killed++;
     }
   }
@@ -4377,6 +4388,33 @@ async function findWebPort(preferredPort) {
   }
   return { port: preferredPort, alreadyRunning: false };
 }
+function hasProductionBuild(webDir) {
+  const buildIdPath = join3(webDir, ".next", "BUILD_ID");
+  return existsSync7(buildIdPath);
+}
+function runCommand(command, args, cwd, env) {
+  return new Promise((resolve7) => {
+    const child = spawn(command, args, {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      env,
+      shell: true
+    });
+    let output = "";
+    child.stdout?.on("data", (data) => {
+      output += data.toString();
+    });
+    child.stderr?.on("data", (data) => {
+      output += data.toString();
+    });
+    child.on("close", (code) => {
+      resolve7({ success: code === 0, output });
+    });
+    child.on("error", (err) => {
+      resolve7({ success: false, output: err.message });
+    });
+  });
+}
 async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false) {
   const webDir = getWebDirectory();
   if (!webDir) {
@@ -4388,39 +4426,90 @@ async function startWebUI(apiPort, webPort = DEFAULT_WEB_PORT, quiet = false) {
     if (!quiet) console.log(`  \u2713 Web UI already running at http://localhost:${actualPort}`);
     return { process: null, port: actualPort };
   }
-  const useNpm = existsSync7(join3(webDir, "package-lock.json"));
-  const command = useNpm ? "npm" : "npx";
-  const args = useNpm ? ["run", "dev", "--", "-p", String(actualPort)] : ["next", "dev", "-p", String(actualPort)];
+  const usePnpm = existsSync7(join3(webDir, "pnpm-lock.yaml"));
+  const useNpm = !usePnpm && existsSync7(join3(webDir, "package-lock.json"));
+  const pkgManager = usePnpm ? "pnpm" : useNpm ? "npm" : "npx";
+  const { NODE_OPTIONS, TSX_TSCONFIG_PATH, ...cleanEnv } = process.env;
+  const webEnv = {
+    ...cleanEnv,
+    NEXT_PUBLIC_API_URL: `http://127.0.0.1:${apiPort}`
+  };
+  const isProduction = process.env.NODE_ENV === "production";
+  let command;
+  let args;
+  if (isProduction) {
+    if (!hasProductionBuild(webDir)) {
+      if (!quiet) console.log("  \u{1F4E6} Building Web UI for production...");
+      const buildArgs = pkgManager === "npx" ? ["next", "build"] : ["run", "build"];
+      const buildResult = await runCommand(pkgManager, buildArgs, webDir, webEnv);
+      if (!buildResult.success) {
+        if (!quiet) console.error("  \u274C Web UI build failed");
+        return { process: null, port: actualPort };
+      }
+      if (!quiet) console.log("  \u2713 Web UI build complete");
+    }
+    command = pkgManager;
+    args = pkgManager === "npx" ? ["next", "start", "-p", String(actualPort)] : ["run", "start", "-p", String(actualPort)];
+  } else {
+    command = pkgManager;
+    args = pkgManager === "npx" ? ["next", "dev", "-p", String(actualPort)] : ["run", "dev", "-p", String(actualPort)];
+  }
   const child = spawn(command, args, {
     cwd: webDir,
     stdio: ["ignore", "pipe", "pipe"],
-    env: {
-      ...process.env,
-      NEXT_PUBLIC_API_URL: `http://127.0.0.1:${apiPort}`
-    },
-    detached: false
+    env: webEnv,
+    detached: false,
+    shell: true
   });
+  const startupTimeout = 3e4;
   let started = false;
-  child.stdout?.on("data", (data) => {
-    const output = data.toString();
-    if (!started && (output.includes("Ready") || output.includes("started") || output.includes("localhost"))) {
-      started = true;
-      if (!quiet) console.log(`  \u2713 Web UI running at http://localhost:${actualPort}`);
-    }
-  });
-  if (!quiet) {
+  let exited = false;
+  let exitCode = null;
+  const startedPromise = new Promise((resolve7) => {
+    const timeout = setTimeout(() => {
+      if (!started && !exited) {
+        resolve7(false);
+      }
+    }, startupTimeout);
+    child.stdout?.on("data", (data) => {
+      const output = data.toString();
+      if (!started && (output.includes("Ready") || output.includes("started") || output.includes("localhost"))) {
+        started = true;
+        clearTimeout(timeout);
+        resolve7(true);
+      }
+    });
     child.stderr?.on("data", (data) => {
       const output = data.toString();
       if (output.toLowerCase().includes("error")) {
-        console.error(`  Web UI error: ${output.trim()}`);
+        if (!quiet) console.error(`  Web UI error: ${output.trim().slice(0, 200)}`);
       }
     });
-  }
-  child.on("exit", () => {
-    webUIProcess = null;
+    child.on("error", (err) => {
+      if (!quiet) console.error(`  \u274C Web UI spawn error: ${err.message}`);
+      clearTimeout(timeout);
+      resolve7(false);
+    });
+    child.on("exit", (code) => {
+      exited = true;
+      exitCode = code;
+      if (!started) {
+        clearTimeout(timeout);
+        resolve7(false);
+      }
+      webUIProcess = null;
+    });
   });
   webUIProcess = child;
-  return { process: child, port: actualPort };
+  const didStart = await startedPromise;
+  if (!didStart) {
+    if (exited && exitCode !== 0) {
+      if (!quiet) console.error(`  \u274C Web UI failed to start (exit code: ${exitCode})`);
+    } else if (!exited) {
+      if (!quiet) console.log(`  \u26A0 Web UI startup timed out, continuing anyway...`);
+    }
+  }
+  return { process: child, port: actualPort, started: didStart };
 }
 function stopWebUI() {
   if (webUIProcess) {
@@ -4514,11 +4603,13 @@ async function startServer(options = {}) {
     hostname: host
   });
   let webPort;
+  let webStarted;
   if (options.webUI !== false) {
     const result = await startWebUI(port, options.webPort || DEFAULT_WEB_PORT, options.quiet);
     webPort = result.port;
+    webStarted = result.started;
   }
-  return { app, port, host, webPort };
+  return { app, port, host, webPort, webStarted };
 }
 function stopServer() {
   stopWebUI();