@goodfellow-cms/github 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Goodfellow contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,17 @@
-# Temporary Holding Version
+# @goodfellow-cms/github
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Edit a Goodfellow site stored on GitHub, straight from the browser: sign-in with an access token, publishing as single commits, conflict checks and deploy status.
+
+```tsx
+import { github } from "@goodfellow-cms/github";
+
+export default defineConfig({ blocks, backend: github({ repo: "your-name/your-site" }) });
+```
+
+[Goodfellow](https://github.com/chartung17/goodfellow-cms) is a website builder for people who aren't developers, with no server or database: pages are files in your own GitHub or GitLab repository, edited in a visual editor built on [Puck](https://puckeditor.com). To start a new site, run `npm create goodfellow@latest my-site`. See the [documentation](https://chartung17.github.io/goodfellow-cms/) for everything else.
+
+More in the docs: [Hosts and business sites](https://chartung17.github.io/goodfellow-cms/docs/hosts).
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,79 @@
+import { DeployStatus, FileChange, GitBackend, GitHost, GitUser, StorageLike, WriteOptions } from "@goodfellow-cms/core";
+//#region src/api.d.ts
+interface ApiOptions {
+  apiUrl: string;
+  token: string;
+  fetch: typeof fetch;
+}
+//#endregion
+//#region src/backend.d.ts
+interface GitHubBackendOptions {
+  api: ApiOptions;
+  repo: string;
+  branch: string;
+  user: GitUser;
+  onSignOut: () => void;
+}
+/**
+ * The site's files on GitHub. Reads come from the commit `revision()` last
+ * returned; saves are single commits made with GraphQL's `createCommitOnBranch`,
+ * which fails if the branch has moved, so nothing is ever overwritten.
+ */
+export declare class GitHubBackend implements GitBackend {
+  readonly user: GitUser;
+  private readonly api;
+  private readonly repo;
+  private readonly branch;
+  private readonly onSignOut;
+  private pinned?;
+  private readonly trees;
+  private readonly blobs;
+  constructor(options: GitHubBackendOptions);
+  revision(): Promise<string>;
+  /** Path → blob id for every file at a commit. Commits never change, so this is cached. */
+  private tree;
+  private currentTree;
+  read(path: string): Promise<string | undefined>;
+  readBytes(path: string): Promise<Uint8Array | undefined>;
+  list(dir: string): Promise<string[]>;
+  write(changes: FileChange[], { message, expectedRevision }: WriteOptions): Promise<{
+    revision: string;
+  }>;
+  changedPaths(from: string, to: string): Promise<string[]>;
+  /**
+   * Reads the deployment GitHub Pages or Vercel created for a commit. Before
+   * one exists, the site counts as building if it has ever been deployed.
+   */
+  deployStatus(revision: string): Promise<DeployStatus>;
+  signOut(): void;
+}
+//#endregion
+//#region src/index.d.ts
+export interface GitHubOptions {
+  /** The site's repository, as `owner/name`. */
+  repo: string;
+  /** The branch the live site is built from. Defaults to the repository's default branch. */
+  branch?: string;
+  /** For GitHub Enterprise. Defaults to `https://api.github.com`. */
+  apiUrl?: string;
+  /** For GitHub Enterprise. Defaults to `https://github.com`. */
+  webUrl?: string;
+  /** For tests. */
+  fetch?: typeof fetch;
+  /** For tests. */
+  storage?: {
+    local?: StorageLike;
+    session?: StorageLike;
+  };
+}
+/**
+ * Links to GitHub's token page with everything filled in except the
+ * repository, which GitHub doesn't let links choose.
+ */
+export declare function githubTokenLinks(repo: string, webUrl?: string): {
+  fineGrained: string;
+  classic: string;
+};
+/** Sign-in and storage for a site whose repository is on GitHub. */
+export declare function github(options: GitHubOptions): GitHost;
+//#endregion

package/dist/index.js

@@ -0,0 +1,265 @@
+import { ConflictError, GitApiError, SignInError, credentialStorage, encodeBase64, encodeBase64Bytes } from "@goodfellow-cms/core";
+//#region src/api.ts
+/** Calls the GitHub REST or GraphQL API. Treats 401 as an expired sign-in; other errors become `GitApiError`. */
+async function githubRequest({ apiUrl, token, fetch }, path, init = {}) {
+	const response = await fetch(`${apiUrl}${path}`, {
+		method: init.method ?? "GET",
+		headers: {
+			accept: init.accept ?? "application/vnd.github+json",
+			authorization: `Bearer ${token}`,
+			"x-github-api-version": "2022-11-28",
+			...init.body !== void 0 && { "content-type": "application/json" }
+		},
+		body: init.body === void 0 ? void 0 : JSON.stringify(init.body),
+		cache: "no-store"
+	});
+	if (response.status === 401) throw new SignInError("invalid", "GitHub didn't accept the sign-in. It may have expired.");
+	if (!response.ok && !init.allow?.includes(response.status)) {
+		const body = await response.json().catch(() => ({}));
+		throw new GitApiError(response.status, `GitHub answered ${response.status}: ${body.message ?? response.statusText}`);
+	}
+	return response;
+}
+async function githubJson(options, path, init) {
+	return await (await githubRequest(options, path, init)).json();
+}
+/** Path segments of a repository name, encoded for URLs: `owner/name` stays `owner/name`. */
+function repoPath(repo) {
+	return repo.split("/").map((part) => encodeURIComponent(part)).join("/");
+}
+//#endregion
+//#region src/backend.ts
+const COMMIT_MUTATION = `mutation ($input: CreateCommitOnBranchInput!) {
+  createCommitOnBranch(input: $input) { commit { oid } }
+}`;
+/**
+* The site's files on GitHub. Reads come from the commit `revision()` last
+* returned; saves are single commits made with GraphQL's `createCommitOnBranch`,
+* which fails if the branch has moved, so nothing is ever overwritten.
+*/
+var GitHubBackend = class {
+	user;
+	api;
+	repo;
+	branch;
+	onSignOut;
+	pinned;
+	trees = /* @__PURE__ */ new Map();
+	blobs = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.api = options.api;
+		this.repo = repoPath(options.repo);
+		this.branch = options.branch;
+		this.user = options.user;
+		this.onSignOut = options.onSignOut;
+	}
+	async revision() {
+		const ref = await githubJson(this.api, `/repos/${this.repo}/git/ref/heads/${encodeURIComponent(this.branch)}`);
+		this.pinned = ref.object.sha;
+		return this.pinned;
+	}
+	/** Path → blob id for every file at a commit. Commits never change, so this is cached. */
+	tree(sha) {
+		let tree = this.trees.get(sha);
+		if (!tree) {
+			tree = githubJson(this.api, `/repos/${this.repo}/git/trees/${sha}?recursive=1`).then((response) => {
+				if (response.truncated) throw new GitApiError(413, "The repository has too many files for GitHub to list at once.");
+				return new Map(response.tree.filter((entry) => entry.type === "blob").map((entry) => [entry.path, entry.sha]));
+			});
+			tree.catch(() => this.trees.delete(sha));
+			this.trees.set(sha, tree);
+		}
+		return tree;
+	}
+	async currentTree() {
+		return this.tree(this.pinned ?? await this.revision());
+	}
+	async read(path) {
+		const sha = (await this.currentTree()).get(path);
+		if (!sha) return void 0;
+		let blob = this.blobs.get(sha);
+		if (!blob) {
+			blob = githubRequest(this.api, `/repos/${this.repo}/git/blobs/${sha}`, { accept: "application/vnd.github.raw+json" }).then((response) => response.text());
+			blob.catch(() => this.blobs.delete(sha));
+			this.blobs.set(sha, blob);
+		}
+		return blob;
+	}
+	async readBytes(path) {
+		const sha = (await this.currentTree()).get(path);
+		if (!sha) return void 0;
+		const response = await githubRequest(this.api, `/repos/${this.repo}/git/blobs/${sha}`, { accept: "application/vnd.github.raw+json" });
+		return new Uint8Array(await response.arrayBuffer());
+	}
+	async list(dir) {
+		const prefix = `${dir}/`;
+		return [...(await this.currentTree()).keys()].filter((path) => path.startsWith(prefix)).sort();
+	}
+	async write(changes, { message, expectedRevision }) {
+		const existing = await this.tree(expectedRevision);
+		const additions = changes.flatMap((change) => "delete" in change ? [] : [{
+			path: change.path,
+			contents: "bytes" in change ? encodeBase64Bytes(change.bytes) : encodeBase64(change.content)
+		}]);
+		const deletions = changes.flatMap((change) => "delete" in change && existing.has(change.path) ? [{ path: change.path }] : []);
+		if (additions.length === 0 && deletions.length === 0) return { revision: expectedRevision };
+		const response = await githubJson(this.api, "/graphql", {
+			method: "POST",
+			body: {
+				query: COMMIT_MUTATION,
+				variables: { input: {
+					branch: {
+						repositoryNameWithOwner: decodeURIComponent(this.repo),
+						branchName: this.branch
+					},
+					message: { headline: message },
+					expectedHeadOid: expectedRevision,
+					fileChanges: {
+						additions,
+						deletions
+					}
+				} }
+			}
+		});
+		const oid = response.data?.createCommitOnBranch?.commit?.oid;
+		if (oid) {
+			this.pinned = oid;
+			return { revision: oid };
+		}
+		if (await this.revision() !== expectedRevision) throw new ConflictError();
+		const error = response.errors?.[0];
+		if (error?.type === "FORBIDDEN") throw new SignInError("cant-publish", "This GitHub account can't publish to the site.");
+		throw new GitApiError(422, `GitHub couldn't save the changes: ${error?.message ?? "unknown error"}`);
+	}
+	async changedPaths(from, to) {
+		const comparison = await githubJson(this.api, `/repos/${this.repo}/compare/${from}...${to}`);
+		return [...new Set((comparison.files ?? []).flatMap((file) => [file.filename, file.previous_filename ?? []].flat()))];
+	}
+	/**
+	* Reads the deployment GitHub Pages or Vercel created for a commit. Before
+	* one exists, the site counts as building if it has ever been deployed.
+	*/
+	async deployStatus(revision) {
+		try {
+			const latest = (await githubJson(this.api, `/repos/${this.repo}/deployments?sha=${revision}&per_page=5`))[0];
+			if (!latest) return { state: (await githubJson(this.api, `/repos/${this.repo}/deployments?per_page=1`)).length > 0 ? "building" : "unknown" };
+			const [status] = await githubJson(this.api, `/repos/${this.repo}/deployments/${latest.id}/statuses?per_page=1`);
+			const detailsUrl = status?.log_url || status?.target_url || void 0;
+			switch (status?.state) {
+				case "success":
+				case "inactive": return {
+					state: "live",
+					detailsUrl
+				};
+				case "failure":
+				case "error": return {
+					state: "failed",
+					detailsUrl
+				};
+				default: return {
+					state: "building",
+					detailsUrl
+				};
+			}
+		} catch (error) {
+			if (error instanceof GitApiError) return { state: "unknown" };
+			throw error;
+		}
+	}
+	signOut() {
+		this.onSignOut();
+	}
+};
+//#endregion
+//#region src/index.ts
+/**
+* Links to GitHub's token page with everything filled in except the
+* repository, which GitHub doesn't let links choose.
+*/
+function githubTokenLinks(repo, webUrl = "https://github.com") {
+	const [owner = ""] = repo.split("/");
+	const fineGrained = new URLSearchParams({
+		name: "Goodfellow admin",
+		description: `Edit ${repo} in its admin panel`,
+		target_name: owner,
+		expires_in: "90",
+		contents: "write",
+		deployments: "read"
+	});
+	const classic = new URLSearchParams({
+		scopes: "repo",
+		description: `Goodfellow admin for ${repo}`
+	});
+	return {
+		fineGrained: `${webUrl}/settings/personal-access-tokens/new?${fineGrained}`,
+		classic: `${webUrl}/settings/tokens/new?${classic}`
+	};
+}
+/** Sign-in and storage for a site whose repository is on GitHub. */
+function github(options) {
+	if (!/^[\w.-]+\/[\w.-]+$/.test(options.repo)) throw new Error(`github({ repo }) must look like "owner/name" (got "${options.repo}").`);
+	const apiUrl = (options.apiUrl ?? "https://api.github.com").replace(/\/$/, "");
+	const links = githubTokenLinks(options.repo, options.webUrl);
+	const storage = credentialStorage(`goodfellow:github:${options.repo}`, options.storage);
+	async function connect(token) {
+		const api = {
+			apiUrl,
+			token,
+			fetch: options.fetch ?? globalThis.fetch.bind(globalThis)
+		};
+		const user = await githubJson(api, "/user");
+		let repo;
+		try {
+			repo = await githubJson(api, `/repos/${repoPath(options.repo)}`);
+		} catch (error) {
+			if (error instanceof GitApiError && (error.status === 404 || error.status === 403)) throw new SignInError("no-access", `The GitHub account ${user.login} can't see ${options.repo}.`);
+			throw error;
+		}
+		if (repo.permissions?.push === false) throw new SignInError("cant-publish", `The GitHub account ${user.login} can see ${options.repo} but can't publish to it.`);
+		return new GitHubBackend({
+			api,
+			repo: options.repo,
+			branch: options.branch ?? repo.default_branch,
+			user: {
+				login: user.login,
+				name: user.name ?? void 0,
+				avatarUrl: user.avatar_url
+			},
+			onSignOut: () => storage.clear()
+		});
+	}
+	return {
+		name: "GitHub",
+		canRedirect: false,
+		tokenLinks: [{
+			url: links.fineGrained,
+			label: "signIn.token.create"
+		}, {
+			url: links.classic,
+			label: "signIn.token.createBroad",
+			hint: "signIn.token.createBroadHint"
+		}],
+		async restore() {
+			const token = storage.load();
+			if (!token) return null;
+			try {
+				return await connect(token);
+			} catch (error) {
+				if (error instanceof SignInError) storage.clear();
+				throw error;
+			}
+		},
+		async signInWithToken(token, remember) {
+			const trimmed = token.trim();
+			if (!trimmed) throw new SignInError("invalid", "Paste a token to sign in.");
+			const backend = await connect(trimmed);
+			storage.save(trimmed, remember);
+			return backend;
+		},
+		async startRedirect() {
+			throw new Error("Signing in by redirect needs a sign-in server, which isn't supported for GitHub yet.");
+		}
+	};
+}
+//#endregion
+export { GitHubBackend, github, githubTokenLinks };

package/dist/testing.d.ts

@@ -0,0 +1,44 @@
+import { FileChange } from "@goodfellow-cms/core";
+import { FakeRepo } from "@goodfellow-cms/core/testing";
+//#region src/testing.d.ts
+export interface FakeGitHubUser {
+  login: string;
+  name?: string;
+  /** Whether the user may publish. Defaults to true. */
+  push?: boolean;
+}
+export interface FakeDeploymentStatus {
+  state: "queued" | "in_progress" | "success" | "failure" | "error" | "inactive";
+  log_url?: string;
+}
+export interface FakeGitHubOptions {
+  /** `owner/name`. */
+  repo: string;
+  files?: Record<string, string>;
+  /** Access tokens and the users they belong to. */
+  tokens?: Record<string, FakeGitHubUser>;
+  /**
+   * Simulates GitHub Pages or Vercel: every commit gets a deployment that
+   * reports success after being checked this many times. Off by default.
+   */
+  deployAfterChecks?: number;
+}
+interface Deployment {
+  id: number;
+  sha: string;
+  statuses: FakeDeploymentStatus[];
+  checks: number;
+}
+export declare function fakeGitHub(options: FakeGitHubOptions): {
+  repo: FakeRepo;
+  deployments: Deployment[];
+  /** Every request received, for checking what the backend sent. */
+  requests: Request[];
+  /** Simulates someone else publishing. */
+  commit: (changes: FileChange[], message: string, expectedHead?: string) => string;
+  handle: (request: Request) => Promise<Response>;
+  /** A `fetch` that answers from the fake instead of the network. */
+  fetch: typeof fetch;
+};
+export type FakeGitHub = ReturnType<typeof fakeGitHub>;
+//#endregion

package/dist/testing.js

@@ -0,0 +1,155 @@
+import { decodeBase64, encodeBase64Bytes } from "@goodfellow-cms/core";
+import { FakeConflictError, FakeRepo, fakeFileBytes } from "@goodfellow-cms/core/testing";
+//#region src/testing.ts
+/**
+* A fake of the parts of GitHub's API that `@goodfellow-cms/github` uses, backed by
+* an in-memory repository. For tests only: pass `fake.fetch` as the backend's
+* `fetch`, or route browser requests to `fake.handle` in end-to-end tests.
+*/
+function json(body, status = 200) {
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: { "content-type": "application/json" }
+	});
+}
+function fakeGitHub(options) {
+	const repo = new FakeRepo(options.files);
+	const tokens = options.tokens ?? { "test-token": {
+		login: "editor",
+		name: "Test Editor"
+	} };
+	const deployments = [];
+	const requests = [];
+	let nextDeployment = 1;
+	function deploy(sha) {
+		if (options.deployAfterChecks === void 0) return;
+		deployments.unshift({
+			id: nextDeployment++,
+			sha,
+			statuses: [{ state: "in_progress" }],
+			checks: 0
+		});
+	}
+	function commit(changes, message, expectedHead) {
+		const sha = repo.commit(changes, message, { expectedHead });
+		deploy(sha);
+		return sha;
+	}
+	async function handle(request) {
+		requests.push(request.clone());
+		const url = new URL(request.url);
+		const path = url.pathname;
+		const user = tokens[request.headers.get("authorization")?.replace(/^Bearer /, "") ?? ""];
+		if (!user) return json({ message: "Bad credentials" }, 401);
+		if (path === "/user") return json({
+			login: user.login,
+			name: user.name ?? null,
+			avatar_url: `https://avatars.example/${user.login}`
+		});
+		if (path === "/graphql" && request.method === "POST") {
+			const { variables } = await request.json();
+			const { input } = variables;
+			if (input.branch.repositoryNameWithOwner !== options.repo) return json({ errors: [{
+				type: "NOT_FOUND",
+				message: "Could not resolve to a Repository"
+			}] });
+			if (user.push === false) return json({ errors: [{
+				type: "FORBIDDEN",
+				message: "Resource not accessible"
+			}] });
+			const files = repo.files(input.branch.branchName);
+			for (const deletion of input.fileChanges.deletions ?? []) if (!files.has(deletion.path)) return json({ errors: [{ message: `No file at ${deletion.path}` }] });
+			try {
+				return json({ data: { createCommitOnBranch: { commit: { oid: commit([...(input.fileChanges.additions ?? []).map((addition) => ({
+					path: addition.path,
+					bytes: decodeBase64(addition.contents)
+				})), ...(input.fileChanges.deletions ?? []).map((deletion) => ({
+					path: deletion.path,
+					delete: true
+				}))], input.message.headline, input.expectedHeadOid) } } } });
+			} catch (error) {
+				if (error instanceof FakeConflictError) return json({
+					data: { createCommitOnBranch: null },
+					errors: [{
+						type: "STALE_DATA",
+						message: "Expected branch to point to another commit"
+					}]
+				});
+				throw error;
+			}
+		}
+		const match = path.match(/^\/repos\/([^/]+\/[^/]+)(\/.*)?$/);
+		if (!match || decodeURIComponent(match[1] ?? "") !== options.repo) return json({ message: "Not Found" }, 404);
+		const rest = match[2] ?? "";
+		if (rest === "") return json({
+			full_name: options.repo,
+			default_branch: repo.defaultBranch,
+			permissions: { push: user.push !== false }
+		});
+		const ref = rest.match(/^\/git\/ref\/heads\/(.+)$/);
+		if (ref) {
+			const sha = repo.branches.get(decodeURIComponent(ref[1] ?? ""));
+			return sha ? json({ object: {
+				sha,
+				type: "commit"
+			} }) : json({ message: "Not Found" }, 404);
+		}
+		const tree = rest.match(/^\/git\/trees\/([0-9a-f]{40})$/);
+		if (tree) {
+			const commitSha = tree[1] ?? "";
+			if (!repo.commitAt(commitSha)) return json({ message: "Not Found" }, 404);
+			return json({
+				sha: commitSha,
+				tree: [...repo.files(commitSha)].map(([file, content]) => ({
+					path: file,
+					type: "blob",
+					sha: repo.blobSha(content)
+				})),
+				truncated: false
+			});
+		}
+		const blob = rest.match(/^\/git\/blobs\/([0-9a-f]{40})$/);
+		if (blob) {
+			const content = repo.blobs.get(blob[1] ?? "");
+			if (content === void 0) return json({ message: "Not Found" }, 404);
+			return request.headers.get("accept")?.includes("raw") ? new Response(fakeFileBytes(content)) : json({
+				content: encodeBase64Bytes(fakeFileBytes(content)),
+				encoding: "base64"
+			});
+		}
+		const compare = rest.match(/^\/compare\/([0-9a-f]{40})\.\.\.([0-9a-f]{40})$/);
+		if (compare) return json({ files: repo.changedPaths(compare[1] ?? "", compare[2] ?? "").map((filename) => ({ filename })) });
+		if (rest === "/deployments") {
+			const sha = url.searchParams.get("sha");
+			return json(deployments.filter((deployment) => !sha || deployment.sha === sha).slice(0, Number(url.searchParams.get("per_page") ?? 30)).map(({ id, sha }) => ({
+				id,
+				sha
+			})));
+		}
+		const statuses = rest.match(/^\/deployments\/(\d+)\/statuses$/);
+		if (statuses) {
+			const deployment = deployments.find((candidate) => candidate.id === Number(statuses[1]));
+			if (!deployment) return json({ message: "Not Found" }, 404);
+			deployment.checks += 1;
+			if (deployment.checks > (options.deployAfterChecks ?? 0) && deployment.statuses[0]?.state === "in_progress") deployment.statuses.unshift({
+				state: "success",
+				log_url: `https://github.com/${options.repo}/actions/runs/${deployment.id}`
+			});
+			return json(deployment.statuses);
+		}
+		return json({ message: "Not Found" }, 404);
+	}
+	return {
+		repo,
+		deployments,
+		/** Every request received, for checking what the backend sent. */
+		requests,
+		/** Simulates someone else publishing. */
+		commit,
+		handle,
+		/** A `fetch` that answers from the fake instead of the network. */
+		fetch: ((input, init) => handle(new Request(input, init)))
+	};
+}
+//#endregion
+export { fakeGitHub };

package/package.json

@@ -1,6 +1,54 @@
 {
   "name": "@goodfellow-cms/github",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Edit a Goodfellow site stored on GitHub, straight from the browser.",
+  "keywords": [
+    "goodfellow",
+    "cms",
+    "website-builder",
+    "puck",
+    "github",
+    "git-based-cms"
+  ],
+  "homepage": "https://chartung17.github.io/goodfellow-cms/docs/hosts",
+  "bugs": "https://github.com/chartung17/goodfellow-cms/issues",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/chartung17/goodfellow-cms.git",
+    "directory": "packages/github"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./testing": {
+      "types": "./dist/testing.d.ts",
+      "import": "./dist/testing.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@goodfellow-cms/core": "0.1.0"
+  },
+  "devDependencies": {
+    "@puckeditor/core": "0.23.0"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc -p tsconfig.json",
+    "test": "vitest run"
+  }
 }