git-daemon 0.1.7 → 0.1.9

package/README.md

@@ -7,7 +7,8 @@ Git Daemon is a local Node.js service that exposes a small, authenticated HTTP A
 
 ## What it does
 
-- Clone, fetch, and read Git status using your system Git credentials
+- Clone, fetch, list branches, and read Git status using your system Git credentials
+- Provide a status summary for UI badges/tooltips
 - Stream long-running job logs via Server-Sent Events (SSE)
 - Open a repo in the OS file browser, terminal, or VS Code (with approvals)
 - Install dependencies with safer defaults (`--ignore-scripts` by default)
@@ -24,7 +25,7 @@ Git Daemon is a local Node.js service that exposes a small, authenticated HTTP A
 ## Requirements
 
 - Node.js (for running the daemon)
-- Git (for clone/fetch/status)
+- Git (for clone/fetch/branches/status/summary)
 - Optional: `code` CLI for VS Code, `pnpm`/`yarn` for dependency installs
 
 ## Install
@@ -153,6 +154,22 @@ curl -N \
   http://127.0.0.1:8790/v1/jobs/<JOB_ID>/stream
 ```
 
+List branches (local + remote by default):
+
+```bash
+curl -H "Origin: https://app.example.com" \
+  -H "Authorization: Bearer <TOKEN>" \
+  "http://127.0.0.1:8790/v1/git/branches?repoPath=owner/repo"
+```
+
+Status summary (UI-friendly):
+
+```bash
+curl -H "Origin: https://app.example.com" \
+  -H "Authorization: Bearer <TOKEN>" \
+  "http://127.0.0.1:8790/v1/git/summary?repoPath=owner/repo"
+```
+
 ## Configuration
 
 Config is stored in OS-specific directories:

package/design.md

@@ -20,6 +20,7 @@ The daemon exposes a **localhost HTTP API** guarded by:
 * Provide additional local dev actions:
 
   * `fetch`
+  * `branches`
   * `status`
   * open folder / terminal / VS Code
   * run dependency installation (`npm i` / pnpm / yarn)
@@ -275,6 +276,14 @@ Meta response fields (examples):
 
   * body: `{ repoPath, remote?: "origin", prune?: true }`
   * note: fetch updates remote tracking only; no merge/rebase is performed
+* `GET /v1/git/branches?repoPath=...&includeRemote=true` → branch list
+
+  * returns: `{ branches: [{ name, fullName, type: "local"|"remote", current, upstream? }] }`
+  * `includeRemote` defaults to `true` and includes remote tracking branches (e.g. `origin/main`)
+* `GET /v1/git/summary?repoPath=...` → status summary for UI badges/tooltips
+
+  * returns: `{ repoPath, exists, branch, upstream, ahead, behind, dirty, staged, unstaged, untracked, conflicts, detached }`
+  * if repo is missing, `exists` is `false` with zeroed counts
 * `GET /v1/git/status?repoPath=...` → structured status
 
   * returns: `{ branch, ahead, behind, stagedCount, unstagedCount, untrackedCount, conflictsCount, clean }`
@@ -472,7 +481,7 @@ Recommended `errorCode` values:
 ## Future Extensions
 
 * Repo registry: “known repos” list for safer operations and better UX
-* `git pull`, `checkout`, `branch list`, `log` endpoints
+* `git pull`, `checkout`, `log` endpoints
 * Support multiple terminals/editors
 * Signed request challenge (HMAC) in addition to bearer token
 

package/openapi.yaml

@@ -182,6 +182,55 @@ paths:
           $ref: '#/components/responses/UnprocessableEntity'
         '500':
           $ref: '#/components/responses/InternalError'
+  /v1/git/branches:
+    get:
+      summary: List repository branches
+      parameters:
+        - $ref: '#/components/parameters/OriginHeader'
+        - $ref: '#/components/parameters/RepoPath'
+        - $ref: '#/components/parameters/IncludeRemote'
+      responses:
+        '200':
+          description: Repository branches
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/GitBranchesResponse'
+        '401':
+          $ref: '#/components/responses/Unauthorized'
+        '403':
+          $ref: '#/components/responses/Forbidden'
+        '404':
+          $ref: '#/components/responses/NotFound'
+        '409':
+          $ref: '#/components/responses/Conflict'
+        '422':
+          $ref: '#/components/responses/UnprocessableEntity'
+        '500':
+          $ref: '#/components/responses/InternalError'
+  /v1/git/summary:
+    get:
+      summary: Get repository status summary
+      parameters:
+        - $ref: '#/components/parameters/OriginHeader'
+        - $ref: '#/components/parameters/RepoPath'
+      responses:
+        '200':
+          description: Repository status summary
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/GitSummary'
+        '401':
+          $ref: '#/components/responses/Unauthorized'
+        '403':
+          $ref: '#/components/responses/Forbidden'
+        '409':
+          $ref: '#/components/responses/Conflict'
+        '422':
+          $ref: '#/components/responses/UnprocessableEntity'
+        '500':
+          $ref: '#/components/responses/InternalError'
   /v1/git/status:
     get:
       summary: Get repository status
@@ -309,6 +358,13 @@ components:
       required: true
       schema:
         type: string
+    IncludeRemote:
+      name: includeRemote
+      in: query
+      required: false
+      schema:
+        type: boolean
+        default: true
   schemas:
     MetaResponse:
       type: object
@@ -548,6 +604,81 @@ components:
           minimum: 0
         clean:
           type: boolean
+    GitSummary:
+      type: object
+      required:
+        - repoPath
+        - exists
+        - branch
+        - upstream
+        - ahead
+        - behind
+        - dirty
+        - staged
+        - unstaged
+        - untracked
+        - conflicts
+        - detached
+      properties:
+        repoPath:
+          type: string
+        exists:
+          type: boolean
+        branch:
+          type: string
+        upstream:
+          type: string
+          nullable: true
+        ahead:
+          type: integer
+          minimum: 0
+        behind:
+          type: integer
+          minimum: 0
+        dirty:
+          type: boolean
+        staged:
+          type: integer
+          minimum: 0
+        unstaged:
+          type: integer
+          minimum: 0
+        untracked:
+          type: integer
+          minimum: 0
+        conflicts:
+          type: integer
+          minimum: 0
+        detached:
+          type: boolean
+    GitBranchesResponse:
+      type: object
+      required:
+        - branches
+      properties:
+        branches:
+          type: array
+          items:
+            $ref: '#/components/schemas/GitBranch'
+    GitBranch:
+      type: object
+      required:
+        - name
+        - fullName
+        - type
+        - current
+      properties:
+        name:
+          type: string
+        fullName:
+          type: string
+        type:
+          type: string
+          enum: [local, remote]
+        current:
+          type: boolean
+        upstream:
+          type: string
     OsOpenRequest:
       type: object
       required:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-daemon",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "private": false,
   "type": "commonjs",
   "main": "dist/daemon.js",

package/src/app.ts

@@ -28,6 +28,8 @@ import {
   pairRequestSchema,
   gitCloneRequestSchema,
   gitFetchRequestSchema,
+  gitBranchesQuerySchema,
+  gitSummaryQuerySchema,
   gitStatusQuerySchema,
   osOpenRequestSchema,
   depsInstallRequestSchema,
@@ -41,6 +43,8 @@ import {
 import {
   cloneRepo,
   fetchRepo,
+  listRepoBranches,
+  getRepoSummary,
   getRepoStatus,
   RepoNotFoundError,
   resolveRepoPath,
@@ -335,6 +339,72 @@ export const createApp = (ctx: DaemonContext) => {
     },
   );
 
+  app.get(
+    "/v1/git/branches",
+    authGuard(ctx.tokenStore),
+    async (req, res, next) => {
+      try {
+        const payload = parseBody(gitBranchesQuerySchema, req.query);
+        const workspaceRoot = ensureWorkspaceRoot(ctx.config.workspaceRoot);
+        const includeRemote = payload.includeRemote !== "false";
+        const branches = await listRepoBranches(
+          workspaceRoot,
+          payload.repoPath,
+          {
+            includeRemote,
+          },
+        );
+        res.json({ branches });
+      } catch (err) {
+        if (
+          err instanceof RepoNotFoundError ||
+          err instanceof MissingPathError
+        ) {
+          next(repoNotFound());
+          return;
+        }
+        next(err);
+      }
+    },
+  );
+
+  app.get(
+    "/v1/git/summary",
+    authGuard(ctx.tokenStore),
+    async (req, res, next) => {
+      let payload: { repoPath: string } | undefined;
+      try {
+        payload = parseBody(gitSummaryQuerySchema, req.query);
+        const workspaceRoot = ensureWorkspaceRoot(ctx.config.workspaceRoot);
+        const summary = await getRepoSummary(workspaceRoot, payload.repoPath);
+        res.json(summary);
+      } catch (err) {
+        if (
+          (err instanceof RepoNotFoundError ||
+            err instanceof MissingPathError) &&
+          payload
+        ) {
+          res.json({
+            repoPath: payload.repoPath,
+            exists: false,
+            branch: "",
+            upstream: null,
+            ahead: 0,
+            behind: 0,
+            dirty: false,
+            staged: 0,
+            unstaged: 0,
+            untracked: 0,
+            conflicts: 0,
+            detached: false,
+          });
+          return;
+        }
+        next(err);
+      }
+    },
+  );
+
   app.get(
     "/v1/git/status",
     authGuard(ctx.tokenStore),

package/src/git.ts

@@ -15,6 +15,41 @@ export type GitStatus = {
   clean: boolean;
 };
 
+export type GitBranch = {
+  name: string;
+  fullName: string;
+  type: "local" | "remote";
+  current: boolean;
+  upstream?: string;
+};
+
+export type GitSummary = {
+  repoPath: string;
+  exists: boolean;
+  branch: string;
+  upstream: string | null;
+  ahead: number;
+  behind: number;
+  dirty: boolean;
+  staged: number;
+  unstaged: number;
+  untracked: number;
+  conflicts: number;
+  detached: boolean;
+};
+
+type GitStatusInfo = {
+  branch: string;
+  upstream: string | null;
+  ahead: number;
+  behind: number;
+  stagedCount: number;
+  unstagedCount: number;
+  untrackedCount: number;
+  conflictsCount: number;
+  detached: boolean;
+};
+
 export class RepoNotFoundError extends Error {}
 
 export const cloneRepo = async (
@@ -76,6 +111,64 @@ export const getRepoStatus = async (
   return parseStatus(result.stdout);
 };
 
+export const getRepoSummary = async (
+  workspaceRoot: string,
+  repoPath: string,
+): Promise<GitSummary> => {
+  const resolved = await resolveRepoPath(workspaceRoot, repoPath);
+  const { execa } = await import("execa");
+  const result = await execa("git", [
+    "-C",
+    resolved,
+    "status",
+    "--porcelain=2",
+    "-b",
+  ]);
+  const info = parseStatusInfo(result.stdout);
+  const dirty =
+    info.stagedCount > 0 ||
+    info.unstagedCount > 0 ||
+    info.untrackedCount > 0 ||
+    info.conflictsCount > 0;
+  const upstream = info.detached ? null : info.upstream;
+  return {
+    repoPath,
+    exists: true,
+    branch: info.branch,
+    upstream,
+    ahead: upstream ? info.ahead : 0,
+    behind: upstream ? info.behind : 0,
+    dirty,
+    staged: info.stagedCount,
+    unstaged: info.unstagedCount,
+    untracked: info.untrackedCount,
+    conflicts: info.conflictsCount,
+    detached: info.detached,
+  };
+};
+
+export const listRepoBranches = async (
+  workspaceRoot: string,
+  repoPath: string,
+  options?: { includeRemote?: boolean },
+): Promise<GitBranch[]> => {
+  const resolved = await resolveRepoPath(workspaceRoot, repoPath);
+  const includeRemote = options?.includeRemote ?? true;
+  const { execa } = await import("execa");
+  const refs = ["refs/heads"];
+  if (includeRemote) {
+    refs.push("refs/remotes");
+  }
+  const result = await execa("git", [
+    "-C",
+    resolved,
+    "for-each-ref",
+    "--format=%(refname)\t%(refname:short)\t%(objectname)\t%(HEAD)\t%(upstream:short)",
+    ...refs,
+  ]);
+  return parseBranches(result.stdout);
+};
+
 export const resolveRepoPath = async (
   workspaceRoot: string,
   repoPath: string,
@@ -99,7 +192,29 @@ const assertRepoExists = async (repoPath: string) => {
 };
 
 const parseStatus = (output: string): GitStatus => {
-  let branch = "";
+  const info = parseStatusInfo(output);
+  const clean =
+    info.stagedCount === 0 &&
+    info.unstagedCount === 0 &&
+    info.untrackedCount === 0 &&
+    info.conflictsCount === 0;
+
+  return {
+    branch: info.branch,
+    ahead: info.ahead,
+    behind: info.behind,
+    stagedCount: info.stagedCount,
+    unstagedCount: info.unstagedCount,
+    untrackedCount: info.untrackedCount,
+    conflictsCount: info.conflictsCount,
+    clean,
+  };
+};
+
+const parseStatusInfo = (output: string): GitStatusInfo => {
+  let head = "";
+  let oid = "";
+  let upstream: string | null = null;
   let ahead = 0;
   let behind = 0;
   let stagedCount = 0;
@@ -110,7 +225,16 @@ const parseStatus = (output: string): GitStatus => {
   const lines = output.split(/\r?\n/);
   for (const line of lines) {
     if (line.startsWith("# branch.head")) {
-      branch = line.split(" ").slice(2).join(" ").trim();
+      head = line.split(" ").slice(2).join(" ").trim();
+      continue;
+    }
+    if (line.startsWith("# branch.oid")) {
+      oid = line.split(" ").slice(2).join(" ").trim();
+      continue;
+    }
+    if (line.startsWith("# branch.upstream")) {
+      const value = line.split(" ").slice(2).join(" ").trim();
+      upstream = value.length > 0 ? value : null;
       continue;
     }
     if (line.startsWith("# branch.ab")) {
@@ -141,20 +265,51 @@ const parseStatus = (output: string): GitStatus => {
     }
   }
 
-  const clean =
-    stagedCount === 0 &&
-    unstagedCount === 0 &&
-    untrackedCount === 0 &&
-    conflictsCount === 0;
+  const detached = head === "(detached)";
+  let branch = head;
+  if (detached) {
+    branch = oid || head;
+    upstream = null;
+  }
 
   return {
     branch,
+    upstream,
     ahead,
     behind,
     stagedCount,
     unstagedCount,
     untrackedCount,
     conflictsCount,
-    clean,
+    detached,
   };
 };
+
+const parseBranches = (output: string): GitBranch[] => {
+  const branches: GitBranch[] = [];
+  const lines = output.split(/\r?\n/);
+  for (const line of lines) {
+    if (!line) {
+      continue;
+    }
+    const [fullName, shortName, , headFlag, upstream] = line.split("\t");
+    if (!fullName || !shortName) {
+      continue;
+    }
+    if (fullName.startsWith("refs/remotes/") && fullName.endsWith("/HEAD")) {
+      continue;
+    }
+    const type = fullName.startsWith("refs/heads/") ? "local" : "remote";
+    const branch: GitBranch = {
+      name: shortName,
+      fullName,
+      type,
+      current: headFlag === "*",
+    };
+    if (upstream) {
+      branch.upstream = upstream;
+    }
+    branches.push(branch);
+  }
+  return branches;
+};

package/src/validation.ts

@@ -56,6 +56,15 @@ export const gitStatusQuerySchema = z.object({
   repoPath: z.string().min(1).max(MAX_PATH_LENGTH),
 });
 
+export const gitSummaryQuerySchema = z.object({
+  repoPath: z.string().min(1).max(MAX_PATH_LENGTH),
+});
+
+export const gitBranchesQuerySchema = z.object({
+  repoPath: z.string().min(1).max(MAX_PATH_LENGTH),
+  includeRemote: z.enum(["true", "false"]).optional(),
+});
+
 export const osOpenRequestSchema = z.object({
   target: z.enum(["folder", "terminal", "vscode"]),
   path: z.string().min(1).max(MAX_PATH_LENGTH),

package/tests/app.test.ts

@@ -4,6 +4,7 @@ import path from "path";
 import os from "os";
 import { promises as fs } from "fs";
 import pino from "pino";
+import { execa } from "execa";
 import { createApp, type DaemonContext } from "../src/app";
 import { TokenStore } from "../src/tokens";
 import { PairingManager } from "../src/pairing";
@@ -13,6 +14,32 @@ import type { AppConfig } from "../src/types";
 const createTempDir = async () =>
   fs.mkdtemp(path.join(os.tmpdir(), "git-daemon-test-"));
 
+const runGit = async (cwd: string, args: string[]) => {
+  await execa("git", args, { cwd });
+};
+
+const setupRepoWithRemote = async (workspaceRoot: string) => {
+  const repoDir = path.join(workspaceRoot, "repo");
+  const remoteDir = path.join(workspaceRoot, "remote.git");
+  await fs.mkdir(repoDir, { recursive: true });
+  await runGit(repoDir, ["init", "-b", "main"]);
+  await runGit(repoDir, ["config", "user.email", "test@example.com"]);
+  await runGit(repoDir, ["config", "user.name", "Test User"]);
+  await fs.writeFile(path.join(repoDir, "README.md"), "hello");
+  await runGit(repoDir, ["add", "README.md"]);
+  await runGit(repoDir, ["commit", "-m", "init"]);
+  await runGit(workspaceRoot, ["init", "--bare", remoteDir]);
+  await runGit(repoDir, ["remote", "add", "origin", remoteDir]);
+  await runGit(repoDir, ["push", "-u", "origin", "main"]);
+  await runGit(repoDir, ["checkout", "-b", "feature"]);
+  await fs.writeFile(path.join(repoDir, "feature.txt"), "feature");
+  await runGit(repoDir, ["add", "feature.txt"]);
+  await runGit(repoDir, ["commit", "-m", "feature"]);
+  await runGit(repoDir, ["push", "-u", "origin", "feature"]);
+  await runGit(repoDir, ["fetch", "origin"]);
+  return { repoPath: "repo" };
+};
+
 const createConfig = (
   workspaceRoot: string | null,
   origin: string,
@@ -119,4 +146,88 @@ describe("Git Daemon API", () => {
     expect(res.status).toBe(422);
     expect(res.body.errorCode).toBe("invalid_repo_url");
   });
+
+  it("lists branches including remotes by default", async () => {
+    const workspaceRoot = await createTempDir();
+    const { repoPath } = await setupRepoWithRemote(workspaceRoot);
+    const { app, ctx } = await createContext(workspaceRoot, origin);
+    const { token } = await ctx.tokenStore.issueToken(origin, 30);
+
+    const res = await request(app)
+      .get("/v1/git/branches")
+      .query({ repoPath })
+      .set("Origin", origin)
+      .set("Host", "127.0.0.1")
+      .set("Authorization", `Bearer ${token}`);
+
+    expect(res.status).toBe(200);
+    const branches = res.body.branches as Array<{
+      name: string;
+      type: "local" | "remote";
+      current: boolean;
+    }>;
+    const names = branches.map((branch) => branch.name);
+    expect(names).toEqual(
+      expect.arrayContaining([
+        "main",
+        "feature",
+        "origin/main",
+        "origin/feature",
+      ]),
+    );
+    const current = branches.find((branch) => branch.current);
+    expect(current?.name).toBe("feature");
+    const originMain = branches.find((branch) => branch.name === "origin/main");
+    expect(originMain?.type).toBe("remote");
+  });
+
+  it("returns a UI-friendly status summary", async () => {
+    const workspaceRoot = await createTempDir();
+    const { repoPath } = await setupRepoWithRemote(workspaceRoot);
+    const repoDir = path.join(workspaceRoot, repoPath);
+    await fs.writeFile(path.join(repoDir, "scratch.txt"), "dirty");
+    const { app, ctx } = await createContext(workspaceRoot, origin);
+    const { token } = await ctx.tokenStore.issueToken(origin, 30);
+
+    const res = await request(app)
+      .get("/v1/git/summary")
+      .query({ repoPath })
+      .set("Origin", origin)
+      .set("Host", "127.0.0.1")
+      .set("Authorization", `Bearer ${token}`);
+
+    expect(res.status).toBe(200);
+    expect(res.body.repoPath).toBe(repoPath);
+    expect(res.body.exists).toBe(true);
+    expect(res.body.branch).toBe("feature");
+    expect(res.body.upstream).toBe("origin/feature");
+    expect(res.body.ahead).toBe(0);
+    expect(res.body.behind).toBe(0);
+    expect(res.body.dirty).toBe(true);
+    expect(res.body.untracked).toBe(1);
+    expect(res.body.staged).toBe(0);
+    expect(res.body.unstaged).toBe(0);
+    expect(res.body.conflicts).toBe(0);
+    expect(res.body.detached).toBe(false);
+  });
+
+  it("returns exists false when summary repo is missing", async () => {
+    const workspaceRoot = await createTempDir();
+    const { app, ctx } = await createContext(workspaceRoot, origin);
+    const { token } = await ctx.tokenStore.issueToken(origin, 30);
+
+    const res = await request(app)
+      .get("/v1/git/summary")
+      .query({ repoPath: "missing" })
+      .set("Origin", origin)
+      .set("Host", "127.0.0.1")
+      .set("Authorization", `Bearer ${token}`);
+
+    expect(res.status).toBe(200);
+    expect(res.body.exists).toBe(false);
+    expect(res.body.branch).toBe("");
+    expect(res.body.dirty).toBe(false);
+    expect(res.body.ahead).toBe(0);
+    expect(res.body.behind).toBe(0);
+  });
 });