gutterpress 0.0.0

package/dist/index-5bxx0c4y.js

@@ -0,0 +1,464 @@
+import {
+  capabilitiesFor,
+  detectProjectSource,
+  findEnclosingRepoDir
+} from "./index-1tyj4bk3.js";
+
+// src/lib/source-provider.ts
+import * as fs from "node:fs";
+import path2 from "node:path";
+import git from "isomorphic-git";
+
+// src/lib/remote-auth/operation-log.ts
+import { appendFileSync, mkdirSync } from "node:fs";
+import path from "node:path";
+var noop = {
+  debug: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {}
+};
+var LEVEL_ORDER = { debug: 0, info: 1, warn: 2, error: 3 };
+function createFileLogger(logFile, operation, minLevel = "debug") {
+  try {
+    mkdirSync(path.dirname(logFile), { recursive: true });
+  } catch {
+    return noop;
+  }
+  function write(level, step, message, data) {
+    if (LEVEL_ORDER[level] < LEVEL_ORDER[minLevel])
+      return;
+    const ts = new Date().toISOString();
+    const fields = formatData(data);
+    const line = `[${ts}] ${level.toUpperCase().padEnd(5)} ${operation}: step=${step}${fields} | ${message}
+`;
+    try {
+      appendFileSync(logFile, line, "utf8");
+    } catch {}
+  }
+  return {
+    debug: (step, message, data) => write("debug", step, message, data),
+    info: (step, message, data) => write("info", step, message, data),
+    warn: (step, message, data) => write("warn", step, message, data),
+    error: (step, message, data) => write("error", step, message, data)
+  };
+}
+function resolveLogger(logFile, operation) {
+  if (!logFile)
+    return noop;
+  return createFileLogger(logFile, operation);
+}
+function formatData(data) {
+  if (!data)
+    return "";
+  const parts = [];
+  for (const [key, value] of Object.entries(data)) {
+    if (value === undefined)
+      continue;
+    if (Array.isArray(value)) {
+      parts.push(`${key}=${value.join(",")}`);
+    } else {
+      parts.push(`${key}=${String(value)}`);
+    }
+  }
+  return parts.length > 0 ? " " + parts.join(" ") : "";
+}
+function shortOid(oid) {
+  return oid.length >= 7 ? oid.slice(0, 7) : oid;
+}
+
+// src/lib/source-provider.ts
+var noopLogger = {
+  debug: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {}
+};
+function gitScopeFor(source) {
+  return source.repoRoot || source.path;
+}
+var HISTORY_PAGE_LIMIT = 100;
+var DEFAULT_AUTHOR = "gutterpress";
+var DEFAULT_EMAIL = "noreply@gutterpress.local";
+var DEFAULT_BRANCH = "main";
+var SNAPSHOT_STAGING_MARKER = "gutterpress-snapshot-staging";
+var repoQueues = new Map;
+function repoLockKey(projectDir) {
+  const resolved = path2.resolve(projectDir);
+  try {
+    return fs.realpathSync(resolved);
+  } catch {
+    return resolved;
+  }
+}
+function withRepoLock(projectDir, fn) {
+  const key = repoLockKey(projectDir);
+  const prev = repoQueues.get(key) ?? Promise.resolve();
+  const run = prev.then(fn, fn);
+  const tail = run.then(() => {
+    return;
+  }, () => {
+    return;
+  });
+  repoQueues.set(key, tail);
+  tail.then(() => {
+    if (repoQueues.get(key) === tail)
+      repoQueues.delete(key);
+  });
+  return run;
+}
+function __repoLockQueueSizeForTests() {
+  return repoQueues.size;
+}
+function gitAuthor(name, email) {
+  const n = (name ?? "").trim();
+  const e = (email ?? "").trim();
+  return { name: n || DEFAULT_AUTHOR, email: e || DEFAULT_EMAIL };
+}
+async function readGitAuthor(dir) {
+  const [name, email] = await Promise.all([
+    git.getConfig({ fs, dir, path: "user.name" }).catch(() => {
+      return;
+    }),
+    git.getConfig({ fs, dir, path: "user.email" }).catch(() => {
+      return;
+    })
+  ]);
+  return {
+    name: typeof name === "string" ? name : undefined,
+    email: typeof email === "string" ? email : undefined
+  };
+}
+async function resolveGitAuthor(dir, name, email) {
+  const existing = await readGitAuthor(dir);
+  return gitAuthor(name || existing.name, email || existing.email);
+}
+async function listWorkdirChanges(dir, cache = {}) {
+  const adds = [];
+  const removes = [];
+  await git.walk({
+    fs,
+    dir,
+    cache,
+    trees: [git.WORKDIR(), git.STAGE()],
+    map: async (filepath, [workdir, stage]) => {
+      if (filepath === ".")
+        return;
+      if (!stage && workdir && await git.isIgnored({ fs, dir, filepath })) {
+        return null;
+      }
+      const [wType, sType] = await Promise.all([
+        workdir ? workdir.type() : Promise.resolve(undefined),
+        stage ? stage.type() : Promise.resolve(undefined)
+      ]);
+      if (wType === "tree" || sType === "tree") {
+        if (sType === "blob")
+          removes.push(filepath);
+        else if (wType === "blob")
+          adds.push(filepath);
+        return;
+      }
+      if (wType === "blob" && !sType) {
+        adds.push(filepath);
+      } else if (!wType && sType === "blob") {
+        removes.push(filepath);
+      } else if (wType === "blob" && sType === "blob") {
+        const workdirOid = await workdir.oid();
+        const stageOid = await stage.oid();
+        if (workdirOid !== stageOid) {
+          adds.push(filepath);
+        } else {
+          const fileBytes = await fs.promises.readFile(path2.join(dir, filepath));
+          const { oid: actualOid } = await git.hashBlob({ object: fileBytes });
+          if (actualOid !== stageOid)
+            adds.push(filepath);
+        }
+      }
+      return;
+    }
+  });
+  return { adds, removes };
+}
+async function stageChanges(dir, changes, cache) {
+  if (changes.adds.length > 0) {
+    await git.add({ fs, dir, cache, filepath: changes.adds });
+  }
+  for (const filepath of changes.removes) {
+    await git.remove({ fs, dir, cache, filepath });
+  }
+}
+async function hasPendingChanges(dir, cache = {}) {
+  const { adds, removes } = await listWorkdirChanges(dir, cache);
+  return adds.length > 0 || removes.length > 0;
+}
+async function hasUncommittedChanges(dir, cache = {}) {
+  if (await hasPendingChanges(dir, cache))
+    return true;
+  return !await stageMatchesHead(dir, cache);
+}
+async function stageMatchesHead(dir, cache) {
+  let headOid;
+  try {
+    headOid = await git.resolveRef({ fs, dir, ref: "HEAD" });
+  } catch {
+    return false;
+  }
+  let differs = false;
+  await git.walk({
+    fs,
+    dir,
+    cache,
+    trees: [git.TREE({ ref: headOid }), git.STAGE()],
+    map: async (filepath, [tree, stage]) => {
+      if (differs || filepath === ".")
+        return differs ? null : undefined;
+      const [tType, sType] = await Promise.all([
+        tree ? tree.type() : Promise.resolve(undefined),
+        stage ? stage.type() : Promise.resolve(undefined)
+      ]);
+      if (tType === "tree" || sType === "tree")
+        return;
+      if (!tType !== !sType) {
+        differs = true;
+        return null;
+      }
+      if (!tType || !sType)
+        return;
+      const [tOid, sOid] = await Promise.all([tree.oid(), stage.oid()]);
+      if (tOid !== sOid)
+        differs = true;
+      return null;
+    }
+  });
+  return !differs;
+}
+
+class LocalFolderSourceProvider {
+  source;
+  capabilities;
+  constructor(source) {
+    this.source = source;
+    this.capabilities = capabilitiesFor(source);
+  }
+  async initVersionHistory(options) {
+    const dir = options.projectDir;
+    if (await findEnclosingRepoDir(dir) !== undefined) {
+      throw new Error("This folder is already inside a versioned project, so gutterpress " + "won't create a separate history here.");
+    }
+    return withRepoLock(dir, async () => {
+      const cache = {};
+      await git.init({ fs, dir, defaultBranch: DEFAULT_BRANCH });
+      await stageChanges(dir, await listWorkdirChanges(dir, cache), cache);
+      await git.commit({
+        fs,
+        dir,
+        cache,
+        message: options.initialMessage?.trim() || "Created project",
+        author: await resolveGitAuthor(dir, options.authorName, options.authorEmail)
+      });
+      return {
+        type: "local-git-folder",
+        path: dir,
+        repoRoot: dir,
+        subPath: "",
+        hasRemote: false,
+        branch: DEFAULT_BRANCH
+      };
+    });
+  }
+  snapshot() {
+    return Promise.reject(new Error("This project has no version history yet. Enable version history first."));
+  }
+  listHistory() {
+    return Promise.resolve([]);
+  }
+  listHistoryPage() {
+    return Promise.resolve({ entries: [], hasMore: false });
+  }
+  restore() {
+    return Promise.reject(new Error("This project has no version history yet. Enable version history first."));
+  }
+}
+
+class LocalGitSourceProvider {
+  source;
+  capabilities;
+  dir;
+  constructor(source) {
+    this.source = source;
+    this.capabilities = capabilitiesFor(source);
+    this.dir = gitScopeFor(source);
+  }
+  async initVersionHistory(options) {
+    try {
+      await this.snapshot({
+        projectDir: options.projectDir,
+        message: options.initialMessage?.trim() || "Created project",
+        authorName: options.authorName,
+        authorEmail: options.authorEmail
+      });
+    } catch (e) {
+      if (!isNoChangesError(e))
+        throw e;
+    }
+    return this.source;
+  }
+  snapshot(options) {
+    return withRepoLock(this.dir, () => this.snapshotUnlocked(options));
+  }
+  snapshotUnlocked(options) {
+    return snapshotWorkingTreeUnlocked({ ...options, repoRoot: this.dir });
+  }
+  async listHistory(projectDir) {
+    return (await this.listHistoryPage(projectDir)).entries;
+  }
+  async listHistoryPage(_projectDir, options = {}) {
+    const dir = this.dir;
+    const limit = Math.min(500, Math.max(1, options.limit ?? HISTORY_PAGE_LIMIT));
+    const before = options.before;
+    let commits;
+    try {
+      commits = await git.log({
+        fs,
+        dir,
+        cache: {},
+        depth: limit + 2,
+        ...before ? { ref: before } : {}
+      });
+    } catch (e) {
+      if (before && e?.code === "NotFoundError") {
+        return { entries: [], hasMore: false };
+      }
+      throw e;
+    }
+    const seen = new Set;
+    let filtered = commits.filter((c) => {
+      if (c.oid === before || seen.has(c.oid))
+        return false;
+      seen.add(c.oid);
+      return true;
+    });
+    const hasMore = filtered.length > limit;
+    if (hasMore)
+      filtered = filtered.slice(0, limit);
+    return {
+      entries: filtered.map((c) => ({
+        id: c.oid,
+        message: c.commit.message.trim(),
+        timestamp: c.commit.author.timestamp * 1000,
+        author: c.commit.author.name
+      })),
+      hasMore
+    };
+  }
+  restore(options) {
+    return withRepoLock(this.dir, () => this.restoreUnlocked(options));
+  }
+  async restoreUnlocked(options) {
+    await git.checkout({
+      fs,
+      dir: this.dir,
+      cache: {},
+      ref: options.id,
+      force: true,
+      noUpdateHead: true
+    });
+  }
+}
+async function snapshotWorkingTreeUnlocked(options) {
+  const dir = options.repoRoot ?? options.projectDir;
+  const logger = options.logFile ? createFileLogger(options.logFile, "snapshot") : noopLogger;
+  const cache = {};
+  const stagingMarker = snapshotStagingMarkerPath(dir);
+  const staleStaging = fs.existsSync(stagingMarker);
+  const changes = await listWorkdirChanges(dir, cache);
+  const workdirClean = changes.adds.length === 0 && changes.removes.length === 0;
+  if (workdirClean && !staleStaging) {
+    logger.debug("snapshot", "no changes — skipping");
+    throw new Error("No changes since the last snapshot — there is nothing new to save.");
+  }
+  if (workdirClean && staleStaging && await stageMatchesHead(dir, cache)) {
+    logger.debug("snapshot", "stale marker outlived a completed commit — clearing, not recommitting");
+    fs.rmSync(stagingMarker, { force: true });
+    const [head2] = await git.log({ fs, dir, cache, depth: 1 });
+    return {
+      id: head2.oid,
+      message: head2.commit.message.trim(),
+      timestamp: head2.commit.author.timestamp * 1000,
+      author: head2.commit.author.name
+    };
+  }
+  logger.info("snapshot", "committing", {
+    adds: changes.adds.length,
+    removes: changes.removes.length,
+    ...staleStaging ? { recoveredStaleStaging: true } : {}
+  });
+  fs.writeFileSync(stagingMarker, "");
+  await stageChanges(dir, changes, cache);
+  const author = await resolveGitAuthor(dir, options.authorName, options.authorEmail);
+  const id = await git.commit({
+    fs,
+    dir,
+    cache,
+    message: options.message,
+    author
+  });
+  fs.rmSync(stagingMarker, { force: true });
+  const [head] = await git.log({ fs, dir, cache, depth: 1 });
+  return {
+    id,
+    message: options.message,
+    timestamp: head ? head.commit.author.timestamp * 1000 : Date.now(),
+    author: author.name
+  };
+}
+function isNoChangesError(e) {
+  return e instanceof Error && /no changes since the last snapshot/i.test(e.message);
+}
+function providerFor(source) {
+  switch (source.type) {
+    case "local-folder":
+      return new LocalFolderSourceProvider(source);
+    case "local-git-folder":
+      return new LocalGitSourceProvider(source);
+    case "managed-github":
+      throw new Error("Managed GitHub projects are not supported yet (#15/#16).");
+  }
+}
+function gitDirFor(projectDir) {
+  return path2.join(projectDir, ".git");
+}
+function snapshotStagingMarkerPath(projectDir) {
+  return path2.join(gitDirFor(projectDir), SNAPSHOT_STAGING_MARKER);
+}
+var RESTORE_BACKUP_MESSAGE = "Automatic backup before restoring an earlier version";
+var AUTO_SNAPSHOT_MESSAGE = "Automatic snapshot";
+async function restoreVersionWithBackup(options) {
+  const { projectDir, id, authorName, authorEmail } = options;
+  const source = await detectProjectSource(projectDir);
+  if (source.type !== "local-git-folder") {
+    throw new Error("This project has no version history yet. Enable version history first.");
+  }
+  const provider = new LocalGitSourceProvider(source);
+  const repoDir = gitScopeFor(source);
+  return withRepoLock(repoDir, async () => {
+    let backupId;
+    if (await hasPendingChanges(repoDir)) {
+      const backup = await provider.snapshotUnlocked({
+        projectDir,
+        message: RESTORE_BACKUP_MESSAGE,
+        authorName,
+        authorEmail
+      });
+      backupId = backup.id;
+    }
+    try {
+      await provider.restoreUnlocked({ projectDir, id });
+    } catch (cause) {
+      throw new Error(backupId ? "The restore could not be completed, but your work is safe — it was " + `automatically saved as a backup snapshot (${backupId.slice(0, 7)}) ` + "and appears in your version history." : "The restore could not be completed. Your project files were not changed.", { cause });
+    }
+    return { restoredId: id, backupId };
+  });
+}
+
+export { resolveLogger, shortOid, gitScopeFor, HISTORY_PAGE_LIMIT, SNAPSHOT_STAGING_MARKER, withRepoLock, __repoLockQueueSizeForTests, gitAuthor, readGitAuthor, resolveGitAuthor, listWorkdirChanges, stageChanges, hasPendingChanges, hasUncommittedChanges, snapshotWorkingTreeUnlocked, isNoChangesError, providerFor, gitDirFor, snapshotStagingMarkerPath, RESTORE_BACKUP_MESSAGE, AUTO_SNAPSHOT_MESSAGE, restoreVersionWithBackup };

package/dist/index-yja077f6.js

@@ -0,0 +1,92 @@
+// src/lib/remote-auth/git-http.ts
+import httpNode from "isomorphic-git/http/node";
+var GIT_HTTP_IDLE_TIMEOUT_MS = 60000;
+var GIT_HTTP_UPLOAD_TIMEOUT_MS = 30 * 60000;
+var SMALL_BODY_MAX_BYTES = 256 * 1024;
+function isSmallBody(body) {
+  if (!Array.isArray(body))
+    return false;
+  let total = 0;
+  for (const c of body) {
+    const size = c?.byteLength;
+    if (typeof size !== "number")
+      return false;
+    total += size;
+  }
+  return total <= SMALL_BODY_MAX_BYTES;
+}
+function gitTimeoutError(what, ms) {
+  return new Error(`Git network operation timed out after ${Math.round(ms / 1000)}s (${what}); ` + `couldn't reach the remote (ETIMEDOUT).`);
+}
+function withIdleTimeout(http, idleMs = GIT_HTTP_IDLE_TIMEOUT_MS, uploadMs = GIT_HTTP_UPLOAD_TIMEOUT_MS) {
+  return {
+    async request(options) {
+      let timer;
+      let trip;
+      const tripped = new Promise((_, reject) => {
+        trip = reject;
+      });
+      tripped.catch(() => {});
+      const arm = (ms, what) => {
+        if (timer)
+          clearTimeout(timer);
+        timer = setTimeout(() => trip(gitTimeoutError(what, ms)), ms);
+        timer.unref?.();
+      };
+      const disarm = () => {
+        if (timer)
+          clearTimeout(timer);
+        timer = undefined;
+      };
+      const race = (p) => Promise.race([p, tripped]).catch((e) => {
+        p.catch(() => {});
+        throw e;
+      });
+      const body = options.body;
+      const isLargeUpload = body != null && !isSmallBody(body);
+      arm(isLargeUpload ? uploadMs : idleMs, isLargeUpload ? "the upload did not complete" : "the remote did not respond");
+      let res;
+      try {
+        res = await race(http.request(options));
+      } finally {
+        disarm();
+      }
+      const rawBody = res.body;
+      if (!rawBody || typeof rawBody[Symbol.asyncIterator] !== "function") {
+        return res;
+      }
+      const source = rawBody[Symbol.asyncIterator]();
+      const guardedBody = {
+        async next() {
+          arm(idleMs, "the remote stopped sending data");
+          try {
+            const step = await race(source.next());
+            disarm();
+            return step;
+          } catch (e) {
+            disarm();
+            try {
+              Promise.resolve(source.return?.()).catch(() => {});
+            } catch {}
+            throw e;
+          }
+        },
+        return(value) {
+          disarm();
+          try {
+            return Promise.resolve(source.return?.(value) ?? { done: true, value: undefined });
+          } catch {
+            return Promise.resolve({ done: true, value: undefined });
+          }
+        },
+        [Symbol.asyncIterator]() {
+          return this;
+        }
+      };
+      return { ...res, body: guardedBody };
+    }
+  };
+}
+var defaultGitHttp = withIdleTimeout(httpNode);
+
+export { GIT_HTTP_IDLE_TIMEOUT_MS, GIT_HTTP_UPLOAD_TIMEOUT_MS, SMALL_BODY_MAX_BYTES, isSmallBody, withIdleTimeout, defaultGitHttp };

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * gutterpress — runtime library for Gutterpress.
+ *
+ * Consumed by:
+ *   - packages/cli  (commands import from here; bundled into the CLI binary + npm package)
+ *   - packages/desktop (SvelteKit API routes import from here at runtime)
+ *
+ * Plugin authors use the type-only exports below to type their plugins without
+ * taking a runtime dependency on this package.
+ */
+export * from "./api/index.ts";
+export { log } from "./utils/logger.ts";
+export { runLint } from "./lib/lint-runner.ts";
+export { openPath } from "./lib/open-path.ts";
+export { executeAndReport, executeValidation } from "./lib/validation-exec.ts";
+export type { ValidationExecutionResult } from "./lib/validation-exec.ts";
+export { formatReport } from "./checks/formatter.ts";
+export type { OutputFormat } from "./checks/formatter.ts";
+export { runChecks } from "./checks/runner.ts";
+export { checkToolAvailability, reportMissingTools } from "./checks/tool-check.ts";
+export type { CheckContext, CheckResult } from "./checks/types.ts";
+export { resolveCheckSelectors, getChecks, getCheckById } from "./checks/registry.ts";
+export type { ResolvedSelectors } from "./checks/registry.ts";
+export type { CheckCategory, CheckPhase } from "./checks/types.ts";
+export { loadManifest } from "./lib/manifest.ts";
+export type { PlatformAdapter, FileStat, FileWriteResult } from "./platform.ts";
+export { inspectImage } from "./lib/image-inspect.ts";
+export type { ImageInfo, ColorSpace } from "./lib/image-inspect.ts";
+export { checkCss } from "./lib/printsafe.ts";
+export type { PrintSafeWarning } from "./lib/printsafe.ts";
+export { ruleRemoteUrls, ruleRiskyProps, rulePagedjsCrashSelectors, ruleSyntax, } from "./lib/printsafe.ts";
+export type { GutterpressPlugin, GutterpressPluginExport, GutterpressPluginMetadata, } from "./lib/markdown/plugins.ts";