@fenglimg/fabric-cli 2.1.0-rc.2 → 2.2.0-rc.10

package/dist/sync-DT5UJMMR.js

@@ -0,0 +1,418 @@
+#!/usr/bin/env node
+import {
+  paint
+} from "./chunk-NLNH64A3.js";
+import {
+  regenerateBindingsSnapshot
+} from "./chunk-PTGQAZEW.js";
+import "./chunk-EOT63RDH.js";
+import "./chunk-QFIVFZRH.js";
+import {
+  loadGlobalConfig,
+  resolveGlobalRoot
+} from "./chunk-FNHDQTPC.js";
+import {
+  getProjectTranslator
+} from "./chunk-HORSMSZL.js";
+
+// src/commands/sync.ts
+import { defineCommand } from "citty";
+
+// src/sync/run-sync.ts
+import { execFileSync } from "child_process";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
+import { join } from "path";
+import { GLOBAL_STATE_DIR, storeRelativePathForMount } from "@fenglimg/fabric-shared";
+import { GenericIOError } from "@fenglimg/fabric-shared/errors";
+
+// src/sync/state-machine.ts
+function syncTransition(state, event) {
+  switch (state) {
+    case "pending":
+      if (event === "rebase_clean") return "synced";
+      if (event === "rebase_conflict") return "conflict";
+      if (event === "network_unavailable") return "offline";
+      break;
+    case "conflict":
+      if (event === "user_continue") return "synced";
+      if (event === "user_abort") return "aborted";
+      if (event === "network_unavailable") return "offline";
+      break;
+    case "offline":
+      if (event === "retry" || event === "rebase_clean") return "synced";
+      if (event === "rebase_conflict") return "conflict";
+      if (event === "network_unavailable") return "offline";
+      break;
+    case "synced":
+    case "aborted":
+      break;
+  }
+  throw new Error(`invalid sync transition: '${state}' --${event}-->`);
+}
+function planSync(stores) {
+  return { stores: stores.map((s) => ({ ...s, state: "pending" })) };
+}
+function applySyncEvent(session, alias, event) {
+  return {
+    stores: session.stores.map(
+      (s) => s.alias === alias ? { ...s, state: syncTransition(s.state, event) } : s
+    )
+  };
+}
+function continueSync(session) {
+  const conflicted = session.stores.find((s) => s.state === "conflict");
+  if (conflicted === void 0) {
+    throw new Error("`sync --continue` with no conflicted store to resume");
+  }
+  return applySyncEvent(session, conflicted.alias, "user_continue");
+}
+function abortSync(session) {
+  const conflicted = session.stores.find((s) => s.state === "conflict");
+  if (conflicted === void 0) {
+    throw new Error("`sync --abort` with no conflicted store to abort");
+  }
+  return applySyncEvent(session, conflicted.alias, "user_abort");
+}
+function isSyncSettled(session) {
+  return session.stores.every((s) => s.state !== "pending" && s.state !== "conflict");
+}
+function deferredPushStores(session) {
+  return session.stores.filter((s) => s.state === "offline");
+}
+
+// src/sync/run-sync.ts
+var NO_GLOBAL_CONFIG = "no global Fabric config \u2014 run `fabric install --global <url>` first";
+var NO_SESSION = "no sync in progress \u2014 run `fabric sync` first";
+var NO_CONFLICT = "no conflicted store to resume \u2014 sync is not paused";
+function syncSessionPath(globalRoot) {
+  return join(globalRoot, GLOBAL_STATE_DIR, "sync-session.json");
+}
+function loadSession(globalRoot) {
+  const path = syncSessionPath(globalRoot);
+  if (!existsSync(path)) {
+    return null;
+  }
+  const raw = readFileSync(path, "utf8");
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    const corruptedPath = `${path}.corrupted.${Date.now()}`;
+    try {
+      writeFileSync(corruptedPath, raw, "utf8");
+    } catch {
+    }
+    throw new GenericIOError(
+      `sync-session.json is corrupt (forensic copy: ${corruptedPath}). Parse error: ${error instanceof Error ? error.message : String(error)}`,
+      {
+        actionHint: `Delete ${path} to start a fresh sync (any in-progress rebase must be resolved manually with git first).`,
+        details: { path, corruptedPath }
+      }
+    );
+  }
+}
+function saveSession(globalRoot, session) {
+  const path = syncSessionPath(globalRoot);
+  mkdirSync(join(path, ".."), { recursive: true });
+  const tmpPath = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmpPath, `${JSON.stringify(session, null, 2)}
+`, "utf8");
+  renameSync(tmpPath, path);
+}
+function clearSession(globalRoot) {
+  rmSync(syncSessionPath(globalRoot), { force: true });
+}
+function defaultPull(storeDir) {
+  try {
+    execFileSync("git", ["pull", "--rebase"], {
+      cwd: storeDir,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return "clean";
+  } catch (error) {
+    const detail = `${gitErrText(error, "stdout")}${gitErrText(error, "stderr")}`;
+    if (/CONFLICT|could not apply|needs merge|rebase --continue/i.test(detail)) {
+      return "conflict";
+    }
+    if (/could not resolve host|could not read from remote|unable to access|connection|network is unreachable|timed out/i.test(
+      detail
+    )) {
+      return "offline";
+    }
+    const gitMessage = detail.trim().length > 0 ? detail.trim() : "unknown git error";
+    throw new GenericIOError(`git pull --rebase failed in ${storeDir}: ${gitMessage}`, {
+      actionHint: "resolve the git issue above (e.g. authentication, a dirty working tree, or a detached HEAD), then re-run `fabric sync`",
+      details: error
+    });
+  }
+}
+function gitErrText(error, key) {
+  const value = error[key];
+  return typeof value === "string" || Buffer.isBuffer(value) ? String(value) : "";
+}
+function defaultPush(storeDir) {
+  try {
+    execFileSync("git", ["push"], {
+      cwd: storeDir,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    return "clean";
+  } catch (error) {
+    const detail = `${gitErrText(error, "stdout")}${gitErrText(error, "stderr")}`;
+    if (/could not resolve host|could not read from remote|unable to access|connection|network is unreachable|timed out/i.test(
+      detail
+    )) {
+      return "offline";
+    }
+    const gitMessage = detail.trim().length > 0 ? detail.trim() : "unknown git error";
+    throw new GenericIOError(`git push failed in ${storeDir}: ${gitMessage}`, {
+      actionHint: "resolve the git issue above (e.g. authentication, no upstream branch, or a rejected non-fast-forward push), then re-run `fabric sync`",
+      details: error
+    });
+  }
+}
+function defaultCommitDirty(storeDir) {
+  try {
+    execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
+      cwd: storeDir,
+      stdio: ["ignore", "ignore", "ignore"]
+    });
+  } catch {
+    return;
+  }
+  try {
+    execFileSync("git", ["add", "-A"], { cwd: storeDir, stdio: ["ignore", "ignore", "pipe"] });
+    try {
+      execFileSync("git", ["diff", "--cached", "--quiet"], {
+        cwd: storeDir,
+        stdio: ["ignore", "ignore", "ignore"]
+      });
+      return;
+    } catch {
+      execFileSync("git", ["commit", "-m", "fabric: sync local knowledge changes"], {
+        cwd: storeDir,
+        stdio: ["ignore", "ignore", "pipe"]
+      });
+    }
+  } catch {
+  }
+}
+function runRebaseStep(storeDir, step) {
+  try {
+    execFileSync("git", ["rebase", `--${step}`], {
+      cwd: storeDir,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+  } catch (error) {
+    const detail = `${gitErrText(error, "stdout")}${gitErrText(error, "stderr")}`.trim();
+    const gitMessage = detail.length > 0 ? detail : "unknown git error";
+    throw new GenericIOError(`git rebase --${step} failed in ${storeDir}: ${gitMessage}`, {
+      actionHint: step === "continue" ? "resolve the remaining conflicts (git status) and stage them, then re-run `fabric sync --continue`; or run `fabric sync --abort` to discard the rebase" : "inspect the store with `git status`; if no rebase is in progress the session may already be resolved \u2014 delete sync-session.json to reset",
+      details: error
+    });
+  }
+}
+function defaultRebaseContinue(storeDir) {
+  runRebaseStep(storeDir, "continue");
+}
+function defaultRebaseAbort(storeDir) {
+  runRebaseStep(storeDir, "abort");
+}
+var OUTCOME_EVENT = {
+  clean: "rebase_clean",
+  conflict: "rebase_conflict",
+  offline: "network_unavailable"
+};
+function walkPending(session, storeDirOf, pull, push, commit, pushableAliases) {
+  let next = session;
+  for (const store of session.stores) {
+    if (store.state !== "pending") {
+      continue;
+    }
+    const dir = storeDirOf(store);
+    commit(dir);
+    const pullOutcome = pull(dir);
+    if (pullOutcome !== "clean") {
+      next = applySyncEvent(next, store.alias, OUTCOME_EVENT[pullOutcome]);
+      if (pullOutcome === "conflict") {
+        break;
+      }
+      continue;
+    }
+    if (!pushableAliases.has(store.alias)) {
+      next = applySyncEvent(next, store.alias, "rebase_clean");
+      continue;
+    }
+    const pushOutcome = push(dir);
+    next = applySyncEvent(
+      next,
+      store.alias,
+      pushOutcome === "clean" ? "rebase_clean" : "network_unavailable"
+    );
+  }
+  return next;
+}
+function finalize(session, options, globalRoot) {
+  const settled = isSyncSettled(session);
+  let snapshotWritten = false;
+  if (settled) {
+    clearSession(globalRoot);
+    const snapshot = regenerateBindingsSnapshot(options.projectRoot, {
+      globalRoot,
+      now: options.now,
+      ...options.writeScope === void 0 ? {} : { writeScope: options.writeScope }
+    });
+    snapshotWritten = snapshot !== null;
+  } else {
+    saveSession(globalRoot, session);
+  }
+  return { session, settled, deferred: deferredPushStores(session), snapshotWritten };
+}
+function runStartSync(options) {
+  const globalRoot = options.globalRoot ?? resolveGlobalRoot();
+  const config = loadGlobalConfig(globalRoot);
+  if (config === null) {
+    throw new Error(NO_GLOBAL_CONFIG);
+  }
+  const syncable = config.stores.filter((store) => store.remote !== void 0);
+  const session = planSync(
+    syncable.map((store) => ({ alias: store.alias, store_uuid: store.store_uuid }))
+  );
+  const storeDirOf = makeStoreDirResolver(globalRoot, config.stores);
+  const pushableAliases = pushableAliasesOf(config);
+  const walked = walkPending(
+    session,
+    storeDirOf,
+    options.pull ?? defaultPull,
+    options.push ?? defaultPush,
+    options.commit ?? defaultCommitDirty,
+    pushableAliases
+  );
+  return finalize(walked, options, globalRoot);
+}
+function pushableAliasesOf(config) {
+  return new Set(
+    config.stores.filter((store) => store.remote !== void 0 && (store.writable ?? true)).map((store) => store.alias)
+  );
+}
+function makeStoreDirResolver(globalRoot, stores) {
+  return (status) => join(
+    globalRoot,
+    storeRelativePathForMount(
+      stores.find((store) => store.store_uuid === status.store_uuid) ?? {
+        store_uuid: status.store_uuid
+      }
+    )
+  );
+}
+function runContinueSync(options) {
+  const globalRoot = options.globalRoot ?? resolveGlobalRoot();
+  const session = loadSession(globalRoot);
+  if (session === null) {
+    throw new GenericIOError(NO_SESSION, {
+      actionHint: "Run `fabric sync` to start a sync before `--continue`/`--abort`."
+    });
+  }
+  const conflicted = session.stores.find((store) => store.state === "conflict");
+  if (conflicted === void 0) {
+    throw new GenericIOError(NO_CONFLICT, {
+      actionHint: "The sync is not paused on a conflict; there is nothing to resume."
+    });
+  }
+  const resumeConfig = loadGlobalConfig(globalRoot) ?? { stores: [] };
+  const storeDirOf = makeStoreDirResolver(globalRoot, resumeConfig.stores);
+  (options.rebaseContinue ?? defaultRebaseContinue)(storeDirOf(conflicted));
+  const pushableAliases = pushableAliasesOf(resumeConfig);
+  const push = options.push ?? defaultPush;
+  let advanced;
+  if (pushableAliases.has(conflicted.alias)) {
+    const pushOutcome = push(storeDirOf(conflicted));
+    advanced = applySyncEvent(
+      session,
+      conflicted.alias,
+      pushOutcome === "clean" ? "user_continue" : "network_unavailable"
+    );
+  } else {
+    advanced = continueSync(session);
+  }
+  const resumed = walkPending(
+    advanced,
+    storeDirOf,
+    options.pull ?? defaultPull,
+    push,
+    options.commit ?? defaultCommitDirty,
+    pushableAliases
+  );
+  return finalize(resumed, options, globalRoot);
+}
+function runAbortSync(options) {
+  const globalRoot = options.globalRoot ?? resolveGlobalRoot();
+  const session = loadSession(globalRoot);
+  if (session === null) {
+    throw new GenericIOError(NO_SESSION, {
+      actionHint: "Run `fabric sync` to start a sync before `--continue`/`--abort`."
+    });
+  }
+  const conflicted = session.stores.find((store) => store.state === "conflict");
+  if (conflicted === void 0) {
+    throw new GenericIOError(NO_CONFLICT, {
+      actionHint: "The sync is not paused on a conflict; there is nothing to resume."
+    });
+  }
+  const resumeConfig = loadGlobalConfig(globalRoot) ?? { stores: [] };
+  const storeDirOf = makeStoreDirResolver(globalRoot, resumeConfig.stores);
+  (options.rebaseAbort ?? defaultRebaseAbort)(storeDirOf(conflicted));
+  const pushableAliases = pushableAliasesOf(resumeConfig);
+  const resumed = walkPending(
+    abortSync(session),
+    storeDirOf,
+    options.pull ?? defaultPull,
+    options.push ?? defaultPush,
+    options.commit ?? defaultCommitDirty,
+    pushableAliases
+  );
+  return finalize(resumed, options, globalRoot);
+}
+
+// src/commands/sync.ts
+function report(result, projectRoot) {
+  const t = getProjectTranslator(projectRoot);
+  for (const store of result.session.stores) {
+    console.log(`${store.alias}	${store.state}`);
+  }
+  if (result.deferred.length > 0) {
+    console.log(t("cli.sync.deferred", { count: String(result.deferred.length) }));
+  }
+  if (!result.settled) {
+    console.log(t("cli.sync.paused"));
+  }
+}
+var syncCommand = defineCommand({
+  meta: { name: "sync", description: "Pull --rebase + push every mounted store; resume conflicts" },
+  args: {
+    continue: { type: "boolean", description: "Resume after resolving a rebase conflict" },
+    abort: { type: "boolean", description: "Abort the conflicted store's rebase" }
+  },
+  run({ args }) {
+    const projectRoot = process.cwd();
+    if (args.continue === true && args.abort === true) {
+      console.error(paint.error("fabric sync: --continue and --abort cannot be used together"));
+      process.exitCode = 1;
+      return;
+    }
+    const options = { projectRoot, now: (/* @__PURE__ */ new Date()).toISOString() };
+    if (args.continue === true) {
+      report(runContinueSync(options), projectRoot);
+      return;
+    }
+    if (args.abort === true) {
+      report(runAbortSync(options), projectRoot);
+      return;
+    }
+    report(runStartSync(options), projectRoot);
+  }
+});
+var sync_default = syncCommand;
+export {
+  sync_default as default,
+  syncCommand
+};