git-daemon 0.1.1 → 0.1.3

package/dist/workspace.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureRelative = exports.resolveInsideWorkspace = exports.ensureWorkspaceRoot = exports.MissingPathError = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const errors_1 = require("./errors");
+class MissingPathError extends Error {
+}
+exports.MissingPathError = MissingPathError;
+const MAX_PATH_LENGTH = 4096;
+const ensureWorkspaceRoot = (root) => {
+    if (!root) {
+        throw (0, errors_1.workspaceRequired)();
+    }
+    if (root.length > MAX_PATH_LENGTH) {
+        throw (0, errors_1.pathOutsideWorkspace)();
+    }
+    return root;
+};
+exports.ensureWorkspaceRoot = ensureWorkspaceRoot;
+const realpathSafe = async (target) => {
+    try {
+        return await fs_1.promises.realpath(target);
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            return null;
+        }
+        throw err;
+    }
+};
+const resolveInsideWorkspace = async (workspaceRoot, candidate, allowMissing = false) => {
+    if (candidate.length > MAX_PATH_LENGTH) {
+        throw (0, errors_1.pathOutsideWorkspace)();
+    }
+    const rootReal = await fs_1.promises.realpath(workspaceRoot);
+    const resolved = path_1.default.resolve(rootReal, candidate);
+    if (!isInside(rootReal, resolved)) {
+        throw (0, errors_1.pathOutsideWorkspace)();
+    }
+    const realResolved = await realpathSafe(resolved);
+    if (realResolved) {
+        if (!isInside(rootReal, realResolved)) {
+            throw (0, errors_1.pathOutsideWorkspace)();
+        }
+        return realResolved;
+    }
+    if (!allowMissing) {
+        throw new MissingPathError("Path does not exist.");
+    }
+    const parent = path_1.default.dirname(resolved);
+    const parentReal = await realpathSafe(parent);
+    if (parentReal && !isInside(rootReal, parentReal)) {
+        throw (0, errors_1.pathOutsideWorkspace)();
+    }
+    return resolved;
+};
+exports.resolveInsideWorkspace = resolveInsideWorkspace;
+const isInside = (root, candidate) => {
+    const relative = path_1.default.relative(root, candidate);
+    if (relative === "") {
+        return true;
+    }
+    return !relative.startsWith("..") && !path_1.default.isAbsolute(relative);
+};
+const ensureRelative = (target) => {
+    if (path_1.default.isAbsolute(target)) {
+        throw (0, errors_1.pathOutsideWorkspace)();
+    }
+    const normalized = path_1.default.normalize(target);
+    if (normalized === "." || normalized.startsWith("..")) {
+        throw (0, errors_1.pathOutsideWorkspace)();
+    }
+    return target;
+};
+exports.ensureRelative = ensureRelative;

package/openapi.yaml

@@ -6,7 +6,7 @@ info:
     Localhost API for the Git Daemon. All requests must include an Origin header
     that matches the allowlist. Non-public endpoints require a Bearer token.
 servers:
-  - url: http://127.0.0.1:8787
+  - url: http://127.0.0.1:8790
 security:
   - bearerAuth: []
 paths:

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "git-daemon",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "private": false,
   "type": "commonjs",
   "main": "dist/daemon.js",
   "scripts": {
     "build": "tsc",
     "daemon": "tsx src/daemon.ts",
+    "daemon:setup": "tsx src/setup.ts",
     "test": "vitest run",
     "test:watch": "vitest",
+    "test:clone": "tsx src/cli-test-clone.ts",
     "lint": "eslint . --ext .ts",
     "lint:fix": "eslint . --ext .ts --fix"
   },
@@ -19,6 +21,7 @@
     "express-rate-limit": "^7.4.0",
     "pino": "^9.3.2",
     "pino-http": "^9.0.0",
+    "pino-pretty": "^13.0.0",
     "rotating-file-stream": "^3.2.5",
     "tree-kill": "^1.2.2",
     "zod": "^3.23.8"

package/src/app.ts

@@ -198,11 +198,34 @@ export const createApp = (ctx: DaemonContext) => {
         res.write(`data: ${JSON.stringify(event)}\n\n`);
       };
 
+      const isTerminalState = (event: unknown) => {
+        if (!event || typeof event !== "object") {
+          return false;
+        }
+        const record = event as { type?: string; state?: string };
+        return (
+          record.type === "state" &&
+          (record.state === "done" ||
+            record.state === "error" ||
+            record.state === "cancelled")
+        );
+      };
+
       for (const event of job.events) {
         sendEvent(event);
+        if (isTerminalState(event)) {
+          res.end();
+          return;
+        }
       }
 
-      const listener = (event: unknown) => sendEvent(event);
+      const listener = (event: unknown) => {
+        sendEvent(event);
+        if (isTerminalState(event)) {
+          job.emitter.off("event", listener);
+          res.end();
+        }
+      };
       job.emitter.on("event", listener);
 
       req.on("close", () => {

package/src/cli-test-clone.ts

@@ -0,0 +1,154 @@
+import http from "http";
+
+const getEnv = (key: string, fallback: string) => process.env[key] || fallback;
+
+const ORIGIN = getEnv("ORIGIN", "https://app.example.com");
+const PORT = Number(getEnv("PORT", "8790"));
+const BASE = `http://127.0.0.1:${PORT}`;
+const REPO = getEnv("REPO_URL", "git@github.com:bunnybones1/git-daemon.git");
+const DEST = getEnv("DEST_RELATIVE", "bunnybones1/git-daemon");
+
+const asRecord = (value: unknown): Record<string, unknown> | null =>
+  value && typeof value === "object"
+    ? (value as Record<string, unknown>)
+    : null;
+
+const getString = (value: unknown): string | null =>
+  typeof value === "string" ? value : null;
+
+const requestJson = (path: string, body: unknown) =>
+  new Promise<{ status: number; data: unknown }>((resolve, reject) => {
+    const payload = JSON.stringify(body);
+    const req = http.request(
+      `${BASE}${path}`,
+      {
+        method: "POST",
+        headers: {
+          Origin: ORIGIN,
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(payload),
+        },
+      },
+      (res) => {
+        let raw = "";
+        res.setEncoding("utf8");
+        res.on("data", (chunk) => {
+          raw += chunk;
+        });
+        res.on("end", () => {
+          try {
+            const data = raw ? JSON.parse(raw) : {};
+            resolve({ status: res.statusCode || 0, data });
+          } catch (err) {
+            reject(err);
+          }
+        });
+      },
+    );
+
+    req.on("error", reject);
+    req.write(payload);
+    req.end();
+  });
+
+const requestJsonAuth = (path: string, token: string, body: unknown) =>
+  new Promise<{ status: number; data: unknown }>((resolve, reject) => {
+    const payload = JSON.stringify(body);
+    const req = http.request(
+      `${BASE}${path}`,
+      {
+        method: "POST",
+        headers: {
+          Origin: ORIGIN,
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(payload),
+        },
+      },
+      (res) => {
+        let raw = "";
+        res.setEncoding("utf8");
+        res.on("data", (chunk) => {
+          raw += chunk;
+        });
+        res.on("end", () => {
+          try {
+            const data = raw ? JSON.parse(raw) : {};
+            resolve({ status: res.statusCode || 0, data });
+          } catch (err) {
+            reject(err);
+          }
+        });
+      },
+    );
+
+    req.on("error", reject);
+    req.write(payload);
+    req.end();
+  });
+
+const streamEvents = (jobId: string, token: string) =>
+  new Promise<void>((resolve, reject) => {
+    const req = http.request(
+      `${BASE}/v1/jobs/${jobId}/stream`,
+      {
+        method: "GET",
+        headers: {
+          Origin: ORIGIN,
+          Authorization: `Bearer ${token}`,
+          Accept: "text/event-stream",
+        },
+      },
+      (res) => {
+        res.setEncoding("utf8");
+        res.on("data", (chunk) => {
+          process.stdout.write(chunk);
+        });
+        res.on("end", () => {
+          resolve();
+        });
+      },
+    );
+    req.on("error", reject);
+    req.end();
+  });
+
+const main = async () => {
+  const start = await requestJson("/v1/pair", { step: "start" });
+  const startData = asRecord(start.data);
+  const code = startData ? getString(startData.code) : null;
+  if (start.status !== 200 || !code) {
+    console.error("Pairing start failed", start.data);
+    process.exit(1);
+  }
+
+  const confirm = await requestJson("/v1/pair", {
+    step: "confirm",
+    code,
+  });
+  const confirmData = asRecord(confirm.data);
+  const token = confirmData ? getString(confirmData.accessToken) : null;
+  if (confirm.status !== 200 || !token) {
+    console.error("Pairing confirm failed", confirm.data);
+    process.exit(1);
+  }
+
+  const clone = await requestJsonAuth("/v1/git/clone", token, {
+    repoUrl: REPO,
+    destRelative: DEST,
+  });
+  const cloneData = asRecord(clone.data);
+  const jobId = cloneData ? getString(cloneData.jobId) : null;
+  if (clone.status !== 202 || !jobId) {
+    console.error("Clone request failed", clone.data);
+    process.exit(1);
+  }
+
+  console.log(`jobId=${jobId}`);
+  await streamEvents(jobId, token);
+};
+
+main().catch((err) => {
+  console.error("Test clone failed", err);
+  process.exit(1);
+});

package/src/config.ts

@@ -26,7 +26,7 @@ export const defaultConfig = (): AppConfig => ({
   configVersion: CONFIG_VERSION,
   server: {
     host: "127.0.0.1",
-    port: 8787,
+    port: 8790,
   },
   originAllowlist: ["https://app.example.com"],
   workspaceRoot: null,

package/src/daemon.ts

@@ -5,6 +5,25 @@ const start = async () => {
   const ctx = await createContext();
   const app = createApp(ctx);
 
+  const startupSummary = {
+    configDir: ctx.configDir,
+    host: ctx.config.server.host,
+    port: ctx.config.server.port,
+    workspaceRoot: ctx.config.workspaceRoot ?? "not configured",
+    originAllowlist: ctx.config.originAllowlist,
+  };
+  ctx.logger.info(startupSummary, "Git Daemon starting");
+  if (process.env.GIT_DAEMON_LOG_STDOUT !== "1") {
+    console.log("[Git Daemon] Startup");
+    console.log(`  config: ${startupSummary.configDir}`);
+    console.log(`  host: ${startupSummary.host}`);
+    console.log(`  port: ${startupSummary.port}`);
+    console.log(`  workspace: ${startupSummary.workspaceRoot}`);
+    console.log(
+      `  allowlist: ${startupSummary.originAllowlist.join(", ") || "none"}`,
+    );
+  }
+
   app.listen(ctx.config.server.port, ctx.config.server.host, () => {
     ctx.logger.info(
       {

package/src/jobs.ts

@@ -1,6 +1,12 @@
 import { EventEmitter } from "events";
 import crypto from "crypto";
-import type { ApiErrorBody, JobEvent, JobState, JobStatus } from "./types";
+import type {
+  ApiErrorBody,
+  JobEvent,
+  JobProgressEvent,
+  JobState,
+  JobStatus,
+} from "./types";
 import { timeoutError } from "./errors";
 
 const MAX_EVENTS = 2000;
@@ -8,7 +14,7 @@ const MAX_EVENTS = 2000;
 export type JobContext = {
   logStdout: (line: string) => void;
   logStderr: (line: string) => void;
-  progress: (event: Omit<JobEvent, "type"> & { type?: "progress" }) => void;
+  progress: (event: Omit<JobProgressEvent, "type">) => void;
   setCancel: (cancel: () => Promise<void>) => void;
   isCancelled: () => boolean;
 };
@@ -157,7 +163,7 @@ export class JobManager {
     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" }),
+      progress: (event) => job.emit({ type: "progress", ...event }),
       setCancel: (fn) => job.setCancel(fn),
       isCancelled: () => job.cancelRequested,
     };

package/src/logger.ts

@@ -1,9 +1,9 @@
 import path from "path";
 import { promises as fs } from "fs";
-import pino from "pino";
+import pino, { multistream } from "pino";
 import pinoHttp from "pino-http";
 import type { Logger } from "pino";
-import rfs from "rotating-file-stream";
+import { createStream } from "rotating-file-stream";
 import type { AppConfig } from "./types";
 
 export const createLogger = async (
@@ -11,16 +11,38 @@ export const createLogger = async (
   logging: AppConfig["logging"],
   enabled = true,
 ): Promise<Logger> => {
+  const level = process.env.GIT_DAEMON_LOG_LEVEL || "info";
+  const logToStdout = process.env.GIT_DAEMON_LOG_STDOUT === "1";
+  const prettyStdout = logToStdout && process.env.GIT_DAEMON_LOG_PRETTY !== "0";
   const logDir = path.join(configDir, logging.directory);
   await fs.mkdir(logDir, { recursive: true });
 
-  const stream = rfs.createStream("daemon.log", {
+  const stream = createStream("daemon.log", {
     size: `${logging.maxBytes}B`,
     maxFiles: logging.maxFiles,
     path: logDir,
   });
 
-  return pino({ enabled }, stream);
+  if (!logToStdout) {
+    return pino({ enabled, level }, stream);
+  }
+
+  const streams: Array<{ stream: NodeJS.WritableStream }> = [{ stream }];
+  if (prettyStdout) {
+    const { default: pretty } = await import("pino-pretty");
+    streams.push({
+      stream: pretty({
+        colorize: true,
+        translateTime: "SYS:standard",
+        ignore: "pid,hostname",
+      }),
+    });
+  } else {
+    streams.push({ stream: process.stdout });
+  }
+
+  return pino({ enabled, level }, multistream(streams));
 };
 
-export const createHttpLogger = (logger: Logger) => pinoHttp({ logger });
+export const createHttpLogger = (logger: Logger) =>
+  pinoHttp({ logger: logger as unknown as Logger });

package/src/process.ts

@@ -39,11 +39,12 @@ export const runCommand = async (
     stderr: "pipe",
   });
 
-  if (subprocess.pid) {
+  const pid = subprocess.pid;
+  if (pid) {
     ctx.setCancel(
       () =>
         new Promise<void>((resolve) => {
-          treeKill(subprocess.pid, "SIGTERM", () => resolve());
+          treeKill(pid, "SIGTERM", () => resolve());
         }),
     );
   }

package/src/setup.ts

@@ -0,0 +1,165 @@
+import path from "path";
+import os from "os";
+import { promises as fs } from "fs";
+import * as fsSync from "fs";
+import readline from "readline";
+import { getConfigDir, loadConfig, saveConfig } from "./config";
+
+const expandHome = (input: string) => {
+  if (input === "~") {
+    return os.homedir();
+  }
+  if (input.startsWith("~/")) {
+    return path.join(os.homedir(), input.slice(2));
+  }
+  return input;
+};
+
+const pathExists = async (target: string) => {
+  try {
+    const stats = await fs.stat(target);
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+};
+
+const createPromptInterface = () => {
+  if (process.stdin.isTTY && process.stdout.isTTY) {
+    return readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+  }
+  const ttyPath = process.platform === "win32" ? "CON" : "/dev/tty";
+  try {
+    const input = fsSync.createReadStream(ttyPath, { encoding: "utf8" });
+    const output = fsSync.createWriteStream(ttyPath);
+    return readline.createInterface({ input, output });
+  } catch {
+    return null;
+  }
+};
+
+const askQuestion = (rl: readline.Interface, question: string) =>
+  new Promise<string>((resolve) => {
+    rl.question(question, (answer) => resolve(answer));
+  });
+
+const promptForWorkspace = async (
+  rl: readline.Interface,
+  initialValue: string,
+) => {
+  let result: string | null = null;
+  while (result === null) {
+    const answer = await askQuestion(
+      rl,
+      `Workspace root directory (absolute path) [${initialValue}]: `,
+    );
+    const trimmed = answer.trim();
+    const value = trimmed.length > 0 ? trimmed : initialValue;
+    if (!value) {
+      return null;
+    }
+    const expanded = expandHome(value);
+    if (!path.isAbsolute(expanded)) {
+      console.log("Workspace root must be an absolute path.");
+      continue;
+    }
+    result = value;
+  }
+  return result;
+};
+
+const promptYesNo = async (
+  rl: readline.Interface,
+  message: string,
+  defaultValue: boolean,
+) => {
+  const suffix = defaultValue ? "[Y/n]" : "[y/N]";
+  const answer = await askQuestion(rl, `${message} ${suffix} `);
+  const normalized = answer.trim().toLowerCase();
+  if (!normalized) {
+    return defaultValue;
+  }
+  return normalized === "y" || normalized === "yes";
+};
+
+const readWorkspaceArg = () => {
+  const args = process.argv.slice(2);
+  const flagIndex = args.findIndex((arg) => arg === "--workspace");
+  if (flagIndex >= 0 && args[flagIndex + 1]) {
+    return args[flagIndex + 1];
+  }
+  const inline = args.find((arg) => arg.startsWith("--workspace="));
+  if (inline) {
+    return inline.split("=").slice(1).join("=");
+  }
+  return null;
+};
+
+const setup = async () => {
+  const configDir = getConfigDir();
+  const config = await loadConfig(configDir);
+
+  console.log(`[Git Daemon setup] config=${configDir}`);
+
+  const provided = process.env.GIT_DAEMON_WORKSPACE_ROOT || readWorkspaceArg();
+
+  let workspaceInput: string | null | undefined = provided?.trim();
+  let rl: readline.Interface | null = null;
+
+  if (!workspaceInput) {
+    rl = createPromptInterface();
+    if (!rl) {
+      console.error(
+        "No interactive prompt available. Use GIT_DAEMON_WORKSPACE_ROOT=/path or --workspace=/path.",
+      );
+      process.exit(1);
+    }
+    workspaceInput = await promptForWorkspace(
+      rl,
+      config.workspaceRoot ?? process.cwd(),
+    );
+  }
+
+  if (!workspaceInput) {
+    console.error("Workspace root was not provided.");
+    process.exit(1);
+  }
+
+  const expanded = expandHome(workspaceInput);
+  const resolved = path.resolve(expanded);
+
+  if (!(await pathExists(resolved))) {
+    if (!rl) {
+      rl = createPromptInterface();
+    }
+    if (!rl) {
+      console.error(`Directory does not exist: ${resolved}`);
+      console.error("Create it manually, then rerun setup.");
+      process.exit(1);
+    }
+    const create = await promptYesNo(
+      rl,
+      `Directory does not exist. Create ${resolved}?`,
+      true,
+    );
+    if (!create) {
+      console.log("Setup aborted. Workspace root not saved.");
+      process.exit(1);
+    }
+    await fs.mkdir(resolved, { recursive: true });
+  }
+
+  config.workspaceRoot = resolved;
+  await saveConfig(configDir, config);
+
+  console.log(`Workspace root set to ${resolved}`);
+  rl?.close();
+};
+
+setup().catch((err) => {
+  console.error("Setup failed", err);
+  process.exit(1);
+});

package/src/types.ts

@@ -65,23 +65,26 @@ export type TokenStoreData = {
 
 export type JobState = "queued" | "running" | "done" | "error" | "cancelled";
 
-export type JobEvent =
-  | {
-      type: "log";
-      stream: "stdout" | "stderr";
-      line: string;
-    }
-  | {
-      type: "progress";
-      kind: "git" | "deps";
-      percent?: number;
-      detail?: string;
-    }
-  | {
-      type: "state";
-      state: JobState;
-      message?: string;
-    };
+export type JobLogEvent = {
+  type: "log";
+  stream: "stdout" | "stderr";
+  line: string;
+};
+
+export type JobProgressEvent = {
+  type: "progress";
+  kind: "git" | "deps";
+  percent?: number;
+  detail?: string;
+};
+
+export type JobStateEvent = {
+  type: "state";
+  state: JobState;
+  message?: string;
+};
+
+export type JobEvent = JobLogEvent | JobProgressEvent | JobStateEvent;
 
 export type JobStatus = {
   id: string;

package/src/typings/pino-pretty.d.ts

@@ -0,0 +1,9 @@
+declare module "pino-pretty" {
+  type PrettyOptions = {
+    colorize?: boolean;
+    translateTime?: string;
+    ignore?: string;
+  };
+  function pretty(options?: PrettyOptions): NodeJS.WritableStream;
+  export default pretty;
+}