turtlecode 0.1.0 → 0.1.3

package/bin/cli.mjs

@@ -1,10 +1,11 @@
 #!/usr/bin/env node
 
-import { createServer } from "node:http"
-import { readFileSync, existsSync, statSync } from "node:fs"
-import { join, extname, dirname } from "node:path"
+import { createServer, request as httpRequest } from "node:http"
+import { readFileSync, existsSync, statSync, mkdirSync } from "node:fs"
+import { join, extname, dirname, resolve } from "node:path"
 import { fileURLToPath } from "node:url"
-import { exec } from "node:child_process"
+import { exec, spawn } from "node:child_process"
+import { homedir } from "node:os"
 
 const root = join(dirname(fileURLToPath(import.meta.url)), "..", "assets")
 
@@ -17,10 +18,14 @@ if (args.includes("--help") || args.includes("-h")) {
     npx turtlecode [options]
 
   Options:
-    --port, -p <number>   Port to serve on (default: 3333)
-    --no-open             Don't auto-open the browser
-    --help, -h            Show this help message
-    --version, -v         Show version
+    --port, -p <number>      Port to serve on (default: 3333)
+    --backend, -b <url>      OpenCode backend URL (default: http://localhost:4096)
+    --no-open                Don't auto-open the browser
+    --help, -h               Show this help message
+    --version, -v            Show version
+
+  The backend server (opencode) is started automatically.
+  Install it with: npm i -g opencode-ai
 `)
   process.exit(0)
 }
@@ -31,9 +36,89 @@ if (args.includes("--version") || args.includes("-v")) {
   process.exit(0)
 }
 
-const idx = Math.max(args.indexOf("--port"), args.indexOf("-p"))
-const port = idx !== -1 && args[idx + 1] ? parseInt(args[idx + 1], 10) : 3333
+function flag(long, short) {
+  const i = Math.max(args.indexOf(long), args.indexOf(short))
+  return i !== -1 && args[i + 1] ? args[i + 1] : undefined
+}
+
+const port = parseInt(flag("--port", "-p") || "3333", 10)
 const open = !args.includes("--no-open")
+const backend = new URL(flag("--backend", "-b") || process.env.OPENCODE_URL || "http://localhost:4096")
+
+// URL-safe base64 encode (matches @opencode-ai/util/encode)
+function encode(str) {
+  return Buffer.from(str).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "")
+}
+
+// Extract directory from base64-encoded path segment, returns { pathname, directory }
+function extractDir(path) {
+  const match = path.match(/^\/([A-Za-z0-9_-]{10,})(\/.*)?$/)
+  if (!match) return { pathname: path }
+
+  const encoded = match[1]
+  const rest = match[2] || "/"
+
+  try {
+    const normalized = encoded.replace(/-/g, "+").replace(/_/g, "/")
+    const decoded = Buffer.from(normalized, "base64").toString("utf-8")
+    return { pathname: rest, directory: decoded }
+  } catch {
+    return { pathname: path }
+  }
+}
+
+function probe(origin) {
+  return new Promise((ok) => {
+    const req = httpRequest(origin, { method: "HEAD", timeout: 1000 }, (res) => {
+      res.resume()
+      ok(true)
+    })
+    req.on("error", () => ok(false))
+    req.on("timeout", () => {
+      req.destroy()
+      ok(false)
+    })
+    req.end()
+  })
+}
+
+async function boot(origin) {
+  if (await probe(origin)) return null
+
+  const url = new URL(origin)
+  if (url.hostname !== "localhost" && url.hostname !== "127.0.0.1") {
+    console.error(`\n  Error: Backend not reachable at ${origin}\n`)
+    process.exit(1)
+  }
+
+  console.log(`  Starting backend on port ${url.port}...`)
+  const child = spawn("opencode", ["serve", "--port", url.port], {
+    cwd: process.cwd(),
+    stdio: ["ignore", "pipe", "pipe"],
+    env: { ...process.env },
+  })
+
+  let exited = false
+  child.on("exit", (code) => {
+    exited = true
+    if (code && code !== 0) console.error(`\n  Backend exited with code ${code}`)
+  })
+
+  child.on("error", (err) => {
+    console.error(`\n  Error: Could not start backend.\n  ${err.message}\n\n  Install: npm i -g opencode-ai\n`)
+    process.exit(1)
+  })
+
+  const deadline = Date.now() + 30_000
+  while (Date.now() < deadline && !exited) {
+    if (await probe(origin)) return child
+    await new Promise((r) => setTimeout(r, 300))
+  }
+
+  if (!exited) child.kill()
+  console.error("\n  Error: Backend failed to start within 30s.\n")
+  process.exit(1)
+}
 
 const mime = {
   ".html": "text/html; charset=utf-8",
@@ -61,19 +146,77 @@ if (!existsSync(join(root, "index.html"))) {
   process.exit(1)
 }
 
+const spawned = await boot(backend.origin)
+
+// Ensure ~/.turtlecode exists for new project creation
+const projectsDir = join(homedir(), ".turtlecode")
+if (!existsSync(projectsDir)) {
+  try {
+    mkdirSync(projectsDir, { recursive: true })
+  } catch {
+    // Ignore errors (permissions, etc.) - backend will handle them
+  }
+}
+
+// Determine whether a request should be proxied to the backend.
+// Static assets are served directly; browser navigation gets the SPA
+// index.html; everything else (API calls, SSE, etc.) is proxied.
+function shouldProxy(req, file) {
+  // Non-GET/HEAD methods are always API requests
+  if (req.method !== "GET" && req.method !== "HEAD") return true
+
+  // If the file exists as a static asset, serve it directly
+  if (existsSync(file) && !statSync(file).isDirectory()) return false
+
+  // GET requests that accept text/html are browser navigation → SPA fallback
+  const accept = req.headers.accept || ""
+  if (accept.includes("text/html")) return false
+
+  // Everything else (JSON, SSE, etc.) → proxy
+  return true
+}
+
+function proxy(req, res) {
+  const url = new URL(req.url, `http://localhost:${port}`)
+
+  // Extract directory from base64 path segment and add header for backend
+  const { pathname, directory } = extractDir(url.pathname)
+  const headers = { ...req.headers, host: backend.host }
+  if (directory) headers["x-opencode-directory"] = directory
+
+  const target = `${backend.origin}${pathname}${url.search}`
+
+  const proxyReq = httpRequest(target, { method: req.method, headers }, (proxyRes) => {
+    res.writeHead(proxyRes.statusCode, proxyRes.headers)
+    proxyRes.pipe(res)
+  })
+
+  proxyReq.on("error", () => {
+    if (res.headersSent) return res.end()
+    res.writeHead(502, { "Content-Type": "application/json" })
+    res.end(
+      JSON.stringify({
+        error: `Backend not reachable at ${backend.origin}. Start it with: opencode serve`,
+      }),
+    )
+  })
+
+  req.pipe(proxyReq)
+}
+
 const server = createServer((req, res) => {
   const url = new URL(req.url, `http://localhost:${port}`)
-  let file = join(root, url.pathname === "/" ? "index.html" : url.pathname)
+  const file = join(root, url.pathname === "/" ? "index.html" : url.pathname)
 
-  if (!existsSync(file) || statSync(file).isDirectory()) {
-    file = join(root, "index.html")
-  }
+  if (shouldProxy(req, file)) return proxy(req, res)
 
-  const ext = extname(file)
+  // Serve static file or SPA fallback
+  const resolved = existsSync(file) && !statSync(file).isDirectory() ? file : join(root, "index.html")
+  const ext = extname(resolved)
   const type = mime[ext] || "application/octet-stream"
 
   try {
-    const body = readFileSync(file)
+    const body = readFileSync(resolved)
     res.writeHead(200, {
       "Content-Type": type,
       "Content-Length": body.length,
@@ -86,26 +229,61 @@ const server = createServer((req, res) => {
   }
 })
 
+// Handle WebSocket upgrade (used by PTY terminal connections)
+server.on("upgrade", (req, socket, head) => {
+  const url = new URL(req.url, `http://localhost:${port}`)
+
+  // Extract directory from base64 path segment and add header (same logic as proxy function)
+  const { pathname, directory } = extractDir(url.pathname)
+  const headers = { ...req.headers, host: backend.host }
+  if (directory) headers["x-opencode-directory"] = directory
+
+  const target = `${backend.origin}${pathname}${url.search}`
+  const proxyReq = httpRequest(target, { method: "GET", headers })
+
+  proxyReq.on("upgrade", (proxyRes, proxySocket, proxyHead) => {
+    socket.write(
+      `HTTP/1.1 101 Switching Protocols\r\n` +
+        Object.entries(proxyRes.headers)
+          .map(([k, v]) => `${k}: ${v}`)
+          .join("\r\n") +
+        "\r\n\r\n",
+    )
+    if (proxyHead.length) socket.write(proxyHead)
+    proxySocket.pipe(socket)
+    socket.pipe(proxySocket)
+  })
+
+  proxyReq.on("error", () => {
+    socket.end("HTTP/1.1 502 Bad Gateway\r\n\r\n")
+  })
+
+  proxyReq.end()
+})
+
 server.listen(port, () => {
-  const url = `http://localhost:${port}`
+  const dir = encode(resolve(process.cwd()))
+  const url = `http://localhost:${port}/${dir}`
   console.log(`
   🐢 turtlecode v${process.env.npm_package_version || "0.1.0"}
 
-  Local:   ${url}
+  Local:    ${url}
+  Backend:  ${backend.origin}
+  Project:  ${process.cwd()}
   Press Ctrl+C to stop
 `)
 
   if (open) {
-    const cmd = process.platform === "darwin"
-      ? "open"
-      : process.platform === "win32"
-        ? "start"
-        : "xdg-open"
+    const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open"
     exec(`${cmd} ${url}`)
   }
 })
 
-process.on("SIGINT", () => {
+function cleanup() {
+  if (spawned) spawned.kill()
   console.log("\n  Stopped.\n")
   process.exit(0)
-})
+}
+
+process.on("SIGINT", cleanup)
+process.on("SIGTERM", cleanup)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "turtlecode",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "AI-powered creative workspace — launch with npx turtlecode",
   "type": "module",
   "bin": {