git-daemon 0.1.2 → 0.1.3

package/.eslintrc.cjs

@@ -14,5 +14,5 @@ module.exports = {
   rules: {
     "@typescript-eslint/no-unused-vars": ["error", { argsIgnorePattern: "^_" }]
   },
-  ignorePatterns: ["dist/", "node_modules/"]
+  ignorePatterns: ["dist/", "node_modules/", "workspace/"]
 };

package/README.md

@@ -41,6 +41,27 @@ npm run daemon
 
 The daemon listens on `http://127.0.0.1:8790` by default.
 
+## Setup workspace root
+
+```bash
+npm run setup
+```
+
+This prompts for an absolute workspace root path and saves it to your config. The prompt reads from the terminal directly (via `/dev/tty` on macOS/Linux) so it still works in many IDE run configurations.
+For development, you can also run `npm run setup:dev`.
+
+Non-interactive setup (no TTY):
+
+```bash
+GIT_DAEMON_WORKSPACE_ROOT=/absolute/path npm run setup
+```
+
+Or:
+
+```bash
+npm run setup -- --workspace=/absolute/path
+```
+
 Verbose logging options:
 
 - `GIT_DAEMON_LOG_STDOUT=1` to mirror logs to stdout

package/dist/app.js

@@ -116,10 +116,30 @@ const createApp = (ctx) => {
         const sendEvent = (event) => {
             res.write(`data: ${JSON.stringify(event)}\n\n`);
         };
+        const isTerminalState = (event) => {
+            if (!event || typeof event !== "object") {
+                return false;
+            }
+            const record = event;
+            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) => sendEvent(event);
+        const listener = (event) => {
+            sendEvent(event);
+            if (isTerminalState(event)) {
+                job.emitter.off("event", listener);
+                res.end();
+            }
+        };
         job.emitter.on("event", listener);
         req.on("close", () => {
             job.emitter.off("event", listener);

package/dist/cli-test-clone.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const http_1 = __importDefault(require("http"));
+const getEnv = (key, fallback) => 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 requestJson = (path, body) => new Promise((resolve, reject) => {
+    const payload = JSON.stringify(body);
+    const req = http_1.default.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, token, body) => new Promise((resolve, reject) => {
+    const payload = JSON.stringify(body);
+    const req = http_1.default.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, token) => new Promise((resolve, reject) => {
+    const req = http_1.default.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" });
+    if (start.status !== 200 || !start.data.code) {
+        console.error("Pairing start failed", start.data);
+        process.exit(1);
+    }
+    const confirm = await requestJson("/v1/pair", {
+        step: "confirm",
+        code: start.data.code,
+    });
+    if (confirm.status !== 200 || !confirm.data.accessToken) {
+        console.error("Pairing confirm failed", confirm.data);
+        process.exit(1);
+    }
+    const token = confirm.data.accessToken;
+    const clone = await requestJsonAuth("/v1/git/clone", token, {
+        repoUrl: REPO,
+        destRelative: DEST,
+    });
+    if (clone.status !== 202 || !clone.data.jobId) {
+        console.error("Clone request failed", clone.data);
+        process.exit(1);
+    }
+    const jobId = clone.data.jobId;
+    console.log(`jobId=${jobId}`);
+    await streamEvents(jobId, token);
+};
+main().catch((err) => {
+    console.error("Test clone failed", err);
+    process.exit(1);
+});

package/dist/daemon.js

@@ -14,7 +14,12 @@ const start = async () => {
     };
     ctx.logger.info(startupSummary, "Git Daemon starting");
     if (process.env.GIT_DAEMON_LOG_STDOUT !== "1") {
-        console.log(`[Git Daemon] config=${startupSummary.configDir} host=${startupSummary.host} port=${startupSummary.port}`);
+        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/dist/setup.js

@@ -0,0 +1,165 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const fs_1 = require("fs");
+const fsSync = __importStar(require("fs"));
+const readline_1 = __importDefault(require("readline"));
+const config_1 = require("./config");
+const expandHome = (input) => {
+    if (input === "~") {
+        return os_1.default.homedir();
+    }
+    if (input.startsWith("~/")) {
+        return path_1.default.join(os_1.default.homedir(), input.slice(2));
+    }
+    return input;
+};
+const pathExists = async (target) => {
+    try {
+        const stats = await fs_1.promises.stat(target);
+        return stats.isDirectory();
+    }
+    catch {
+        return false;
+    }
+};
+const createPromptInterface = () => {
+    if (process.stdin.isTTY && process.stdout.isTTY) {
+        return readline_1.default.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_1.default.createInterface({ input, output });
+    }
+    catch {
+        return null;
+    }
+};
+const askQuestion = (rl, question) => new Promise((resolve) => {
+    rl.question(question, (answer) => resolve(answer));
+});
+const promptForWorkspace = async (rl, initialValue) => {
+    while (true) {
+        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_1.default.isAbsolute(expanded)) {
+            console.log("Workspace root must be an absolute path.");
+            continue;
+        }
+        return value;
+    }
+};
+const promptYesNo = async (rl, message, defaultValue) => {
+    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 = (0, config_1.getConfigDir)();
+    const config = await (0, config_1.loadConfig)(configDir);
+    console.log(`[Git Daemon setup] config=${configDir}`);
+    const provided = process.env.GIT_DAEMON_WORKSPACE_ROOT || readWorkspaceArg();
+    let workspaceInput = provided?.trim();
+    let rl = 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_1.default.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_1.promises.mkdir(resolved, { recursive: true });
+    }
+    config.workspaceRoot = resolved;
+    await (0, config_1.saveConfig)(configDir, config);
+    console.log(`Workspace root set to ${resolved}`);
+    rl?.close();
+};
+setup().catch((err) => {
+    console.error("Setup failed", err);
+    process.exit(1);
+});

package/package.json

@@ -1,14 +1,16 @@
 {
   "name": "git-daemon",
-  "version": "0.1.2",
+  "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"
   },

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/daemon.ts

@@ -14,8 +14,13 @@ const start = async () => {
   };
   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(
-      `[Git Daemon] config=${startupSummary.configDir} host=${startupSummary.host} port=${startupSummary.port}`,
+      `  allowlist: ${startupSummary.originAllowlist.join(", ") || "none"}`,
     );
   }
 

package/src/jobs.ts

@@ -1,6 +1,12 @@
 import { EventEmitter } from "events";
 import crypto from "crypto";
-import type { ApiErrorBody, JobEvent, JobProgressEvent, JobState, JobStatus } from "./types";
+import type {
+  ApiErrorBody,
+  JobEvent,
+  JobProgressEvent,
+  JobState,
+  JobStatus,
+} from "./types";
 import { timeoutError } from "./errors";
 
 const MAX_EVENTS = 2000;

package/src/logger.ts

@@ -1,6 +1,6 @@
 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 { createStream } from "rotating-file-stream";
@@ -41,8 +41,8 @@ export const createLogger = async (
     streams.push({ stream: process.stdout });
   }
 
-  return pino({ enabled, level }, (pino as any).multistream(streams));
+  return pino({ enabled, level }, multistream(streams));
 };
 
 export const createHttpLogger = (logger: Logger) =>
-  pinoHttp({ logger: logger as any });
+  pinoHttp({ logger: logger as unknown as Logger });

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);
+});