@dotobokuri/fleet-console 1.26.2 → 1.28.0

package/dist/fleet-plugins/{diff → repository}/routes.mjs

@@ -8,12 +8,12 @@ import fs from 'fs/promises';
 function definePlugin(definition) {
   return definition;
 }
-function registerRouter(ctx, path4, handler) {
-  ctx.registerRouter(normalizePath(path4), handler);
+function registerRouter(ctx, path5, handler) {
+  ctx.registerRouter(normalizePath(path5), handler);
 }
-function normalizePath(path4) {
-  if (path4.length === 0 || path4 === "/") return "/";
-  return path4;
+function normalizePath(path5) {
+  if (path5.length === 0 || path5 === "/") return "/";
+  return path5;
 }
 
 // ../../packages/core-process/src/hidden.ts
@@ -21,7 +21,7 @@ function withHidden(options) {
   return { ...options ?? {}, windowsHide: true };
 }
 
-// ../fleet-plugins/diff/server/git-executor.ts
+// ../fleet-plugins/repository/server/git-executor.ts
 var GitExecutorError = class extends Error {
   code;
   exitCode;
@@ -173,7 +173,7 @@ async function resolveGitCwd(theaterPath, rawSubPath) {
   if (realSub !== realTheater && !realSub.startsWith(norm)) return null;
   return { gitCwd: resolvedSub };
 }
-async function handleDiffChanged(req, res, ctx) {
+async function handleRepositoryChanged(req, res, ctx) {
   if (req.method !== "POST") {
     ctx.host.http.writeJson(res, 405, { error: "Method not allowed" });
     return;
@@ -242,7 +242,7 @@ async function handleDiffChanged(req, res, ctx) {
     throw error;
   }
 }
-async function handleDiffFile(req, res, ctx) {
+async function handleRepositoryFile(req, res, ctx) {
   if (req.method !== "POST") {
     ctx.host.http.writeJson(res, 405, { error: "Method not allowed" });
     return;
@@ -345,7 +345,7 @@ async function handleDiffFile(req, res, ctx) {
   }
 }
 
-// ../fleet-plugins/diff/server/commit.ts
+// ../fleet-plugins/repository/server/commit.ts
 var REF_RE = /^[0-9a-f]{7,40}$/i;
 function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -366,7 +366,7 @@ function parseCommitMeta(output) {
     parents: rawParents.split(" ").filter(Boolean).map((full) => ({ full, short: full.slice(0, 9) }))
   };
 }
-async function handleDiffCommit(req, res, ctx) {
+async function handleRepositoryCommit(req, res, ctx) {
   if (req.method !== "POST") {
     ctx.host.http.writeJson(res, 405, { error: "Method not allowed" });
     return;
@@ -442,7 +442,7 @@ function resolveLiteralFilePath(gitCwd, rawPath) {
 function literalPathspec2(relativePath) {
   return `:(literal)${relativePath}`;
 }
-async function handleDiffCommitFile(req, res, ctx) {
+async function handleRepositoryCommitFile(req, res, ctx) {
   if (req.method !== "POST") {
     ctx.host.http.writeJson(res, 405, { error: "Method not allowed" });
     return;
@@ -500,17 +500,22 @@ async function handleDiffCommitFile(req, res, ctx) {
   }
 }
 var WORKTREE_SHA_RE = /^[0-9a-f]{40}$/;
+var CANONICAL_REF_RE = /^refs\/(?:heads|remotes|tags)\//;
+var REF_METACHAR_RE = /[~^:?*\[\\\s\x00-\x1f\x7f]/;
 function isPlainObject4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function isCanonicalRepositoryRef(ref) {
+  return CANONICAL_REF_RE.test(ref) && !ref.startsWith("-") && !ref.includes("..") && !ref.includes("//") && !REF_METACHAR_RE.test(ref) && !ref.includes("@{") && !ref.endsWith("/") && !ref.endsWith(".") && !ref.split("/").some((part) => part.startsWith(".") || part.endsWith(".lock"));
+}
 function parseLogOutput(stdout) {
   if (!stdout.trim()) return [];
   const commits = [];
   for (const chunk of stdout.split("")) {
     const trimmed = chunk.trimStart();
     if (!trimmed) continue;
-    const lines = trimmed.split("\n");
-    const firstLine = lines[0] ?? "";
+    const lines2 = trimmed.split("\n");
+    const firstLine = lines2[0] ?? "";
     const fields = firstLine.split("\0");
     const fullHash = fields[0] ?? "";
     const shortHash = fields[1] ?? "";
@@ -608,7 +613,7 @@ async function readCurrentWorktreePath(gitCwd) {
     throw error;
   }
 }
-async function handleDiffLog(req, res, ctx) {
+async function handleRepositoryLog(req, res, ctx) {
   if (req.method !== "POST") {
     ctx.host.http.writeJson(res, 405, { error: "Method not allowed" });
     return;
@@ -639,7 +644,13 @@ async function handleDiffLog(req, res, ctx) {
     return;
   }
   const { gitCwd } = cwdResult;
+  const requestedRef = body.ref;
+  if (requestedRef !== void 0 && (typeof requestedRef !== "string" || !isCanonicalRepositoryRef(requestedRef))) {
+    ctx.host.http.writeJson(res, 400, { error: "invalid_ref" });
+    return;
+  }
   try {
+    const resolvedRef = typeof requestedRef === "string" ? (await runGit(["rev-parse", "--verify", "--end-of-options", `${requestedRef}^{commit}`], { cwd: gitCwd })).stdout.trim() : null;
     const [worktrees, currentWorktreePath, headRevList] = await Promise.all([
       runGit(["worktree", "list", "--porcelain"], { cwd: gitCwd }),
       readCurrentWorktreePath(gitCwd),
@@ -648,7 +659,7 @@ async function handleDiffLog(req, res, ctx) {
     const checkouts = await parseWorktreePorcelain(worktrees.stdout, currentWorktreePath);
     const worktreeRevs = [...new Set(checkouts.map((checkout) => checkout.sha))].filter((sha) => WORKTREE_SHA_RE.test(sha) && !/^0+$/.test(sha));
     const headRevs = headRevList ? ["HEAD"] : [];
-    const result = await runGit(
+    const result = resolvedRef ? await runGit(["log", resolvedRef, "--date-order", "-n", "200", "--relative", "--decorate=full", "--pretty=format:%x1e%H%x00%h%x00%s%x00%an%x00%ar%x00%at%x00%D%x00%P", "--", "."], { cwd: gitCwd }) : await runGit(
       // --all은 refs/stash·refs/notes까지 그래프에 유입시키므로 브랜치/태그/원격 + 현재 HEAD + 워크트리 HEAD로 한정한다
       ["log", "--branches", "--tags", "--remotes", "--date-order", "-n", "200", "--relative", "--decorate=full", "--pretty=format:%x1e%H%x00%h%x00%s%x00%an%x00%ar%x00%at%x00%D%x00%P", ...headRevs, ...worktreeRevs, "--", "."],
       { cwd: gitCwd }
@@ -657,6 +668,10 @@ async function handleDiffLog(req, res, ctx) {
     ctx.host.http.writeJson(res, 200, { commits, checkouts, ...result.truncated ? { truncated: true } : {} });
   } catch (error) {
     if (error instanceof GitExecutorError) {
+      if (requestedRef !== void 0 && error.code === "non_zero_exit") {
+        ctx.host.http.writeJson(res, 400, { error: "invalid_ref" });
+        return;
+      }
       if (error.code === "no_git_repo") {
         ctx.host.http.writeJson(res, 200, { commits: [], checkouts: [] });
         return;
@@ -675,29 +690,140 @@ async function handleDiffLog(req, res, ctx) {
     throw error;
   }
 }
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function lines(stdout) {
+  return stdout.split("\n").map((line) => line.trim()).filter(Boolean);
+}
+function parseRefItems(stdout, current) {
+  return lines(stdout).flatMap((line) => {
+    const [ref, label] = line.split("\0");
+    return ref && label ? [{ ref, label, current: ref === current }] : [];
+  });
+}
+async function readCurrentWorktreePath2(gitCwd) {
+  try {
+    return (await runGit(["rev-parse", "--show-toplevel"], { cwd: gitCwd })).stdout.trim();
+  } catch (error) {
+    if (error instanceof GitExecutorError) return "";
+    throw error;
+  }
+}
+async function readStashes(gitCwd) {
+  try {
+    return (await runGit(["stash", "list", "--format=%gd%x00%s"], { cwd: gitCwd })).stdout;
+  } catch (error) {
+    if (error instanceof GitExecutorError) return "";
+    throw error;
+  }
+}
+async function parseWorktrees(stdout, currentWorktreePath, theaterPath, deps = {}) {
+  const records = stdout.split("\n\n").map((record) => record.split("\n"));
+  const realpath = deps.realpath ?? fs.realpath;
+  const normalizedCurrent = currentWorktreePath ? await realpath(currentWorktreePath).catch(() => currentWorktreePath) : "";
+  const realTheaterPath = await realpath(theaterPath).catch(() => null);
+  return Promise.all(records.flatMap((record) => {
+    const rawPath = record.find((line) => line.startsWith("worktree "))?.slice(9);
+    if (!rawPath) return [];
+    const branchRef = record.find((line) => line.startsWith("branch "))?.slice(7) ?? null;
+    const branch = branchRef?.startsWith("refs/heads/") ? branchRef.slice(11) : null;
+    return [{ rawPath, name: path2.basename(rawPath) || "worktree", branch }];
+  }).map(async ({ rawPath, ...item }) => {
+    const realWorktreePath = await realpath(rawPath).catch(() => null);
+    const currentPath = realWorktreePath ?? rawPath;
+    const contextRelPath = realTheaterPath !== null && realWorktreePath !== null && isWithinTheater(realWorktreePath, realTheaterPath) ? path2.relative(realTheaterPath, realWorktreePath).split(path2.sep).join("/") : null;
+    return { ...item, current: normalizedCurrent !== "" && currentPath === normalizedCurrent, contextRelPath };
+  }));
+}
+function isWithinTheater(candidate, theaterPath) {
+  const normalizedTheaterPath = theaterPath.endsWith(path2.sep) ? theaterPath : `${theaterPath}${path2.sep}`;
+  return candidate === theaterPath || candidate.startsWith(normalizedTheaterPath);
+}
+async function handleRepositoryRefs(req, res, ctx) {
+  if (req.method !== "POST") {
+    ctx.host.http.writeJson(res, 405, { error: "Method not allowed" });
+    return;
+  }
+  if (!ctx.host.security.isTerminalAuthorized(req)) {
+    ctx.host.http.writeJson(res, 401, { error: "unauthorized" });
+    return;
+  }
+  const body = await ctx.host.http.readJsonBody(req);
+  if (!isObject(body) || typeof body.theaterId !== "string") {
+    ctx.host.http.writeJson(res, 400, { error: "invalid_request" });
+    return;
+  }
+  const theaterPath = ctx.host.paths.resolveTheaterPath(body.theaterId);
+  if (!theaterPath) {
+    ctx.host.http.writeJson(res, 404, { error: "theater_not_found" });
+    return;
+  }
+  const resolved = await resolveGitCwd(theaterPath, typeof body.subPath === "string" ? body.subPath : "");
+  if (!resolved) {
+    ctx.host.http.writeJson(res, 403, { error: "path_outside_theater" });
+    return;
+  }
+  try {
+    const [head, local, remote, tags, stashes, worktrees] = await Promise.all([
+      runGit(["symbolic-ref", "--quiet", "HEAD"], { cwd: resolved.gitCwd, allowExitCodes: [1] }),
+      runGit(["for-each-ref", "--format=%(refname)%00%(refname:short)", "refs/heads"], { cwd: resolved.gitCwd }),
+      runGit(["for-each-ref", "--format=%(refname)%00%(refname:short)", "refs/remotes"], { cwd: resolved.gitCwd }),
+      runGit(["for-each-ref", "--format=%(refname)%00%(refname:short)", "refs/tags"], { cwd: resolved.gitCwd }),
+      readStashes(resolved.gitCwd),
+      runGit(["worktree", "list", "--porcelain"], { cwd: resolved.gitCwd })
+    ]);
+    const current = head.stdout.trim();
+    const currentWorktreePath = await readCurrentWorktreePath2(resolved.gitCwd);
+    ctx.host.http.writeJson(res, 200, {
+      branches: parseRefItems(local.stdout, current),
+      remotes: parseRefItems(remote.stdout, current),
+      tags: parseRefItems(tags.stdout, current),
+      stashes: lines(stashes).map((line) => {
+        const [name, subject = ""] = line.split("\0");
+        return { name, subject };
+      }),
+      worktrees: await parseWorktrees(worktrees.stdout, currentWorktreePath, theaterPath)
+    });
+  } catch (error) {
+    if (error instanceof GitExecutorError && error.code === "no_git_repo") {
+      ctx.host.http.writeJson(res, 200, { branches: [], remotes: [], tags: [], stashes: [], worktrees: [] });
+      return;
+    }
+    if (error instanceof GitExecutorError && error.code === "git_unavailable") {
+      ctx.host.http.writeJson(res, 422, { error: error.code });
+      return;
+    }
+    ctx.host.http.writeJson(res, 500, { error: "git_failed" });
+  }
+}
 
-// ../fleet-plugins/diff/routes.ts
+// ../fleet-plugins/repository/routes.ts
 var routes_default = definePlugin({
-  id: "diff",
+  id: "repository",
   register(ctx) {
     registerRouter(ctx, "changed", async ({ req, res }) => {
-      await handleDiffChanged(req, res, ctx);
+      await handleRepositoryChanged(req, res, ctx);
       return true;
     });
     registerRouter(ctx, "file", async ({ req, res }) => {
-      await handleDiffFile(req, res, ctx);
+      await handleRepositoryFile(req, res, ctx);
       return true;
     });
     registerRouter(ctx, "log", async ({ req, res }) => {
-      await handleDiffLog(req, res, ctx);
+      await handleRepositoryLog(req, res, ctx);
+      return true;
+    });
+    registerRouter(ctx, "refs", async ({ req, res }) => {
+      await handleRepositoryRefs(req, res, ctx);
       return true;
     });
     registerRouter(ctx, "commit", async ({ req, res }) => {
-      await handleDiffCommit(req, res, ctx);
+      await handleRepositoryCommit(req, res, ctx);
       return true;
     });
     registerRouter(ctx, "commit-file", async ({ req, res }) => {
-      await handleDiffCommitFile(req, res, ctx);
+      await handleRepositoryCommitFile(req, res, ctx);
       return true;
     });
   }

package/dist/fleet-plugins/skills/routes.mjs

@@ -16402,6 +16402,21 @@ var models_default = {
         { modelId: "claude-opus-4-8[1m]", name: "Claude Opus 4.8 [1M]", effort: { supported: true, levels: ["low", "medium", "high", "xhigh", "max"], default: "high" } }
       ]
     },
+    "claude-kimi": {
+      name: "Kimi via Claude Code",
+      defaultModel: "kimi-for-coding",
+      models: [
+        { modelId: "kimi-for-coding", name: "Kimi for Coding", description: "Available on every Kimi Code membership tier (262K context)", effort: { supported: false } },
+        { modelId: "k3", name: "Kimi K3", description: "Available on Moderato and higher tiers (262K context)", effort: { supported: true, levels: ["max"], default: "max" } },
+        { modelId: "k3[1m]", name: "Kimi K3 [1M]", description: "Available on Allegretto and higher tiers (1M context)", effort: { supported: true, levels: ["max"], default: "max" } },
+        { modelId: "kimi-for-coding-highspeed", name: "Kimi for Coding Highspeed", description: "Available on Allegretto and higher tiers (262K context)", effort: { supported: false } }
+      ],
+      modelsMapping: {
+        haiku: "kimi-for-coding",
+        sonnet: "kimi-for-coding",
+        opus: "kimi-for-coding"
+      }
+    },
     codex: {
       name: "Codex",
       defaultModel: "gpt-5.6-sol",
@@ -16554,6 +16569,32 @@ var CLI_BACKENDS = {
     usesNpxBridge: true,
     defaultMaxTokens: 16384
   },
+  "claude-kimi": {
+    id: "claude-kimi",
+    cliCommand: "claude",
+    protocol: "acp",
+    authRequired: true,
+    npxPackage: "@agentclientprotocol/claude-agent-acp@0.33.1",
+    modes: [
+      { id: "default", label: "Default" },
+      { id: "plan", label: "Plan" },
+      { id: "bypassPermissions", label: "YOLO" }
+    ],
+    supportsSessionClose: true,
+    supportsSessionLoad: true,
+    requiresModelAtSpawn: false,
+    usesNpxBridge: true,
+    defaultMaxTokens: 262144,
+    defaultEnv: {
+      ANTHROPIC_BASE_URL: "https://api.kimi.com/coding/",
+      ANTHROPIC_MODEL: "kimi-for-coding",
+      ANTHROPIC_DEFAULT_HAIKU_MODEL: "kimi-for-coding",
+      ANTHROPIC_DEFAULT_SONNET_MODEL: "kimi-for-coding",
+      ANTHROPIC_DEFAULT_OPUS_MODEL: "kimi-for-coding",
+      CLAUDE_CODE_SUBAGENT_MODEL: "kimi-for-coding",
+      API_TIMEOUT_MS: "3000000"
+    }
+  },
   codex: {
     id: "codex",
     cliCommand: "codex",