import { spawnSync } from "node:child_process";
import * as fs from "node:fs";
import * as fsp from "node:fs/promises";
import * as path from "node:path";
function run(cmd, args, opts = {}) {
return spawnSync(cmd, args, {
stdio: ["ignore", "pipe", "pipe"],
encoding: "utf8",
shell: false,
...opts,
});
}
function runInherit(cmd, args, opts = {}) {
return spawnSync(cmd, args, {
stdio: "inherit",
encoding: "utf8",
shell: false,
...opts,
});
}
function normalizeRelPath(p) {
return String(p || "").replace(/\\/g, "/");
}
function readJsonIfExists(filePath) {
try {
if (!fs.existsSync(filePath)) return undefined;
const raw = fs.readFileSync(filePath, "utf8");
return JSON.parse(raw);
} catch {
return undefined;
}
}
function detectTypeScriptProject() {
if (fs.existsSync("tsconfig.json")) return true;
const pkg = readJsonIfExists("package.json");
const buildScript = String(pkg?.scripts?.build || "");
if (buildScript.includes("tsc")) return true;
if (pkg?.devDependencies?.typescript) return true;
return false;
}
function detectDistEntry() {
// default requested: /dist/index.js
const defaultEntry = "dist/index.js";
const pkg = readJsonIfExists("package.json");
const start = String(pkg?.scripts?.start || "").trim();
const m = /^node\s+(.+)$/.exec(start);
const inferred = m && m[1] ? String(m[1]).trim() : "";
const entry = inferred || defaultEntry;
return normalizeRelPath(entry);
}
function ensureGitRepoRoot() {
const r = run("git", ["rev-parse", "--show-toplevel"], { cwd: process.cwd() });
if (r.status !== 0) {
const err = (r.stderr || r.stdout || "").trim();
throw new Error(
"git repo is required for packaging (to respect .gitignore).\n" + err,
);
}
const top = String(r.stdout || "").trim();
if (!top) throw new Error("Failed to resolve git repo root");
process.chdir(top);
return top;
}
function gitFileList() {
const r = run("git", [
"ls-files",
"-z",
"--cached",
"--others",
"--exclude-standard",
]);
if (r.status !== 0) {
const err = (r.stderr || r.stdout || "").trim();
throw new Error(
"git is required for packaging (and to respect .gitignore).\n" + err,
);
}
const raw = r.stdout || "";
return raw.split("\u0000").filter(Boolean).map(normalizeRelPath);
}
function shouldExcludeFromPackage(relPath) {
const p = normalizeRelPath(relPath);
if (!p) return true;
// 1) scripts/package.mjs does not need to be packaged
if (p === "scripts/package.mjs") return true;
// temp files created by this script
if (p.startsWith(".glosc-tmp/")) return true;
return false;
}
function uniqStable(list) {
const seen = new Set();
const out = [];
for (const item of list) {
if (seen.has(item)) continue;
seen.add(item);
out.push(item);
}
return out;
}
async function ensureDir(p) {
await fsp.mkdir(p, { recursive: true });
}
async function prepareTmpDir() {
const tmpDir = path.join(process.cwd(), ".glosc-tmp");
await fsp.rm(tmpDir, { recursive: true, force: true });
await ensureDir(tmpDir);
return tmpDir;
}
async function writeNulSeparatedList(tmpDir, filePaths) {
// Use NUL-separated pathspec so we can pass it to git safely (no quoting issues).
const listPath = path.join(tmpDir, "pathspec.nul");
const normalized = filePaths.map(normalizeRelPath);
const buf = Buffer.from(normalized.join(" ") + " ", "utf8");
await fsp.writeFile(listPath, buf);
return listPath;
}
function gitArchiveZipFromWorkingTreeFiles(outZip, filePaths) {
// Create a temporary index so we can archive *tracked + untracked* files without
// touching the user's real index or requiring a commit.
const tmpIndex = path.join(process.cwd(), ".glosc-tmp", "index");
const env = { ...process.env, GIT_INDEX_FILE: tmpIndex };
// Add files (force-add so ignored build output like dist/index.js can be included).
const add = run(
"git",
[
"add",
"-f",
"--pathspec-from-file=.glosc-tmp/pathspec.nul",
"--pathspec-file-nul",
"--",
],
{ cwd: process.cwd(), env },
);
if (add.status !== 0) {
// Fallback for older Git versions without --pathspec-from-file.
const chunkSize = 200;
for (let i = 0; i < filePaths.length; i += chunkSize) {
const chunk = filePaths.slice(i, i + chunkSize);
const r = run("git", ["add", "-f", "--", ...chunk], { cwd: process.cwd(), env });
if (r.status !== 0) {
const err = (r.stderr || r.stdout || "").trim();
throw new Error("git add (temp index) failed\n" + err);
}
}
}
const wt = run("git", ["write-tree"], { cwd: process.cwd(), env });
if (wt.status !== 0) {
const err = (wt.stderr || wt.stdout || "").trim();
throw new Error("git write-tree failed\n" + err);
}
const tree = String(wt.stdout || "").trim();
if (!tree) throw new Error("git write-tree produced empty tree hash");
const ar = run(
"git",
["archive", "--format=zip", "--output", outZip, tree],
{ cwd: process.cwd() },
);
if (ar.status !== 0) {
const err = (ar.stderr || ar.stdout || "").trim();
throw new Error("git archive failed\n" + err);
}
}
function timestamp() {
const d = new Date();
const pad = (n) => String(n).padStart(2, "0");
return (
String(d.getFullYear()) +
pad(d.getMonth() + 1) +
pad(d.getDate()) +
"-" +
pad(d.getHours()) +
pad(d.getMinutes()) +
pad(d.getSeconds())
);
}
async function main() {
ensureGitRepoRoot();
const isTs = detectTypeScriptProject();
const distEntry = detectDistEntry();
const isWin = process.platform === "win32";
// 2) For TypeScript, run build and package dist entry
if (isTs) {
const r = isWin
? runInherit("cmd", ["/d", "/s", "/c", "npm run build"], { cwd: process.cwd() })
: runInherit("npm", ["run", "build"], { cwd: process.cwd() });
if (r.error) throw new Error("Failed to run npm: " + String(r.error?.message || r.error));
if (r.status !== 0) throw new Error("npm run build failed");
if (!fs.existsSync(distEntry)) {
throw new Error("Expected build output missing: " + distEntry);
}
}
let files = gitFileList().filter((p) => !shouldExcludeFromPackage(p));
if (isTs) {
// dist/ is typically ignored; ensure we still include the built entry
files = files.filter((p) => !p.startsWith("dist/"));
files.push(distEntry);
}
files = uniqStable(files);
if (files.length === 0) {
throw new Error(
"No files found to package. If you just created the project, make sure git is initialized and .gitignore exists.",
);
}
const outDir = path.join(process.cwd(), "dist");
await ensureDir(outDir);
const outZip = path.join(outDir, "glosc-package-" + timestamp() + ".zip");
const tmpDir = await prepareTmpDir();
try {
await writeNulSeparatedList(tmpDir, files);
gitArchiveZipFromWorkingTreeFiles(outZip, files);
} finally {
try {
await fsp.rm(tmpDir, { recursive: true, force: true });
} catch {
// ignore
}
}
const st = await fsp.stat(outZip).catch(() => undefined);
if (!st || st.size <= 0) {
throw new Error("Packaging failed: zip was not created: " + outZip);
}
console.log("Created: " + outZip);
}
main().catch((err) => {
console.error(String(err?.message || err));
process.exit(1);
});
