saeeol 1.4.7 → 1.4.8

package/desktop.js

@@ -1,85 +1,81 @@
 #!/usr/bin/env node
 
-// fabulist — launches saeeol server + Electron desktop with React UI
-const { existsSync, realpathSync, createReadStream, statSync, readdirSync } = require("fs")
-const { join, dirname, extname, mimeLookup } = require("path")
+// fabulist — saeeol server + Electron desktop with React UI
+"use strict"
+const { existsSync, realpathSync, createReadStream, statSync, mkdirSync, writeFileSync } = require("fs")
+const { join, dirname, extname } = require("path")
 const { spawn } = require("child_process")
 const http = require("http")
 
+// Resolve script directory (works with symlinks and global installs)
+function getScriptDir() {
+  // 1. process.argv[1] (how npm bin scripts invoke us)
+  if (process.argv[1]) {
+    try { const r = realpathSync(process.argv[1]); if (r) return dirname(r) } catch {}
+  }
+  // 2. __filename (CJS context)
+  try { if (typeof __filename === "string") return dirname(realpathSync(__filename)) } catch {}
+  // 3. require.main
+  try { if (require.main && require.main.filename) return dirname(realpathSync(require.main.filename)) } catch {}
+  // 4. find saeeol package in global node_modules
+  try { const p = require.resolve("saeeol/cli.js"); return dirname(p) } catch {}
+  return process.cwd()
+}
+const SCRIPT_DIR = getScriptDir()
+
 const MIME = {
-  ".html": "text/html",
-  ".js": "text/javascript",
-  ".css": "text/css",
-  ".json": "application/json",
-  ".png": "image/png",
-  ".ico": "image/x-icon",
-  ".svg": "image/svg+xml",
-  ".woff2": "font/woff2",
-  ".wasm": "application/wasm",
+  ".html": "text/html", ".js": "text/javascript", ".css": "text/css",
+  ".json": "application/json", ".png": "image/png", ".ico": "image/x-icon",
+  ".svg": "image/svg+xml", ".woff2": "font/woff2", ".wasm": "application/wasm",
 }
 
 function getBinaryName() {
-  const archMap = { x64: "x64", arm64: "arm64" }
-  const platformMap = { win32: "windows", darwin: "darwin", linux: "linux" }
-  const p = platformMap[process.platform] || process.platform
-  const a = archMap[process.arch] || process.arch
-  return `saeeol-${p}-${a}`
+  const a = { x64: "x64", arm64: "arm64" }
+  const p = { win32: "windows", darwin: "darwin", linux: "linux" }
+  return `saeeol-${p[process.platform] || process.platform}-${a[process.arch] || process.arch}`
 }
 
 function findBinary() {
-  const binaryName = getBinaryName()
-  const binaryRel = process.platform === "win32" ? "bin/saeeol.exe" : "bin/saeeol"
-  const scriptDir = dirname(realpathSync(__filename))
-
-  const local = join(scriptDir, "node_modules", binaryName, binaryRel)
+  const name = getBinaryName()
+  const rel = process.platform === "win32" ? "bin/saeeol.exe" : "bin/saeeol"
+  // node_modules of this package
+  const local = join(SCRIPT_DIR, "node_modules", name, rel)
   if (existsSync(local)) return local
-
-  let current = scriptDir
+  // walk up
+  let dir = SCRIPT_DIR
   for (let i = 0; i < 10; i++) {
-    const candidate = join(current, "node_modules", binaryName, binaryRel)
-    if (existsSync(candidate)) return candidate
-    const parent = dirname(current)
-    if (parent === current) break
-    current = parent
+    const c = join(dir, "node_modules", name, rel)
+    if (existsSync(c)) return c
+    const parent = dirname(dir)
+    if (parent === dir) break
+    dir = parent
   }
-
-  const dl = join(scriptDir, "download", process.platform === "win32" ? `${binaryName}.exe` : "saeeol")
+  // download fallback
+  const dl = join(SCRIPT_DIR, "download", process.platform === "win32" ? `${name}.exe` : "saeeol")
   if (existsSync(dl)) return dl
-
   return null
 }
 
 function findElectron() {
-  const scriptDir = dirname(realpathSync(__filename))
   const exe = process.platform === "win32" ? "electron.exe" : "electron"
-  const p = join(scriptDir, "node_modules", "electron", "dist", exe)
-  if (existsSync(p)) return p
-  return null
+  const p = join(SCRIPT_DIR, "node_modules", "electron", "dist", exe)
+  return existsSync(p) ? p : null
 }
 
 function serveStatic(webDir, port) {
-  return new Promise((resolve) => {
+  return new Promise((resolve, reject) => {
     const server = http.createServer((req, res) => {
-      let urlPath = req.url.split("?")[0]
-      if (urlPath === "/") urlPath = "/index.html"
-
-      const filePath = join(webDir, urlPath)
-      if (!existsSync(filePath)) {
-        res.writeHead(404)
-        res.end("not found")
-        return
-      }
-
-      const ext = extname(filePath)
-      const ct = MIME[ext] || "application/octet-stream"
-      const stat = statSync(filePath)
-      res.writeHead(200, { "Content-Type": ct, "Content-Length": stat.size })
-      createReadStream(filePath).pipe(res)
-    })
-
-    server.listen(port, "127.0.0.1", () => {
-      resolve(server)
+      let path = req.url.split("?")[0]
+      if (path === "/") path = "/index.html"
+      const fp = join(webDir, path)
+      if (!existsSync(fp)) { res.writeHead(404); res.end("not found"); return }
+      const ct = MIME[extname(fp)] || "application/octet-stream"
+      const s = statSync(fp)
+      res.writeHead(200, { "Content-Type": ct, "Content-Length": s.size })
+      createReadStream(fp).pipe(res)
     })
+    server.listen(port, "127.0.0.1", () => resolve(server))
+    server.on("error", reject)
   })
 }
 
@@ -87,100 +83,80 @@ async function main() {
   const binaryPath = findBinary()
   if (!binaryPath) {
     console.error(`saeeol binary not found (${getBinaryName()})`)
-    console.error(`Run: npm install saeeol`)
+    console.error("Run: npm install saeeol")
     process.exit(1)
   }
 
   const electronPath = findElectron()
-  const webDir = join(dirname(realpathSync(__filename)), "web")
+  const webDir = join(SCRIPT_DIR, "web")
   const hasWebUI = existsSync(join(webDir, "index.html"))
 
+  // Fallback to terminal mode if no electron or no web UI
   if (!electronPath || !hasWebUI) {
-    // Fallback: terminal mode
-    if (!electronPath) {
-      console.log("Electron not found, starting in terminal mode.\n")
-    } else {
-      console.log("Web UI not found, starting in terminal mode.\n")
-    }
+    console.log(!electronPath ? "Electron not found." : "Web UI not found.")
+    console.log("Starting in terminal mode.\n")
     const child = spawn(binaryPath, process.argv.slice(2), {
-      stdio: "inherit",
-      env: { ...process.env },
-      windowsHide: false,
+      stdio: "inherit", env: { ...process.env }, windowsHide: false,
     })
     child.on("exit", (code) => process.exit(code || 0))
     return
   }
 
-  // Find ports
   const webPort = 31000 + Math.floor(Math.random() * 5000)
   const apiPort = 32000 + Math.floor(Math.random() * 5000)
 
   // 1. Start saeeol API server
   console.log("Starting saeeol API server...")
   const api = spawn(binaryPath, ["web", "--port", String(apiPort), "--hostname", "127.0.0.1"], {
-    stdio: "pipe",
-    env: { ...process.env },
-    windowsHide: true,
+    stdio: "pipe", env: { ...process.env }, windowsHide: true,
   })
   api.stdout.on("data", (d) => { const m = d.toString().trim(); if (m) console.log(`[api] ${m}`) })
   api.stderr.on("data", (d) => { const m = d.toString().trim(); if (m) console.error(`[api] ${m}`) })
 
-  // 2. Start static file server for React UI
+  // 2. Serve React UI
   const staticServer = await serveStatic(webDir, webPort)
-  console.log(`UI server: http://127.0.0.1:${webPort}`)
+  console.log(`UI: http://127.0.0.1:${webPort}`)
 
-  // 3. Wait for API to be ready
+  // 3. Wait for API
   await new Promise((r) => setTimeout(r, 3000))
 
-  // 4. Launch Electron with inline app
+  // 4. Write Electron app inline
   console.log("Opening FABULIST desktop...")
-
-  const electronAppDir = join(dirname(realpathSync(__filename__)), "desktop-app")
-  const { mkdirSync, writeFileSync } = require("fs")
-  mkdirSync(electronAppDir, { recursive: true })
-  writeFileSync(join(electronAppDir, "package.json"), '{"name":"fabulist-desktop"}')
-  writeFileSync(join(electronAppDir, "main.js"), `
+  const appDir = join(SCRIPT_DIR, ".desktop-cache")
+  mkdirSync(appDir, { recursive: true })
+  writeFileSync(join(appDir, "package.json"), '{"name":"fabulist-desktop"}')
+  writeFileSync(join(appDir, "main.js"), `
 const { app, BrowserWindow } = require("electron")
-const path = require("path")
-
 function createWindow() {
   const win = new BrowserWindow({
-    width: 1400,
-    height: 900,
-    minWidth: 800,
-    minHeight: 600,
-    title: "파불리스트 — FABULIST",
+    width: 1400, height: 900, minWidth: 800, minHeight: 600,
+    title: "\uD30C\uBD88\uB9AC\uC2A4\uD2B8 \u2014 FABULIST",
     autoHideMenuBar: true,
     webPreferences: { nodeIntegration: false, contextIsolation: true },
   })
   win.loadURL("http://127.0.0.1:${webPort}")
 }
-
 app.whenReady().then(createWindow)
 app.on("window-all-closed", () => app.quit())
 `)
 
-  const electron = spawn(electronPath, [join(electronAppDir, "main.js")], {
-    stdio: "inherit",
-    env: { ...process.env },
+  // Remove ELECTRON_RUN_AS_NODE if set (prevents Electron from running as Node)
+  const env = { ...process.env }
+  delete env.ELECTRON_RUN_AS_NODE
+
+  const electron = spawn(electronPath, [join(appDir, "main.js")], {
+    stdio: "ignore",
+    env,
+    detached: true,
     windowsHide: false,
   })
+  electron.unref()
 
-  electron.on("exit", (code) => {
-    api.kill()
-    staticServer.close()
-    process.exit(code || 0)
-  })
+  console.log("FABULIST desktop opened! Close the window to exit.")
+  console.log("Press Ctrl+C to stop the server.")
 
-  process.on("SIGINT", () => {
-    api.kill()
-    electron.kill()
-    staticServer.close()
-    process.exit(0)
-  })
+  const cleanup = () => { api.kill(); staticServer.close(); process.exit(0) }
+  process.on("SIGINT", cleanup)
 }
 
-main().catch((err) => {
-  console.error(err.message)
-  process.exit(1)
-})
+main().catch((err) => { console.error(err.message); process.exit(1) })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "saeeol",
-  "version": "1.4.7",
+  "version": "1.4.8",
   "description": "AI agent engine for SAEEOL — CLI + Desktop in one package",
   "author": "byfabulist",
   "license": "Apache-2.0",