git-daemon 0.1.1 → 0.1.3

package/dist/logger.js

@@ -0,0 +1,77 @@
+"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 });
+exports.createHttpLogger = exports.createLogger = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = require("fs");
+const pino_1 = __importDefault(require("pino"));
+const pino_http_1 = __importDefault(require("pino-http"));
+const rotating_file_stream_1 = require("rotating-file-stream");
+const createLogger = async (configDir, logging, enabled = true) => {
+    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_1.default.join(configDir, logging.directory);
+    await fs_1.promises.mkdir(logDir, { recursive: true });
+    const stream = (0, rotating_file_stream_1.createStream)("daemon.log", {
+        size: `${logging.maxBytes}B`,
+        maxFiles: logging.maxFiles,
+        path: logDir,
+    });
+    if (!logToStdout) {
+        return (0, pino_1.default)({ enabled, level }, stream);
+    }
+    const streams = [{ stream }];
+    if (prettyStdout) {
+        const { default: pretty } = await Promise.resolve().then(() => __importStar(require("pino-pretty")));
+        streams.push({
+            stream: pretty({
+                colorize: true,
+                translateTime: "SYS:standard",
+                ignore: "pid,hostname",
+            }),
+        });
+    }
+    else {
+        streams.push({ stream: process.stdout });
+    }
+    return (0, pino_1.default)({ enabled, level }, pino_1.default.multistream(streams));
+};
+exports.createLogger = createLogger;
+const createHttpLogger = (logger) => (0, pino_http_1.default)({ logger: logger });
+exports.createHttpLogger = createHttpLogger;

package/dist/os.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openTarget = void 0;
+const execa_1 = require("execa");
+const openTarget = async (target, resolvedPath) => {
+    const platform = process.platform;
+    if (target === "folder") {
+        if (platform === "darwin") {
+            await (0, execa_1.execa)("open", [resolvedPath]);
+            return;
+        }
+        if (platform === "win32") {
+            await (0, execa_1.execa)("cmd", ["/c", "start", "", resolvedPath]);
+            return;
+        }
+        await (0, execa_1.execa)("xdg-open", [resolvedPath]);
+        return;
+    }
+    if (target === "terminal") {
+        if (platform === "darwin") {
+            await (0, execa_1.execa)("open", ["-a", "Terminal", resolvedPath]);
+            return;
+        }
+        if (platform === "win32") {
+            await (0, execa_1.execa)("cmd", [
+                "/c",
+                "start",
+                "",
+                "cmd.exe",
+                "/k",
+                "cd",
+                "/d",
+                resolvedPath,
+            ]);
+            return;
+        }
+        await (0, execa_1.execa)("x-terminal-emulator", ["--working-directory", resolvedPath]);
+        return;
+    }
+    await (0, execa_1.execa)("code", [resolvedPath]);
+};
+exports.openTarget = openTarget;

package/dist/pairing.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PairingManager = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const PAIRING_TTL_MS = 10 * 60 * 1000;
+class PairingManager {
+    constructor(tokenStore, ttlDays) {
+        this.codes = new Map();
+        this.tokenStore = tokenStore;
+        this.ttlDays = ttlDays;
+    }
+    start(origin) {
+        const code = crypto_1.default.randomBytes(4).toString("hex");
+        const expiresAt = Date.now() + PAIRING_TTL_MS;
+        this.codes.set(origin, { code, expiresAt });
+        return {
+            step: "start",
+            instructions: "Enter this code in the Git Daemon pairing prompt within 10 minutes.",
+            code,
+            expiresAt: new Date(expiresAt).toISOString(),
+        };
+    }
+    async confirm(origin, code) {
+        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",
+            accessToken: token,
+            tokenType: "Bearer",
+            expiresAt,
+        };
+    }
+}
+exports.PairingManager = PairingManager;

package/dist/process.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCommand = void 0;
+const execa_1 = require("execa");
+const tree_kill_1 = __importDefault(require("tree-kill"));
+const attachLineReader = (stream, onLine) => {
+    if (!stream) {
+        return;
+    }
+    let buffer = "";
+    stream.on("data", (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split(/\r?\n/);
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+            if (line.length > 0) {
+                onLine(line);
+            }
+        }
+    });
+    stream.on("end", () => {
+        if (buffer.length > 0) {
+            onLine(buffer);
+        }
+    });
+};
+const runCommand = async (ctx, command, args, options) => {
+    const subprocess = (0, execa_1.execa)(command, args, {
+        ...options,
+        stdout: "pipe",
+        stderr: "pipe",
+    });
+    const pid = subprocess.pid;
+    if (pid) {
+        ctx.setCancel(() => new Promise((resolve) => {
+            (0, tree_kill_1.default)(pid, "SIGTERM", () => resolve());
+        }));
+    }
+    attachLineReader(subprocess.stdout, ctx.logStdout);
+    attachLineReader(subprocess.stderr, ctx.logStderr);
+    await subprocess;
+};
+exports.runCommand = runCommand;

package/dist/security.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authGuard = exports.loopbackGuard = exports.hostGuard = exports.originGuard = exports.getOrigin = void 0;
+const errors_1 = require("./errors");
+const ALLOWED_HOSTS = new Set(["127.0.0.1", "localhost"]);
+const getOrigin = (req) => req.headers.origin || "";
+exports.getOrigin = getOrigin;
+const isLoopbackAddress = (address) => {
+    if (!address) {
+        return false;
+    }
+    if (address === "127.0.0.1" || address === "::1") {
+        return true;
+    }
+    return address.startsWith("::ffff:127.0.0.1");
+};
+const originGuard = (allowlist) => {
+    return (req, res, next) => {
+        const origin = (0, exports.getOrigin)(req);
+        if (!origin || !allowlist.includes(origin)) {
+            return next((0, errors_1.originNotAllowed)());
+        }
+        res.setHeader("Access-Control-Allow-Origin", origin);
+        res.setHeader("Vary", "Origin");
+        res.setHeader("Access-Control-Allow-Headers", "Authorization, Content-Type");
+        res.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS");
+        res.setHeader("Access-Control-Max-Age", "600");
+        if (req.method === "OPTIONS") {
+            res.status(204).end();
+            return;
+        }
+        next();
+    };
+};
+exports.originGuard = originGuard;
+const hostGuard = () => {
+    return (req, _res, next) => {
+        const host = req.headers.host?.split(":")[0];
+        if (!host || !ALLOWED_HOSTS.has(host)) {
+            return next((0, errors_1.originNotAllowed)());
+        }
+        next();
+    };
+};
+exports.hostGuard = hostGuard;
+const loopbackGuard = () => {
+    return (req, _res, next) => {
+        if (!isLoopbackAddress(req.socket.remoteAddress)) {
+            return next((0, errors_1.originNotAllowed)());
+        }
+        next();
+    };
+};
+exports.loopbackGuard = loopbackGuard;
+const authGuard = (tokenStore) => {
+    return (req, _res, next) => {
+        const origin = (0, exports.getOrigin)(req);
+        const auth = req.headers.authorization;
+        if (!auth) {
+            return next((0, errors_1.authRequired)());
+        }
+        const match = auth.match(/^Bearer (.+)$/i);
+        if (!match) {
+            return next((0, errors_1.authInvalid)());
+        }
+        const token = match[1];
+        if (!tokenStore.verifyToken(origin, token)) {
+            return next((0, errors_1.authInvalid)());
+        }
+        next();
+    };
+};
+exports.authGuard = authGuard;

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/dist/tokens.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenStore = void 0;
+const fs_1 = require("fs");
+const crypto_1 = __importDefault(require("crypto"));
+const config_1 = require("./config");
+const TOKEN_BYTES = 32;
+const HASH_BYTES = 32;
+class TokenStore {
+    constructor(configDir) {
+        this.entries = [];
+        this.tokensPath = (0, config_1.getTokensPath)(configDir);
+    }
+    async load() {
+        try {
+            const raw = await fs_1.promises.readFile(this.tokensPath, "utf8");
+            const data = JSON.parse(raw);
+            this.entries = Array.isArray(data.entries) ? data.entries : [];
+        }
+        catch (err) {
+            if (err.code !== "ENOENT") {
+                throw err;
+            }
+            this.entries = [];
+            await this.save();
+        }
+        this.pruneExpired();
+    }
+    async save() {
+        const payload = { entries: this.entries };
+        await fs_1.promises.writeFile(this.tokensPath, JSON.stringify(payload, null, 2));
+    }
+    pruneExpired() {
+        const now = Date.now();
+        this.entries = this.entries.filter((entry) => {
+            const expiresAt = Date.parse(entry.expiresAt);
+            return Number.isNaN(expiresAt) || expiresAt > now;
+        });
+    }
+    getActiveToken(origin) {
+        this.pruneExpired();
+        return this.entries.find((entry) => entry.origin === origin);
+    }
+    async issueToken(origin, ttlDays) {
+        const token = crypto_1.default.randomBytes(TOKEN_BYTES).toString("base64url");
+        const salt = crypto_1.default.randomBytes(16).toString("base64url");
+        const tokenHash = crypto_1.default
+            .scryptSync(token, salt, HASH_BYTES)
+            .toString("base64url");
+        const now = new Date();
+        const expiresAt = new Date(now.getTime() + ttlDays * 24 * 60 * 60 * 1000);
+        const entry = {
+            origin,
+            tokenHash,
+            salt,
+            createdAt: now.toISOString(),
+            expiresAt: expiresAt.toISOString(),
+        };
+        this.entries = this.entries.filter((item) => item.origin !== origin);
+        this.entries.push(entry);
+        await this.save();
+        return {
+            token,
+            expiresAt: entry.expiresAt,
+        };
+    }
+    async revokeToken(origin) {
+        this.entries = this.entries.filter((item) => item.origin !== origin);
+        await this.save();
+    }
+    verifyToken(origin, token) {
+        this.pruneExpired();
+        const entry = this.entries.find((item) => item.origin === origin);
+        if (!entry) {
+            return false;
+        }
+        const derived = crypto_1.default.scryptSync(token, entry.salt, HASH_BYTES);
+        const stored = Buffer.from(entry.tokenHash, "base64url");
+        if (stored.length !== derived.length) {
+            return false;
+        }
+        return crypto_1.default.timingSafeEqual(stored, derived);
+    }
+}
+exports.TokenStore = TokenStore;

package/dist/tools.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isToolInstalled = exports.detectCapabilities = void 0;
+const execa_1 = require("execa");
+const detect = async (command, args = ["--version"]) => {
+    try {
+        const result = await (0, execa_1.execa)(command, args);
+        const version = result.stdout.trim();
+        return { installed: true, version };
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            return { installed: false };
+        }
+        return { installed: false };
+    }
+};
+const detectCapabilities = async () => {
+    const [git, node, npm, pnpm, yarn, code] = await Promise.all([
+        detect("git", ["--version"]),
+        detect("node", ["--version"]),
+        detect("npm", ["--version"]),
+        detect("pnpm", ["--version"]),
+        detect("yarn", ["--version"]),
+        detect("code", ["--version"]),
+    ]);
+    return {
+        tools: {
+            git,
+            node,
+            npm,
+            pnpm,
+            yarn,
+            code,
+        },
+    };
+};
+exports.detectCapabilities = detectCapabilities;
+const isToolInstalled = async (command) => {
+    const info = await detect(command, ["--version"]);
+    return info.installed;
+};
+exports.isToolInstalled = isToolInstalled;

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/validation.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.depsInstallRequestSchema = exports.osOpenRequestSchema = exports.gitStatusQuerySchema = exports.gitFetchRequestSchema = exports.gitCloneRequestSchema = exports.pairRequestSchema = void 0;
+const zod_1 = require("zod");
+const MAX_PATH_LENGTH = 4096;
+const isValidRepoUrl = (value) => {
+    if (value.startsWith("file://")) {
+        return false;
+    }
+    if (value.startsWith("/") ||
+        value.startsWith("./") ||
+        value.startsWith("../")) {
+        return false;
+    }
+    if (/^git@[^:]+:.+/.test(value)) {
+        return true;
+    }
+    if (/^https:\/\/[^/]+\/.+/.test(value)) {
+        return true;
+    }
+    if (/^ssh:\/\/[^/]+\/.+/.test(value)) {
+        return true;
+    }
+    return false;
+};
+exports.pairRequestSchema = zod_1.z.discriminatedUnion("step", [
+    zod_1.z.object({
+        step: zod_1.z.literal("start"),
+    }),
+    zod_1.z.object({
+        step: zod_1.z.literal("confirm"),
+        code: zod_1.z.string().min(1),
+    }),
+]);
+exports.gitCloneRequestSchema = zod_1.z.object({
+    repoUrl: zod_1.z.string().min(1).refine(isValidRepoUrl),
+    destRelative: zod_1.z.string().min(1).max(MAX_PATH_LENGTH),
+    options: zod_1.z
+        .object({
+        branch: zod_1.z.string().min(1).optional(),
+        depth: zod_1.z.number().int().min(1).optional(),
+    })
+        .optional(),
+});
+exports.gitFetchRequestSchema = zod_1.z.object({
+    repoPath: zod_1.z.string().min(1).max(MAX_PATH_LENGTH),
+    remote: zod_1.z.string().min(1).optional(),
+    prune: zod_1.z.boolean().optional(),
+});
+exports.gitStatusQuerySchema = zod_1.z.object({
+    repoPath: zod_1.z.string().min(1).max(MAX_PATH_LENGTH),
+});
+exports.osOpenRequestSchema = zod_1.z.object({
+    target: zod_1.z.enum(["folder", "terminal", "vscode"]),
+    path: zod_1.z.string().min(1).max(MAX_PATH_LENGTH),
+});
+exports.depsInstallRequestSchema = zod_1.z.object({
+    repoPath: zod_1.z.string().min(1).max(MAX_PATH_LENGTH),
+    manager: zod_1.z.enum(["auto", "npm", "pnpm", "yarn"]).optional(),
+    mode: zod_1.z.enum(["auto", "ci", "install"]).optional(),
+    safer: zod_1.z.boolean().optional(),
+});