kcg-code 0.0.0-stage → 0.2.0

package/src/server/routes/tunnel.routes.ts

@@ -0,0 +1,132 @@
+/**
+ * Tabel rute API tunnel publik (`https://<username>.<domain>`, domain dari VPS).
+ *
+ * - `GET  /api/tunnel`                status (tanpa token/secret)
+ * - `GET  /api/tunnel/logs?from=<n>`  baris log frpc mulai indeks n
+ * - `POST /api/tunnel/connect`        mulai device flow -> kode + URL
+ * - `POST /api/tunnel/connect/cancel`
+ * - `POST /api/tunnel/start` | `/stop` | `/rotate-secret` | `/signout`
+ * - `PUT  /api/tunnel/provider`      `{ provider: "kcg" | "lhr" }` — pindah
+ *   penyedia; yang lama dimatikan lebih dulu (hanya satu tunnel aktif).
+ * - `GET  /api/tunnel/lhr`, `/lhr/logs`, `POST /lhr/start` | `/lhr/stop` —
+ *   tunnel localhost.run (tanpa akun, via ssh).
+ *
+ * Seluruhnya dijaga `guardRoutes` (sesi + Origin). Tanpa app lock, tunnel
+ * ditolak (`TUNNEL_LOCK_REQUIRED`).
+ */
+import { errorStatus, json, readJson, serverError } from "./helpers";
+import type { ApiRouteContext } from "./types";
+
+export function tunnelRoutes(ctx: ApiRouteContext) {
+  const { tunnel, lhr } = ctx;
+  const wrap =
+    <A extends unknown[]>(fn: (...a: A) => Promise<Response> | Response) =>
+    async (...a: A) => {
+      try {
+        return await fn(...a);
+      } catch (e) {
+        return serverError(e);
+      }
+    };
+
+  return {
+    "/api/tunnel": {
+      GET: wrap(() =>
+        json({ tunnel: tunnel.status(), provider: ctx.tunnelProvider(), lhr: lhr.status() }),
+      ),
+    },
+
+    "/api/tunnel/logs": {
+      GET: wrap((req: Request) => {
+        const from = Number(new URL(req.url).searchParams.get("from") ?? "0");
+        return json(tunnel.logs(Number.isFinite(from) && from >= 0 ? from : 0));
+      }),
+    },
+
+    "/api/tunnel/connect": {
+      POST: wrap(async () => {
+        const res = await tunnel.connect();
+        if (!res.ok) return json({ error: res.error }, errorStatus(res.error));
+        return json({ tunnel: res.data });
+      }),
+    },
+
+    "/api/tunnel/connect/cancel": {
+      POST: wrap(() => {
+        tunnel.cancelConnect();
+        return json({ tunnel: tunnel.status() });
+      }),
+    },
+
+    "/api/tunnel/start": {
+      POST: wrap(async () => {
+        await lhr.stop();
+        ctx.setTunnelProvider("kcg");
+        const res = await tunnel.start();
+        if (!res.ok) return json({ error: res.error }, errorStatus(res.error));
+        return json({ tunnel: res.data });
+      }),
+    },
+
+    "/api/tunnel/stop": {
+      POST: wrap(async () => json({ tunnel: await tunnel.stop() })),
+    },
+
+    "/api/tunnel/rotate-secret": {
+      POST: wrap(async () => {
+        const res = await tunnel.rotateSecret();
+        if (!res.ok) return json({ error: res.error }, errorStatus(res.error));
+        return json({ tunnel: res.data });
+      }),
+    },
+
+    "/api/tunnel/signout": {
+      POST: wrap(async () => json({ tunnel: await tunnel.signOut() })),
+    },
+
+    // ---- Pilihan penyedia (satu tunnel aktif) ----
+    "/api/tunnel/provider": {
+      PUT: wrap(async (req: Request) => {
+        const body = await readJson(req);
+        if (!body.ok) return json({ error: "INVALID_JSON" }, 400);
+        const provider = (body.data as { provider?: unknown }).provider;
+        if (provider !== "kcg" && provider !== "lhr") {
+          return json({ error: "INVALID_PROVIDER" }, 400);
+        }
+        // Matikan penyedia lain dulu: dua alamat publik sekaligus membingungkan
+        // dan memperluas permukaan akses.
+        if (provider === "lhr") await tunnel.stop();
+        else await lhr.stop();
+        ctx.setTunnelProvider(provider);
+        return json({ provider, tunnel: tunnel.status(), lhr: lhr.status() });
+      }),
+    },
+
+    // ---- localhost.run ----
+    "/api/tunnel/lhr": {
+      GET: wrap(() => json({ lhr: lhr.status() })),
+    },
+
+    "/api/tunnel/lhr/logs": {
+      GET: wrap((req: Request) => {
+        const from = Number(new URL(req.url).searchParams.get("from") ?? "0");
+        return json(lhr.logs(Number.isFinite(from) && from >= 0 ? from : 0));
+      }),
+    },
+
+    "/api/tunnel/lhr/start": {
+      POST: wrap(async () => {
+        // Pastikan hanya satu tunnel publik aktif.
+        await tunnel.stop();
+        ctx.setTunnelProvider("lhr");
+        const res = await lhr.start();
+        if (!res.ok) return json({ error: res.error }, errorStatus(res.error));
+        return json({ lhr: res.data });
+      }),
+    },
+
+    "/api/tunnel/lhr/stop": {
+      POST: wrap(async () => json({ lhr: await lhr.stop() })),
+    },
+  };
+}

package/src/server/routes/types.ts

@@ -0,0 +1,35 @@
+/**
+ * Tipe bersama tabel rute API (pola `routes/types.ts` kcgcode).
+ *
+ * Composition root (`app.ts`) merakit service lalu menyuntikkannya ke tiap
+ * tabel rute via `ApiRouteContext`; handler tidak lagi menutup dependency
+ * secara langsung seperti saat semuanya menumpuk di `app.ts`.
+ */
+
+import type { TunnelProvider } from "../db/tunnel";
+import type { AttachmentManager } from "../services/attachments";
+import type { ProjectManager } from "../services/project-manager";
+import type { SessionManager } from "../services/session-manager";
+import type { SkillInstallJobs } from "../services/skill-install-jobs";
+import type { SkillsRegistry } from "../services/skills-registry";
+import type { TunnelManager } from "../services/tunnel";
+import type { LhrManager } from "../services/tunnel-lhr";
+
+export interface ApiRouteContext {
+  projectManager: ProjectManager;
+  sessionManager: SessionManager;
+  attachments: AttachmentManager;
+  skillsRegistry: SkillsRegistry;
+  skillInstalls: SkillInstallJobs;
+  tunnel: TunnelManager;
+  /** Tunnel localhost.run (alternatif tanpa akun). */
+  lhr: LhrManager;
+  /** Penyedia remote access terpilih. */
+  tunnelProvider: () => TunnelProvider;
+  setTunnelProvider: (provider: TunnelProvider) => void;
+  /**
+   * Beri tahu semua klien bahwa daftar Project/Session berubah (buat/hapus)
+   * agar sidebar & daftar di perangkat lain ikut terbarui.
+   */
+  notifyDataChanged: () => void;
+}

package/src/server/routes/uploads.routes.ts

@@ -0,0 +1,54 @@
+/**
+ * Tabel rute muat & hapus lampiran gambar (`/api/uploads/:sessionId/:id`).
+ *
+ * GET mengalirkan bytes gambar untuk bubble & reattach; DELETE menghapus
+ * lampiran yang belum terkirim (pengguna membatalkan). Dipasang composition
+ * root (`app.ts`) — pola kcgcode (`*.routes.ts`).
+ */
+import type { BunRequest } from "bun";
+import { isPreviewableImage } from "../../lib/attachments";
+import { errorStatus, json, serverError } from "./helpers";
+import type { ApiRouteContext } from "./types";
+
+export function uploadsRoutes(ctx: ApiRouteContext) {
+  const { attachments } = ctx;
+  return {
+    // ---- Muat gambar upload (render bubble & reattach) ----
+    "/api/uploads/:sessionId/:id": {
+      GET: (req: BunRequest<"/api/uploads/:sessionId/:id">) => {
+        try {
+          const res = attachments.read(req.params.sessionId, req.params.id);
+          if (!res.ok) return json({ error: res.error }, errorStatus(res.error));
+          // Salin ke Uint8Array ber-buffer ArrayBuffer agar lolos tipe BodyInit.
+          const bytes = new Uint8Array(res.data.bytes);
+          // Lampiran bisa file apa saja (html/svg/js …) dan disajikan dari
+          // origin yang sama dengan aplikasi: hanya gambar raster yang boleh
+          // tampil inline; sisanya dipaksa unduh + nosniff + CSP sandbox agar
+          // tidak pernah dieksekusi browser (XSS).
+          const inline = isPreviewableImage(res.data.mime);
+          const name = encodeURIComponent(res.data.filename);
+          return new Response(new Blob([bytes]), {
+            headers: {
+              "content-type": inline ? res.data.mime : "application/octet-stream",
+              "content-disposition": `${inline ? "inline" : "attachment"}; filename*=UTF-8''${name}`,
+              "x-content-type-options": "nosniff",
+              "content-security-policy": "default-src 'none'; sandbox",
+              "cache-control": "private, max-age=3600",
+            },
+          });
+        } catch (e) {
+          return serverError(e);
+        }
+      },
+      /** Hapus lampiran yang belum terkirim (pengguna membatalkan). */
+      DELETE: (req: BunRequest<"/api/uploads/:sessionId/:id">) => {
+        try {
+          attachments.remove(req.params.sessionId, req.params.id);
+          return json({ ok: true });
+        } catch (e) {
+          return serverError(e);
+        }
+      },
+    },
+  };
+}

package/src/server/routes/workspace.routes.ts

@@ -0,0 +1,127 @@
+/**
+ * Tabel rute API Workspace (Sandbox_Root) — Settings -> Workspace.
+ *
+ * - `GET /api/workspace`   root aktif + jumlah Project di dalamnya
+ * - `PUT /api/workspace`   `{ path, create?, current? }` ganti root
+ *
+ * Keduanya dijaga `guardRoutes` (sesi + Origin). Mengganti root adalah
+ * perubahan batas keamanan, jadi saat app dikunci `current` (PIN/password)
+ * wajib benar — dengan rate limit yang sama seperti login.
+ */
+import { mkdirSync } from "node:fs";
+import type { Server } from "bun";
+import type { AuthService } from "../services/auth";
+import {
+  displayPath,
+  projectsOutside,
+  validateWorkspaceRoot,
+  type WorkspaceInfo,
+  writeSandboxRoot,
+} from "../services/workspace";
+import { clientIp } from "./auth-guard";
+import { errorStatus, json, readJson, serverError } from "./helpers";
+import type { ApiRouteContext } from "./types";
+
+export interface WorkspaceRouteDeps {
+  auth: AuthService;
+  configPath: string;
+  /** Folder milik KCG Code yang tak boleh tumpang tindih dengan workspace. */
+  protectedDirs: string[];
+  /** Home pengguna (`~`) — diinjeksi agar test tidak menyentuh home asli. */
+  home?: string;
+}
+
+function rateLimitedResponse(code: string): Response | null {
+  if (!code.startsWith("AUTH_RATE_LIMITED:")) return null;
+  const wait = Number(code.slice("AUTH_RATE_LIMITED:".length)) || 30;
+  return new Response(JSON.stringify({ error: "AUTH_RATE_LIMITED", retryAfterSec: wait }), {
+    status: 429,
+    headers: { "content-type": "application/json", "retry-after": String(wait) },
+  });
+}
+
+export function workspaceRoutes(ctx: ApiRouteContext, deps: WorkspaceRouteDeps) {
+  const { projectManager } = ctx;
+
+  const info = (): WorkspaceInfo => {
+    const root = projectManager.getSandboxRoot();
+    const all = projectManager.listProjects();
+    return {
+      root,
+      display: displayPath(root, deps.home),
+      projectCount: all.length - projectsOutside(root, all).length,
+      configPath: deps.configPath,
+    };
+  };
+
+  return {
+    "/api/workspace": {
+      GET: () => {
+        try {
+          return json({ workspace: info() });
+        } catch (e) {
+          return serverError(e);
+        }
+      },
+      PUT: async (req: Request, server: Server<unknown>) => {
+        try {
+          const body = await readJson(req);
+          if (!body.ok || body.data === null || typeof body.data !== "object") {
+            return json({ error: "INVALID_JSON" }, 400);
+          }
+          const b = body.data as { path?: unknown; create?: unknown; current?: unknown };
+
+          // 1. Konfirmasi sandi (bila dikunci) SEBELUM menyentuh filesystem —
+          //    pesan validasi path tidak boleh jadi oracle tanpa sandi.
+          if (deps.auth.isProtected()) {
+            const check = await deps.auth.internal.checkCurrentSecret(
+              typeof b.current === "string" ? b.current : "",
+              clientIp(req, server),
+            );
+            if (!check.ok) {
+              const code = check.error ?? "CURRENT_SECRET_INVALID";
+              return rateLimitedResponse(code) ?? json({ error: code }, errorStatus(code));
+            }
+          }
+
+          // 2. Validasi path kandidat.
+          const v = validateWorkspaceRoot(b.path, {
+            create: b.create === true,
+            protectedDirs: deps.protectedDirs,
+            home: deps.home,
+          });
+          if (!v.ok) return json({ error: v.error }, errorStatus(v.error));
+          const root = v.data.root;
+
+          // 3. Project terdaftar di luar root baru -> tolak (dengan daftarnya).
+          const outside = projectsOutside(root, projectManager.listProjects());
+          if (outside.length > 0) {
+            return json(
+              {
+                error: "WORKSPACE_PROJECTS_OUTSIDE",
+                projects: outside.map((p) => ({ id: p.id, name: p.name, path: p.path })),
+              },
+              409,
+            );
+          }
+
+          // 4. Buat folder (opsional), simpan ke config, terapkan.
+          if (v.data.willCreate) {
+            try {
+              mkdirSync(root);
+            } catch {
+              return json({ error: "WORKSPACE_CREATE_FAILED" }, 500);
+            }
+          }
+          const saved = writeSandboxRoot(deps.configPath, root);
+          if (!saved.ok) return json({ error: saved.error }, 500);
+          projectManager.setSandboxRoot(root);
+          ctx.notifyDataChanged();
+          return json({ workspace: info() });
+        } catch (e) {
+          return serverError(e);
+        }
+      },
+    },
+  };
+}

package/src/server/services/__tests__/app-info.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, test } from "bun:test";
+import { resolveVersionLabel } from "../app-info";
+
+describe("resolveVersionLabel", () => {
+  test("bun dev (mode dev, tanpa NODE_ENV) -> 'dev'", () => {
+    expect(resolveVersionLabel("0.1.0", "dev", undefined)).toBe("dev");
+    expect(resolveVersionLabel("0.1.0", "dev", "development")).toBe("dev");
+  });
+
+  test("bun start (mode dev + NODE_ENV=production) -> versi package", () => {
+    expect(resolveVersionLabel("0.1.0", "dev", "production")).toBe("0.1.0");
+  });
+
+  test("CLI global -> selalu versi package", () => {
+    expect(resolveVersionLabel("1.2.3", "cli", undefined)).toBe("1.2.3");
+    expect(resolveVersionLabel("1.2.3", "cli", "production")).toBe("1.2.3");
+  });
+});

package/src/server/services/__tests__/attachments.test.ts

@@ -0,0 +1,159 @@
+/**
+ * Unit test `attachments.ts` — Attachment_Store gambar upload.
+ *
+ * Yang diuji (tanpa server sungguhan):
+ * - save menerima semua jenis file + batas ukuran; mime & nama dinormalkan.
+ * - id dibangkitkan server (UUID) dan path aman dari traversal.
+ * - info/read mengembalikan metadata & bytes yang sama (round-trip).
+ * - remove & removeSession membersihkan file.
+ */
+import { expect, test } from "bun:test";
+import { existsSync, mkdtempSync, readdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { createAttachmentManager, MAX_UPLOAD_BYTES } from "../attachments";
+
+function freshRoot(): string {
+  return mkdtempSync(path.join(tmpdir(), "kcg-attach-"));
+}
+
+function tinyPng(): Uint8Array {
+  return new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 1, 2, 3]);
+}
+
+test("save + info + read: round-trip bytes & metadata per Session", () => {
+  const root = freshRoot();
+  try {
+    const m = createAttachmentManager(root);
+    const saved = m.save("ses1", "foto.png", "image/png", tinyPng());
+    expect(saved.ok).toBe(true);
+    if (!saved.ok) return;
+    expect(saved.data.id).toMatch(/^[0-9a-f-]{36}$/);
+
+    const info = m.info("ses1", saved.data.id);
+    expect(info.ok).toBe(true);
+    if (info.ok) {
+      expect(info.data.filename).toBe("foto.png");
+      expect(info.data.mime).toBe("image/png");
+      expect(info.data.absPath).toContain(saved.data.id);
+      expect(existsSync(info.data.absPath)).toBe(true);
+    }
+    const read = m.read("ses1", saved.data.id);
+    expect(read.ok).toBe(true);
+    if (read.ok) {
+      expect([...read.data.bytes]).toEqual([...tinyPng()]);
+      expect(read.data.mime).toBe("image/png");
+    }
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("save menerima file apa saja, menolak file kosong dan file > 20 MiB", () => {
+  const root = freshRoot();
+  try {
+    const m = createAttachmentManager(root);
+    const txt = m.save("s", "a.txt", "text/plain", new TextEncoder().encode("x"));
+    expect(txt.ok).toBe(true);
+    const zip = m.save("s", "arsip.zip", "application/zip", new Uint8Array([1, 2]));
+    expect(zip.ok && zip.data.mime).toBe("application/zip");
+    expect(m.save("s", "a.png", "image/png", new Uint8Array(0)).ok).toBe(false);
+    const big = m.save("s", "a.png", "image/png", new Uint8Array(MAX_UPLOAD_BYTES + 1));
+    expect(!big.ok && big.error).toBe("FILE_TOO_LARGE");
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("save menormalkan mime & nama file (tanpa path / karakter kontrol)", () => {
+  const root = freshRoot();
+  try {
+    const m = createAttachmentManager(root);
+    const r = m.save("s", "../../etc/pa\nss.txt", "text/html\r\nx: y", new Uint8Array([1]));
+    expect(r.ok).toBe(true);
+    if (r.ok) {
+      expect(r.data.filename).toBe("pass.txt");
+      expect(r.data.mime).toBe("application/octet-stream");
+    }
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("id tak dikenal / bukan UUID -> info & read gagal tanpa akses path", () => {
+  const root = freshRoot();
+  try {
+    const m = createAttachmentManager(root);
+    expect(m.info("ses1", "00000000-0000-0000-0000-000000000000").ok).toBe(false);
+    expect(m.read("ses1", "../../etc/passwd").ok).toBe(false); // traversal ditolak
+    expect(m.info("ses1", "bukan-uuid").ok).toBe(false);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("info.absPath selalu absolut walau uploadsRoot relatif (agar URL file:// valid untuk opencode)", () => {
+  const dir = freshRoot();
+  try {
+    // uploadsRoot relatif (mis. `data/uploads`) — persis konfigurasi default
+    // app yang dulu menghasilkan URL `file://data/…` (host="data") sehingga
+    // opencode menolak prompt ("File URL host must be localhost or empty").
+    const relRoot = path.relative(process.cwd(), dir);
+    expect(path.isAbsolute(relRoot)).toBe(false);
+    const m = createAttachmentManager(relRoot);
+    const saved = m.save("ses1", "a.png", "image/png", tinyPng());
+    expect(saved.ok).toBe(true);
+    if (!saved.ok) return;
+    const info = m.info("ses1", saved.data.id);
+    expect(info.ok).toBe(true);
+    if (info.ok) {
+      expect(path.isAbsolute(info.data.absPath)).toBe(true);
+      expect(info.data.absPath.startsWith("/")).toBe(true);
+      expect(existsSync(info.data.absPath)).toBe(true);
+      // URL file:// yang dibangun dari absPath harus hostless (`file:///…`).
+      const url = `file://${info.data.absPath}`;
+      expect(url.startsWith("file:///")).toBe(true);
+    }
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("remove menghapus file & metadata; removeSession menghapus seluruh Session", () => {
+  const root = freshRoot();
+  try {
+    const m = createAttachmentManager(root);
+    const s1 = m.save("s1", "a.png", "image/png", tinyPng());
+    const s2 = m.save("s2", "b.jpg", "image/jpeg", new Uint8Array([9, 9]));
+    expect(s1.ok && s2.ok).toBe(true);
+    if (!s1.ok || !s2.ok) return;
+
+    m.remove("s1", s1.data.id);
+    expect(m.info("s1", s1.data.id).ok).toBe(false);
+    expect(m.info("s2", s2.data.id).ok).toBe(true); // Session lain tidak tersentuh
+
+    m.removeSession("s2");
+    expect(m.info("s2", s2.data.id).ok).toBe(false);
+    expect(readdirSync(path.join(root, "s1"))).toHaveLength(0);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("Session berbeda terisolasi walau nama file sama", () => {
+  const root = freshRoot();
+  try {
+    const m = createAttachmentManager(root);
+    const a = m.save("s1", "x.png", "image/png", new Uint8Array([1]));
+    const b = m.save("s2", "x.png", "image/png", new Uint8Array([2]));
+    expect(a.ok && b.ok).toBe(true);
+    if (!a.ok || !b.ok) return;
+    expect(a.data.id).not.toBe(b.data.id);
+    const ra = m.read("s1", a.data.id);
+    const rb = m.read("s2", b.data.id);
+    expect(ra.ok && rb.ok).toBe(true);
+    if (ra.ok && rb.ok) expect([...ra.data.bytes]).toEqual([1]);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});