kcg-code 0.0.0-stage → 0.2.0

package/src/server/services/websocket-gateway.ts

@@ -0,0 +1,374 @@
+/**
+ * WebSocket_Gateway — registrasi koneksi, reattach, broadcast (versi headless).
+ *
+ * Perubahan dari versi PTY/TUI:
+ * - Cursor `seq` per-koneksi dihapus (tidak ada lagi chunk Output_Stream);
+ *   reattach mengirim `history` berisi `messages` + `prompts` pending.
+ * - `input` / `prompt_response` kini asinkron (HTTP ke server headless);
+ *   error asinkron dilaporkan via pesan `error` ke Client pengirim.
+ * - Pesan `stop` meneruskan ke `stopSession`; pesan `interrupt` meneruskan
+ *   ke `interruptSession` (hentikan balasan saja, Session tetap berjalan).
+ *
+ * Prinsip yang dipertahankan: kegagalan `send` ke satu Client ditangkap
+ * per-Client (hapus subscriber) tanpa menghentikan broadcast ke Client lain
+ * (Requirement 5.3); attach ke Session tidak ditemukan -> `error` + `close`
+ * (Requirement 4.3).
+ */
+import type { SessionStore } from "../../db";
+import type {
+  InteractivePrompt,
+  MessagePart,
+  PromptResponse,
+  SessionMessage,
+  SessionStatus,
+} from "../../types";
+import { ErrorCodes, type ServerMessage } from "../../ws-protocol";
+import type { SessionManager } from "./session-manager";
+
+/** Abstraksi koneksi — diimplementasikan oleh `bunWsSubscriber` atau mock test. */
+export interface Subscriber {
+  send(msg: ServerMessage): void;
+  close(): void;
+}
+
+/**
+ * Koneksi yang ter-attach ke sebuah Session.
+ * `sessionId: null` = mode daftar (tanpa Session) — hanya menerima broadcast
+ * global seperti `session_title` (daftar Session di halaman Project).
+ */
+export interface AttachedInfo {
+  sessionId: string | null;
+}
+
+export interface WebSocketGatewayOptions {
+  store: SessionStore;
+  sessionManager: SessionManager;
+}
+
+export interface WebSocketGateway {
+  attach(sub: Subscriber, sessionId: string): void;
+  input(
+    sub: Subscriber,
+    sessionId: string,
+    text: string,
+    files?: string[],
+    images?: string[],
+  ): void;
+  promptResponse(
+    sub: Subscriber,
+    sessionId: string,
+    promptId: string,
+    response: PromptResponse,
+  ): void;
+  stop(sub: Subscriber, sessionId: string): void;
+  /** Hentikan balasan model saja (interrupt) — Session tetap running. */
+  interrupt(sub: Subscriber, sessionId: string): void;
+  notifyMessage(sessionId: string, message: SessionMessage): void;
+  notifyMessagePart(sessionId: string, messageId: string, part: MessagePart): void;
+  notifyMessagePartDelta(
+    sessionId: string,
+    messageId: string,
+    partId: string,
+    field: string,
+    delta: string,
+  ): void;
+  notifyPrompt(sessionId: string, prompt: InteractivePrompt): void;
+  notifySessionStatus(sessionId: string, status: SessionStatus): void;
+  /** Broadcast judul Session baru hasil generate opencode. */
+  notifySessionTitle(sessionId: string, title: string): void;
+  /** Beri tahu subscriber apakah model sedang merespon (turn aktif). */
+  notifyTurnActive(sessionId: string, active: boolean): void;
+  notifySessionDeleted(sessionId: string): void;
+  /** Daftar Project/Session berubah — broadcast ke semua koneksi. */
+  notifyDataChanged(): void;
+  notifyPromptResolved(sessionId: string, promptId: string): void;
+  notifyError(sessionId: string, code: string, message: string): void;
+  detach(sub: Subscriber): void;
+  subscriberCount(sessionId: string): number;
+}
+
+/** Pemetaan error domain Session_Manager ke kode protokol `error`. */
+function toErrorCode(error: string): string {
+  if (error === ErrorCodes.SESSION_NOT_FOUND) return ErrorCodes.SESSION_NOT_FOUND;
+  if (error === "SESSION_NOT_RUNNING" || error === "SESSION_NOT_ACTIVE") {
+    return ErrorCodes.SESSION_NOT_RUNNING;
+  }
+  if (error === "TEXT_EMPTY" || error === "TEXT_TOO_LONG") return ErrorCodes.INVALID_TEXT;
+  if (error === "ATTACHMENT_NOT_FOUND") return ErrorCodes.ATTACHMENT_NOT_FOUND;
+  if (error === ErrorCodes.PROMPT_NOT_FOUND) return ErrorCodes.PROMPT_NOT_FOUND;
+  if (error === ErrorCodes.PROMPT_ALREADY_RESOLVED) return ErrorCodes.PROMPT_ALREADY_RESOLVED;
+  if (error === "INVALID_PROMPT_OPTION" || error === "INVALID_PROMPT_RESPONSE") {
+    return ErrorCodes.INVALID_RESPONSE;
+  }
+  return "ERROR";
+}
+
+/**
+ * Pesan ramah untuk kegagalan reply prompt (kartu tetap bisa dicoba lagi):
+ * error mentah dari opencode-client berupa kode seperti
+ * `OC_QUESTION_REPLY_FAILED(400)` — kurang berguna bagi user.
+ */
+function friendlyPromptError(raw: string): string {
+  if (raw === "PROMPT_EXPIRED") {
+    return "The agent stopped waiting for that answer, so it was dismissed. Send a new message to continue.";
+  }
+  if (
+    raw === ErrorCodes.PROMPT_NOT_FOUND ||
+    raw.startsWith("OC_QUESTION") ||
+    raw.startsWith("OC_PERMISSION")
+  ) {
+    return "The agent is no longer waiting for this answer (it may have moved on). Try again or send a new message.";
+  }
+  if (raw === "SESSION_NOT_ACTIVE" || raw === "SESSION_NOT_RUNNING") {
+    return "The session is not running. Start it again to answer.";
+  }
+  if (raw === ErrorCodes.PROMPT_ALREADY_RESOLVED) {
+    return "This prompt was already answered.";
+  }
+  return `Failed to send the answer (${raw.split("(")[0] ?? raw}). Try again.`;
+}
+
+export function createWebSocketGateway(opts: WebSocketGatewayOptions): WebSocketGateway {
+  const { store, sessionManager } = opts;
+  const subs = new Map<Subscriber, AttachedInfo>();
+
+  /** Kirim pesan; bila `send` melempar, hapus subscriber (Req 5.3). */
+  function sendSafe(sub: Subscriber, msg: ServerMessage): boolean {
+    try {
+      sub.send(msg);
+      return true;
+    } catch {
+      subs.delete(sub);
+      return false;
+    }
+  }
+
+  function attach(sub: Subscriber, sessionId: string): void {
+    // Mode daftar (sessionId kosong): tanpa `history`, cukup daftar sebagai
+    // penerima broadcast global (`session_title`, `session_status`,
+    // `session_deleted`).
+    if (sessionId === "") {
+      subs.set(sub, { sessionId: null });
+      return;
+    }
+    // (1) validasi Session ada di store (Req 4.3)
+    const sess = store.getSession(sessionId);
+    if (!sess.ok) {
+      sendSafe(sub, {
+        type: "error",
+        code: ErrorCodes.SESSION_NOT_FOUND,
+        message: "Session not found.",
+      });
+      sub.close();
+      return;
+    }
+
+    // (2) riwayat pesan terstruktur + prompt pending (Req 4.1, 4.4)
+    const messages = store.getMessages(sessionId);
+    if (!messages.ok) {
+      sendSafe(sub, { type: "error", code: "STORE_ERROR", message: messages.error });
+      sub.close();
+      return;
+    }
+    const prompts = store.listPendingPrompts(sessionId);
+    if (!sendSafe(sub, { type: "history", sessionId, messages: messages.data, prompts })) return;
+
+    // (3) daftarkan sebagai subscriber live
+    subs.set(sub, { sessionId });
+  }
+
+  function input(
+    sub: Subscriber,
+    sessionId: string,
+    text: string,
+    files?: string[],
+    images?: string[],
+  ): void {
+    void sessionManager
+      .sendFreeTextInput(sessionId, text, files ?? [], images ?? [])
+      .then((res) => {
+        if (!res.ok) {
+          const code = toErrorCode(res.error ?? "");
+          sendSafe(sub, { type: "error", code, message: res.error ?? "ERROR" });
+        }
+      })
+      .catch(() => {
+        sendSafe(sub, { type: "error", code: "ERROR", message: "Failed to send the message." });
+      });
+  }
+
+  function promptResponse(
+    sub: Subscriber,
+    sessionId: string,
+    promptId: string,
+    response: PromptResponse,
+  ): void {
+    void sessionManager
+      .resolvePrompt(sessionId, promptId, response)
+      .then((res) => {
+        if (!res.ok && res.error === "PROMPT_EXPIRED") {
+          // Prompt sudah ditutup secara lokal (agent tidak lagi menunggu):
+          // hapus kartu di semua klien lalu beri tahu pengirim kenapa —
+          // session kembali bisa dipakai (composer muncul lagi).
+          notifyPromptResolved(sessionId, promptId);
+          sendSafe(sub, {
+            type: "error",
+            code: ErrorCodes.PROMPT_EXPIRED,
+            message: friendlyPromptError("PROMPT_EXPIRED"),
+          });
+          return;
+        }
+        if (!res.ok) {
+          // Kode PROMPT_FAILED: client menampilkan error ini DI kartu prompt
+          // (bukan banner global) agar klik yang gagal tidak terasa mati.
+          sendSafe(sub, {
+            type: "error",
+            code: ErrorCodes.PROMPT_FAILED,
+            message: friendlyPromptError(res.error ?? "ERROR"),
+          });
+          return;
+        }
+        notifyPromptResolved(sessionId, promptId);
+      })
+      .catch(() => {
+        sendSafe(sub, {
+          type: "error",
+          code: ErrorCodes.PROMPT_FAILED,
+          message: "Failed to send the answer to the agent. Try again.",
+        });
+      });
+  }
+
+  function stop(sub: Subscriber, sessionId: string): void {
+    const res = sessionManager.stopSession(sessionId);
+    if (!res.ok) {
+      const code = toErrorCode(res.error ?? "");
+      sendSafe(sub, { type: "error", code, message: res.error ?? "ERROR" });
+    }
+  }
+
+  function interrupt(sub: Subscriber, sessionId: string): void {
+    const res = sessionManager.interruptSession(sessionId);
+    if (!res.ok) {
+      const code = toErrorCode(res.error ?? "");
+      sendSafe(sub, { type: "error", code, message: res.error ?? "ERROR" });
+    }
+  }
+
+  function broadcast(sessionId: string, build: () => ServerMessage): void {
+    for (const [sub, info] of subs) {
+      if (info.sessionId !== sessionId) continue;
+      sendSafe(sub, build());
+    }
+  }
+
+  /**
+   * Broadcast ke seluruh koneksi — dipakai pesan yang relevan lintas Session
+   * (mis. `session_title`: pemilik koneksi mungkin sedang membuka daftar
+   * Session, bukan me-attach satu Session).
+   */
+  function broadcastAll(build: () => ServerMessage): void {
+    for (const sub of subs.keys()) {
+      sendSafe(sub, build());
+    }
+  }
+
+  function notifyMessage(sessionId: string, message: SessionMessage): void {
+    broadcast(sessionId, () => ({ type: "message", sessionId, message }));
+  }
+
+  function notifyMessagePart(sessionId: string, messageId: string, part: MessagePart): void {
+    broadcast(sessionId, () => ({ type: "message_part", sessionId, messageId, part }));
+  }
+
+  function notifyMessagePartDelta(
+    sessionId: string,
+    messageId: string,
+    partId: string,
+    field: string,
+    delta: string,
+  ): void {
+    broadcast(sessionId, () => ({
+      type: "message_part_delta",
+      sessionId,
+      messageId,
+      partId,
+      field,
+      delta,
+    }));
+  }
+
+  function notifyPrompt(sessionId: string, prompt: InteractivePrompt): void {
+    broadcast(sessionId, () => ({ type: "prompt", sessionId, prompt }));
+  }
+
+  function notifySessionStatus(sessionId: string, status: SessionStatus): void {
+    // Relevan lintas halaman: titik status di sidebar / daftar Session harus
+    // ikut berubah walau koneksi itu tidak sedang attach Session ini.
+    broadcastAll(() => ({ type: "session_status", sessionId, status }));
+  }
+
+  function notifySessionTitle(sessionId: string, title: string): void {
+    // `session_title` relevan bagi koneksi mana pun (daftar Session di
+    // halaman Project), jadi dikirim ke semua koneksi — termasuk yang tidak
+    // sedang attach satu Session.
+    broadcastAll(() => ({ type: "session_title", sessionId, title }));
+  }
+
+  function notifyTurnActive(sessionId: string, active: boolean): void {
+    broadcast(sessionId, () => ({ type: "turn_active", sessionId, active }));
+  }
+
+  /**
+   * Session dihapus permanen — dikirim ke SEMUA koneksi: yang sedang membuka
+   * Session ini meninggalkan halamannya, sidebar/daftar menghapus barisnya.
+   */
+  function notifySessionDeleted(sessionId: string): void {
+    broadcastAll(() => ({ type: "session_deleted", sessionId }));
+  }
+
+  function notifyDataChanged(): void {
+    broadcastAll(() => ({ type: "data_changed" }));
+  }
+
+  function notifyPromptResolved(sessionId: string, promptId: string): void {
+    broadcast(sessionId, () => ({ type: "prompt_resolved", sessionId, promptId }));
+  }
+
+  function notifyError(sessionId: string, code: string, message: string): void {
+    broadcast(sessionId, () => ({ type: "error", code, message }));
+  }
+
+  function detach(sub: Subscriber): void {
+    subs.delete(sub);
+  }
+
+  function subscriberCount(sessionId: string): number {
+    let n = 0;
+    for (const info of subs.values()) {
+      if (info.sessionId === sessionId) n += 1;
+    }
+    return n;
+  }
+
+  return {
+    attach,
+    input,
+    promptResponse,
+    stop,
+    interrupt,
+    notifyMessage,
+    notifyMessagePart,
+    notifyMessagePartDelta,
+    notifyPrompt,
+    notifySessionStatus,
+    notifySessionTitle,
+    notifyTurnActive,
+    notifySessionDeleted,
+    notifyDataChanged,
+    notifyPromptResolved,
+    notifyError,
+    detach,
+    subscriberCount,
+  };
+}

package/src/server/services/workspace.ts

@@ -0,0 +1,223 @@
+/**
+ * Workspace (Sandbox_Root) yang bisa diubah dari Settings tanpa restart.
+ *
+ * Sandbox_Root adalah BATAS KEAMANAN: semua Project, Folder_Browser, dan
+ * agent hanya boleh bekerja di dalamnya (termasuk saat diakses lewat
+ * tunnel). Karena itu mengganti root:
+ * - wajib konfirmasi PIN/password bila app dikunci (`AuthService`),
+ * - menolak folder yang terlalu luas (root filesystem, home, direktori
+ *   sistem) dan folder milik KCG Code sendiri (data / config),
+ * - menolak bila masih ada Project terdaftar di luar root baru — Project
+ *   tidak boleh diam-diam menjadi "di luar sandbox",
+ * - ditulis ke `config.json` (sumber kebenaran yang sama dengan CLI
+ *   `kcgcode init`), lalu berlaku seketika di proses yang berjalan.
+ */
+import {
+  accessSync,
+  constants,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  realpathSync,
+  renameSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import type { Project } from "../../types";
+import type { Result } from "../result";
+
+export const WORKSPACE_PATH_MAX = 1024;
+
+export interface WorkspaceInfo {
+  /** Root aktif (path absolut hasil realpath). */
+  root: string;
+  /** Root ditampilkan dengan `~` untuk home (lebih mudah dibaca). */
+  display: string;
+  /** Jumlah Project terdaftar di dalam root. */
+  projectCount: number;
+  configPath: string;
+}
+
+export interface WorkspaceCandidate {
+  /** Path absolut hasil realpath (folder dibuat bila `create`). */
+  root: string;
+  /** Folder belum ada & akan dibuat. */
+  willCreate: boolean;
+}
+
+/** Tampilkan path dengan `~` bila berada di home pengguna. */
+export function displayPath(p: string, home: string = homedir()): string {
+  // `undefined` eksplisit dari pemanggil -> tetap pakai home asli.
+  home ??= homedir();
+  if (p === home) return "~";
+  if (p.startsWith(home + path.sep)) return `~${p.slice(home.length)}`;
+  return p;
+}
+
+/** Perluas `~` / `~/x` ke home. Path relatif ditolak (ambigu: relatif ke cwd server). */
+export function expandUserPath(input: string, home: string = homedir()): string | null {
+  const raw = input.trim();
+  if (raw === "~") return home;
+  if (raw.startsWith("~/") || raw.startsWith("~\\")) return path.join(home, raw.slice(2));
+  if (!path.isAbsolute(raw)) return null;
+  return path.normalize(raw);
+}
+
+/**
+ * Direktori yang terlalu luas / sensitif untuk dijadikan workspace: memberi
+ * agent akses ke seluruh sistem atau seluruh home pengguna.
+ */
+export function isTooBroad(realRoot: string, home: string = homedir()): boolean {
+  const p = path.resolve(realRoot);
+  // Root filesystem (`/`, `C:\`).
+  if (path.dirname(p) === p) return true;
+  const homeReal = safeRealpath(home) ?? home;
+  if (p === homeReal || p === home) return true;
+  // Leluhur home (mis. `/home`, `/Users`) juga mencakup home pengguna lain.
+  if (homeReal.startsWith(p + path.sep)) return true;
+  if (process.platform !== "win32") {
+    const system = [
+      "/bin",
+      "/boot",
+      "/dev",
+      "/etc",
+      "/lib",
+      "/lib64",
+      "/opt",
+      "/proc",
+      "/root",
+      "/run",
+      "/sbin",
+      "/srv",
+      "/sys",
+      "/tmp",
+      "/usr",
+      "/var",
+      "/System",
+      "/Library",
+      "/Applications",
+      "/private",
+      "/Volumes",
+      "/mnt",
+      "/media",
+    ];
+    // Persis direktori sistem (sub-folder di /mnt/data atau /opt/work boleh).
+    if (system.includes(p)) return true;
+  }
+  return false;
+}
+
+function safeRealpath(p: string): string | null {
+  try {
+    return realpathSync(p);
+  } catch {
+    return null;
+  }
+}
+
+function isWithin(root: string, p: string): boolean {
+  return p === root || p.startsWith(root + path.sep);
+}
+
+/**
+ * Validasi kandidat root baru. `protectedDirs` = folder milik KCG Code
+ * (data, uploads, config) yang tidak boleh berada di dalam workspace —
+ * agent bisa membaca DB (hash sandi, token tunnel) bila itu terjadi.
+ */
+export function validateWorkspaceRoot(
+  input: unknown,
+  opts: { create: boolean; protectedDirs: string[]; home?: string },
+): Result<WorkspaceCandidate> {
+  if (typeof input !== "string" || input.trim() === "") {
+    return { ok: false, error: "WORKSPACE_PATH_REQUIRED" };
+  }
+  if (input.length > WORKSPACE_PATH_MAX || input.includes("\0")) {
+    return { ok: false, error: "WORKSPACE_PATH_INVALID" };
+  }
+  const home = opts.home ?? homedir();
+  const expanded = expandUserPath(input, home);
+  if (expanded === null) return { ok: false, error: "WORKSPACE_PATH_NOT_ABSOLUTE" };
+
+  let willCreate = false;
+  if (!existsSync(expanded)) {
+    if (!opts.create) return { ok: false, error: "WORKSPACE_NOT_FOUND" };
+    // Hanya satu tingkat terakhir yang boleh dibuat: induknya harus ada
+    // (menghindari salah ketik membuat pohon folder baru di tempat acak).
+    const parent = path.dirname(expanded);
+    if (!existsSync(parent)) return { ok: false, error: "WORKSPACE_PARENT_NOT_FOUND" };
+    willCreate = true;
+  }
+
+  // Resolusi symlink: keputusan keamanan berdasarkan lokasi NYATA.
+  const real = willCreate
+    ? path.join(
+        safeRealpath(path.dirname(expanded)) ?? path.dirname(expanded),
+        path.basename(expanded),
+      )
+    : safeRealpath(expanded);
+  if (real === null) return { ok: false, error: "WORKSPACE_NOT_FOUND" };
+
+  if (!willCreate) {
+    try {
+      if (!statSync(real).isDirectory()) return { ok: false, error: "WORKSPACE_NOT_DIRECTORY" };
+    } catch {
+      return { ok: false, error: "WORKSPACE_NOT_FOUND" };
+    }
+  }
+
+  if (isTooBroad(real, home)) return { ok: false, error: "WORKSPACE_TOO_BROAD" };
+
+  for (const dir of opts.protectedDirs) {
+    const d = safeRealpath(dir) ?? path.resolve(dir);
+    // Workspace tidak boleh MEMUAT folder data KCG Code, dan sebaliknya
+    // tidak boleh berada di dalamnya.
+    if (isWithin(real, d) || isWithin(d, real)) {
+      return { ok: false, error: "WORKSPACE_CONTAINS_APP_DATA" };
+    }
+  }
+
+  const writableTarget = willCreate ? path.dirname(real) : real;
+  try {
+    accessSync(writableTarget, constants.R_OK | constants.W_OK);
+  } catch {
+    return { ok: false, error: "WORKSPACE_NOT_WRITABLE" };
+  }
+
+  return { ok: true, data: { root: real, willCreate } };
+}
+
+/** Project yang akan berada DI LUAR root baru (menghalangi perubahan). */
+export function projectsOutside(root: string, projects: Project[]): Project[] {
+  return projects.filter((p) => !isWithin(root, safeRealpath(p.path) ?? path.resolve(p.path)));
+}
+
+/**
+ * Tulis `sandboxRoot` ke config.json. Kunci lain di file dipertahankan;
+ * penulisan atomik (file sementara + rename) agar config tidak pernah
+ * setengah tertulis bila proses mati di tengah jalan.
+ */
+export function writeSandboxRoot(configPath: string, root: string): Result<null> {
+  let obj: Record<string, unknown> = {};
+  try {
+    if (existsSync(configPath)) {
+      const parsed = JSON.parse(readFileSync(configPath, "utf8")) as unknown;
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        obj = parsed as Record<string, unknown>;
+      }
+    }
+  } catch {
+    return { ok: false, error: "WORKSPACE_CONFIG_UNREADABLE" };
+  }
+  obj.sandboxRoot = root;
+  try {
+    mkdirSync(path.dirname(configPath), { recursive: true });
+    const tmp = `${configPath}.${process.pid}.tmp`;
+    writeFileSync(tmp, `${JSON.stringify(obj, null, 2)}\n`, "utf8");
+    renameSync(tmp, configPath);
+  } catch {
+    return { ok: false, error: "WORKSPACE_CONFIG_WRITE_FAILED" };
+  }
+  return { ok: true, data: null };
+}