git-daemon 0.1.0

package/src/deps.ts

@@ -0,0 +1,134 @@
+import path from "path";
+import { promises as fs } from "fs";
+import type { JobContext } from "./jobs";
+import { runCommand } from "./process";
+import { resolveInsideWorkspace } from "./workspace";
+import { isToolInstalled } from "./tools";
+
+export type DepsRequest = {
+  repoPath: string;
+  manager: "auto" | "npm" | "pnpm" | "yarn";
+  mode: "auto" | "ci" | "install";
+  safer: boolean;
+};
+
+export const installDeps = async (
+  ctx: JobContext,
+  workspaceRoot: string,
+  request: DepsRequest,
+) => {
+  const repoPath = await resolveInsideWorkspace(
+    workspaceRoot,
+    request.repoPath,
+  );
+  await fs.access(path.join(repoPath, "package.json"));
+
+  const manager = await selectManager(repoPath, request.manager);
+  const { command, args } = await buildInstallCommand(
+    repoPath,
+    manager,
+    request.mode,
+    request.safer,
+  );
+
+  ctx.progress({ kind: "deps", detail: `${command} ${args.join(" ")}` });
+  await runCommand(ctx, command, args, { cwd: repoPath });
+};
+
+const selectManager = async (
+  repoPath: string,
+  requested: DepsRequest["manager"],
+) => {
+  if (requested !== "auto") {
+    const installed = await isToolInstalled(requested);
+    if (!installed) {
+      throw new Error(`${requested} is not installed.`);
+    }
+    return requested;
+  }
+
+  const packageManager = await readPackageManager(repoPath);
+  if (packageManager) {
+    const name = packageManager.split("@")[0];
+    if (name === "pnpm" || name === "yarn" || name === "npm") {
+      const installed = await isToolInstalled(name);
+      if (installed) {
+        return name;
+      }
+    }
+  }
+
+  if (await fileExists(path.join(repoPath, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (await fileExists(path.join(repoPath, "yarn.lock"))) {
+    return "yarn";
+  }
+  if (await fileExists(path.join(repoPath, "package-lock.json"))) {
+    return "npm";
+  }
+  return "npm";
+};
+
+const readPackageManager = async (repoPath: string) => {
+  try {
+    const raw = await fs.readFile(path.join(repoPath, "package.json"), "utf8");
+    const parsed = JSON.parse(raw) as { packageManager?: string };
+    return parsed.packageManager;
+  } catch {
+    return null;
+  }
+};
+
+const buildInstallCommand = async (
+  repoPath: string,
+  manager: "npm" | "pnpm" | "yarn",
+  mode: "auto" | "ci" | "install",
+  safer: boolean,
+) => {
+  const lockfileExists = await hasAnyLockfile(repoPath);
+  const useCi = mode === "ci" || (mode === "auto" && lockfileExists);
+
+  if (manager === "pnpm") {
+    const args = ["install"];
+    if (useCi) {
+      args.push("--frozen-lockfile");
+    }
+    if (safer) {
+      args.push("--ignore-scripts");
+    }
+    return { command: "pnpm", args };
+  }
+
+  if (manager === "yarn") {
+    const args = ["install"];
+    const isBerry = await fileExists(path.join(repoPath, ".yarnrc.yml"));
+    if (useCi || isBerry) {
+      args.push("--immutable");
+    }
+    if (safer) {
+      args.push("--ignore-scripts");
+    }
+    return { command: "yarn", args };
+  }
+
+  const args = [useCi ? "ci" : "install"];
+  if (safer) {
+    args.push("--ignore-scripts");
+  }
+  return { command: "npm", args };
+};
+
+const hasAnyLockfile = async (repoPath: string) =>
+  (await fileExists(path.join(repoPath, "pnpm-lock.yaml"))) ||
+  (await fileExists(path.join(repoPath, "yarn.lock"))) ||
+  (await fileExists(path.join(repoPath, "package-lock.json")));
+
+const fileExists = async (target: string) => {
+  try {
+    await fs.access(target);
+    return true;
+  } catch {
+    return false;
+  }
+};

package/src/errors.ts

@@ -0,0 +1,76 @@
+import type { ApiErrorBody } from "./types";
+
+export class ApiError extends Error {
+  readonly status: number;
+  readonly body: ApiErrorBody;
+
+  constructor(status: number, body: ApiErrorBody) {
+    super(body.message);
+    this.status = status;
+    this.body = body;
+  }
+}
+
+export const errorBody = (
+  errorCode: ApiErrorBody["errorCode"],
+  message: string,
+  details?: Record<string, unknown>,
+): ApiErrorBody => ({
+  errorCode,
+  message,
+  ...(details ? { details } : {}),
+});
+
+export const authRequired = () =>
+  new ApiError(401, errorBody("auth_required", "Bearer token required."));
+
+export const authInvalid = () =>
+  new ApiError(
+    401,
+    errorBody("auth_invalid", "Bearer token invalid or expired."),
+  );
+
+export const originNotAllowed = () =>
+  new ApiError(403, errorBody("origin_not_allowed", "Origin not allowed."));
+
+export const rateLimited = () =>
+  new ApiError(429, errorBody("rate_limited", "Too many requests."));
+
+export const workspaceRequired = () =>
+  new ApiError(
+    409,
+    errorBody("workspace_required", "Workspace root not configured."),
+  );
+
+export const pathOutsideWorkspace = () =>
+  new ApiError(
+    409,
+    errorBody("path_outside_workspace", "Path is outside the workspace root."),
+  );
+
+export const invalidRepoUrl = () =>
+  new ApiError(
+    422,
+    errorBody("invalid_repo_url", "Repository URL is invalid."),
+  );
+
+export const capabilityNotGranted = () =>
+  new ApiError(
+    409,
+    errorBody("capability_not_granted", "Capability approval required."),
+  );
+
+export const jobNotFound = () =>
+  new ApiError(404, errorBody("job_not_found", "Job not found."));
+
+export const repoNotFound = () =>
+  new ApiError(404, errorBody("internal_error", "Repository not found."));
+
+export const pathNotFound = () =>
+  new ApiError(404, errorBody("internal_error", "Path not found."));
+
+export const timeoutError = () =>
+  new ApiError(500, errorBody("timeout", "Job timed out."));
+
+export const internalError = (message = "Unexpected error.") =>
+  new ApiError(500, errorBody("internal_error", message));

package/src/git.ts

@@ -0,0 +1,160 @@
+import path from "path";
+import { promises as fs } from "fs";
+import type { JobContext } from "./jobs";
+import { runCommand } from "./process";
+import { resolveInsideWorkspace, ensureRelative } from "./workspace";
+
+export type GitStatus = {
+  branch: string;
+  ahead: number;
+  behind: number;
+  stagedCount: number;
+  unstagedCount: number;
+  untrackedCount: number;
+  conflictsCount: number;
+  clean: boolean;
+};
+
+export class RepoNotFoundError extends Error {}
+
+export const cloneRepo = async (
+  ctx: JobContext,
+  workspaceRoot: string,
+  repoUrl: string,
+  destRelative: string,
+  options?: { branch?: string; depth?: number },
+) => {
+  ensureRelative(destRelative);
+  const destPath = await resolveInsideWorkspace(
+    workspaceRoot,
+    destRelative,
+    true,
+  );
+
+  const args = ["clone", repoUrl, destPath];
+  if (options?.branch) {
+    args.splice(1, 0, "--branch", options.branch);
+  }
+  if (options?.depth) {
+    args.splice(1, 0, "--depth", options.depth.toString());
+  }
+
+  await runCommand(ctx, "git", args, { cwd: workspaceRoot });
+};
+
+export const fetchRepo = async (
+  ctx: JobContext,
+  workspaceRoot: string,
+  repoPath: string,
+  remote = "origin",
+  prune = false,
+) => {
+  const resolved = await resolveRepoPath(workspaceRoot, repoPath);
+
+  const args = ["-C", resolved, "fetch", remote];
+  if (prune) {
+    args.push("--prune");
+  }
+
+  await runCommand(ctx, "git", args);
+};
+
+export const getRepoStatus = async (
+  workspaceRoot: string,
+  repoPath: string,
+): Promise<GitStatus> => {
+  const resolved = await resolveRepoPath(workspaceRoot, repoPath);
+
+  const { execa } = await import("execa");
+  const result = await execa("git", [
+    "-C",
+    resolved,
+    "status",
+    "--porcelain=2",
+    "-b",
+  ]);
+  return parseStatus(result.stdout);
+};
+
+export const resolveRepoPath = async (
+  workspaceRoot: string,
+  repoPath: string,
+) => {
+  const resolved = await resolveInsideWorkspace(workspaceRoot, repoPath);
+  await assertRepoExists(resolved);
+  return resolved;
+};
+
+const assertRepoExists = async (repoPath: string) => {
+  const stats = await fs.stat(repoPath);
+  if (!stats.isDirectory()) {
+    throw new RepoNotFoundError("Repository path is not a directory.");
+  }
+  const gitPath = path.join(repoPath, ".git");
+  try {
+    await fs.access(gitPath);
+  } catch {
+    throw new RepoNotFoundError("Repository .git directory not found.");
+  }
+};
+
+const parseStatus = (output: string): GitStatus => {
+  let branch = "";
+  let ahead = 0;
+  let behind = 0;
+  let stagedCount = 0;
+  let unstagedCount = 0;
+  let untrackedCount = 0;
+  let conflictsCount = 0;
+
+  const lines = output.split(/\r?\n/);
+  for (const line of lines) {
+    if (line.startsWith("# branch.head")) {
+      branch = line.split(" ").slice(2).join(" ").trim();
+      continue;
+    }
+    if (line.startsWith("# branch.ab")) {
+      const parts = line.split(" ");
+      const aheadPart = parts.find((part) => part.startsWith("+"));
+      const behindPart = parts.find((part) => part.startsWith("-"));
+      ahead = aheadPart ? Number(aheadPart.slice(1)) : 0;
+      behind = behindPart ? Number(behindPart.slice(1)) : 0;
+      continue;
+    }
+    if (line.startsWith("?")) {
+      untrackedCount += 1;
+      continue;
+    }
+    if (line.startsWith("u")) {
+      conflictsCount += 1;
+      continue;
+    }
+    if (line.startsWith("1 ") || line.startsWith("2 ")) {
+      const x = line[2];
+      const y = line[3];
+      if (x && x !== ".") {
+        stagedCount += 1;
+      }
+      if (y && y !== ".") {
+        unstagedCount += 1;
+      }
+    }
+  }
+
+  const clean =
+    stagedCount === 0 &&
+    unstagedCount === 0 &&
+    untrackedCount === 0 &&
+    conflictsCount === 0;
+
+  return {
+    branch,
+    ahead,
+    behind,
+    stagedCount,
+    unstagedCount,
+    untrackedCount,
+    conflictsCount,
+    clean,
+  };
+};

package/src/jobs.ts

@@ -0,0 +1,194 @@
+import { EventEmitter } from "events";
+import crypto from "crypto";
+import type { ApiErrorBody, JobEvent, JobState, JobStatus } from "./types";
+import { timeoutError } from "./errors";
+
+const MAX_EVENTS = 2000;
+
+export type JobContext = {
+  logStdout: (line: string) => void;
+  logStderr: (line: string) => void;
+  progress: (event: Omit<JobEvent, "type"> & { type?: "progress" }) => void;
+  setCancel: (cancel: () => Promise<void>) => void;
+  isCancelled: () => boolean;
+};
+
+export type JobRunner = (ctx: JobContext) => Promise<void>;
+
+export class Job {
+  readonly id: string;
+  state: JobState = "queued";
+  createdAt = new Date().toISOString();
+  startedAt?: string;
+  finishedAt?: string;
+  error?: ApiErrorBody;
+  events: JobEvent[] = [];
+  readonly emitter = new EventEmitter();
+  cancelRequested = false;
+  private cancelFn?: () => Promise<void>;
+
+  constructor() {
+    this.id = crypto.randomUUID();
+  }
+
+  setCancel(fn: () => Promise<void>) {
+    this.cancelFn = fn;
+  }
+
+  async cancel() {
+    this.cancelRequested = true;
+    if (this.cancelFn) {
+      await this.cancelFn();
+    }
+  }
+
+  emit(event: JobEvent) {
+    this.events.push(event);
+    if (this.events.length > MAX_EVENTS) {
+      this.events.shift();
+    }
+    this.emitter.emit("event", event);
+  }
+
+  snapshot(): JobStatus {
+    return {
+      id: this.id,
+      state: this.state,
+      createdAt: this.createdAt,
+      startedAt: this.startedAt,
+      finishedAt: this.finishedAt,
+      error: this.error,
+    };
+  }
+}
+
+export class JobManager {
+  private readonly maxConcurrent: number;
+  private readonly timeoutMs: number;
+  private running = 0;
+  private readonly queue: { job: Job; run: JobRunner }[] = [];
+  private readonly jobs = new Map<string, Job>();
+  private readonly history: Job[] = [];
+
+  constructor(maxConcurrent: number, timeoutSeconds: number) {
+    this.maxConcurrent = maxConcurrent;
+    this.timeoutMs = timeoutSeconds * 1000;
+  }
+
+  enqueue(run: JobRunner): Job {
+    const job = new Job();
+    this.jobs.set(job.id, job);
+    this.queue.push({ job, run });
+    this.track(job);
+    this.drain();
+    return job;
+  }
+
+  get(id: string) {
+    return this.jobs.get(id);
+  }
+
+  cancel(id: string) {
+    const queuedIndex = this.queue.findIndex((entry) => entry.job.id === id);
+    if (queuedIndex >= 0) {
+      const [entry] = this.queue.splice(queuedIndex, 1);
+      entry.job.state = "cancelled";
+      entry.job.finishedAt = new Date().toISOString();
+      entry.job.emit({ type: "state", state: "cancelled" });
+      return true;
+    }
+
+    const runningJob = this.jobs.get(id);
+    if (!runningJob) {
+      return false;
+    }
+    if (runningJob.state !== "running") {
+      return false;
+    }
+    void runningJob.cancel();
+    runningJob.state = "cancelled";
+    runningJob.finishedAt = new Date().toISOString();
+    runningJob.emit({ type: "state", state: "cancelled" });
+    return true;
+  }
+
+  listRecent() {
+    return this.history.map((job) => job.snapshot());
+  }
+
+  private track(job: Job) {
+    this.history.push(job);
+    if (this.history.length > 100) {
+      this.history.shift();
+    }
+  }
+
+  private drain() {
+    while (this.running < this.maxConcurrent && this.queue.length > 0) {
+      const entry = this.queue.shift();
+      if (!entry) {
+        return;
+      }
+      this.runJob(entry.job, entry.run);
+    }
+  }
+
+  private runJob(job: Job, run: JobRunner) {
+    this.running += 1;
+    job.state = "running";
+    job.startedAt = new Date().toISOString();
+    job.emit({ type: "state", state: "running" });
+
+    let timeoutHandle: NodeJS.Timeout | undefined;
+
+    if (this.timeoutMs > 0) {
+      timeoutHandle = setTimeout(async () => {
+        if (job.state !== "running") {
+          return;
+        }
+        job.error = timeoutError().body;
+        await job.cancel();
+        job.state = "error";
+        job.finishedAt = new Date().toISOString();
+        job.emit({ type: "state", state: "error", message: "Timed out" });
+      }, this.timeoutMs);
+    }
+
+    const ctx: JobContext = {
+      logStdout: (line) => job.emit({ type: "log", stream: "stdout", line }),
+      logStderr: (line) => job.emit({ type: "log", stream: "stderr", line }),
+      progress: (event) => job.emit({ ...event, type: "progress" }),
+      setCancel: (fn) => job.setCancel(fn),
+      isCancelled: () => job.cancelRequested,
+    };
+
+    run(ctx)
+      .then(() => {
+        if (job.state !== "running") {
+          return;
+        }
+        job.state = "done";
+        job.finishedAt = new Date().toISOString();
+        job.emit({ type: "state", state: "done" });
+      })
+      .catch((err: unknown) => {
+        if (job.state !== "running") {
+          return;
+        }
+        job.state = "error";
+        job.finishedAt = new Date().toISOString();
+        job.error = {
+          errorCode: "internal_error",
+          message: err instanceof Error ? err.message : "Job failed.",
+        };
+        job.emit({ type: "state", state: "error", message: job.error.message });
+      })
+      .finally(() => {
+        if (timeoutHandle) {
+          clearTimeout(timeoutHandle);
+        }
+        this.running -= 1;
+        this.drain();
+      });
+  }
+}

package/src/logger.ts

@@ -0,0 +1,26 @@
+import path from "path";
+import { promises as fs } from "fs";
+import pino from "pino";
+import pinoHttp from "pino-http";
+import type { Logger } from "pino";
+import rfs from "rotating-file-stream";
+import type { AppConfig } from "./types";
+
+export const createLogger = async (
+  configDir: string,
+  logging: AppConfig["logging"],
+  enabled = true,
+): Promise<Logger> => {
+  const logDir = path.join(configDir, logging.directory);
+  await fs.mkdir(logDir, { recursive: true });
+
+  const stream = rfs.createStream("daemon.log", {
+    size: `${logging.maxBytes}B`,
+    maxFiles: logging.maxFiles,
+    path: logDir,
+  });
+
+  return pino({ enabled }, stream);
+};
+
+export const createHttpLogger = (logger: Logger) => pinoHttp({ logger });

package/src/os.ts

@@ -0,0 +1,45 @@
+import { execa } from "execa";
+
+export const openTarget = async (
+  target: "folder" | "terminal" | "vscode",
+  resolvedPath: string,
+) => {
+  const platform = process.platform;
+
+  if (target === "folder") {
+    if (platform === "darwin") {
+      await execa("open", [resolvedPath]);
+      return;
+    }
+    if (platform === "win32") {
+      await execa("cmd", ["/c", "start", "", resolvedPath]);
+      return;
+    }
+    await execa("xdg-open", [resolvedPath]);
+    return;
+  }
+
+  if (target === "terminal") {
+    if (platform === "darwin") {
+      await execa("open", ["-a", "Terminal", resolvedPath]);
+      return;
+    }
+    if (platform === "win32") {
+      await execa("cmd", [
+        "/c",
+        "start",
+        "",
+        "cmd.exe",
+        "/k",
+        "cd",
+        "/d",
+        resolvedPath,
+      ]);
+      return;
+    }
+    await execa("x-terminal-emulator", ["--working-directory", resolvedPath]);
+    return;
+  }
+
+  await execa("code", [resolvedPath]);
+};

package/src/pairing.ts

@@ -0,0 +1,52 @@
+import crypto from "crypto";
+import type { TokenStore } from "./tokens";
+
+const PAIRING_TTL_MS = 10 * 60 * 1000;
+
+export class PairingManager {
+  private readonly tokenStore: TokenStore;
+  private readonly ttlDays: number;
+  private readonly codes = new Map<
+    string,
+    { code: string; expiresAt: number }
+  >();
+
+  constructor(tokenStore: TokenStore, ttlDays: number) {
+    this.tokenStore = tokenStore;
+    this.ttlDays = ttlDays;
+  }
+
+  start(origin: string) {
+    const code = crypto.randomBytes(4).toString("hex");
+    const expiresAt = Date.now() + PAIRING_TTL_MS;
+    this.codes.set(origin, { code, expiresAt });
+
+    return {
+      step: "start" as const,
+      instructions:
+        "Enter this code in the Git Daemon pairing prompt within 10 minutes.",
+      code,
+      expiresAt: new Date(expiresAt).toISOString(),
+    };
+  }
+
+  async confirm(origin: string, code: string) {
+    const entry = this.codes.get(origin);
+    if (!entry || entry.code !== code || entry.expiresAt < Date.now()) {
+      return null;
+    }
+
+    this.codes.delete(origin);
+    const { token, expiresAt } = await this.tokenStore.issueToken(
+      origin,
+      this.ttlDays,
+    );
+
+    return {
+      step: "confirm" as const,
+      accessToken: token,
+      tokenType: "Bearer" as const,
+      expiresAt,
+    };
+  }
+}