kcg-code 0.0.0-stage → 0.1.0

package/src/server/__tests__/db.test.ts

@@ -0,0 +1,485 @@
+/**
+ * Property & integration test `db.ts` (versi headless).
+ * - Property 8: Round-trip pesan terstruktur (Requirements 3.1, 3.4)
+ * - Property 9: Riwayat status append-only (Requirement 3.3)
+ * - Property 10: Query Session tidak ditemukan (Requirement 3.5)
+ * - Integration: kegagalan tulis & persistensi setelah restart (3.2, 3.6)
+ * - Migrasi DB lama (kolom oc_session_id / kind / title + tabel messages)
+ */
+import { expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import fc from "fast-check";
+import { openSessionStore } from "../../db";
+import type { InteractivePrompt, Session, SessionMessage, SessionStatus } from "../../types";
+
+function makeSession(id = "s1", status: SessionStatus = "running"): Session {
+  return {
+    id,
+    projectId: "p1",
+    agentType: "opencode",
+    cwd: "/sandbox/proj",
+    status,
+    ocSessionId: id === "s1" ? "ses_1" : null,
+    model: id === "s1" ? { providerID: "kcgcode", modelID: "kiro/claude-opus-5" } : null,
+    agent: null,
+    title: null,
+    createdAt: 1,
+    updatedAt: 1,
+  };
+}
+
+function makeMessage(id: string, role: "user" | "assistant" = "user"): SessionMessage {
+  return {
+    id,
+    sessionId: "s1",
+    role,
+    parts: [{ type: "text", text: `isi-${id}` }],
+    createdAt: 1,
+  };
+}
+
+function seedProject(store: ReturnType<typeof openSessionStore>) {
+  const res = store.insertProject({ id: "p1", name: "proj", path: "/sandbox/proj", createdAt: 1 });
+  if (!res.ok) throw new Error(`seed project gagal: ${res.error}`);
+}
+
+function makeMemoryStore() {
+  const store = openSessionStore(":memory:");
+  seedProject(store);
+  return store;
+}
+
+// Feature: kcg-code, Property 8: Round-trip penyimpanan pesan terstruktur
+test("Property 8: round-trip messages — urutan identik dengan penyimpanan", () => {
+  fc.assert(
+    fc.property(
+      fc.array(fc.constantFrom("user", "assistant" as const), { maxLength: 40 }),
+      (roles) => {
+        const store = makeMemoryStore();
+        try {
+          expect(store.insertSession(makeSession()).ok).toBe(true);
+          roles.forEach((role, i) => {
+            const r = store.insertMessage(makeMessage(`m${i}`, role));
+            expect(r.ok).toBe(true);
+          });
+
+          const res = store.getMessages("s1");
+          expect(res.ok).toBe(true);
+          if (res.ok) {
+            expect(res.data.map((m) => m.id)).toEqual(roles.map((_, i) => `m${i}`));
+            expect(res.data.map((m) => m.role)).toEqual(roles);
+          }
+        } finally {
+          store.close();
+        }
+      },
+    ),
+    { numRuns: 100 },
+  );
+});
+
+// Feature: kcg-code, Property 9: Riwayat status bersifat append-only
+test("Property 9: riwayat status append-only — jumlah baris tidak pernah berkurang", () => {
+  fc.assert(
+    fc.property(
+      fc.array(fc.constantFrom("running", "stopped", "crashed" as const), { maxLength: 40 }),
+      (statuses) => {
+        const store = makeMemoryStore();
+        try {
+          expect(store.insertSession(makeSession()).ok).toBe(true);
+
+          const seen: { status: SessionStatus; changedAt: number }[] = [];
+          statuses.forEach((status, i) => {
+            const changedAt = i + 1;
+            expect(store.insertStatusHistory("s1", status, changedAt).ok).toBe(true);
+            seen.push({ status, changedAt });
+
+            const res = store.getStatusHistory("s1");
+            expect(res.ok).toBe(true);
+            if (res.ok) {
+              expect(res.data.length).toBeGreaterThanOrEqual(seen.length);
+              for (const prev of seen) {
+                expect(res.data).toContainEqual({ sessionId: "s1", ...prev });
+              }
+            }
+          });
+        } finally {
+          store.close();
+        }
+      },
+    ),
+    { numRuns: 100 },
+  );
+});
+
+// Feature: kcg-code, Property 10: Query terhadap Session tidak ditemukan
+test("Property 10: query Session tidak ditemukan -> not-found tanpa data", () => {
+  fc.assert(
+    fc.property(fc.string(), fc.string(), (sid1, sid2) => {
+      const store = openSessionStore(":memory:");
+      try {
+        const out = store.getMessages(sid1);
+        expect(out.ok).toBe(false);
+        if (!out.ok) expect(out.error).toBe("SESSION_NOT_FOUND");
+
+        const hist = store.getStatusHistory(sid2);
+        expect(hist.ok).toBe(false);
+        if (!hist.ok) expect(hist.error).toBe("SESSION_NOT_FOUND");
+      } finally {
+        store.close();
+      }
+    }),
+    { numRuns: 100 },
+  );
+});
+
+test("5.1: CRUD sessions — insert, update status, get, getByOcId, list", () => {
+  const store = makeMemoryStore();
+  expect(store.insertSession(makeSession()).ok).toBe(true);
+
+  const listed = store.listSessions();
+  expect(listed).toHaveLength(1);
+  expect(listed[0]?.id).toBe("s1");
+  expect(listed[0]?.ocSessionId).toBe("ses_1");
+
+  const byOc = store.getSessionByOcId("ses_1");
+  expect(byOc.ok).toBe(true);
+  if (byOc.ok) expect(byOc.data.id).toBe("s1");
+  expect(store.getSessionByOcId("nope").ok).toBe(false);
+
+  const upd = store.updateSessionStatus("s1", "stopped", 99);
+  expect(upd.ok).toBe(true);
+  if (upd.ok) expect(upd.data.status).toBe("stopped");
+
+  const got = store.getSession("s1");
+  expect(got.ok).toBe(true);
+  if (got.ok) expect(got.data.status).toBe("stopped");
+
+  // updateSessionStatus juga mencatat ke riwayat (Requirement 3.3)
+  const hist = store.getStatusHistory("s1");
+  expect(hist.ok).toBe(true);
+  if (hist.ok) expect(hist.data.map((h) => h.status)).toEqual(["stopped"]);
+  store.close();
+});
+
+test("5.1: CRUD messages — insert, get, duplikat ditolak, not found session", () => {
+  const store = makeMemoryStore();
+  expect(store.insertSession(makeSession()).ok).toBe(true);
+
+  expect(store.insertMessage(makeMessage("m1")).ok).toBe(true);
+  // Duplikat message_id -> gagal (tidak menimpa).
+  expect(store.insertMessage(makeMessage("m1")).ok).toBe(false);
+
+  // Insert ke session tak dikenal -> ditolak.
+  expect(
+    store.insertMessage({ id: "mx", sessionId: "nope", role: "user", parts: [], createdAt: 1 }).ok,
+  ).toBe(false);
+
+  const res = store.getMessages("s1");
+  expect(res.ok).toBe(true);
+  if (res.ok) expect(res.data.map((m) => m.id)).toEqual(["m1"]);
+  store.close();
+});
+
+test("5.1: CRUD prompts — kind/title ikut tersimpan; update status", () => {
+  const store = makeMemoryStore();
+  expect(store.insertSession(makeSession()).ok).toBe(true);
+
+  const permission = {
+    id: "pr1",
+    sessionId: "s1",
+    kind: "permission" as const,
+    type: "confirmation" as const,
+    title: "bash:ls",
+    options: null,
+    status: "pending" as const,
+    createdAt: 1,
+    resolvedAt: null,
+  };
+  expect(store.insertPrompt(permission).ok).toBe(true);
+
+  const question = {
+    id: "que1",
+    sessionId: "s1",
+    kind: "question" as const,
+    type: "menu" as const,
+    custom: true,
+    title: "Pilih mode",
+    // String polos = bentuk lama di DB — sengaja dipertahankan untuk
+    // memverifikasi normalisasi saat dibaca kembali (mapPrompt).
+    options: ["Build", "Plan"] as unknown as InteractivePrompt["options"],
+    status: "pending" as const,
+    createdAt: 2,
+    resolvedAt: null,
+  };
+  expect(store.insertPrompt(question).ok).toBe(true);
+
+  // Question multi-select (skema tool `question` opencode: multiple: true)
+  // beserta description per opsi — ikut roundtrip lewat kolom prompts.
+  const multiQuestion = {
+    id: "quemulti1",
+    sessionId: "s1",
+    kind: "question" as const,
+    type: "menu" as const,
+    custom: true,
+    multiple: true,
+    title: "Pilih area",
+    options: [
+      { label: "Debug", description: "investigasi bug" },
+      { label: "Config", description: null },
+    ],
+    // Multi-question: dua pertanyaan dalam satu request.
+    questions: [
+      {
+        question: "Pilih area",
+        header: null,
+        options: [
+          { label: "Debug", description: "investigasi bug" },
+          { label: "Config", description: null },
+        ],
+        multiple: true,
+        custom: true,
+      },
+      {
+        question: "Kapan mulai?",
+        header: null,
+        options: [{ label: "Sekarang", description: null }],
+        custom: true,
+      },
+    ],
+    status: "pending" as const,
+    createdAt: 3,
+    resolvedAt: null,
+  };
+  expect(store.insertPrompt(multiQuestion).ok).toBe(true);
+
+  const pending = store.listPendingPrompts("s1");
+  expect(pending).toHaveLength(3);
+
+  const upd = store.updatePromptStatus("pr1", "resolved", 5);
+  expect(upd.ok).toBe(true);
+  if (upd.ok) expect(upd.data.status).toBe("resolved");
+  expect(store.listPendingPrompts("s1")).toHaveLength(2);
+
+  const got = store.getPrompt("que1");
+  expect(got.ok).toBe(true);
+  if (got.ok) {
+    expect(got.data.kind).toBe("question");
+    expect(got.data.title).toBe("Pilih mode");
+    // String polos dari DB lama dinormalisasi jadi PromptOption.
+    expect(got.data.options).toEqual([
+      { label: "Build", description: null },
+      { label: "Plan", description: null },
+    ]);
+    // Flag custom ikut roundtrip lewat kolom `prompts.custom`.
+    expect(got.data.custom).toBe(true);
+  }
+  const gotMulti = store.getPrompt("quemulti1");
+  expect(gotMulti.ok).toBe(true);
+  if (gotMulti.ok) {
+    // Opsi berobjek + flag multiple ikut tersimpan & terbaca kembali.
+    expect(gotMulti.data.options).toEqual([
+      { label: "Debug", description: "investigasi bug" },
+      { label: "Config", description: null },
+    ]);
+    expect(gotMulti.data.multiple).toBe(true);
+    // Seluruh pertanyaan ikut roundtrip lewat kolom `questions_json`.
+    expect(gotMulti.data.questions).toHaveLength(2);
+    expect(gotMulti.data.questions?.[1]?.question).toBe("Kapan mulai?");
+  }
+  expect(store.getPrompt("nope").ok).toBe(false);
+  store.close();
+});
+
+test("5.1: CRUD projects — insert, get by name/path, list", () => {
+  const store = makeMemoryStore();
+  const proj = { id: "p2", name: "proj2", path: "/sandbox/proj2", createdAt: 2 };
+  expect(store.insertProject(proj).ok).toBe(true);
+
+  const byName = store.getProjectByName("proj2");
+  expect(byName.ok).toBe(true);
+  if (byName.ok) expect(byName.data.path).toBe("/sandbox/proj2");
+
+  expect(store.getProjectByPath("/sandbox/proj2").ok).toBe(true);
+  expect(store.listProjects()).toHaveLength(2);
+  store.close();
+});
+
+test("updateProjectInstructions: simpan, hapus (null), id tak dikenal -> PROJECT_NOT_FOUND", () => {
+  const store = makeMemoryStore();
+  const proj = { id: "p3", name: "proj3", path: "/sandbox/proj3", createdAt: 3 };
+  expect(store.insertProject(proj).ok).toBe(true);
+
+  const fresh = store.getProjectById("p3");
+  expect(fresh.ok && fresh.data.instructions).toBeNull();
+
+  const saved = store.updateProjectInstructions("p3", "Use tabs.");
+  expect(saved.ok && saved.data.instructions).toBe("Use tabs.");
+
+  const cleared = store.updateProjectInstructions("p3", null);
+  expect(cleared.ok && cleared.data.instructions).toBeNull();
+
+  expect(store.updateProjectInstructions("nope", "x").ok).toBe(false);
+  store.close();
+});
+
+test("deleteProject: menolak selama masih ada Session, sukses setelah Session dihapus", () => {
+  const store = makeMemoryStore();
+  expect(store.insertSession(makeSession("s1")).ok).toBe(true);
+
+  expect(store.listProjectSessions("p1").map((s) => s.id)).toEqual(["s1"]);
+
+  // Session harus dibersihkan lewat SessionManager lebih dulu — jalur ini
+  // menolak agar sesi remote opencode tidak jadi yatim.
+  const blocked = store.deleteProject("p1");
+  expect(blocked.ok).toBe(false);
+  if (!blocked.ok) expect(blocked.error).toBe("PROJECT_HAS_SESSIONS");
+  expect(store.getProjectById("p1").ok).toBe(true);
+
+  expect(store.deleteSession("s1").ok).toBe(true);
+  expect(store.deleteProject("p1").ok).toBe(true);
+  expect(store.getProjectById("p1").ok).toBe(false);
+  expect(store.listProjects()).toHaveLength(0);
+  store.close();
+});
+
+test("deleteProject: id tak dikenal -> PROJECT_NOT_FOUND", () => {
+  const store = makeMemoryStore();
+  const res = store.deleteProject("tidak-ada");
+  expect(res.ok).toBe(false);
+  if (!res.ok) expect(res.error).toBe("PROJECT_NOT_FOUND");
+  expect(store.listProjectSessions("tidak-ada")).toEqual([]);
+  store.close();
+});
+
+test("migrasi: DB lama (skema PTY) dibuka dengan store baru -> kolom & tabel ditambah", () => {
+  const dir = mkdtempSync(path.join(tmpdir(), "kcg-mig-"));
+  const dbPath = path.join(dir, "legacy.sqlite");
+
+  // Simulasikan DB lama: skema versi PTY (tanpa oc_session_id, kind, title, messages).
+  writeFileSync(dbPath, "");
+  const { Database } = require("bun:sqlite") as typeof import("bun:sqlite");
+  const db = new Database(dbPath);
+  db.exec(`
+    CREATE TABLE projects (id TEXT PRIMARY KEY, name TEXT NOT NULL UNIQUE, path TEXT NOT NULL UNIQUE, created_at INTEGER NOT NULL);
+    CREATE TABLE sessions (id TEXT PRIMARY KEY, project_id TEXT NOT NULL, agent_type TEXT NOT NULL, cwd TEXT NOT NULL, status TEXT NOT NULL, created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL);
+    CREATE TABLE session_status_history (id INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT NOT NULL, status TEXT NOT NULL, changed_at INTEGER NOT NULL);
+    CREATE TABLE output_stream (id INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT NOT NULL, seq INTEGER NOT NULL, chunk TEXT NOT NULL, created_at INTEGER NOT NULL);
+    CREATE TABLE prompts (id TEXT PRIMARY KEY, session_id TEXT NOT NULL, type TEXT NOT NULL, options_json TEXT, status TEXT NOT NULL, created_at INTEGER NOT NULL, resolved_at INTEGER);
+    INSERT INTO projects (id, name, path, created_at) VALUES ('p1', 'old', '/sandbox/old', 1);
+    INSERT INTO sessions (id, project_id, agent_type, cwd, status, created_at, updated_at) VALUES ('s1', 'p1', 'opencode', '/sandbox/old', 'running', 1, 1);
+    INSERT INTO output_stream (session_id, seq, chunk, created_at) VALUES ('s1', 1, 'old chunk', 1);
+  `);
+  db.close();
+
+  // Buka dengan store baru: migrasi menambah kolom + tabel messages.
+  const store = openSessionStore(dbPath);
+  const sess = store.getSession("s1");
+  expect(sess.ok).toBe(true);
+  if (sess.ok) expect(sess.data.ocSessionId).toBeNull();
+
+  // Data lama output_stream tetap utuh (tidak dihapus migrasi).
+  const legacy = dbExec(dbPath, "SELECT chunk FROM output_stream WHERE session_id='s1'");
+  expect(legacy).toEqual([{ chunk: "old chunk" }]);
+
+  // Tabel & kolom baru bisa dipakai.
+  expect(store.insertSession(makeSession("s2")).ok).toBe(true);
+  expect(store.insertMessage(makeMessage("m1")).ok).toBe(true);
+  // Kolom projects.instructions ditambahkan; Project lama tanpa instruksi.
+  const oldProj = store.getProjectById("p1");
+  expect(oldProj.ok && oldProj.data.instructions).toBeNull();
+  expect(store.updateProjectInstructions("p1", "hi").ok).toBe(true);
+  store.close();
+  rmSync(dir, { recursive: true, force: true });
+});
+
+function dbExec(dbPath: string, sql: string): Record<string, unknown>[] {
+  const { Database } = require("bun:sqlite") as typeof import("bun:sqlite");
+  const db = new Database(dbPath);
+  try {
+    return db.query(sql).all() as Record<string, unknown>[];
+  } finally {
+    db.close();
+  }
+}
+
+// ---- Integration: kegagalan tulis & persistensi setelah restart ----
+test("4.4: kegagalan tulis tidak menghapus data lama (simulasi db tertutup)", () => {
+  const dir = mkdtempSync(path.join(tmpdir(), "kcg-db2-"));
+  const dbPath = path.join(dir, "kcg.sqlite");
+
+  const store = openSessionStore(dbPath);
+  seedProject(store);
+  expect(store.insertSession(makeSession()).ok).toBe(true);
+  expect(store.insertMessage(makeMessage("m1")).ok).toBe(true);
+  expect(store.insertMessage(makeMessage("m2", "assistant")).ok).toBe(true);
+  expect(store.insertStatusHistory("s1", "running", 1).ok).toBe(true);
+
+  // Simulasi kegagalan tulis: tutup koneksi lalu coba tulis lagi.
+  store.close();
+  const failed = store.insertMessage(makeMessage("m3"));
+  expect(failed.ok).toBe(false);
+
+  // Data lama tetap utuh setelah dibuka ulang (Requirement 3.6).
+  const store2 = openSessionStore(dbPath);
+  const messages = store2.getMessages("s1");
+  expect(messages.ok).toBe(true);
+  if (messages.ok) expect(messages.data.map((m) => m.id)).toEqual(["m1", "m2"]);
+  const hist = store2.getStatusHistory("s1");
+  expect(hist.ok).toBe(true);
+  if (hist.ok) expect(hist.data.map((h) => h.status)).toEqual(["running"]);
+  store2.close();
+  rmSync(dir, { recursive: true, force: true });
+});
+
+test("4.4: persistensi setelah restart server (file sqlite yang sama)", () => {
+  const dir = mkdtempSync(path.join(tmpdir(), "kcg-db2-"));
+  const dbPath = path.join(dir, "kcg.sqlite");
+
+  const store1 = openSessionStore(dbPath);
+  seedProject(store1);
+  expect(store1.insertSession(makeSession()).ok).toBe(true);
+  store1.insertMessage(makeMessage("m1"));
+  store1.insertMessage(makeMessage("m2", "assistant"));
+  store1.insertStatusHistory("s1", "running", 1);
+  store1.insertStatusHistory("s1", "crashed", 2);
+  store1.close();
+
+  const store2 = openSessionStore(dbPath);
+  const messages = store2.getMessages("s1");
+  expect(messages.ok).toBe(true);
+  if (messages.ok) expect(messages.data.map((m) => m.id)).toEqual(["m1", "m2"]);
+  const hist = store2.getStatusHistory("s1");
+  expect(hist.ok).toBe(true);
+  if (hist.ok) expect(hist.data.map((h) => h.status)).toEqual(["running", "crashed"]);
+  store2.close();
+  rmSync(dir, { recursive: true, force: true });
+});
+
+test("migrasi onboarded_at: instalasi lama (sudah punya project/kunci) ditandai selesai", () => {
+  const { Database } = require("bun:sqlite") as typeof import("bun:sqlite");
+  const { runMigrations } = require("../db/schema") as typeof import("../db/schema");
+  // DB lama: skema tanpa kolom onboarded_at + sudah ada nickname.
+  const old = new Database(":memory:");
+  old.exec(`CREATE TABLE auth_settings (
+    id INTEGER PRIMARY KEY CHECK (id = 1), lock_kind TEXT, lock_hash TEXT, nickname TEXT,
+    avatar_mime TEXT, avatar BLOB, avatar_version INTEGER NOT NULL DEFAULT 0,
+    auto_lock_minutes INTEGER NOT NULL DEFAULT 15, updated_at INTEGER NOT NULL)`);
+  old.exec("INSERT INTO auth_settings (id, nickname, updated_at) VALUES (1, 'Irsyad', 42)");
+  runMigrations(old);
+  const row = old.query("SELECT onboarded_at FROM auth_settings WHERE id = 1").get() as {
+    onboarded_at: number | null;
+  };
+  expect(row.onboarded_at).toBe(42);
+
+  // DB baru (belum ada apa-apa) -> tetap butuh onboarding.
+  const fresh = new Database(":memory:");
+  runMigrations(fresh);
+  fresh.exec("INSERT INTO auth_settings (id, updated_at) VALUES (1, 1)");
+  const r2 = fresh.query("SELECT onboarded_at FROM auth_settings WHERE id = 1").get() as {
+    onboarded_at: number | null;
+  };
+  expect(r2.onboarded_at).toBeNull();
+});

package/src/server/__tests__/host.test.ts

@@ -0,0 +1,14 @@
+/**
+ * Alamat bind server (src/server/host.ts): default loopback, bisa di-override.
+ */
+import { expect, test } from "bun:test";
+import { DEFAULT_HOSTNAME, resolveHostname } from "../host";
+
+test("default hostname loopback 127.0.0.1", () => {
+  expect(DEFAULT_HOSTNAME).toBe("127.0.0.1");
+  expect(resolveHostname({})).toBe("127.0.0.1");
+});
+
+test("KCG_HOST meng-override hostname", () => {
+  expect(resolveHostname({ KCG_HOST: "0.0.0.0" })).toBe("0.0.0.0");
+});

package/src/server/__tests__/tunnel-config.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, test } from "bun:test";
+import { parseTunnelApiUrl, resolveTunnelConfig } from "../services/tunnel-config";
+
+describe("tunnel API URL", () => {
+  test("parseTunnelApiUrl normalises and rejects unsafe values", () => {
+    expect(parseTunnelApiUrl(undefined)).toEqual({ ok: true, url: null });
+    expect(parseTunnelApiUrl("https://rp.example.com/")).toEqual({
+      ok: true,
+      url: "https://rp.example.com",
+    });
+    expect(parseTunnelApiUrl("https://rp.example.com/base/")).toEqual({
+      ok: true,
+      url: "https://rp.example.com/base",
+    });
+    for (const bad of ["ftp://x", "not a url", "https://u:p@x.com", "https://x.com/?a=1", 42]) {
+      expect(parseTunnelApiUrl(bad).ok).toBe(false);
+    }
+  });
+
+  test("env wins over the baked-in URL; neither -> not configured", () => {
+    expect(resolveTunnelConfig("", "")).toEqual({ apiUrl: null });
+    expect(resolveTunnelConfig("", "https://baked.example.com")).toEqual({
+      apiUrl: "https://baked.example.com",
+    });
+    expect(resolveTunnelConfig("https://env.example.com/", "https://baked.example.com")).toEqual({
+      apiUrl: "https://env.example.com",
+    });
+    // Invalid env falls back to the baked-in value instead of breaking.
+    expect(resolveTunnelConfig("ftp://nope", "https://baked.example.com")).toEqual({
+      apiUrl: "https://baked.example.com",
+    });
+  });
+
+  test("the repo never ships a baked-in URL (stamped only at pack time)", async () => {
+    const { BUILD_TUNNEL_API_URL } = await import("../../build-config");
+    expect(BUILD_TUNNEL_API_URL).toBe("");
+  });
+});