kcg-code 0.0.0-stage → 0.2.0

package/src/server/services/__tests__/claude-skills.test.ts

@@ -0,0 +1,63 @@
+/**
+ * Unit test pemindai skill Claude Code (src/server/services/claude-skills.ts)
+ * — frontmatter SKILL.md dan pemindaian `.claude/skills` di direktori temp.
+ */
+import { describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { claudeGlobalSkillsDir, listClaudeSkills, parseSkillFrontmatter } from "../claude-skills";
+
+function writeSkill(dir: string, body: string): void {
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "SKILL.md"), body);
+}
+
+describe("parseSkillFrontmatter", () => {
+  test("nilai satu baris, berkutip maupun tidak", () => {
+    expect(
+      parseSkillFrontmatter('---\nname: pdf\ndescription: "Read PDFs: fast"\n---\n# PDF'),
+    ).toEqual({ name: "pdf", description: "Read PDFs: fast" });
+  });
+
+  test("blok `>` digabung menjadi satu baris", () => {
+    expect(
+      parseSkillFrontmatter("---\nname: x\ndescription: >\n  first line\n  second line\n---\n"),
+    ).toEqual({ name: "x", description: "first line second line" });
+  });
+
+  test("tanpa frontmatter -> null", () => {
+    expect(parseSkillFrontmatter("# Just markdown")).toEqual({ name: null, description: null });
+  });
+});
+
+describe("listClaudeSkills", () => {
+  test("Project + global, ikuti symlink, fallback nama folder", async () => {
+    const root = mkdtempSync(join(tmpdir(), "kcg-cc-skills-"));
+    const project = join(root, "proj");
+    const global = join(root, "home-skills");
+    // Pola CLI `skills --agent claude-code`: isi di .agents/skills, symlink di .claude/skills.
+    writeSkill(join(project, ".agents/skills/linked"), "---\nname: linked\ndescription: L\n---\n");
+    mkdirSync(join(project, ".claude/skills"), { recursive: true });
+    symlinkSync(join(project, ".agents/skills/linked"), join(project, ".claude/skills/linked"));
+    writeSkill(join(project, ".claude/skills/plain"), "no frontmatter");
+    writeSkill(join(global, "global-one"), "---\nname: global-one\n---\n");
+
+    const skills = await listClaudeSkills(project, global);
+    expect(skills.map((s) => [s.name, s.source, s.description])).toEqual([
+      ["global-one", "global", null],
+      ["linked", "project", "L"],
+      ["plain", "project", null],
+    ]);
+    expect(skills[1]?.location).toBe(join(project, ".claude/skills/linked/SKILL.md"));
+  });
+
+  test("direktori tidak ada -> daftar kosong", async () => {
+    expect(await listClaudeSkills("/nonexistent-kcg", "/nonexistent-kcg-global")).toEqual([]);
+  });
+
+  test("claudeGlobalSkillsDir menghormati CLAUDE_CONFIG_DIR", () => {
+    expect(claudeGlobalSkillsDir({ CLAUDE_CONFIG_DIR: "/cfg" })).toBe("/cfg/skills");
+    expect(claudeGlobalSkillsDir({})).toEndWith("/.claude/skills");
+  });
+});

package/src/server/services/__tests__/frpc-installer.test.ts

@@ -0,0 +1,83 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, mkdtempSync, readdirSync, rmSync, statSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import path from "node:path";
+import { createFrpcInstaller, FRP_VERSION } from "../frpc-installer";
+
+let dirs: string[] = [];
+afterEach(() => {
+  for (const d of dirs) rmSync(d, { recursive: true, force: true });
+  dirs = [];
+});
+
+/** Build a real frp-shaped .tar.gz with a fake frpc script inside. */
+async function fakeRelease(): Promise<{ bytes: ArrayBuffer; sha256: string }> {
+  const src = mkdtempSync(path.join(tmpdir(), "kcg-frp-src-"));
+  dirs.push(src);
+  const name = `frp_${FRP_VERSION}_linux_amd64`;
+  mkdirSync(path.join(src, name));
+  await Bun.write(path.join(src, name, "frpc"), "#!/bin/sh\necho fake\n");
+  const archive = path.join(src, `${name}.tar.gz`);
+  const proc = Bun.spawn(["tar", "-czf", archive, "-C", src, name]);
+  expect(await proc.exited).toBe(0);
+  const bytes = await Bun.file(archive).arrayBuffer();
+  return { bytes, sha256: new Bun.CryptoHasher("sha256").update(bytes).digest("hex") };
+}
+
+describe("frpc installer", () => {
+  test("rejects an archive whose checksum does not match the pinned one", async () => {
+    const { bytes } = await fakeRelease();
+    const binDir = mkdtempSync(path.join(tmpdir(), "kcg-frpc-test-"));
+    dirs.push(binDir);
+    const installer = createFrpcInstaller({
+      binDir,
+      platform: "linux",
+      arch: "x64",
+      which: () => null,
+      fetch: (async () => new Response(bytes)) as unknown as typeof fetch,
+    });
+
+    const r = await installer.ensure();
+    expect(r).toEqual({ ok: false, error: "FRPC_CHECKSUM_MISMATCH" });
+    expect(existsSync(path.join(binDir, "frpc"))).toBe(false);
+  });
+
+  test("installs across filesystems (tmpdir -> home) without EXDEV, atomically", async () => {
+    const { bytes, sha256 } = await fakeRelease();
+    // binDir under $HOME while extraction happens in tmpdir(): on many systems
+    // /tmp is tmpfs, so a plain rename() would fail with EXDEV.
+    const binDir = mkdtempSync(path.join(homedir(), ".kcg-frpc-test-"));
+    dirs.push(binDir);
+    const installer = createFrpcInstaller({
+      binDir,
+      platform: "linux",
+      arch: "x64",
+      which: () => null,
+      fetch: (async () => new Response(bytes)) as unknown as typeof fetch,
+      sha256Override: sha256,
+    });
+
+    const r = await installer.ensure();
+    expect(r.ok).toBe(true);
+    const target = path.join(binDir, "frpc");
+    expect(r.ok && r.data).toBe(target);
+    expect(statSync(target).mode & 0o777).toBe(0o755);
+    expect(readdirSync(binDir)).toEqual(["frpc"]);
+  });
+
+  test("prefers an existing binary and does not download", async () => {
+    const binDir = mkdtempSync(path.join(tmpdir(), "kcg-frpc-test-"));
+    dirs.push(binDir);
+    let fetched = false;
+    const installer = createFrpcInstaller({
+      binDir,
+      which: () => "/usr/local/bin/frpc",
+      fetch: (async () => {
+        fetched = true;
+        return new Response("");
+      }) as unknown as typeof fetch,
+    });
+    expect(await installer.ensure()).toEqual({ ok: true, data: "/usr/local/bin/frpc" });
+    expect(fetched).toBe(false);
+  });
+});

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

@@ -0,0 +1,74 @@
+/**
+ * Unit test `git-info.ts` — dijalankan pada repo git SUNGGUHAN di tmpdir
+ * (bukan mock `Bun.spawn`), karena yang rawan salah justru penafsiran output
+ * git: urutan `--left-right` pada `rev-list` mudah tertukar antara
+ * ahead & behind.
+ */
+import { expect, test } from "bun:test";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { readGitInfo } from "../git-info";
+
+async function run(cwd: string, args: string[]): Promise<void> {
+  const proc = Bun.spawn(args, { cwd, stdout: "ignore", stderr: "ignore", stdin: "ignore" });
+  await proc.exited;
+}
+
+async function commit(cwd: string, name: string): Promise<void> {
+  writeFileSync(path.join(cwd, name), name);
+  await run(cwd, ["git", "add", "."]);
+  await run(cwd, ["git", "commit", "-m", name]);
+}
+
+test("cabang, ahead/behind, dan remote dibaca dari repo sungguhan", async () => {
+  const root = mkdtempSync(path.join(tmpdir(), "kcg-git-"));
+  const remote = path.join(root, "remote.git");
+  const work = path.join(root, "work");
+  try {
+    await run(root, ["git", "init", "--bare", "-b", "main", remote]);
+    await run(root, ["git", "clone", remote, work]);
+    await run(work, ["git", "config", "user.email", "t@example.com"]);
+    await run(work, ["git", "config", "user.name", "Tester"]);
+    await commit(work, "a.txt");
+    await run(work, ["git", "push", "-u", "origin", "main"]);
+
+    const synced = await readGitInfo(work);
+    expect(synced.branch).toBe("main");
+    expect(synced.hasRemote).toBe(true);
+    expect(synced.ahead).toBe(0);
+    expect(synced.behind).toBe(0);
+
+    // Dua commit lokal yang belum dipush = ahead 2 (BUKAN behind).
+    await commit(work, "b.txt");
+    await commit(work, "c.txt");
+    const ahead = await readGitInfo(work);
+    expect(ahead.ahead).toBe(2);
+    expect(ahead.behind).toBe(0);
+
+    // Cabang baru tanpa upstream -> selisih tidak diketahui, bukan 0.
+    await run(work, ["git", "checkout", "-b", "feature"]);
+    const noUpstream = await readGitInfo(work);
+    expect(noUpstream.branch).toBe("feature");
+    expect(noUpstream.ahead).toBeNull();
+    expect(noUpstream.behind).toBeNull();
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test("direktori biasa (bukan repo git) -> info kosong, bukan error", async () => {
+  const dir = mkdtempSync(path.join(tmpdir(), "kcg-nogit-"));
+  try {
+    const info = await readGitInfo(dir);
+    expect(info).toEqual({ branch: null, ahead: null, behind: null, hasRemote: false });
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test("path yang tidak ada -> info kosong (tidak melempar)", async () => {
+  const info = await readGitInfo("/tmp/kcg-does-not-exist-xyz");
+  expect(info.branch).toBeNull();
+  expect(info.hasRemote).toBe(false);
+});

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

@@ -0,0 +1,320 @@
+/**
+ * Unit test helper murni `opencode-client.ts` & `opencode-server.ts`.
+ *
+ * Yang diuji (tanpa jaringan/proses sungguhan):
+ * - `parseSseFrame` / `normalizeEvent`: parsing & normalisasi event SSE.
+ * - `parseListeningPort`: ekstraksi port dari baris log server.
+ * - `flattenProviders`: respons GET /config/providers -> daftar model UI.
+ * - `flattenAgents`: respons GET /agent -> daftar mode (primary/all saja).
+ * - `configFingerprint`: deteksi perubahan file config opencode.
+ * - `ensureFreshServer`: restart saat fingerprint config berubah.
+ */
+import { expect, test } from "bun:test";
+import { mkdtempSync, utimesSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import fc from "fast-check";
+import type { OpenCodeClient } from "../opencode-client";
+import { flattenAgents, flattenMcp, flattenProviders, flattenSkills } from "../opencode-client";
+import {
+  configFingerprint,
+  createOpenCodeServerManager,
+  parseListeningPort,
+  type ServerProcessLike,
+} from "../opencode-server";
+import { normalizeEvent, parseSseFrame } from "../opencode-sse";
+
+test("parseSseFrame: mengambil baris data; frame tanpa data -> null", () => {
+  expect(parseSseFrame('data: {"a":1}\n\n')).toBe('{"a":1}');
+  expect(parseSseFrame("event: x\ndata: hello\n")).toBe("hello");
+  expect(parseSseFrame("comment saja\n\n")).toBeNull();
+  expect(parseSseFrame("")).toBeNull();
+});
+
+test("normalizeEvent: {id,type,properties} -> event datar (type + properties)", () => {
+  const ev = normalizeEvent({
+    id: "evt_1",
+    type: "permission.asked",
+    properties: { requestID: "per_1", sessionID: "ses_1", permission: "bash:ls" },
+  });
+  expect(ev).toEqual({
+    id: "evt_1",
+    type: "permission.asked",
+    requestID: "per_1",
+    sessionID: "ses_1",
+    permission: "bash:ls",
+  });
+
+  // Payload tanpa properties -> tetap aman.
+  expect(normalizeEvent({ type: "server.connected" })).toEqual({ type: "server.connected" });
+
+  // Payload invalid -> null.
+  expect(normalizeEvent(null)).toBeNull();
+  expect(normalizeEvent("x")).toBeNull();
+  expect(normalizeEvent({})).toBeNull();
+  expect(normalizeEvent({ id: 1 })).toBeNull();
+});
+
+test("flattenAgents: hanya primary/all; subagent murni disaring", () => {
+  const agents = flattenAgents([
+    { name: "build", mode: "primary", description: "Full tool access" },
+    { name: "plan", mode: "primary", description: "Planning only" },
+    { name: "general", mode: "subagent", description: "Sub-agent" },
+    { name: "explore", mode: "all", description: null },
+    { name: "", mode: "primary" },
+    "rusak",
+  ]);
+  expect(agents.map((a) => a.name)).toEqual(["build", "plan", "explore"]);
+  expect(agents[2]).toEqual({ name: "explore", mode: "all", description: null });
+});
+
+test("flattenAgents: payload bukan array / kosong -> []", () => {
+  expect(flattenAgents(null)).toEqual([]);
+  expect(flattenAgents({})).toEqual([]);
+  expect(flattenAgents([])).toEqual([]);
+});
+
+test("parseListeningPort: mengekstrak port dari baris log opencode", () => {
+  expect(parseListeningPort("opencode server listening on http://127.0.0.1:4096")).toBe(4096);
+  expect(parseListeningPort("listening on http://0.0.0.0:4599")).toBe(4599);
+  expect(parseListeningPort("beberapa teks tanpa port")).toBeNull();
+  expect(parseListeningPort("port 80 di tengah teks")).toBeNull();
+});
+
+test("parseListeningPort: properti — port valid apa pun selalu diekstrak", () => {
+  fc.assert(
+    fc.property(fc.integer({ min: 1024, max: 65535 }), (p) => {
+      expect(parseListeningPort(`opencode server listening on http://127.0.0.1:${p}`)).toBe(p);
+    }),
+    { numRuns: 50 },
+  );
+});
+
+// ---------------------------------------------------------------------------
+// flattenProviders (GET /config/providers -> daftar model untuk UI)
+// ---------------------------------------------------------------------------
+
+test("flattenProviders: flatten provider + model dengan nama tampilan", () => {
+  const payload = {
+    providers: [
+      {
+        id: "kcgcode",
+        name: "kcgcode",
+        models: {
+          "kiro/claude-opus-5": { id: "kiro/claude-opus-5", name: "Claude Opus 5" },
+          "mimo/mimo-v2.5": { id: "mimo/mimo-v2.5" }, // tanpa name -> fallback id
+        },
+      },
+    ],
+  };
+  expect(flattenProviders(payload)).toEqual([
+    {
+      providerID: "kcgcode",
+      providerName: "kcgcode",
+      modelID: "kiro/claude-opus-5",
+      name: "Claude Opus 5",
+    },
+    {
+      providerID: "kcgcode",
+      providerName: "kcgcode",
+      modelID: "mimo/mimo-v2.5",
+      name: "mimo/mimo-v2.5",
+    },
+  ]);
+});
+
+test("flattenProviders: model deprecated disaring", () => {
+  const payload = {
+    providers: [
+      {
+        id: "p",
+        name: "P",
+        models: {
+          lama: { id: "lama", status: "deprecated" },
+          baru: { id: "baru", status: "active" },
+        },
+      },
+    ],
+  };
+  const out = flattenProviders(payload);
+  expect(out.map((m) => m.modelID)).toEqual(["baru"]);
+});
+
+test("flattenProviders: payload tidak valid / kosong -> []", () => {
+  expect(flattenProviders(null)).toEqual([]);
+  expect(flattenProviders({})).toEqual([]);
+  expect(flattenProviders({ providers: "bukan array" })).toEqual([]);
+  // provider tanpa id / tanpa models diabaikan
+  expect(flattenProviders({ providers: [{ name: "tanpa-id" }, { id: "kosong" }] })).toEqual([]);
+});
+
+test("flattenProviders: provider name kosong fallback ke id", () => {
+  const out = flattenProviders({
+    providers: [{ id: "opencode", name: "", models: { m1: { id: "m1", name: "M1" } } }],
+  });
+  expect(out[0]).toMatchObject({ providerID: "opencode", providerName: "opencode" });
+});
+
+// ---------------------------------------------------------------------------
+// configFingerprint / ensureFreshServer (live reread config opencode)
+// ---------------------------------------------------------------------------
+
+function makeFakeProc(port: number): ServerProcessLike & { kills: string[] } {
+  const kills: string[] = [];
+  let resolveExited: (code: number | null) => void = () => {};
+  const exited = new Promise<number | null>((res) => {
+    resolveExited = res;
+  });
+  const stdout = new ReadableStream<Uint8Array>({
+    start(controller) {
+      controller.close();
+    },
+  });
+  // stderr sengaja tidak di-close: ensureServer menunggu baris "listening".
+  const stderr = new ReadableStream<Uint8Array>({
+    start(controller) {
+      const enc = new TextEncoder();
+      controller.enqueue(enc.encode(`opencode server listening on http://127.0.0.1:${port}\n`));
+    },
+  });
+  return {
+    kills,
+    kill(signal) {
+      kills.push(signal);
+      resolveExited(0);
+    },
+    exited,
+    stderr,
+    stdout,
+    pid: undefined,
+  };
+}
+
+function makeFakeClientFactory() {
+  const clients: OpenCodeClient[] = [];
+  const factory = (): OpenCodeClient => {
+    const client = {
+      health: async () => true,
+      subscribeEvents: () => () => {},
+    } as unknown as OpenCodeClient;
+    clients.push(client);
+    return client;
+  };
+  return { clients, factory };
+}
+
+function makeFastManager() {
+  const procs: ReturnType<typeof makeFakeProc>[] = [];
+  const { clients, factory } = makeFakeClientFactory();
+  let nextPort = 9000;
+  const manager = createOpenCodeServerManager({
+    portTimeoutMs: 2000,
+    readyTimeoutMs: 2000,
+    spawn: () => {
+      const proc = makeFakeProc(nextPort++);
+      procs.push(proc);
+      return proc;
+    },
+    clientFactory: factory,
+  });
+  return { manager, procs, clients };
+}
+
+test("configFingerprint: file project ikut masuk dan berubah saat disentuh", () => {
+  const dir = mkdtempSync(join(tmpdir(), "kcg-fp-"));
+  const base = configFingerprint(dir);
+  const p = join(dir, "opencode.json");
+  writeFileSync(p, "{}");
+  const t = new Date("2026-01-01T00:00:00Z");
+  utimesSync(p, t, t);
+  const fp1 = configFingerprint(dir);
+  expect(fp1).toContain("opencode.json");
+  expect(fp1).not.toBe(base);
+  // Stabil bila file tidak disentuh.
+  expect(configFingerprint(dir)).toBe(fp1);
+  // Sentuh file -> fingerprint berubah.
+  utimesSync(p, new Date("2026-01-02T00:00:00Z"), new Date("2026-01-02T00:00:00Z"));
+  expect(configFingerprint(dir)).not.toBe(fp1);
+});
+
+test("ensureFreshServer: config tak berubah -> instance sama; berubah -> restart", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "kcg-fresh-"));
+  const { manager, procs } = makeFastManager();
+
+  const first = await manager.ensureFreshServer("p1", dir);
+  expect(first.ok).toBe(true);
+  if (!first.ok) return;
+  expect(procs).toHaveLength(1);
+
+  // Config tidak berubah: tidak spawn ulang.
+  const second = await manager.ensureFreshServer("p1", dir);
+  expect(second.ok).toBe(true);
+  expect(procs).toHaveLength(1);
+  if (second.ok) expect(second.data.baseUrl).toBe(first.data.baseUrl);
+
+  // Ubah config project -> fingerprint beda -> stop + spawn baru.
+  writeFileSync(join(dir, "opencode.json"), "{}");
+  const third = await manager.ensureFreshServer("p1", dir);
+  expect(third.ok).toBe(true);
+  if (!third.ok) return;
+  expect(procs).toHaveLength(2);
+  expect(procs[0]?.kills).toContain("SIGTERM");
+  expect(third.data.baseUrl).not.toBe(first.data.baseUrl);
+});
+
+test("flattenMcp: map nama -> status, terurut; status tak dikenal -> unknown", () => {
+  expect(
+    flattenMcp({
+      zeta: { status: "connected" },
+      alpha: { status: "failed", error: "spawn ENOENT" },
+      mid: { status: "weird" },
+      "": { status: "connected" },
+    }),
+  ).toEqual([
+    { name: "alpha", status: "failed", error: "spawn ENOENT" },
+    { name: "mid", status: "unknown", error: null },
+    { name: "zeta", status: "connected", error: null },
+  ]);
+  expect(flattenMcp(null)).toEqual([]);
+  expect(flattenMcp([])).toEqual([]);
+});
+
+test("flattenSkills: klasifikasi asal (builtin/project/global), content dibuang", () => {
+  const out = flattenSkills(
+    [
+      {
+        name: "shadcn",
+        description: "UI",
+        location: "/work/app/.agents/skills/shadcn/SKILL.md",
+        content: "x",
+      },
+      { name: "customize", description: "", location: "<built-in>", content: "x" },
+      {
+        name: "firecrawl",
+        description: "Web",
+        location: "/home/u/.config/opencode/skills/f/SKILL.md",
+      },
+      // Prefix path mirip tapi bukan di dalam Project -> global.
+      { name: "other", location: "/work/app-2/SKILL.md" },
+      { description: "tanpa nama" },
+    ],
+    "/work/app/",
+  );
+  expect(out).toEqual([
+    { name: "customize", description: null, location: null, source: "builtin" },
+    {
+      name: "firecrawl",
+      description: "Web",
+      location: "/home/u/.config/opencode/skills/f/SKILL.md",
+      source: "global",
+    },
+    { name: "other", description: null, location: "/work/app-2/SKILL.md", source: "global" },
+    {
+      name: "shadcn",
+      description: "UI",
+      location: "/work/app/.agents/skills/shadcn/SKILL.md",
+      source: "project",
+    },
+  ]);
+  expect(flattenSkills({})).toEqual([]);
+});