Fork 主题如何更新？基于 Ink 构建主题更新 CLI 工具

const currentBranch = execSync("git rev-parse --abbrev-ref HEAD")

  .toString()

  .trim();

if (currentBranch !== "main") {

  throw new Error(`仅支持在 main 分支执行更新，当前分支: ${currentBranch}`);

}

const statusOutput = execSync("git status --porcelain").toString();

const uncommittedFiles = statusOutput.split("\n").filter((line) => line.trim());

const isClean = uncommittedFiles.length === 0;

// UPSTREAM_URL 需替换为你的上游仓库地址

const UPSTREAM_URL = "https://github.com/original/repo.git";

function ensureUpstreamRemote(): string {

  try {

    return execSync("git remote get-url upstream").toString().trim();

  } catch {

    execSync(`git remote add upstream ${UPSTREAM_URL}`);

    return UPSTREAM_URL;

  }

}

const revList = execSync(

  "git rev-list --left-right --count HEAD...upstream/main"

)

  .toString()

  .trim();

const [aheadStr, behindStr] = revList.split("\t");

const aheadCount = parseInt(aheadStr, 10);

const behindCount = parseInt(behindStr, 10);

console.log(`本地领先 ${aheadCount} 个提交，落后 ${behindCount} 个提交`);

const commitFormat = "%h|%s|%ar|%an";

const output = execSync(

  `git log HEAD..upstream/main --pretty=format:"${commitFormat}" --no-merges`

).toString();

const commits = output

  .split("\n")

  .filter(Boolean)

  .map((line) => {

    const [hash, message, date, author] = line.split("|");

    return { hash, message, date, author };

  });

const packageJson = execSync("git show upstream/main:package.json").toString();

const { version } = JSON.parse(packageJson);

console.log(`最新版本: ${version}`);

const statusOutput = execSync("git status --porcelain").toString();

const conflictFiles = statusOutput

  .split("\n")

  .filter((line) => {

    const status = line.slice(0, 2);

    // U = Unmerged, AA = both added, DD = both deleted

    return status.includes("U") || status === "AA" || status === "DD";

  })

  // 注：为简化展示，这里直接截取路径

  // 若需完整兼容重命名 / 特殊路径，应使用更严格的 porcelain 解析

  .map((line) => line.slice(3).trim());

function abortMerge(): boolean {

  try {

    execSync("git merge --abort");

    return true;

  } catch {

    return false;

  }

}

// 12 种状态覆盖完整流程

type UpdateStatus =

  | "checking" // 检查 Git 状态

  | "dirty-warning" // 工作区有未提交更改

  | "backup-confirm" // 确认备份

  | "backing-up" // 正在备份

  | "fetching" // 获取更新

  | "preview" // 显示更新预览

  | "merging" // 合并中

  | "installing" // 安装依赖

  | "done" // 完成

  | "conflict" // 有冲突

  | "up-to-date" // 已是最新

  | "error"; // 错误

// Action 驱动状态转换

type UpdateAction =

  | { type: "GIT_CHECKED"; payload: GitStatusInfo }

  | { type: "FETCHED"; payload: UpdateInfo }

  | { type: "BACKUP_CONFIRM" | "BACKUP_SKIP" | "UPDATE_CONFIRM" | "INSTALLED" }

  | { type: "BACKUP_DONE"; backupFile: string }

  | { type: "MERGED"; payload: MergeResult }

  | { type: "ERROR"; error: string };

function updateReducer(state: UpdateState, action: UpdateAction): UpdateState {

  const { status, options } = state;

  // 通用错误处理：任何状态都可以转到 error

  if (action.type === "ERROR") {

    return { ...state, status: "error", error: action.error };

  }

  switch (status) {

    case "checking": {

      if (action.type !== "GIT_CHECKED") return state;

      const { payload: gitStatus } = action;

      if (gitStatus.currentBranch !== "main") {

        return {

          ...state,

          status: "error",

          error: "仅支持在 main 分支执行更新",

        };

      }

      if (!gitStatus.isClean && !options.force) {

        return { ...state, status: "dirty-warning", gitStatus };

      }

      return { ...state, status: "fetching", gitStatus };

    }

    case "fetching": {

      if (action.type !== "FETCHED") return state;

      const { payload: updateInfo } = action;

      if (updateInfo.behindCount === 0) {

        return { ...state, status: "up-to-date", updateInfo };

      }

      const nextStatus = options.skipBackup ? "preview" : "backup-confirm";

      return { ...state, status: nextStatus, updateInfo };

    }

    //... 其他状态处理

  }

}

type EffectFn = (

  state: UpdateState,

  dispatch: Dispatch<UpdateAction>

) => (() => void) | undefined;

const statusEffects: Partial<Record<UpdateStatus, EffectFn>> = {

  checking: (_state, dispatch) => {

    const gitStatus = checkGitStatus();

    ensureUpstreamRemote();

    dispatch({ type: "GIT_CHECKED", payload: gitStatus });

    return undefined;

  },

  fetching: (_state, dispatch) => {

    fetchUpstream();

    const info = getUpdateInfo();

    dispatch({ type: "FETCHED", payload: info });

    return undefined;

  },

  installing: (_state, dispatch) => {

    let cancelled = false;

    installDeps().then((result) => {

      if (cancelled) return;

      dispatch(

        result.success

          ? { type: "INSTALLED" }

          : { type: "ERROR", error: result.error }

      );

    });

    return () => {

      cancelled = true;

    }; // cleanup

  },

};

function UpdateApp({ checkOnly, skipBackup, force }) {

  const [state, dispatch] = useReducer(

    updateReducer,

    { checkOnly, skipBackup, force },

    createInitialState

  );

  // 核心：单一 effect 处理所有副作用

  useEffect(() => {

    const effect = statusEffects[state.status];

    if (!effect) return;

    return effect(state, dispatch);

  }, [state.status, state]);

  // UI 渲染基于 state.status

  return <Box>...</Box>;

}

import { execSync } from "node:child_process";

function git(args: string): string {

  return execSync(`git ${args}`, {

    encoding: "utf-8",

    stdio: ["pipe", "pipe", "pipe"],

  }).trim();

}

function gitSafe(args: string): string | null {

  try {

    return git(args);

  } catch {

    return null;

  }

}

export function checkGitStatus(): GitStatusInfo {

  const currentBranch = git("rev-parse --abbrev-ref HEAD");

  const statusOutput = gitSafe("status --porcelain") || "";

  const uncommittedFiles = statusOutput

    .split("\n")

    .filter((line) => line.trim());

  return {

    currentBranch,

    isClean: uncommittedFiles.length === 0,

    // 注：简化处理，完整兼容需更严格的 porcelain 解析

    uncommittedFiles: uncommittedFiles.map((line) => line.slice(3).trim()),

  };

}

export function getUpdateInfo(): UpdateInfo {

  const revList =

    gitSafe("rev-list --left-right --count HEAD...upstream/main") || "0\t0";

  const [aheadStr, behindStr] = revList.split("\t");

  const commitFormat = "%h|%s|%ar|%an";

  const commitsOutput =

    gitSafe(

      `log HEAD..upstream/main --pretty=format:"${commitFormat}" --no-merges`

    ) || "";

  const commits = commitsOutput

    .split("\n")

    .filter(Boolean)

    .map((line) => {

      const [hash, message, date, author] = line.split("|");

      return { hash, message, date, author };

    });

  return {

    behindCount: parseInt(behindStr, 10),

    aheadCount: parseInt(aheadStr, 10),

    commits,

  };

}

export function mergeUpstream(): MergeResult {

  try {

    git("merge upstream/main --no-edit");

    return { success: true, hasConflict: false, conflictFiles: [] };

  } catch {

    const conflictFiles = getConflictFiles();

    return {

      success: false,

      hasConflict: conflictFiles.length > 0,

      conflictFiles,

    };

  }

}

function getConflictFiles(): string[] {

  const output = gitSafe("diff --name-only --diff-filter=U") || "";

  return output.split("\n").filter(Boolean);

}

export interface BackupItem {

  src: string; // 源路径（相对于项目根目录）

  dest: string; // 备份内目标路径

  label: string; // 显示标签

  required: boolean; // 是否为必需项（basic 模式包含）

}

export const BACKUP_ITEMS: BackupItem[] = [

  // 基础备份项（required: true）

  {

    src: "src/content/blog",

    dest: "content/blog",

    label: "博客文章",

    required: true,

  },

  {

    src: "config/site.yaml",

    dest: "config/site.yaml",

    label: "网站配置",

    required: true,

  },

  {

    src: "src/pages/about.md",

    dest: "pages/about.md",

    label: "关于页面",

    required: true,

  },

  {

    src: "public/img/avatar.webp",

    dest: "img/avatar.webp",

    label: "用户头像",

    required: true,

  },

  { src: ".env", dest: "env", label: "环境变量", required: true },

  // 完整备份额外项目（required: false）

  { src: "public/img", dest: "img", label: "所有图片", required: false },

  {

    src: "src/assets/lqips.json",

    dest: "assets/lqips.json",

    label: "LQIP 数据",

    required: false,

  },

  {

    src: "src/assets/similarities.json",

    dest: "assets/similarities.json",

    label: "相似度数据",

    required: false,

  },

  {

    src: "src/assets/summaries.json",

    dest: "assets/summaries.json",

    label: "AI 摘要数据",

    required: false,

  },

];

export function runBackup(

  isFullBackup: boolean,

  onProgress?: (results: BackupResult[]) => void

): BackupOutput {

  // 1. 创建备份目录和临时目录

  fs.mkdirSync(BACKUP_DIR, { recursive: true });

  const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);

  const tempDir = path.join(BACKUP_DIR, `.tmp-backup-${timestamp}`);

  // 2. 过滤备份项目（基础备份只包含 required: true 的项目）

  const itemsToBackup = BACKUP_ITEMS.filter(

    (item) => item.required || isFullBackup

  );

  // 3. 复制文件到临时目录

  const results: BackupResult[] = [];

  for (const item of itemsToBackup) {

    const srcPath = path.join(PROJECT_ROOT, item.src);

    const destPath = path.join(tempDir, item.dest);

    if (fs.existsSync(srcPath)) {

      fs.cpSync(srcPath, destPath, { recursive: true });

      results.push({ item, success: true, skipped: false });

    } else {

      results.push({ item, success: false, skipped: true });

    }

    onProgress?.([...results]); // 进度回调

  }

  // 4. 生成 manifest.json

  const manifest = {

    name: "astro-koharu-backup",

    version: getVersion(),

    type: isFullBackup ? "full" : "basic",

    timestamp,

    created_at: new Date().toISOString(),

    files: Object.fromEntries(results.map((r) => [r.item.dest, r.success])),

  };

  fs.writeFileSync(

    path.join(tempDir, "manifest.json"),

    JSON.stringify(manifest, null, 2)

  );

  // 5. 压缩并清理

  tarCreate(backupFilePath, tempDir);

  fs.rmSync(tempDir, { recursive: true, force: true });

  return { results, backupFile: backupFilePath, fileSize, timestamp };

}

// 安全验证：防止路径遍历攻击

function validateTarEntries(entries: string[], archivePath: string): void {

  for (const entry of entries) {

    if (entry.includes("\0")) {

      throw new Error(`tar entry contains null byte`);

    }

    const normalized = path.posix.normalize(entry);

    if (path.posix.isAbsolute(normalized)) {

      throw new Error(`tar entry is absolute path: ${entry}`);

    }

    if (normalized.split("/").includes("..")) {

      throw new Error(`tar entry contains parent traversal: ${entry}`);

    }

  }

}

// 创建压缩包

export function tarCreate(archivePath: string, sourceDir: string): void {

  spawnSync("tar", ["-czf", archivePath, "-C", sourceDir, "."]);

}

// 解压到指定目录

export function tarExtract(archivePath: string, destDir: string): void {

  listTarEntries(archivePath); // 先验证条目安全性

  spawnSync("tar", ["-xzf", archivePath, "-C", destDir]);

}

// 读取 manifest（不解压整个文件）

export function tarExtractManifest(archivePath: string): string | null {

  const result = spawnSync("tar", ["-xzf", archivePath, "-O", "manifest.json"]);

  return result.status === 0 ? result.stdout : null;

}

// 路径映射：从备份项配置自动生成，确保一致性

export const RESTORE_MAP: Record<string, string> = Object.fromEntries(

  BACKUP_ITEMS.map((item) => [item.dest, item.src])

);

export function restoreBackup(backupPath: string): RestoreResult {

  // 1. 创建临时目录并解压

  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "restore-"));

  tarExtract(backupPath, tempDir);

  // 2. 读取 manifest 获取实际备份的文件列表

  const manifestPath = path.join(tempDir, "manifest.json");

  const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));

  const restored: string[] = [];

  const skipped: string[] = [];

  // 3. 基于 manifest.files 还原（只还原成功备份的文件）

  for (const [backupPath, success] of Object.entries(manifest.files)) {

    // 跳过备份失败的文件

    if (!success) {

      skipped.push(backupPath);

      continue;

    }

    const projectPath = RESTORE_MAP[backupPath];

    if (!projectPath) {

      console.warn(`未知的备份路径: ${backupPath}，跳过`);

      skipped.push(backupPath);

      continue;

    }

    const srcPath = path.join(tempDir, backupPath);

    const destPath = path.join(PROJECT_ROOT, projectPath);

    if (fs.existsSync(srcPath)) {

      fs.mkdirSync(path.dirname(destPath), { recursive: true });

      fs.cpSync(srcPath, destPath, { recursive: true });

      restored.push(projectPath);

    } else {

      skipped.push(backupPath);

    }

  }

  // 4. 清理临时目录

  fs.rmSync(tempDir, { recursive: true, force: true });

  return {

    restored,

    skipped,

    backupType: manifest.type,

    version: manifest.version,

  };

}

// 预览函数：只读取 manifest，不解压不修改文件

export function getRestorePreview(backupPath: string): RestorePreviewItem[] {

  // 只提取 manifest.json，不解压整个归档

  const manifestContent = tarExtractManifest(backupPath);

  if (!manifestContent) {

    throw new Error("无法读取备份 manifest");

  }

  const manifest = JSON.parse(manifestContent);

  const previewItems: RestorePreviewItem[] = [];

  // 基于 manifest.files 生成预览

  for (const [backupPath, success] of Object.entries(manifest.files)) {

    if (!success) continue; // 跳过备份失败的文件

    const projectPath = RESTORE_MAP[backupPath];

    if (!projectPath) continue;

    // 从归档中统计文件数量（不解压）

    const files = tarList(backupPath);

    const matchingFiles = files.filter(

      (f) => f === backupPath || f.startsWith(`${backupPath}/`)

    );

    const fileCount = matchingFiles.length;

    previewItems.push({

      path: projectPath,

      fileCount: fileCount || 1,

      backupPath,

    });

  }

  return previewItems;

}

// 执行函数：实际解压并复制文件

export function restoreBackup(backupPath: string): RestoreResult {

  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "restore-"));

  tarExtract(backupPath, tempDir); // 实际解压

  // 读取 manifest 驱动还原

  const manifest = JSON.parse(

    fs.readFileSync(path.join(tempDir, "manifest.json"), "utf-8")

  );

  const restored: string[] = [];

  for (const [backupPath, success] of Object.entries(manifest.files)) {

    if (!success) continue;

    const projectPath = RESTORE_MAP[backupPath];

    //... 实际复制文件

    fs.cpSync(srcPath, destPath, { recursive: true });

    restored.push(projectPath);

  }

  return { restored, skipped: [], backupType: manifest.type };

}

interface RestoreAppProps {

  dryRun?: boolean; // 是否为预览模式

  force?: boolean; // 是否跳过确认

}

export function RestoreApp({ dryRun = false, force = false }: RestoreAppProps) {

  const [result, setResult] = useState<{

    items: RestorePreviewItem[] | string[];

    backupType?: string;

    skipped?: string[];

  }>();

  // 预览模式：只读取 manifest

  const runDryRun = useCallback(() => {

    const previewItems = getRestorePreview(selectedBackup);

    setResult({ items: previewItems });

    setStatus("done");

  }, [selectedBackup]);

  // 实际还原：基于 manifest 执行还原

  const runRestore = useCallback(() => {

    setStatus("restoring");

    const { restored, skipped, backupType } = restoreBackup(selectedBackup);

    setResult({ items: restored, backupType, skipped });

    setStatus("done");

  }, [selectedBackup]);

  // 确认时根据模式分发

  function handleConfirm() {

    if (dryRun) {

      runDryRun();

    } else {

      runRestore();

    }

  }

}