remote-claude-code 0.1.0

package/server/db.ts

@@ -0,0 +1,134 @@
+import { Database, type Statement } from "bun:sqlite";
+import { join } from "node:path";
+import { mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+
+const DATA_DIR = join(
+  homedir(),
+  ".remote-claude-code"
+);
+
+function ensureDataDir() {
+  try {
+    mkdirSync(DATA_DIR, { recursive: true });
+  } catch {}
+}
+
+export class DataStore {
+  private db: Database;
+  private stmts: {
+    getConfig: Statement;
+    setConfig: Statement;
+    createSession: Statement;
+    completeSession: Statement;
+    saveMessage: Statement;
+    getRecentSessions: Statement;
+    getSessionMessages: Statement;
+  };
+
+  constructor() {
+    ensureDataDir();
+    this.db = new Database(join(DATA_DIR, "data.db"));
+    this.db.exec("PRAGMA journal_mode = WAL");
+    this.db.exec("PRAGMA foreign_keys = ON");
+    this.init();
+    this.stmts = this.prepareStatements();
+  }
+
+  private init() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS config (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL,
+        updated_at INTEGER DEFAULT (unixepoch())
+      );
+
+      CREATE TABLE IF NOT EXISTS sessions (
+        id TEXT PRIMARY KEY,
+        cwd TEXT NOT NULL,
+        started_at INTEGER DEFAULT (unixepoch()),
+        ended_at INTEGER,
+        is_error INTEGER DEFAULT 0,
+        num_turns INTEGER DEFAULT 0,
+        duration_ms INTEGER
+      );
+
+      CREATE TABLE IF NOT EXISTS messages (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id TEXT NOT NULL,
+        role TEXT NOT NULL,
+        content TEXT NOT NULL,
+        timestamp INTEGER DEFAULT (unixepoch()),
+        FOREIGN KEY (session_id) REFERENCES sessions(id)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id);
+    `);
+  }
+
+  private prepareStatements() {
+    return {
+      getConfig: this.db.query("SELECT value FROM config WHERE key = ?"),
+      setConfig: this.db.query("INSERT OR REPLACE INTO config (key, value) VALUES (?, ?)"),
+      createSession: this.db.query("INSERT OR IGNORE INTO sessions (id, cwd) VALUES (?, ?)"),
+      completeSession: this.db.query("UPDATE sessions SET ended_at = unixepoch(), is_error = ?, num_turns = ?, duration_ms = ? WHERE id = ?"),
+      saveMessage: this.db.query("INSERT INTO messages (session_id, role, content) VALUES (?, ?, ?)"),
+      getRecentSessions: this.db.query("SELECT * FROM sessions ORDER BY started_at DESC LIMIT ?"),
+      getSessionMessages: this.db.query("SELECT * FROM messages WHERE session_id = ? ORDER BY timestamp ASC"),
+    };
+  }
+
+  getPasswordHash(): string | null {
+    const row = this.stmts.getConfig.get("password_hash") as { value: string } | null;
+    return row?.value ?? null;
+  }
+
+  setPasswordHash(hash: string) {
+    this.stmts.setConfig.run("password_hash", hash);
+  }
+
+  createSession(id: string, cwd: string) {
+    this.stmts.createSession.run(id, cwd);
+  }
+
+  completeSession(
+    id: string,
+    result: { isError: boolean; numTurns: number; durationMs: number }
+  ) {
+    this.stmts.completeSession.run(result.isError ? 1 : 0, result.numTurns, result.durationMs, id);
+  }
+
+  saveMessage(sessionId: string, role: string, content: unknown) {
+    this.stmts.saveMessage.run(sessionId, role, JSON.stringify(content));
+  }
+
+  getJwtSecret(): string | null {
+    const row = this.stmts.getConfig.get("jwt_secret") as { value: string } | null;
+    return row?.value ?? null;
+  }
+
+  setJwtSecret(secret: string) {
+    this.stmts.setConfig.run("jwt_secret", secret);
+  }
+
+  getProjects(): Array<{ path: string; name: string; addedAt: number }> {
+    const row = this.stmts.getConfig.get("projects") as { value: string } | null;
+    return row ? JSON.parse(row.value) : [];
+  }
+
+  setProjects(projects: Array<{ path: string; name: string; addedAt: number }>) {
+    this.stmts.setConfig.run("projects", JSON.stringify(projects));
+  }
+
+  getRecentSessions(limit = 20) {
+    return this.stmts.getRecentSessions.all(limit);
+  }
+
+  getSessionMessages(sessionId: string) {
+    return this.stmts.getSessionMessages.all(sessionId);
+  }
+
+  close() {
+    this.db.close();
+  }
+}

package/server/index.ts

@@ -0,0 +1,177 @@
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { logger } from "hono/logger";
+import { serveStatic } from "hono/bun";
+import { createBunWebSocket } from "hono/bun";
+import { DataStore } from "./db";
+import { createAuthRoutes } from "./auth";
+import { createWSHandlers, sessionManager, terminalManager, type WSState } from "./ws";
+import { createThreadRoutes } from "./threads";
+import { createUploadRoutes } from "./upload";
+import { createProjectRoutes } from "./projects";
+import { launchTunnel, getTunnelInfo, stopTunnel } from "./tunnel";
+import { detectTailscale, getTailscaleInfo } from "./tailscale";
+import { createPreviewRoutes } from "./preview";
+
+import { existsSync } from "node:fs";
+
+const PORT = parseInt(process.env.PORT || "3456");
+const ENABLE_TUNNEL = process.env.NO_TUNNEL !== "1";
+const ENABLE_TAILSCALE = process.env.NO_TAILSCALE !== "1";
+const VITE_PORT = 5173;
+const IS_DEV = !existsSync("./dist/client/index.html");
+
+// 初始化
+const db = new DataStore();
+
+// JWT_SECRET: 优先环境变量 > DB 持久化 > 新生成并存入 DB
+const JWT_SECRET = (() => {
+  if (process.env.RCC_JWT_SECRET) return process.env.RCC_JWT_SECRET;
+  const stored = db.getJwtSecret();
+  if (stored) return stored;
+  const newSecret = crypto.randomUUID();
+  db.setJwtSecret(newSecret);
+  return newSecret;
+})();
+const app = new Hono();
+const { upgradeWebSocket, websocket } = createBunWebSocket();
+
+// 全局中间件
+app.use("*", logger());
+app.use("*", cors());
+
+// 认证路由（公开）
+app.route("/api/auth", createAuthRoutes(db, JWT_SECRET));
+
+// 网络信息
+app.get("/api/network", (c) =>
+  c.json({ tunnel: getTunnelInfo(), tailscale: getTailscaleInfo() })
+);
+app.get("/api/tunnel", (c) => c.json(getTunnelInfo()));
+
+// Thread 管理路由（需要 JWT）
+app.route("/api/threads", createThreadRoutes(JWT_SECRET));
+
+// 项目管理路由（需要 JWT）
+app.route("/api/projects", createProjectRoutes(db, JWT_SECRET));
+
+// 文件上传路由（需要 JWT）
+app.route("/api", createUploadRoutes(JWT_SECRET));
+
+// Web Preview 代理路由（需要 JWT）
+app.route("/api/preview", createPreviewRoutes(JWT_SECRET));
+
+// WebSocket 路由
+const wsHandlers = createWSHandlers(JWT_SECRET, db);
+app.get(
+  "/ws",
+  upgradeWebSocket((_c) => ({
+    onOpen(_event, ws) {
+      const raw = ws.raw as import("bun").ServerWebSocket<WSState>;
+      Object.assign(raw.data, {
+        authenticated: false,
+        clientId: crypto.randomUUID(),
+        activeSessionId: null,
+      });
+      wsHandlers.open(raw);
+    },
+    onMessage(event, ws) {
+      const raw = ws.raw as import("bun").ServerWebSocket<WSState>;
+      wsHandlers.message(raw, event.data as string);
+    },
+    onClose(_event, ws) {
+      const raw = ws.raw as import("bun").ServerWebSocket<WSState>;
+      wsHandlers.close(raw);
+    },
+  }))
+);
+
+// 生产环境：静态文件服务
+app.use("/*", serveStatic({ root: "./dist/client" }));
+app.get("*", serveStatic({ path: "./dist/client/index.html" }));
+
+// 启动服务器
+const server = Bun.serve({
+  port: PORT,
+  fetch: app.fetch,
+  websocket: {
+    ...websocket,
+    // 使用应用层 ping/pong 保活，避免默认空闲超时在移动端/PWA 上误杀连接。
+    idleTimeout: 0,
+    sendPings: false,
+  },
+});
+const listeningPort = server.port ?? PORT;
+
+console.log(`[Server] Running at http://localhost:${listeningPort}`);
+
+// 并行启动网络服务
+const networkTasks: Promise<void>[] = [];
+
+if (ENABLE_TAILSCALE) {
+  networkTasks.push(
+    detectTailscale(listeningPort)
+      .then((info) => {
+        if (info.isAvailable) {
+          console.log(`[Tailscale] Detected: ${info.ip}${info.hostname ? ` (${info.hostname})` : ""}`);
+        } else {
+          console.log("[Tailscale] Not available");
+        }
+      })
+      .catch(() => {})
+  );
+}
+
+if (ENABLE_TUNNEL) {
+  const tunnelPort = IS_DEV ? VITE_PORT : PORT;
+  networkTasks.push(
+    launchTunnel(tunnelPort)
+      .then(() => {})
+      .catch((err) => {
+        console.warn(`[Tunnel] Failed: ${err.message}`);
+      })
+  );
+}
+
+// 全部完成后打印统一横幅
+Promise.allSettled(networkTasks).then(() => {
+  const lines: string[] = [];
+  lines.push(`  Local:      http://localhost:${server.port}`);
+
+  const ts = getTailscaleInfo();
+  if (ts.isAvailable) {
+    lines.push(`  Tailscale:  ${ts.url}`);
+  }
+
+  const tn = getTunnelInfo();
+  if (tn.isRunning && tn.url) {
+    lines.push(`  Tunnel:     ${tn.url}`);
+  }
+
+  const width = 42;
+  console.log(`\n${"=".repeat(width)}`);
+  console.log("  Remote Claude Code");
+  console.log(`${"-".repeat(width)}`);
+  for (const line of lines) console.log(line);
+  console.log(`${"-".repeat(width)}`);
+  console.log("  Open any URL above on your phone!");
+  console.log(`${"=".repeat(width)}\n`);
+});
+
+// 优雅关闭
+process.on("SIGINT", () => {
+  console.log("\n[Server] Shutting down...");
+  terminalManager.destroyAll();
+  sessionManager.dispose();
+  stopTunnel();
+  db.close();
+  process.exit(0);
+});
+
+process.on("SIGTERM", () => {
+  terminalManager.destroyAll();
+  sessionManager.dispose();
+  stopTunnel();
+  db.close();
+  process.exit(0);
+});

package/server/preview.ts

@@ -0,0 +1,93 @@
+import { Hono } from "hono";
+import { jwt } from "hono/jwt";
+import { PREVIEW_SESSION_COOKIE } from "./auth-cookie";
+
+export function createPreviewRoutes(jwtSecret: string) {
+  const app = new Hono();
+
+  // JWT 认证
+  app.use(
+    "/*",
+    jwt({
+      secret: jwtSecret,
+      alg: "HS256",
+      cookie: PREVIEW_SESSION_COOKIE,
+    })
+  );
+
+  // 反向代理：转发到 localhost:<port>
+  app.all("/:port{[0-9]+}/*", async (c) => {
+    const port = c.req.param("port");
+    const portNum = parseInt(port, 10);
+    if (portNum <= 0 || portNum > 65535) {
+      return c.text("Invalid port", 400);
+    }
+
+    // 构建目标 URL
+    const url = new URL(c.req.url);
+    const pathPrefix = `/api/preview/${port}`;
+    const targetPath = url.pathname.startsWith(pathPrefix)
+      ? url.pathname.slice(pathPrefix.length) || "/"
+      : "/";
+    const targetUrl = `http://localhost:${port}${targetPath}${url.search}`;
+
+    try {
+      // 转发请求
+      const headers = new Headers(c.req.raw.headers);
+      headers.delete("host");
+      headers.delete("origin");
+      // 移除认证头（JWT token 不应转发给目标服务）
+      headers.delete("authorization");
+
+      const response = await fetch(targetUrl, {
+        method: c.req.method,
+        headers,
+        body: c.req.method !== "GET" && c.req.method !== "HEAD" ? c.req.raw.body : undefined,
+        redirect: "manual",
+      });
+
+      // 复制响应头
+      const responseHeaders = new Headers(response.headers);
+      // 移除可能冲突的头
+      responseHeaders.delete("transfer-encoding");
+
+      const contentType = responseHeaders.get("content-type") || "";
+
+      // HTML 响应注入 <base> 标签
+      if (contentType.includes("text/html")) {
+        let html = await response.text();
+        const baseTag = `<base href="/api/preview/${port}/">`;
+        if (html.includes("<head>")) {
+          html = html.replace("<head>", `<head>${baseTag}`);
+        } else if (html.includes("<HEAD>")) {
+          html = html.replace("<HEAD>", `<HEAD>${baseTag}`);
+        } else {
+          html = baseTag + html;
+        }
+        return new Response(html, {
+          status: response.status,
+          headers: responseHeaders,
+        });
+      }
+
+      return new Response(response.body, {
+        status: response.status,
+        headers: responseHeaders,
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Proxy error";
+      if (message.includes("ECONNREFUSED")) {
+        return c.text(`No server running on port ${port}`, 502);
+      }
+      return c.text(message, 502);
+    }
+  });
+
+  // 无路径时重定向到 /
+  app.get("/:port{[0-9]+}", (c) => {
+    const port = c.req.param("port");
+    return c.redirect(`/api/preview/${port}/`);
+  });
+
+  return app;
+}