@zdreamer/forge 0.1.1 → 0.1.2

package/dist/{components/workspace-policy → server/src/components/workspace-policy/authoring}/internal/types.d.ts

@@ -5,7 +5,7 @@ export interface RepositoryDeclaration {
 export interface WorkspaceChange {
     readonly repo: string;
     readonly path: string;
-    readonly kind: "added" | "modified" | "deleted" | "renamed" | "copied" | "type_changed";
+    readonly kind: "added" | "modified" | "deleted" | "renamed";
     readonly from?: string;
 }
 /** Identity is concrete; several codebases may share the same guidance folder. */
@@ -17,9 +17,11 @@ export interface CodebaseContext {
  * Trusted project code, called explicitly after loading. Forge probes only
  * declared repositories; missing locations are skipped, not configuration errors.
  * Routing is synchronous, side-effect-free and must handle absent
- * files lexically. Rename/copy membership includes both old and new paths.
+ * files lexically. Rename membership includes both old and new paths.
  */
 export interface WorkspacePolicy {
+    /** Literal display text; omission uses the canonical workspace root basename. */
+    readonly displayName?: string;
     readonly repositories: readonly RepositoryDeclaration[];
     codebasesForChange(change: WorkspaceChange): readonly CodebaseContext[];
 }

package/dist/server/src/components/workspace-policy/authoring/internal/types.js

@@ -0,0 +1 @@
+export {};

package/dist/{components → server/src/components}/workspace-policy/index.d.ts

@@ -1,3 +1,4 @@
+export type { CodebaseContext, RepositoryDeclaration, WorkspaceChange, WorkspacePolicy, } from "./authoring/index.ts";
 export { loadWorkspacePolicy } from "./internal/load.ts";
+export type { RepositoryResolution } from "./internal/repositories.ts";
 export { resolveRepositories } from "./internal/repositories.ts";
-export type { CodebaseContext, RepositoryDeclaration, WorkspaceChange, WorkspacePolicy, } from "./internal/types.ts";

package/dist/{components → server/src/components}/workspace-policy/internal/load.d.ts

@@ -1,3 +1,3 @@
-import type { WorkspacePolicy } from "./types.ts";
+import type { WorkspacePolicy } from "../authoring/index.ts";
 /** Imports execute trusted workspace code; this is not a sandbox or hot loader. */
 export declare function loadWorkspacePolicy(absolutePath: string): Promise<WorkspacePolicy>;

package/dist/{components → server/src/components}/workspace-policy/internal/load.js

@@ -20,6 +20,9 @@ export async function loadWorkspacePolicy(absolutePath) {
         typeof policy.codebasesForChange !== "function") {
         throw new TypeError("Workspace module must default-export a WorkspacePolicy");
     }
+    if ("displayName" in policy && (typeof policy.displayName !== "string" || policy.displayName.length === 0)) {
+        throw new TypeError("Workspace displayName must be a nonempty string");
+    }
     const paths = new Set();
     for (const repository of policy.repositories) {
         if (typeof repository !== "object" ||

package/dist/{components → server/src/components}/workspace-policy/internal/repositories.d.ts

@@ -1,4 +1,5 @@
-import type { RepositoryDeclaration } from "./types.ts";
+import { type GitProcess } from "../../../lib/git/index.ts";
+import type { RepositoryDeclaration } from "../authoring/index.ts";
 export declare function validRepositoryPath(path: string): boolean;
 export type RepositoryResolution = {
     readonly path: string;
@@ -9,4 +10,4 @@ export type RepositoryResolution = {
     readonly status: "missing";
 };
 /** Explicit startup/reload probe, never a recursive scan or change-list poll. */
-export declare function resolveRepositories(workspaceRoot: string, declarations: readonly RepositoryDeclaration[]): Promise<readonly RepositoryResolution[]>;
+export declare function resolveRepositories(workspaceRoot: string, declarations: readonly RepositoryDeclaration[], git: GitProcess): Promise<readonly RepositoryResolution[]>;

package/dist/{components → server/src/components}/workspace-policy/internal/repositories.js

@@ -1,8 +1,6 @@
-import { execFile } from "node:child_process";
 import { realpath, stat } from "node:fs/promises";
 import { isAbsolute, relative, resolve, sep } from "node:path";
-import { promisify } from "node:util";
-const execute = promisify(execFile);
+import { gitFailure } from "../../../lib/git/index.js";
 export function validRepositoryPath(path) {
     return (path === "." ||
         (path.length > 0 &&
@@ -12,7 +10,7 @@ export function validRepositoryPath(path) {
             path.split("/").every((part) => part !== "" && part !== "." && part !== "..")));
 }
 /** Explicit startup/reload probe, never a recursive scan or change-list poll. */
-export async function resolveRepositories(workspaceRoot, declarations) {
+export async function resolveRepositories(workspaceRoot, declarations, git) {
     const root = await realpath(workspaceRoot);
     const results = [];
     const seen = new Set();
@@ -40,8 +38,16 @@ export async function resolveRepositories(workspaceRoot, declarations) {
         if (isAbsolute(within) || within === ".." || within.startsWith(`..${sep}`)) {
             throw new Error(`Declared repository escapes workspace root: ${path}`);
         }
-        const { stdout } = await execute("git", ["-C", directory, "rev-parse", "--show-toplevel"]);
-        const gitRoot = await realpath(stdout.trim());
+        const result = await git(directory, ["rev-parse", "--show-toplevel"]);
+        if (result.code !== 0)
+            throw gitFailure(`repository probe (${path})`, result);
+        if (result.stdout.at(-1) !== 10)
+            throw new Error("Git returned an invalid repository root");
+        const gitRoot = await realpath(new TextDecoder("utf-8", { fatal: true }).decode(result.stdout.subarray(0, -1)));
+        const fromGitRoot = relative(gitRoot, directory);
+        if (isAbsolute(fromGitRoot) || fromGitRoot === ".." || fromGitRoot.startsWith(`..${sep}`)) {
+            throw new Error(`Git root does not contain workspace: ${path}`);
+        }
         // '.' intentionally permits a Git root above the selected workspace.
         if (path !== "." && gitRoot !== directory) {
             throw new Error(`Declared nested repository resolves to another Git root: ${path}`);

package/dist/server/src/lib/git/index.d.ts

@@ -0,0 +1,2 @@
+export type { GitProcess, GitResult } from "./internal/process.ts";
+export { createGitProcess, gitFailure, preflightRepository } from "./internal/process.ts";

package/dist/server/src/lib/git/index.js

@@ -0,0 +1 @@
+export { createGitProcess, gitFailure, preflightRepository } from "./internal/process.js";

package/dist/server/src/lib/git/internal/process.d.ts

@@ -0,0 +1,16 @@
+export type GitResult = {
+    code: number;
+    stdout: Buffer;
+    stderr: Buffer;
+};
+export type GitProcess = (cwd: string, args: readonly string[], options?: {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+    maxOutputBytes?: number;
+    input?: Buffer;
+}) => Promise<GitResult>;
+/** Keep deliberate config isolation while ignoring ambient checkout/index redirection. */
+export declare function createGitProcess(environment: Readonly<NodeJS.ProcessEnv>): GitProcess;
+export declare function gitFailure(operation: string, result: GitResult): Error;
+/** Refuse incomplete object stores before commands can request missing objects. Trusted filters remain enabled. */
+export declare function preflightRepository(git: GitProcess, cwd: string, signal?: AbortSignal, objectPath?: string): Promise<void>;

package/dist/server/src/lib/git/internal/process.js

@@ -0,0 +1,166 @@
+import { spawn } from "node:child_process";
+import { readdir } from "node:fs/promises";
+import { isAbsolute, join, resolve } from "node:path";
+/** Keep deliberate config isolation while ignoring ambient checkout/index redirection. */
+export function createGitProcess(environment) {
+    const env = {};
+    const configIsolation = new Set([
+        "GIT_CONFIG_GLOBAL",
+        "GIT_CONFIG_SYSTEM",
+        "GIT_CONFIG_NOSYSTEM",
+        "GIT_ATTR_NOSYSTEM",
+    ]);
+    for (const [name, value] of Object.entries(environment)) {
+        if (!name.startsWith("GIT_") || configIsolation.has(name))
+            env[name] = value;
+    }
+    Object.assign(env, { GIT_OPTIONAL_LOCKS: "0", GIT_NO_LAZY_FETCH: "1", GIT_TERMINAL_PROMPT: "0", LC_ALL: "C" });
+    return (cwd, args, options = {}) => new Promise((resolve, reject) => {
+        if (options.signal?.aborted) {
+            reject(options.signal.reason ?? new Error("Git operation aborted"));
+            return;
+        }
+        if ((options.input?.length ?? 0) > 16 * 1024 * 1024) {
+            reject(new Error("Git input exceeded the collection limit"));
+            return;
+        }
+        const child = spawn("git", [
+            "--no-optional-locks",
+            "-c",
+            "core.fsmonitor=false",
+            "-c",
+            "core.hooksPath=/dev/null",
+            "-c",
+            "gc.auto=0",
+            "-c",
+            "maintenance.auto=false",
+            "-c",
+            "diff.autoRefreshIndex=false",
+            ...args,
+        ], { cwd, env, detached: true, stdio: ["pipe", "pipe", "pipe"] });
+        const stdout = [];
+        const stderr = [];
+        let size = 0;
+        let failure;
+        let killTimer;
+        let closed = false;
+        let exitCode = null;
+        const signalGroup = (signal) => {
+            if (!child.pid)
+                return false;
+            try {
+                process.kill(-child.pid, signal);
+                return true;
+            }
+            catch (error) {
+                if (error.code !== "ESRCH")
+                    failure ??= error;
+                return false;
+            }
+        };
+        const settle = () => {
+            if (!closed || killTimer)
+                return;
+            clearTimeout(timer);
+            options.signal?.removeEventListener("abort", abort);
+            if (failure)
+                reject(failure);
+            else if (exitCode === null)
+                reject(new Error("Git process terminated"));
+            else
+                resolve({ code: exitCode, stdout: Buffer.concat(stdout), stderr: Buffer.concat(stderr) });
+        };
+        const terminate = () => {
+            if (killTimer || !signalGroup("SIGTERM"))
+                return;
+            // A filter may outlive Git or ignore TERM. Keep the group escalation even after Git closes.
+            killTimer = setTimeout(() => {
+                signalGroup("SIGKILL");
+                killTimer = undefined;
+                settle();
+            }, 250);
+        };
+        const stop = (error) => {
+            if (failure)
+                return;
+            failure = error;
+            terminate();
+        };
+        const abort = () => stop(new Error("Git operation aborted", { cause: options.signal?.reason }));
+        const timer = setTimeout(() => stop(new Error(`Git command timed out (${args[0] ?? "unknown"})`)), options.timeoutMs ?? 30_000);
+        options.signal?.addEventListener("abort", abort, { once: true });
+        if (options.signal?.aborted)
+            abort();
+        const consume = (chunks, chunk) => {
+            size += chunk.length;
+            if (size > Math.min(options.maxOutputBytes ?? 16 * 1024 * 1024, 16 * 1024 * 1024))
+                stop(new Error("Git output exceeded the collection limit"));
+            else if (!failure)
+                chunks.push(chunk);
+        };
+        child.stdout.on("data", (chunk) => consume(stdout, chunk));
+        child.stderr.on("data", (chunk) => consume(stderr, chunk));
+        child.stdin.on("error", (error) => {
+            // A command can reject its arguments and close stdin before consuming the supplied bytes.
+            if (error.code !== "EPIPE" && error.code !== "ERR_STREAM_DESTROYED")
+                stop(error);
+        });
+        child.stdin.end(options.input);
+        child.on("error", (error) => {
+            failure ??= error;
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            closed = true;
+            exitCode = code;
+            terminate();
+            settle();
+        });
+    });
+}
+export function gitFailure(operation, result) {
+    const detail = result.stderr
+        .subarray(0, 1000)
+        .toString("utf8")
+        .replace(/\p{Cc}/gu, " ")
+        .trim();
+    return new Error(`Git ${operation} failed (${result.code})${detail ? `: ${detail}` : ""}`);
+}
+/** Refuse incomplete object stores before commands can request missing objects. Trusted filters remain enabled. */
+export async function preflightRepository(git, cwd, signal, objectPath) {
+    const result = await git(cwd, ["config", "--null", "--list"], { signal });
+    if (result.code !== 0)
+        throw gitFailure("configuration inspection", result);
+    const text = new TextDecoder("utf-8", { fatal: true }).decode(result.stdout);
+    if (text && !text.endsWith("\0"))
+        throw new Error("Git returned truncated configuration");
+    for (const record of text.split("\0").slice(0, -1)) {
+        const separator = record.indexOf("\n");
+        const key = (separator < 0 ? record : record.slice(0, separator)).toLowerCase();
+        const value = separator < 0 ? "" : record.slice(separator + 1);
+        if (key === "extensions.partialclone" ||
+            (/^remote\..+\.promisor$/s.test(key) && !/^(false|no|off|0)$/i.test(value.trim()))) {
+            throw new Error("Partial/promisor repositories are unsupported for read-only collection");
+        }
+    }
+    let path = objectPath;
+    if (path === undefined) {
+        const location = await git(cwd, ["rev-parse", "--path-format=absolute", "--git-path", "objects"], { signal });
+        if (location.code !== 0)
+            throw gitFailure("object-store location", location);
+        path = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(location.stdout).replace(/\n$/, "");
+    }
+    if (!path || path.includes("\0"))
+        throw new Error("Git returned an invalid object-store location");
+    const objects = isAbsolute(path) ? path : resolve(cwd, path);
+    try {
+        const names = await readdir(join(objects, "pack"));
+        if (names.some((name) => name.endsWith(".promisor"))) {
+            throw new Error("Partial/promisor repositories are unsupported for read-only collection");
+        }
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+}

package/dist/server/src/lib/loopback-access/index.d.ts

@@ -0,0 +1 @@
+export { AccessRejectedError, createRequestGuard } from "./internal/request-guard.ts";

package/dist/server/src/lib/loopback-access/index.js

@@ -0,0 +1 @@
+export { AccessRejectedError, createRequestGuard } from "./internal/request-guard.js";

package/dist/server/src/lib/loopback-access/internal/request-guard.d.ts

@@ -0,0 +1,9 @@
+import type { MiddlewareHandler } from "hono";
+export declare class AccessRejectedError extends Error {
+    constructor();
+}
+type Deps = {
+    port: number;
+};
+export declare function createRequestGuard({ port }: Deps): MiddlewareHandler;
+export {};

package/dist/server/src/lib/loopback-access/internal/request-guard.js

@@ -0,0 +1,17 @@
+export class AccessRejectedError extends Error {
+    constructor() {
+        super("Request forbidden");
+        this.name = "AccessRejectedError";
+    }
+}
+export function createRequestGuard({ port }) {
+    const host = `127.0.0.1:${port}`;
+    const origin = `http://${host}`;
+    return async (context, next) => {
+        const headers = context.req.raw.headers;
+        if (headers.get("host") !== host || (headers.has("origin") && headers.get("origin") !== origin)) {
+            throw new AccessRejectedError();
+        }
+        await next();
+    };
+}

package/dist/server/src/main.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import { readFile } from "node:fs/promises";
+import { findPackageJSON } from "node:module";
+import { fileURLToPath } from "node:url";
+import { inspect } from "./app/inspect.js";
+import { start } from "./app/startup.js";
+const usage = "forge serve --workspace <path>\nforge inspect-workspace <workspace.ts> <repository> <path> [previous-path]";
+const [command, ...args] = process.argv.slice(2);
+try {
+    if (command === "--help" || command === undefined) {
+        console.log(usage);
+    }
+    else if (command === "serve" && args.length === 2 && args[0] === "--workspace" && args[1] !== "") {
+        const manifestPath = findPackageJSON(import.meta.url);
+        if (manifestPath === undefined)
+            throw new Error("Forge package manifest was not found");
+        const manifest = JSON.parse(await readFile(manifestPath, "utf8"));
+        const server = await start({ workspace: args[1], cwd: process.cwd(), env: process.env });
+        console.log(`Forge @zdreamer/forge ${manifest.version}\nExecutable: ${JSON.stringify(fileURLToPath(import.meta.url))}\nWorkspace: ${JSON.stringify(server.snapshot.root)}\n${server.address}`);
+    }
+    else if (command === "inspect-workspace" && (args.length === 3 || args.length === 4)) {
+        const [modulePath, repo, path, from] = args;
+        console.log(JSON.stringify(await inspect(modulePath, repo, path, from)));
+    }
+    else {
+        console.error(`Usage: ${usage}`);
+        process.exitCode = 1;
+    }
+}
+catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+}

package/dist/server/src/workspace.d.ts

@@ -0,0 +1 @@
+export type { CodebaseContext, RepositoryDeclaration, WorkspaceChange, WorkspacePolicy, } from "./components/workspace-policy/authoring/index.ts";

package/dist/server/src/workspace.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zdreamer/forge",
-	"version": "0.1.1",
+	"version": "0.1.2",
 	"description": "Forge workspace application and typed workspace policy contract",
 	"license": "MIT",
 	"repository": {
@@ -17,12 +17,12 @@
 		"dist/"
 	],
 	"bin": {
-		"forge": "./dist/main.js"
+		"forge": "./dist/server/src/main.js"
 	},
 	"exports": {
 		"./workspace": {
-			"types": "./dist/workspace.d.ts",
-			"default": "./dist/workspace.js"
+			"types": "./dist/server/src/workspace.d.ts",
+			"default": "./dist/server/src/workspace.js"
 		}
 	},
 	"engines": {
@@ -31,7 +31,8 @@
 	"packageManager": "pnpm@11.15.1",
 	"scripts": {
 		"build": "node --input-type=module -e \"import { rmSync } from 'node:fs'; rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.build.json",
-		"check": "tsc --noEmit && biome check . && depcruise --config .dependency-cruiser.mjs 'src/**/*.ts' && node --test",
+		"check": "tsc --noEmit && biome check . && corepack pnpm --config.verify-deps-before-run=error run check:server && depcruise --config .dependency-cruiser.mjs server/src ui/src && node --test tools/*.test.ts",
+		"check:server": "tsc -p server/tsconfig.json --noEmit && tsc -p server/tsconfig.contract.json --noEmit && biome check server && cd server && depcruise --config .dependency-cruiser.mjs 'src/**/*.ts' && node --test",
 		"test:workspace": "node tools/workspace-consumer.ts"
 	},
 	"devDependencies": {
@@ -41,5 +42,9 @@
 		"@zdreamer/forge-ts-service": "0.1.1",
 		"dependency-cruiser": "18.2.0",
 		"typescript": "7.0.2"
+	},
+	"dependencies": {
+		"@hono/node-server": "2.1.4",
+		"hono": "4.13.13"
 	}
 }

package/dist/main.js

@@ -1,23 +0,0 @@
-#!/usr/bin/env node
-import { inspect } from "./app/inspect.js";
-const [command, modulePath, repo, path, from, ...extra] = process.argv.slice(2);
-if (command === "--help" || command === undefined) {
-    console.log("forge inspect-workspace <workspace.ts> <repository> <path> [previous-path]");
-}
-else if (command !== "inspect-workspace" ||
-    modulePath === undefined ||
-    repo === undefined ||
-    path === undefined ||
-    extra.length > 0) {
-    console.error("Usage: forge inspect-workspace <workspace.ts> <repository> <path> [previous-path]");
-    process.exitCode = 1;
-}
-else {
-    try {
-        console.log(JSON.stringify(await inspect(modulePath, repo, path, from)));
-    }
-    catch (error) {
-        console.error(error instanceof Error ? error.message : String(error));
-        process.exitCode = 1;
-    }
-}

package/dist/workspace.d.ts

@@ -1 +0,0 @@
-export type { CodebaseContext, RepositoryDeclaration, WorkspaceChange, WorkspacePolicy, } from "./components/workspace-policy/index.ts";