kcg-code 0.0.0-stage → 0.1.0

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

@@ -0,0 +1,249 @@
+/**
+ * Workspace (Sandbox_Root) — validasi path, penulisan config, dan rute HTTP.
+ */
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import {
+  chmodSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { openSessionStore } from "../../../db";
+import type { Project } from "../../../types";
+import type { ApiRouteContext } from "../../routes/types";
+import { workspaceRoutes } from "../../routes/workspace.routes";
+import { createAuthService } from "../auth";
+import { createProjectManager } from "../project-manager";
+import {
+  displayPath,
+  expandUserPath,
+  isTooBroad,
+  projectsOutside,
+  validateWorkspaceRoot,
+  writeSandboxRoot,
+} from "../workspace";
+
+let base: string;
+let home: string;
+let data: string;
+
+beforeAll(() => {
+  base = mkdtempSync(path.join(tmpdir(), "kcg-ws-"));
+  home = path.join(base, "home");
+  data = path.join(home, ".kcgcode", "data");
+  mkdirSync(path.join(home, "code", "a"), { recursive: true });
+  mkdirSync(path.join(home, "work"), { recursive: true });
+  mkdirSync(data, { recursive: true });
+  writeFileSync(path.join(home, "file.txt"), "x");
+});
+
+afterAll(() => {
+  rmSync(base, { recursive: true, force: true });
+});
+
+const opts = (over: Partial<Parameters<typeof validateWorkspaceRoot>[1]> = {}) => ({
+  create: false,
+  protectedDirs: [data],
+  home,
+  ...over,
+});
+
+describe("util path", () => {
+  test("displayPath & expandUserPath memakai ~", () => {
+    expect(displayPath(path.join(home, "code"), home)).toBe("~/code");
+    expect(displayPath(home, home)).toBe("~");
+    expect(displayPath("/srv/x", home)).toBe("/srv/x");
+    expect(expandUserPath("~/code", home)).toBe(path.join(home, "code"));
+    expect(expandUserPath("relative/x", home)).toBeNull();
+  });
+
+  test("isTooBroad: root fs, home, leluhur home, direktori sistem", () => {
+    expect(isTooBroad("/", home)).toBe(true);
+    expect(isTooBroad(home, home)).toBe(true);
+    expect(isTooBroad(path.dirname(home), home)).toBe(true);
+    expect(isTooBroad(path.join(home, "code"), home)).toBe(false);
+    if (process.platform !== "win32") {
+      expect(isTooBroad("/etc", home)).toBe(true);
+      expect(isTooBroad("/usr", home)).toBe(true);
+    }
+  });
+});
+
+describe("validateWorkspaceRoot", () => {
+  test("folder valid -> realpath", () => {
+    const r = validateWorkspaceRoot("~/code", opts());
+    expect(r).toEqual({ ok: true, data: { root: path.join(home, "code"), willCreate: false } });
+  });
+
+  test("ditolak: kosong, relatif, tidak ada, bukan folder", () => {
+    expect(validateWorkspaceRoot("", opts()).ok).toBe(false);
+    expect(validateWorkspaceRoot("code", opts())).toMatchObject({
+      error: "WORKSPACE_PATH_NOT_ABSOLUTE",
+    });
+    expect(validateWorkspaceRoot("~/nope", opts())).toMatchObject({ error: "WORKSPACE_NOT_FOUND" });
+    expect(validateWorkspaceRoot("~/file.txt", opts())).toMatchObject({
+      error: "WORKSPACE_NOT_DIRECTORY",
+    });
+  });
+
+  test("terlalu luas: home & root fs", () => {
+    expect(validateWorkspaceRoot("~", opts())).toMatchObject({ error: "WORKSPACE_TOO_BROAD" });
+    expect(validateWorkspaceRoot("/", opts())).toMatchObject({ error: "WORKSPACE_TOO_BROAD" });
+  });
+
+  test("tumpang tindih dengan data KCG Code ditolak (dua arah)", () => {
+    // Workspace MEMUAT folder data.
+    expect(validateWorkspaceRoot("~/.kcgcode", opts())).toMatchObject({
+      error: "WORKSPACE_CONTAINS_APP_DATA",
+    });
+    // Workspace DI DALAM folder data.
+    mkdirSync(path.join(data, "inner"), { recursive: true });
+    expect(validateWorkspaceRoot(path.join(data, "inner"), opts())).toMatchObject({
+      error: "WORKSPACE_CONTAINS_APP_DATA",
+    });
+  });
+
+  test("symlink dinilai dari lokasi aslinya", () => {
+    const link = path.join(home, "link-to-home");
+    symlinkSync(home, link);
+    expect(validateWorkspaceRoot(link, opts())).toMatchObject({ error: "WORKSPACE_TOO_BROAD" });
+  });
+
+  test("create: hanya satu tingkat terakhir yang boleh dibuat", () => {
+    expect(validateWorkspaceRoot("~/projects", opts({ create: true }))).toEqual({
+      ok: true,
+      data: { root: path.join(home, "projects"), willCreate: true },
+    });
+    expect(validateWorkspaceRoot("~/a/b/c", opts({ create: true }))).toMatchObject({
+      error: "WORKSPACE_PARENT_NOT_FOUND",
+    });
+  });
+
+  test.skipIf(process.platform === "win32" || process.getuid?.() === 0)(
+    "folder tanpa izin tulis ditolak",
+    () => {
+      const ro = path.join(home, "readonly");
+      mkdirSync(ro);
+      chmodSync(ro, 0o555);
+      try {
+        expect(validateWorkspaceRoot(ro, opts())).toMatchObject({
+          error: "WORKSPACE_NOT_WRITABLE",
+        });
+      } finally {
+        chmodSync(ro, 0o755);
+      }
+    },
+  );
+});
+
+describe("projectsOutside & writeSandboxRoot", () => {
+  const proj = (p: string): Project => ({
+    id: p,
+    name: p,
+    path: p,
+    createdAt: 0,
+    instructions: null,
+  });
+
+  test("Project di luar root baru terdeteksi", () => {
+    const root = path.join(home, "code");
+    const inside = proj(path.join(root, "a"));
+    const outside = proj(path.join(home, "work"));
+    expect(projectsOutside(root, [inside, outside]).map((p) => p.id)).toEqual([outside.id]);
+  });
+
+  test("menulis sandboxRoot & mempertahankan kunci lain", () => {
+    const cfg = path.join(base, "config.json");
+    writeFileSync(cfg, JSON.stringify({ sandboxRoot: "/old", extra: 1 }));
+    expect(writeSandboxRoot(cfg, "/new").ok).toBe(true);
+    expect(JSON.parse(readFileSync(cfg, "utf8"))).toEqual({ sandboxRoot: "/new", extra: 1 });
+  });
+});
+
+describe("rute /api/workspace", () => {
+  async function setup(locked: boolean) {
+    const store = openSessionStore(":memory:");
+    const auth = createAuthService({
+      store,
+      hash: async (s) => `h:${s}`,
+      verify: async (s, h) => h === `h:${s}`,
+    });
+    if (locked) {
+      await auth.setLock({ kind: "pin", secret: "482915" }, { ip: "1.1.1.1", userAgent: null });
+    }
+    const root = path.join(home, "code");
+    const pm = createProjectManager(root, store);
+    const cfg = path.join(base, `cfg-${locked ? "l" : "u"}-${Math.random()}.json`);
+    writeFileSync(cfg, JSON.stringify({ sandboxRoot: root }));
+    let changed = 0;
+    const ctx = {
+      projectManager: pm,
+      notifyDataChanged: () => {
+        changed++;
+      },
+    } as unknown as ApiRouteContext;
+    // `home` diinjeksi: "~" mengarah ke folder sementara, BUKAN home asli.
+    const routes = workspaceRoutes(ctx, { auth, configPath: cfg, protectedDirs: [data], home });
+    const server = { requestIP: () => ({ address: "5.5.5.5" }) } as never;
+    const put = (body: unknown) =>
+      routes["/api/workspace"].PUT(
+        new Request("http://x/api/workspace", {
+          method: "PUT",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify(body),
+        }),
+        server,
+      );
+    return { pm, cfg, put, routes, changed: () => changed };
+  }
+
+  test("GET: root aktif, tampilan ~, jumlah project", async () => {
+    const h = await setup(false);
+    h.pm.createProject("a", "a");
+    const res = h.routes["/api/workspace"].GET();
+    const body = (await res.json()) as { workspace: { display: string; projectCount: number } };
+    expect(body.workspace.display).toBe("~/code");
+    expect(body.workspace.projectCount).toBe(1);
+  });
+
+  test("terkunci: sandi salah ditolak SEBELUM path divalidasi", async () => {
+    const h = await setup(true);
+    const res = await h.put({ path: "/", current: "000000" });
+    expect(res.status).toBe(401);
+    expect(((await res.json()) as { error: string }).error).toBe("CURRENT_SECRET_INVALID");
+  });
+
+  test("sukses: config ditulis, root berlaku seketika, klien diberi tahu", async () => {
+    const h = await setup(true);
+    const res = await h.put({ path: "~/work", current: "482915" });
+    expect(res.status).toBe(200);
+    expect(h.pm.getSandboxRoot()).toBe(path.join(home, "work"));
+    expect(JSON.parse(readFileSync(h.cfg, "utf8")).sandboxRoot).toBe(path.join(home, "work"));
+    expect(h.changed()).toBe(1);
+    // Folder browser kini memakai root baru.
+    expect(h.pm.listDirectory("").ok).toBe(true);
+  });
+
+  test("Project di luar root baru -> 409 berisi daftarnya, root tidak berubah", async () => {
+    const h = await setup(false);
+    h.pm.createProject("a", "a");
+    const res = await h.put({ path: "~/work" });
+    expect(res.status).toBe(409);
+    const body = (await res.json()) as { error: string; projects: { name: string }[] };
+    expect(body.error).toBe("WORKSPACE_PROJECTS_OUTSIDE");
+    expect(body.projects.map((p) => p.name)).toEqual(["a"]);
+    expect(h.pm.getSandboxRoot()).toBe(path.join(home, "code"));
+  });
+
+  test("create: folder baru dibuat lalu dipakai", async () => {
+    const h = await setup(false);
+    const res = await h.put({ path: "~/fresh-ws", create: true });
+    expect(res.status).toBe(200);
+    expect(h.pm.getSandboxRoot()).toBe(path.join(home, "fresh-ws"));
+  });
+});

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

@@ -0,0 +1,29 @@
+/**
+ * Info aplikasi untuk halaman Settings -> About.
+ *
+ * Versi diambil dari `package.json` paket (root repo / paket global),
+ * kecuali saat development (`bun dev` = mode runtime `dev` tanpa
+ * `NODE_ENV=production`): versinya ditampilkan sebagai `"dev"` agar build
+ * lokal tidak tertukar dengan rilis.
+ */
+import { readPackageVersion } from "../../cli/theme";
+import { getRunMode, type RunMode } from "../../runtime";
+
+export interface AppInfo {
+  /** Versi semver dari package.json, atau `"dev"` saat development. */
+  version: string;
+}
+
+/** Fungsi murni: tentukan label versi dari mode runtime & NODE_ENV. */
+export function resolveVersionLabel(
+  packageVersion: string,
+  mode: RunMode,
+  nodeEnv: string | undefined,
+): string {
+  return mode === "dev" && nodeEnv !== "production" ? "dev" : packageVersion;
+}
+
+export async function readAppInfo(): Promise<AppInfo> {
+  const pkg = await readPackageVersion();
+  return { version: resolveVersionLabel(pkg, getRunMode(), process.env.NODE_ENV) };
+}

package/src/server/services/attachments.ts

@@ -0,0 +1,193 @@
+/**
+ * Attachment_Store — penyimpanan file yang di-upload Client untuk Session
+ * (gambar, dokumen, kode, arsip, …).
+ *
+ * File dikirim dari browser ke KCG Code (HTTP), disimpan di disk sebagai
+ * file tak ternama (`<uuid>` di `<uploadsRoot>/<sessionId>/`), lalu dirujuk
+ * oleh Session sebagai part `file` + `url: file:///…` saat prompt dikirim ke
+ * opencode (lihat `session-manager.ts`; mime yang dikirim ke model dipilih
+ * `modelFacingMime` di `lib/attachments.ts`).
+ *
+ * - Semua jenis file diterima; mime dinormalisasi (`normalizeMime`) agar
+ *   header Content-Type saat serve tidak bisa disuntik.
+ * - Batas 20 MiB per file (mengikuti batas attachment opencode).
+ * - File disimpan per-Session agar mudah dibersihkan saat Session dihapus
+ *   (`removeSession`) dan tidak tercampur antar Session/Project.
+ * - `id` adalah UUID acak yang dibangkitkan server — path upload tidak pernah
+ *   menerima masukan pengguna, sehingga aman dari path traversal.
+ * - Metadata (nama asli + mime) disimpan sebagai sidecar JSON per file agar
+ *   echo pesan & part file tetap membawa nama tampilan asli pengguna.
+ *
+ * Dipakai oleh:
+ * - `app.ts` (route HTTP upload + serve),
+ * - `session-manager.ts` (resolve upload id -> file URL absolut saat kirim
+ *   prompt & membersihkan file saat Session dihapus).
+ */
+import { randomUUID } from "node:crypto";
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { MAX_ATTACHMENT_BYTES, normalizeMime } from "../../lib/attachments";
+import type { Result } from "../result";
+
+/** Batas ukuran upload (byte) — mengikuti limit attachment opencode (20 MiB). */
+export const MAX_UPLOAD_BYTES = MAX_ATTACHMENT_BYTES;
+
+export interface AttachmentMeta {
+  /** Id lampiran (UUID acak, dibangkitkan server). */
+  id: string;
+  /** Nama file asli dari perangkat pengguna (untuk tampilan). */
+  filename: string;
+  /** MIME ternormalisasi (`application/octet-stream` bila tidak dikenal). */
+  mime: string;
+  size: number;
+}
+
+export interface AttachmentManager {
+  /**
+   * Simpan bytes file ke penyimpanan Session. Memvalidasi ukuran;
+   * mengembalikan metadata lampiran (termasuk `id` untuk rujukan berikutnya).
+   */
+  save(
+    sessionId: string,
+    filename: string,
+    mime: string,
+    bytes: Uint8Array,
+  ): Result<AttachmentMeta>;
+  /** Baca metadata + path absolut file lampiran (untuk part `file` opencode). */
+  info(sessionId: string, id: string): Result<AttachmentMeta & { absPath: string }>;
+  /** Baca bytes file lampiran (untuk route serve ke browser). */
+  read(
+    sessionId: string,
+    id: string,
+  ): Result<{ bytes: Uint8Array; mime: string; filename: string }>;
+  /** Hapus satu lampiran (mis. pengguna membatalkan sebelum mengirim). */
+  remove(sessionId: string, id: string): void;
+  /** Hapus seluruh lampiran milik Session (saat Session dihapus permanen). */
+  removeSession(sessionId: string): void;
+}
+
+/** Id lampiran valid: UUID tanpa karakter path (`-` di dalamnya aman). */
+function isValidId(id: string): boolean {
+  return /^[0-9a-fA-F-]{36}$/.test(id);
+}
+
+/**
+ * Path aman untuk file bytes di bawah direktori Session; mengembalikan null
+ * bila `id` bukan UUID (mencegah traversal).
+ */
+function safeIdPath(dir: string, id: string): string | null {
+  if (!isValidId(id)) return null;
+  return path.join(dir, id);
+}
+
+/** Path aman sidecar metadata `<id>.meta.json` (id UUID tervalidasi). */
+function safeMetaPath(dir: string, id: string): string | null {
+  if (!isValidId(id)) return null;
+  return path.join(dir, `${id}.meta.json`);
+}
+
+function errResult(msg: string): { ok: false; error: string } {
+  return { ok: false, error: msg };
+}
+
+/** Buat direktori Session (bila belum ada). */
+function ensureDir(dir: string): void {
+  mkdirSync(dir, { recursive: true });
+}
+
+function readMeta(
+  dir: string,
+  id: string,
+): { filename: string; mime: string; size: number } | null {
+  const metaPath = safeMetaPath(dir, id);
+  if (!metaPath) return null;
+  try {
+    const raw = JSON.parse(readFileSync(metaPath, "utf8")) as {
+      filename?: unknown;
+      mime?: unknown;
+      size?: unknown;
+    };
+    if (typeof raw.filename !== "string" || typeof raw.mime !== "string") return null;
+    return {
+      filename: raw.filename,
+      mime: raw.mime,
+      size: typeof raw.size === "number" ? raw.size : 0,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function createAttachmentManager(uploadsRoot: string): AttachmentManager {
+  return {
+    save(sessionId, rawFilename, rawMime, bytes) {
+      if (bytes.byteLength === 0) return errResult("EMPTY_UPLOAD");
+      if (bytes.byteLength > MAX_UPLOAD_BYTES) return errResult("FILE_TOO_LARGE");
+      const mime = normalizeMime(rawMime);
+      // Nama tampilan saja (bukan path): buang direktori & karakter kontrol.
+      const base = rawFilename.split(/[\\/]/).pop() ?? "";
+      const filename =
+        [...base]
+          .filter((ch) => {
+            const code = ch.charCodeAt(0);
+            return code > 0x1f && code !== 0x7f;
+          })
+          .join("")
+          .slice(0, 255) || "file";
+
+      const dir = path.join(uploadsRoot, sessionId);
+      ensureDir(dir);
+      const id = randomUUID();
+      try {
+        writeFileSync(safeIdPath(dir, id) as string, bytes);
+        writeFileSync(
+          safeMetaPath(dir, id) as string,
+          JSON.stringify({ filename, mime, size: bytes.byteLength }),
+        );
+      } catch (e) {
+        return errResult(`UPLOAD_WRITE_FAILED: ${(e as Error).message}`);
+      }
+      return { ok: true, data: { id, filename, mime, size: bytes.byteLength } };
+    },
+
+    info(sessionId, id) {
+      const dir = path.join(uploadsRoot, sessionId);
+      const filePath = safeIdPath(dir, id);
+      if (!filePath) return errResult("ATTACHMENT_NOT_FOUND");
+      const meta = readMeta(dir, id);
+      if (!meta) return errResult("ATTACHMENT_NOT_FOUND");
+      // `absPath` wajib absolut: dipakai untuk URL `file:///…` yang dikirim
+      // ke opencode — `file://rel/path` (host=rel) ditolak opencode ("File
+      // URL host must be localhost or empty") dan prompt gagal diam-diam.
+      return { ok: true, data: { ...meta, id, absPath: path.resolve(filePath) } };
+    },
+
+    read(sessionId, id) {
+      const dir = path.join(uploadsRoot, sessionId);
+      const filePath = safeIdPath(dir, id);
+      if (!filePath) return errResult("ATTACHMENT_NOT_FOUND");
+      const meta = readMeta(dir, id);
+      if (!meta) return errResult("ATTACHMENT_NOT_FOUND");
+      try {
+        return {
+          ok: true,
+          data: { bytes: readFileSync(filePath), mime: meta.mime, filename: meta.filename },
+        };
+      } catch {
+        return errResult("ATTACHMENT_NOT_FOUND");
+      }
+    },
+
+    remove(sessionId, id) {
+      const dir = path.join(uploadsRoot, sessionId);
+      const filePath = safeIdPath(dir, id);
+      if (filePath) rmSync(filePath, { force: true });
+      const metaPath = safeMetaPath(dir, id);
+      if (metaPath) rmSync(metaPath, { force: true });
+    },
+
+    removeSession(sessionId) {
+      rmSync(path.join(uploadsRoot, sessionId), { recursive: true, force: true });
+    },
+  };
+}