claude-settings-sync 0.3.0

package/dist/cli.js

@@ -0,0 +1,1693 @@
+#!/usr/bin/env node
+import {
+  CATEGORIES,
+  createGist,
+  findGist,
+  getGist,
+  getGistAtRevision,
+  getHistory,
+  parseMeta,
+  updateGist
+} from "./chunk-45GTBXRR.js";
+import {
+  scanFiles
+} from "./chunk-BRTRPVT7.js";
+import {
+  ask,
+  askHidden,
+  c,
+  confirm,
+  detectLang,
+  error,
+  heading,
+  info,
+  loadLangConfig,
+  printDiff,
+  select,
+  setLang,
+  success,
+  t,
+  warn
+} from "./chunk-XTJEVOK3.js";
+import {
+  authFilePath,
+  autoConfigPath,
+  autoLogPath,
+  claudeDir,
+  fromGistFilename,
+  getMachineId,
+  isPathSafe,
+  lockFilePath,
+  machineName,
+  pendingNotificationsPath,
+  platformString
+} from "./chunk-VBOSEAEH.js";
+
+// src/core/auth.ts
+import { readFileSync, writeFileSync, chmodSync, existsSync } from "fs";
+import { execSync } from "child_process";
+var KEYCHAIN_SERVICE = "claudesync";
+var KEYCHAIN_ACCOUNT = "github-token";
+function keychainSet(token) {
+  try {
+    execSync(
+      `security add-generic-password -U -s "${KEYCHAIN_SERVICE}" -a "${KEYCHAIN_ACCOUNT}" -w "${token}"`,
+      { stdio: "ignore" }
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+function secretToolSet(token) {
+  try {
+    execSync(
+      `echo -n "${token}" | secret-tool store --label="claudesync" service claudesync account github-token`,
+      { stdio: "ignore" }
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+function fileSet(config) {
+  const path = authFilePath();
+  writeFileSync(path, JSON.stringify(config, null, 2), "utf-8");
+  chmodSync(path, 384);
+}
+function fileGet() {
+  const path = authFilePath();
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function saveToken(token) {
+  if (process.platform === "darwin") {
+    keychainSet(token);
+  } else if (process.platform === "linux") {
+    secretToolSet(token);
+  }
+  const existing = fileGet() || { token: "" };
+  existing.token = token;
+  fileSet(existing);
+}
+function loadConfig() {
+  return fileGet();
+}
+function saveConfig(config) {
+  saveToken(config.token);
+  fileSet(config);
+}
+async function validateToken(token) {
+  try {
+    const res = await fetch("https://api.github.com/user", {
+      headers: {
+        Authorization: `token ${token}`,
+        "User-Agent": "claudesync"
+      }
+    });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+async function deviceFlow() {
+  const CLIENT_ID = "Ov23liVJuAxxwWUqtala";
+  const codeRes = await fetch("https://github.com/login/device/code", {
+    method: "POST",
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ client_id: CLIENT_ID, scope: "gist" })
+  });
+  const codeData = await codeRes.json();
+  console.log(`
+${t("auth.device_url").replace("{url}", codeData.verification_uri)}`);
+  console.log(`${t("auth.device_code").replace("{code}", codeData.user_code)}
+`);
+  const interval = (codeData.interval || 5) * 1e3;
+  const deadline = Date.now() + codeData.expires_in * 1e3;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, interval));
+    const tokenRes = await fetch("https://github.com/login/oauth/access_token", {
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        client_id: CLIENT_ID,
+        device_code: codeData.device_code,
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+      })
+    });
+    const tokenData = await tokenRes.json();
+    if (tokenData.access_token) return tokenData.access_token;
+    if (tokenData.error === "authorization_pending") continue;
+    if (tokenData.error === "slow_down") {
+      await new Promise((r) => setTimeout(r, 5e3));
+      continue;
+    }
+    throw new Error(t("auth.oauth_error").replace("{error}", String(tokenData.error)));
+  }
+  throw new Error(t("auth.device_flow_timeout"));
+}
+
+// src/commands/init.ts
+async function runInit(options) {
+  let token;
+  if (options.useToken) {
+    token = await askHidden(t("auth.enter_token"));
+    if (!token.trim()) {
+      error(t("init.no_token_input"));
+      return;
+    }
+    token = token.trim();
+  } else if (options.linkGistId) {
+    const existing = loadConfig();
+    if (!existing?.token) {
+      error(t("auth.no_token"));
+      return;
+    }
+    token = existing.token;
+    saveConfig({
+      token,
+      gist_id: options.linkGistId,
+      machine_name: machineName()
+    });
+    success(t("init.gist_linked").replace("{id}", options.linkGistId));
+    return;
+  } else {
+    info(t("auth.device_prompt"));
+    try {
+      token = await deviceFlow();
+    } catch (err) {
+      error(err instanceof Error ? err.message : String(err));
+      return;
+    }
+  }
+  info(t("init.validating"));
+  const valid = await validateToken(token);
+  if (!valid) {
+    error(t("init.token_invalid"));
+    return;
+  }
+  info(t("init.searching_gist"));
+  const existingGist = await findGist(token);
+  const config = {
+    token,
+    gist_id: existingGist?.id,
+    machine_name: machineName()
+  };
+  saveConfig(config);
+  success(t("auth.token_saved"));
+  if (existingGist) {
+    success(t("init.gist_found").replace("{id}", existingGist.id));
+  } else {
+    warn(t("init.no_gist"));
+  }
+}
+
+// src/core/conflict.ts
+var META_FILE = "_meta.json";
+function compareForPush(localFiles, gist) {
+  const changes = [];
+  const localMap = new Map(localFiles.map((f) => [f.gistFilename, f]));
+  const remoteNames = new Set(
+    Object.keys(gist.files).filter((n) => n !== META_FILE)
+  );
+  for (const [gistName, local] of localMap) {
+    const remote = gist.files[gistName];
+    if (!remote) {
+      changes.push({
+        gistFilename: gistName,
+        relativePath: local.relativePath,
+        category: local.category,
+        status: "added",
+        localContent: local.content
+      });
+    } else if (remote.content !== local.content) {
+      changes.push({
+        gistFilename: gistName,
+        relativePath: local.relativePath,
+        category: local.category,
+        status: "modified",
+        localContent: local.content,
+        remoteContent: remote.content ?? void 0
+      });
+    } else {
+      changes.push({
+        gistFilename: gistName,
+        relativePath: local.relativePath,
+        category: local.category,
+        status: "unchanged",
+        localContent: local.content,
+        remoteContent: remote.content ?? void 0
+      });
+    }
+    remoteNames.delete(gistName);
+  }
+  const meta = parseMeta(gist);
+  for (const gistName of remoteNames) {
+    const entry = meta?.file_map[gistName];
+    changes.push({
+      gistFilename: gistName,
+      relativePath: entry?.path ?? fromGistFilename(gistName),
+      category: entry?.category ?? "settings",
+      status: "deleted",
+      remoteContent: gist.files[gistName]?.content ?? void 0
+    });
+  }
+  return changes;
+}
+function compareForPull(gist, localFiles) {
+  const changes = [];
+  const localMap = new Map(localFiles.map((f) => [f.gistFilename, f]));
+  const meta = parseMeta(gist);
+  for (const [gistName, gistFile] of Object.entries(gist.files)) {
+    if (gistName === META_FILE) continue;
+    if (!gistFile?.content) continue;
+    const local = localMap.get(gistName);
+    const entry = meta?.file_map[gistName];
+    const relativePath = entry?.path ?? fromGistFilename(gistName);
+    const category = entry?.category ?? "settings";
+    if (!local) {
+      changes.push({
+        gistFilename: gistName,
+        relativePath,
+        category,
+        status: "added",
+        remoteContent: gistFile.content
+      });
+    } else if (local.content !== gistFile.content) {
+      changes.push({
+        gistFilename: gistName,
+        relativePath,
+        category,
+        status: "modified",
+        localContent: local.content,
+        remoteContent: gistFile.content
+      });
+    } else {
+      changes.push({
+        gistFilename: gistName,
+        relativePath,
+        category,
+        status: "unchanged",
+        localContent: local.content,
+        remoteContent: gistFile.content
+      });
+    }
+  }
+  return changes;
+}
+function simpleDiff(a, b) {
+  const linesA = a.split("\n");
+  const linesB = b.split("\n");
+  const result = [];
+  const maxLen = Math.max(linesA.length, linesB.length);
+  for (let i = 0; i < maxLen; i++) {
+    const lineA = linesA[i];
+    const lineB = linesB[i];
+    if (lineA === void 0) {
+      result.push(`+${lineB}`);
+    } else if (lineB === void 0) {
+      result.push(`-${lineA}`);
+    } else if (lineA !== lineB) {
+      result.push(`-${lineA}`);
+      result.push(`+${lineB}`);
+    }
+  }
+  return result;
+}
+
+// src/core/redactor.ts
+var SECRET_PATTERNS = [
+  { name: "AWS Access Key", regex: /AKIA[0-9A-Z]{16}/ },
+  { name: "AWS Secret Key", regex: /(?:aws_secret_access_key|secret_key)\s*[=:]\s*\S+/i },
+  { name: "GitHub Token", regex: /gh[pousr]_[A-Za-z0-9_]{36,}/ },
+  { name: "GitHub Classic Token", regex: /ghp_[A-Za-z0-9]{36,}/ },
+  { name: "Anthropic API Key", regex: /sk-ant-[A-Za-z0-9-_]{20,}/ },
+  { name: "OpenAI API Key", regex: /sk-[A-Za-z0-9]{32,}/ },
+  { name: "Slack Token", regex: /xox[bprs]-[A-Za-z0-9-]+/ },
+  { name: "Slack Webhook", regex: /hooks\.slack\.com\/services\/T[A-Z0-9]+\/B[A-Z0-9]+\/[A-Za-z0-9]+/ },
+  { name: "Private Key", regex: /-----BEGIN (?:RSA |EC |DSA |OPENSSH )?PRIVATE KEY-----/ },
+  { name: "Generic Secret", regex: /(?:secret|password|passwd|token|api_key|apikey|auth)\s*[=:]\s*['"][^'"]{8,}['"]/i },
+  { name: "Bearer Token", regex: /Bearer\s+[A-Za-z0-9\-._~+/]+=*/i },
+  { name: "Basic Auth", regex: /Basic\s+[A-Za-z0-9+/]+=*/i },
+  { name: "Connection String", regex: /(?:mongodb|postgres|mysql|redis):\/\/[^\s]+/i },
+  { name: "npm Token", regex: /\/\/registry\.npmjs\.org\/:_authToken=\S+/ },
+  { name: "Hex Secret (32+)", regex: /(?:secret|key|token|password)\s*[=:]\s*[0-9a-f]{32,}/i }
+];
+var REDACT_COMMENT = "# claudesync:redact";
+function detectSecrets(content) {
+  const matches = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.includes(REDACT_COMMENT)) {
+      matches.push({
+        line: i + 1,
+        pattern: "Explicit redact marker",
+        match: line.trim(),
+        lineContent: line
+      });
+      continue;
+    }
+    for (const { name, regex } of SECRET_PATTERNS) {
+      const m = line.match(regex);
+      if (m) {
+        matches.push({
+          line: i + 1,
+          pattern: name,
+          match: m[0].slice(0, 20) + (m[0].length > 20 ? "..." : ""),
+          lineContent: line
+        });
+        break;
+      }
+    }
+    if (!matches.some((m) => m.line === i + 1)) {
+      const tokens = line.match(/[A-Za-z0-9+/=_\-]{32,}/g);
+      if (tokens) {
+        for (const token of tokens) {
+          if (shannonEntropy(token) > 4.5) {
+            matches.push({
+              line: i + 1,
+              pattern: "High entropy string",
+              match: token.slice(0, 20) + "...",
+              lineContent: line
+            });
+            break;
+          }
+        }
+      }
+    }
+  }
+  return matches;
+}
+function redactContent(content, secrets) {
+  const lines = content.split("\n");
+  const secretLines = new Set(secrets.map((s) => s.line));
+  return lines.map((line, i) => {
+    if (secretLines.has(i + 1)) {
+      return "# [REDACTED by claudesync]";
+    }
+    return line;
+  }).join("\n");
+}
+function shannonEntropy(str) {
+  const freq = /* @__PURE__ */ new Map();
+  for (const ch of str) {
+    freq.set(ch, (freq.get(ch) || 0) + 1);
+  }
+  let entropy = 0;
+  const len = str.length;
+  for (const count of freq.values()) {
+    const p = count / len;
+    entropy -= p * Math.log2(p);
+  }
+  return entropy;
+}
+
+// src/core/crypto.ts
+import { randomBytes, scryptSync, createCipheriv, createDecipheriv } from "crypto";
+var MAGIC_PREFIX = "CLAUDESYNC_ENC:";
+var ALGORITHM = "aes-256-gcm";
+var KEY_LENGTH = 32;
+var IV_LENGTH = 16;
+var SALT_LENGTH = 32;
+var AUTH_TAG_LENGTH = 16;
+var SCRYPT_PARAMS = { N: 16384, r: 8, p: 1 };
+function deriveKey(passphrase, salt) {
+  return scryptSync(passphrase, salt, KEY_LENGTH, SCRYPT_PARAMS);
+}
+function encrypt(content, passphrase) {
+  const salt = randomBytes(SALT_LENGTH);
+  const key = deriveKey(passphrase, salt);
+  const iv = randomBytes(IV_LENGTH);
+  const cipher = createCipheriv(ALGORITHM, key, iv, { authTagLength: AUTH_TAG_LENGTH });
+  const encrypted = Buffer.concat([cipher.update(content, "utf-8"), cipher.final()]);
+  const authTag = cipher.getAuthTag();
+  const combined = Buffer.concat([salt, iv, authTag, encrypted]);
+  return MAGIC_PREFIX + combined.toString("base64");
+}
+function decrypt(encoded, passphrase) {
+  if (!encoded.startsWith(MAGIC_PREFIX)) throw new Error("Not encrypted by claudesync");
+  const combined = Buffer.from(encoded.slice(MAGIC_PREFIX.length), "base64");
+  const salt = combined.subarray(0, SALT_LENGTH);
+  const iv = combined.subarray(SALT_LENGTH, SALT_LENGTH + IV_LENGTH);
+  const authTag = combined.subarray(SALT_LENGTH + IV_LENGTH, SALT_LENGTH + IV_LENGTH + AUTH_TAG_LENGTH);
+  const ciphertext = combined.subarray(SALT_LENGTH + IV_LENGTH + AUTH_TAG_LENGTH);
+  const key = deriveKey(passphrase, salt);
+  const decipher = createDecipheriv(ALGORITHM, key, iv, { authTagLength: AUTH_TAG_LENGTH });
+  decipher.setAuthTag(authTag);
+  const decrypted = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+  return decrypted.toString("utf-8");
+}
+function isEncrypted(content) {
+  return content.startsWith(MAGIC_PREFIX);
+}
+
+// src/commands/push.ts
+async function runPush(options) {
+  const config = loadConfig();
+  if (!config?.token) {
+    error(t("auth.no_token"));
+    return;
+  }
+  info(t("push.scanning"));
+  const files = scanFiles(options.only);
+  if (files.length === 0) {
+    warn(t("push.no_files"));
+    return;
+  }
+  const processedFiles = [];
+  for (const file of files) {
+    const secrets = detectSecrets(file.content);
+    if (secrets.length > 0) {
+      warn(t("push.secret_found").replace("{path}", file.relativePath).replace("{count}", String(secrets.length)));
+      for (const s of secrets) {
+        console.log(`  ${c.dim(`L${s.line}`)} ${c.yellow(s.pattern)}: ${s.match}`);
+      }
+      const redacted = redactContent(file.content, secrets);
+      processedFiles.push({ ...file, content: redacted });
+    } else {
+      processedFiles.push(file);
+    }
+  }
+  const encryptedFiles = /* @__PURE__ */ new Set();
+  const finalFiles = options.encrypt ? processedFiles.map((f) => {
+    encryptedFiles.add(f.gistFilename);
+    return { ...f, content: encrypt(f.content, config.token) };
+  }) : processedFiles;
+  if (config.gist_id) {
+    try {
+      const gist = await getGist(config.token, config.gist_id);
+      const changes = compareForPush(finalFiles, gist);
+      const modified = changes.filter((c2) => c2.status !== "unchanged");
+      if (modified.length === 0) {
+        success(t("push.no_changes"));
+        return;
+      }
+      heading(t("push.summary"));
+      for (const change of modified) {
+        const icon = change.status === "added" ? c.green("+") : change.status === "deleted" ? c.red("-") : c.yellow("~");
+        console.log(`  ${icon} [${change.category}] ${change.relativePath}`);
+        if (change.status === "modified" && change.localContent && change.remoteContent) {
+          const diff = simpleDiff(change.remoteContent, change.localContent);
+          if (diff.length > 0 && diff.length <= 20) {
+            printDiff(change.relativePath, diff);
+          }
+        }
+      }
+      console.log();
+      if (!options.force) {
+        const ok = await confirm(t("push.confirm"));
+        if (!ok) {
+          warn(t("push.cancelled"));
+          return;
+        }
+      }
+      const deletedFiles = changes.filter((c2) => c2.status === "deleted").map((c2) => c2.gistFilename);
+      const filesToUpload = finalFiles.filter(
+        (f) => changes.some((c2) => c2.gistFilename === f.gistFilename && c2.status !== "unchanged")
+      );
+      await updateGist(config.token, config.gist_id, filesToUpload, deletedFiles, encryptedFiles, options.message);
+      success(t("push.success"));
+    } catch (err) {
+      if (String(err).includes("404")) {
+        info(t("push.gist_not_found_creating"));
+        const newGist = await createGist(config.token, finalFiles, encryptedFiles, options.message);
+        config.gist_id = newGist.id;
+        saveConfig(config);
+        success(`${t("push.success")} (${newGist.html_url})`);
+      } else {
+        throw err;
+      }
+    }
+  } else {
+    heading(t("push.uploading_new").replace("{count}", String(finalFiles.length)));
+    for (const f of finalFiles) {
+      console.log(`  [${f.category}] ${f.relativePath}`);
+    }
+    console.log();
+    if (!options.force) {
+      const ok = await confirm(t("push.confirm"));
+      if (!ok) {
+        warn(t("push.cancelled"));
+        return;
+      }
+    }
+    info(t("push.creating_gist"));
+    const newGist = await createGist(config.token, finalFiles, encryptedFiles, options.message);
+    config.gist_id = newGist.id;
+    saveConfig(config);
+    success(`${t("push.success")} (${newGist.html_url})`);
+  }
+}
+
+// src/commands/pull.ts
+import { writeFileSync as writeFileSync2, mkdirSync, existsSync as existsSync2, copyFileSync } from "fs";
+import { join, dirname } from "path";
+async function runPull(options) {
+  const config = loadConfig();
+  if (!config?.token) {
+    error(t("auth.no_token"));
+    return;
+  }
+  if (!config.gist_id) {
+    error(t("pull.no_gist"));
+    return;
+  }
+  info(t("pull.fetching"));
+  const gist = await getGist(config.token, config.gist_id);
+  const localFiles = scanFiles(options.only);
+  const changes = compareForPull(gist, localFiles);
+  const modified = changes.filter((c2) => c2.status !== "unchanged");
+  const meta = parseMeta(gist);
+  const toApply = options.only ? modified.filter((c2) => c2.category === options.only) : modified;
+  if (toApply.length === 0) {
+    success(t("pull.no_changes"));
+    return;
+  }
+  await applyChanges(toApply, config.token, options.force ?? false, meta);
+}
+async function applyChanges(changes, token, force, meta) {
+  heading(t("pull.changes_heading"));
+  for (const change of changes) {
+    const icon = change.status === "added" ? c.green(t("pull.icon_added")) : change.status === "modified" ? c.yellow(t("pull.icon_modified")) : c.red(t("pull.icon_deleted"));
+    console.log(`  ${icon} [${change.category}] ${change.relativePath}`);
+    if (change.status === "modified" && change.localContent && change.remoteContent) {
+      const diff = simpleDiff(change.localContent, change.remoteContent);
+      if (diff.length > 0 && diff.length <= 30) {
+        printDiff(change.relativePath, diff);
+      } else if (diff.length > 30) {
+        console.log(c.dim(`    (${t("pull.diff_truncated").replace("{count}", String(diff.length))})`));
+      }
+    }
+  }
+  console.log();
+  if (!force) {
+    const ok = await confirm(t("pull.confirm"));
+    if (!ok) {
+      warn(t("pull.cancelled"));
+      return;
+    }
+  }
+  const base = claudeDir();
+  let applied = 0;
+  for (const change of changes) {
+    if (!isPathSafe(change.relativePath)) {
+      error(`${t("error.path_unsafe")} ${change.relativePath}`);
+      continue;
+    }
+    const targetPath = join(base, change.relativePath);
+    if (change.status === "deleted") {
+      warn(t("pull.skip_deleted").replace("{path}", change.relativePath));
+      continue;
+    }
+    let content = change.remoteContent ?? "";
+    const metaEntry = meta?.file_map[change.gistFilename];
+    const needsDecrypt = metaEntry?.encrypted || isEncrypted(content);
+    if (needsDecrypt) {
+      try {
+        content = decrypt(content, token);
+      } catch {
+        error(t("pull.decrypt_failed").replace("{path}", change.relativePath));
+        continue;
+      }
+    }
+    if (existsSync2(targetPath)) {
+      copyFileSync(targetPath, targetPath + ".bak");
+    }
+    const dir = dirname(targetPath);
+    if (!existsSync2(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync2(targetPath, content, "utf-8");
+    applied++;
+  }
+  success(`${t("pull.success")} (${t("pull.applied").replace("{count}", String(applied))})`);
+}
+
+// src/commands/diff.ts
+async function runDiff(options) {
+  const config = loadConfig();
+  if (!config?.token) {
+    error(t("auth.no_token"));
+    return;
+  }
+  if (!config.gist_id) {
+    error(t("diff.no_gist"));
+    return;
+  }
+  info(t("diff.fetching"));
+  const gist = await getGist(config.token, config.gist_id);
+  const localFiles = scanFiles(options.only);
+  const changes = compareForPull(gist, localFiles);
+  const modified = changes.filter((ch) => ch.status !== "unchanged");
+  if (modified.length === 0) {
+    console.log(t("diff.no_diff"));
+    return;
+  }
+  for (const change of modified) {
+    const icon = change.status === "added" ? c.green("NEW") : change.status === "modified" ? c.yellow("MOD") : c.red("DEL");
+    console.log(`
+${icon} [${change.category}] ${change.relativePath}`);
+    if (change.status === "modified" && change.localContent && change.remoteContent) {
+      const diff = simpleDiff(change.localContent, change.remoteContent);
+      printDiff(change.relativePath, diff);
+    } else if (change.status === "added" && change.remoteContent) {
+      const lines = change.remoteContent.split("\n").map((l) => `+${l}`);
+      printDiff(change.relativePath, lines);
+    }
+  }
+  console.log(`
+${t("diff.total").replace("{count}", String(modified.length))}`);
+}
+
+// src/commands/status.ts
+async function runStatus() {
+  const config = loadConfig();
+  heading(t("status.title"));
+  if (config?.token) {
+    console.log(`  ${t("status.auth_label")}: ${c.green(t("status.authenticated"))}`);
+  } else {
+    console.log(`  ${t("status.auth_label")}: ${c.red(t("status.not_authenticated"))}`);
+    return;
+  }
+  if (config.gist_id) {
+    console.log(`  ${t("status.gist_label")}: ${c.green(config.gist_id)}`);
+    try {
+      const gist = await getGist(config.token, config.gist_id);
+      const meta = parseMeta(gist);
+      if (meta) {
+        console.log(`  ${t("status.last_sync")}`);
+        console.log(`    ${t("status.machine")}: ${meta.last_sync.machine}`);
+        console.log(`    ${t("status.host")}: ${meta.last_sync.hostname}`);
+        console.log(`    ${t("status.platform")}: ${meta.last_sync.platform}`);
+        console.log(`    ${t("status.time")}: ${meta.last_sync.timestamp}`);
+        console.log(`    ${t("status.file_count")}: ${meta.last_sync.file_count}`);
+      }
+      const fileCount = Object.keys(gist.files).filter((n) => n !== "_meta.json").length;
+      console.log(`  ${t("status.remote_files").replace("{count}", String(fileCount))}`);
+    } catch {
+      console.log(`  ${c.yellow(t("status.gist_fetch_failed"))}`);
+    }
+  } else {
+    console.log(`  ${t("status.gist_label")}: ${c.yellow(t("status.no_gist"))}`);
+  }
+  console.log(`  ${t("status.current_machine")}: ${machineName()}`);
+  console.log(`  ${t("status.platform")}: ${platformString()}`);
+}
+
+// src/commands/history.ts
+var MAX_REVISIONS = 10;
+async function runHistory() {
+  const config = loadConfig();
+  if (!config?.token) {
+    error(t("auth.no_token"));
+    return;
+  }
+  if (!config.gist_id) {
+    error(t("history.no_gist"));
+    return;
+  }
+  const allRevisions = await getHistory(config.token, config.gist_id);
+  if (allRevisions.length === 0) {
+    console.log(t("history.empty"));
+    return;
+  }
+  const revisions = allRevisions.slice(0, MAX_REVISIONS);
+  info(t("history.loading").replace("{count}", String(revisions.length)));
+  const messages = await Promise.all(
+    revisions.map(async (rev) => {
+      try {
+        const gist = await getGistAtRevision(config.token, config.gist_id, rev.version);
+        const meta = parseMeta(gist);
+        return meta?.last_sync.message ?? null;
+      } catch {
+        return null;
+      }
+    })
+  );
+  heading(t("history.title"));
+  for (let i = 0; i < revisions.length; i++) {
+    const rev = revisions[i];
+    const date = new Date(rev.committed_at).toLocaleString();
+    const shortSha = rev.version.slice(0, 8);
+    const stats = `+${rev.change_status.additions} -${rev.change_status.deletions}`;
+    const msg = messages[i];
+    const prefix = i === 0 ? c.green("\u25CF") : c.dim("\u25CB");
+    const msgStr = msg ? ` ${c.cyan(msg)}` : "";
+    console.log(`  ${prefix} ${c.bold(shortSha)} ${c.dim(date)} ${c.yellow(stats)}${msgStr}`);
+  }
+  if (allRevisions.length > MAX_REVISIONS) {
+    console.log(c.dim(`  ${t("history.more").replace("{count}", String(allRevisions.length - MAX_REVISIONS))}`));
+  }
+  console.log(`
+${t("history.total").replace("{count}", String(allRevisions.length))}`);
+  console.log(c.dim(t("history.rollback_hint")));
+}
+
+// src/commands/rollback.ts
+import { writeFileSync as writeFileSync3, mkdirSync as mkdirSync2, existsSync as existsSync3, copyFileSync as copyFileSync2 } from "fs";
+import { join as join2, dirname as dirname2 } from "path";
+var META_FILE2 = "_meta.json";
+async function runRollback(version) {
+  const config = loadConfig();
+  if (!config?.token) {
+    error(t("auth.no_token"));
+    return;
+  }
+  if (!config.gist_id) {
+    error(t("rollback.no_gist"));
+    return;
+  }
+  const revisions = await getHistory(config.token, config.gist_id);
+  const matched = revisions.find((r) => r.version.startsWith(version));
+  if (!matched) {
+    error(t("rollback.not_found").replace("{version}", version));
+    return;
+  }
+  const fullSha = matched.version;
+  info(t("rollback.restoring").replace("{sha}", fullSha.slice(0, 8)).replace("{date}", new Date(matched.committed_at).toLocaleString()));
+  const gist = await getGistAtRevision(config.token, config.gist_id, fullSha);
+  const meta = parseMeta(gist);
+  const localFiles = scanFiles();
+  const localMap = new Map(localFiles.map((f) => [f.gistFilename, f]));
+  const base = claudeDir();
+  const filesToApply = [];
+  heading(t("rollback.target_heading"));
+  for (const [gistName, gistFile] of Object.entries(gist.files)) {
+    if (gistName === META_FILE2 || !gistFile?.content) continue;
+    const entry = meta?.file_map[gistName];
+    const relativePath = entry?.path ?? fromGistFilename(gistName);
+    const local = localMap.get(gistName);
+    if (!local) {
+      console.log(`  ${c.green("+")} ${relativePath} ${t("rollback.new_file")}`);
+    } else if (local.content !== gistFile.content) {
+      console.log(`  ${c.yellow("~")} ${relativePath}`);
+      const diff = simpleDiff(local.content, gistFile.content);
+      if (diff.length <= 20) {
+        printDiff(relativePath, diff);
+      }
+    } else {
+      continue;
+    }
+    let content = gistFile.content;
+    const needsDecrypt = entry?.encrypted || isEncrypted(content);
+    if (needsDecrypt) {
+      try {
+        content = decrypt(content, config.token);
+      } catch {
+        error(t("rollback.decrypt_failed").replace("{path}", relativePath));
+        continue;
+      }
+    }
+    filesToApply.push({ relativePath, content });
+  }
+  if (filesToApply.length === 0) {
+    success(t("rollback.no_changes"));
+    return;
+  }
+  console.log(`
+${t("rollback.files_changed").replace("{count}", String(filesToApply.length))}`);
+  const ok = await confirm(t("rollback.confirm"));
+  if (!ok) {
+    warn(t("rollback.cancelled"));
+    return;
+  }
+  for (const { relativePath, content } of filesToApply) {
+    if (!isPathSafe(relativePath)) {
+      error(`${t("error.path_unsafe")} ${relativePath}`);
+      continue;
+    }
+    const targetPath = join2(base, relativePath);
+    if (existsSync3(targetPath)) {
+      copyFileSync2(targetPath, targetPath + ".bak");
+    }
+    const dir = dirname2(targetPath);
+    if (!existsSync3(dir)) {
+      mkdirSync2(dir, { recursive: true });
+    }
+    writeFileSync3(targetPath, content, "utf-8");
+  }
+  success(t("rollback.success").replace("{sha}", fullSha.slice(0, 8)));
+}
+
+// src/core/auto-config.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync4, unlinkSync, existsSync as existsSync4, chmodSync as chmodSync2 } from "fs";
+function saveAutoConfig(config) {
+  const path = autoConfigPath();
+  writeFileSync4(path, JSON.stringify(config, null, 2), "utf-8");
+  chmodSync2(path, 384);
+}
+function loadAutoConfig() {
+  const path = autoConfigPath();
+  if (!existsSync4(path)) return null;
+  try {
+    return JSON.parse(readFileSync2(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+function removeAutoConfig() {
+  const path = autoConfigPath();
+  if (existsSync4(path)) unlinkSync(path);
+}
+
+// src/core/scheduler.ts
+import { writeFileSync as writeFileSync5, unlinkSync as unlinkSync2, existsSync as existsSync5, mkdirSync as mkdirSync3 } from "fs";
+import { execSync as execSync2 } from "child_process";
+import { join as join3 } from "path";
+import { homedir } from "os";
+var LAUNCHD_LABEL = "com.claudesync.auto";
+var SYSTEMD_SERVICE = "claudesync-auto";
+function buildLaunchdPlist(cliArgs, intervalSeconds) {
+  const argsXml = [...cliArgs, "auto-run"].map((arg) => `    <string>${arg}</string>`).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LAUNCHD_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${argsXml}
+  </array>
+  <key>StartInterval</key>
+  <integer>${intervalSeconds}</integer>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${join3(homedir(), ".claudesync", "launchd-stdout.log")}</string>
+  <key>StandardErrorPath</key>
+  <string>${join3(homedir(), ".claudesync", "launchd-stderr.log")}</string>
+</dict>
+</plist>`;
+}
+function buildSystemdService(cliArgs) {
+  const execStart = [...cliArgs, "auto-run"].join(" ");
+  return `[Unit]
+Description=claudesync auto sync
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=oneshot
+ExecStart=${execStart}
+Environment=PATH=/usr/local/bin:/usr/bin:/bin
+
+[Install]
+WantedBy=default.target`;
+}
+function buildSystemdTimer(intervalSeconds) {
+  return `[Unit]
+Description=claudesync auto sync timer
+
+[Timer]
+OnBootSec=60s
+OnUnitActiveSec=${intervalSeconds}s
+Persistent=true
+
+[Install]
+WantedBy=timers.target`;
+}
+function buildSchtasksXml(cliArgs, intervalSeconds) {
+  const command = cliArgs[0];
+  const args = [...cliArgs.slice(1), "auto-run"].join(" ");
+  const minutes = Math.max(1, Math.round(intervalSeconds / 60));
+  return `<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo>
+    <Description>claudesync-auto automatic sync</Description>
+  </RegistrationInfo>
+  <Triggers>
+    <TimeTrigger>
+      <Repetition>
+        <Interval>PT${minutes}M</Interval>
+        <StopAtDurationEnd>false</StopAtDurationEnd>
+      </Repetition>
+      <StartBoundary>2026-01-01T00:00:00</StartBoundary>
+      <Enabled>true</Enabled>
+    </TimeTrigger>
+  </Triggers>
+  <Actions>
+    <Exec>
+      <Command>${command}</Command>
+      <Arguments>${args}</Arguments>
+    </Exec>
+  </Actions>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+  </Settings>
+</Task>`;
+}
+function resolveCliArgs() {
+  try {
+    const bin = execSync2("which claudesync", { encoding: "utf-8" }).trim();
+    return [bin];
+  } catch {
+  }
+  const scriptPath = process.argv[1];
+  if (scriptPath) {
+    return [process.execPath, scriptPath];
+  }
+  throw new Error(t("error.cli_not_found"));
+}
+function registerScheduler(intervalSeconds) {
+  const cliArgs = resolveCliArgs();
+  if (process.platform === "darwin") {
+    registerLaunchd(cliArgs, intervalSeconds);
+  } else if (process.platform === "linux") {
+    registerSystemd(cliArgs, intervalSeconds);
+  } else if (process.platform === "win32") {
+    registerSchtasks(cliArgs, intervalSeconds);
+  } else {
+    throw new Error(t("error.unsupported_platform").replace("{platform}", process.platform));
+  }
+}
+function unregisterScheduler() {
+  if (process.platform === "darwin") {
+    unregisterLaunchd();
+  } else if (process.platform === "linux") {
+    unregisterSystemd();
+  } else if (process.platform === "win32") {
+    unregisterSchtasks();
+  }
+}
+function launchdPlistPath() {
+  return join3(homedir(), "Library", "LaunchAgents", `${LAUNCHD_LABEL}.plist`);
+}
+function registerLaunchd(cliArgs, intervalSeconds) {
+  const plistDir = join3(homedir(), "Library", "LaunchAgents");
+  if (!existsSync5(plistDir)) mkdirSync3(plistDir, { recursive: true });
+  const plistPath = launchdPlistPath();
+  try {
+    execSync2(`launchctl unload "${plistPath}"`, { stdio: "ignore" });
+  } catch {
+  }
+  writeFileSync5(plistPath, buildLaunchdPlist(cliArgs, intervalSeconds), "utf-8");
+  execSync2(`launchctl load "${plistPath}"`, { stdio: "ignore" });
+}
+function unregisterLaunchd() {
+  const plistPath = launchdPlistPath();
+  if (existsSync5(plistPath)) {
+    try {
+      execSync2(`launchctl unload "${plistPath}"`, { stdio: "ignore" });
+    } catch {
+    }
+    unlinkSync2(plistPath);
+  }
+}
+function systemdDir() {
+  return join3(homedir(), ".config", "systemd", "user");
+}
+function registerSystemd(cliArgs, intervalSeconds) {
+  const dir = systemdDir();
+  if (!existsSync5(dir)) mkdirSync3(dir, { recursive: true });
+  writeFileSync5(join3(dir, `${SYSTEMD_SERVICE}.service`), buildSystemdService(cliArgs), "utf-8");
+  writeFileSync5(join3(dir, `${SYSTEMD_SERVICE}.timer`), buildSystemdTimer(intervalSeconds), "utf-8");
+  execSync2("systemctl --user daemon-reload", { stdio: "ignore" });
+  execSync2(`systemctl --user enable --now ${SYSTEMD_SERVICE}.timer`, { stdio: "ignore" });
+}
+function unregisterSystemd() {
+  const dir = systemdDir();
+  try {
+    execSync2(`systemctl --user disable --now ${SYSTEMD_SERVICE}.timer`, { stdio: "ignore" });
+  } catch {
+  }
+  const servicePath = join3(dir, `${SYSTEMD_SERVICE}.service`);
+  const timerPath = join3(dir, `${SYSTEMD_SERVICE}.timer`);
+  if (existsSync5(servicePath)) unlinkSync2(servicePath);
+  if (existsSync5(timerPath)) unlinkSync2(timerPath);
+  try {
+    execSync2("systemctl --user daemon-reload", { stdio: "ignore" });
+  } catch {
+  }
+}
+function registerSchtasks(cliArgs, intervalSeconds) {
+  const xmlPath = join3(homedir(), ".claudesync", "schtask.xml");
+  writeFileSync5(xmlPath, buildSchtasksXml(cliArgs, intervalSeconds), "utf-16le");
+  execSync2(`schtasks /Create /TN "claudesync-auto" /XML "${xmlPath}" /F`, { stdio: "ignore" });
+  unlinkSync2(xmlPath);
+}
+function unregisterSchtasks() {
+  try {
+    execSync2('schtasks /Delete /TN "claudesync-auto" /F', { stdio: "ignore" });
+  } catch {
+  }
+}
+
+// src/commands/auto.ts
+import { hostname } from "os";
+var MIN_INTERVAL_SECONDS = 60;
+function parseInterval(input) {
+  const match = input.trim().match(/^(\d+)\s*(s|m|h|d)$/i);
+  if (!match) return null;
+  const value = parseInt(match[1], 10);
+  const unit = match[2].toLowerCase();
+  switch (unit) {
+    case "s":
+      return value;
+    case "m":
+      return value * 60;
+    case "h":
+      return value * 3600;
+    case "d":
+      return value * 86400;
+    default:
+      return null;
+  }
+}
+function formatInterval(seconds) {
+  if (seconds < 60) return `${seconds}s`;
+  if (seconds < 3600) return `${seconds / 60}m`;
+  if (seconds < 86400) return `${seconds / 3600}h`;
+  return `${seconds / 86400}d`;
+}
+async function runAuto() {
+  const config = loadConfig();
+  if (!config?.token) {
+    error(t("auth.no_token"));
+    return;
+  }
+  if (!config.gist_id) {
+    error(t("auto.no_gist"));
+    return;
+  }
+  heading(t("auto.title"));
+  const dirIdx = await select(t("auto.select_direction"), [
+    t("auto.direction_push"),
+    t("auto.direction_pull")
+  ]);
+  const direction = dirIdx === 0 ? "push" : "pull";
+  let primaryDevice;
+  if (direction === "push") {
+    try {
+      const gist = await getGist(config.token, config.gist_id);
+      const meta = parseMeta(gist);
+      if (meta?.primary_device) {
+        const current = meta.primary_device;
+        const isMe = current.machine_id === getMachineId();
+        if (!isMe) {
+          console.log();
+          warn(
+            t("auto.primary_warning").replace("{machine}", current.machine).replace("{hostname}", current.hostname)
+          );
+          const ok = await confirm(t("auto.confirm_primary_change"), false);
+          if (!ok) {
+            warn(t("auto.setup_cancelled"));
+            return;
+          }
+        }
+      }
+    } catch {
+    }
+    primaryDevice = {
+      machine_id: getMachineId(),
+      machine: machineName(),
+      hostname: hostname(),
+      platform: platformString(),
+      registered_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  let conflictPolicy;
+  if (direction === "pull") {
+    const policyIdx = await select(t("auto.select_conflict_policy"), [
+      t("auto.policy_overwrite"),
+      t("auto.policy_skip"),
+      t("auto.policy_backup")
+    ]);
+    conflictPolicy = ["overwrite", "skip", "backup"][policyIdx];
+  }
+  let intervalSeconds = null;
+  while (intervalSeconds === null) {
+    const input = await ask(t("auto.select_interval") + " ");
+    intervalSeconds = parseInterval(input);
+    if (intervalSeconds === null) {
+      warn(t("auto.interval_invalid"));
+      continue;
+    }
+    if (intervalSeconds < MIN_INTERVAL_SECONDS) {
+      warn(t("auto.interval_too_short"));
+      intervalSeconds = null;
+    }
+  }
+  console.log();
+  const allCats = [...CATEGORIES];
+  console.log(`${t("auto.select_categories")}`);
+  console.log(`  ${c.dim(allCats.join(", "))}`);
+  const catInput = await ask("> ");
+  let selectedCategories = catInput.trim() ? catInput.split(",").map((s) => s.trim()).filter((s) => allCats.includes(s)) : [...allCats];
+  if (catInput.trim() && selectedCategories.length === 0) {
+    warn(t("auto.invalid_categories"));
+    selectedCategories = [...allCats];
+  }
+  const encrypt2 = await confirm(t("auto.select_encrypt"), false);
+  const autoConfig = {
+    direction,
+    interval_seconds: intervalSeconds,
+    categories: selectedCategories,
+    encrypt: encrypt2,
+    enabled: true,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    ...conflictPolicy && { conflict_policy: conflictPolicy }
+  };
+  saveAutoConfig(autoConfig);
+  try {
+    unregisterScheduler();
+    registerScheduler(intervalSeconds);
+  } catch (err) {
+    error(t("auto.scheduler_failed").replace("{error}", err instanceof Error ? err.message : String(err)));
+    return;
+  }
+  if (direction === "push" && primaryDevice) {
+    try {
+      const { scanFiles: scanFiles2 } = await import("./scanner-M3SQGNTI.js");
+      const files = scanFiles2();
+      const { updateGist: updateGistFn } = await import("./gist-AMKOY723.js");
+      await updateGistFn(config.token, config.gist_id, files, void 0, void 0, "auto-sync: primary device registered", primaryDevice);
+    } catch {
+      warn(t("auto.primary_register_failed"));
+    }
+  }
+  console.log();
+  success(t("auto.enabled"));
+  console.log(`  ${c.bold(t("auto.summary_direction") + ":")} ${direction}`);
+  console.log(`  ${c.bold(t("auto.summary_interval") + ":")}  ${formatInterval(intervalSeconds)}`);
+  console.log(`  ${c.bold(t("auto.summary_categories") + ":")} ${selectedCategories.join(", ")}`);
+  console.log(`  ${c.bold(t("auto.summary_encrypt") + ":")}  ${encrypt2 ? t("auto.yes") : t("auto.no")}`);
+  if (conflictPolicy) {
+    console.log(`  ${c.bold(t("auto.summary_conflict") + ":")}  ${conflictPolicy}`);
+  }
+}
+
+// src/core/lock.ts
+import { writeFileSync as writeFileSync6, readFileSync as readFileSync3, unlinkSync as unlinkSync3, existsSync as existsSync6 } from "fs";
+var STALE_TIMEOUT_MS = 5 * 60 * 1e3;
+function acquireLock() {
+  const path = lockFilePath();
+  if (existsSync6(path)) {
+    try {
+      const data = JSON.parse(readFileSync3(path, "utf-8"));
+      const age = Date.now() - data.timestamp;
+      if (age > STALE_TIMEOUT_MS) {
+        unlinkSync3(path);
+      } else {
+        return false;
+      }
+    } catch {
+      unlinkSync3(path);
+    }
+  }
+  const lockData = { pid: process.pid, timestamp: Date.now() };
+  writeFileSync6(path, JSON.stringify(lockData), "utf-8");
+  return true;
+}
+function releaseLock() {
+  const path = lockFilePath();
+  if (existsSync6(path)) {
+    unlinkSync3(path);
+  }
+}
+
+// src/core/auto-log.ts
+import { appendFileSync, readFileSync as readFileSync4, existsSync as existsSync7 } from "fs";
+function appendLog(direction, status, message) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const line = `${timestamp} [${direction}] [${status}] ${message}
+`;
+  appendFileSync(autoLogPath(), line, "utf-8");
+}
+function readRecentLogs(count) {
+  const path = autoLogPath();
+  if (!existsSync7(path)) return [];
+  const content = readFileSync4(path, "utf-8").trim();
+  if (!content) return [];
+  const lines = content.split("\n");
+  return lines.slice(-count);
+}
+
+// src/core/notify.ts
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync7, unlinkSync as unlinkSync4, existsSync as existsSync8 } from "fs";
+import { execFileSync } from "child_process";
+function sendOsNotification(title, message) {
+  try {
+    if (process.platform === "darwin") {
+      execFileSync("osascript", [
+        "-e",
+        `display notification "${message}" with title "${title}"`
+      ], { stdio: "ignore" });
+    } else if (process.platform === "linux") {
+      execFileSync("notify-send", [title, message], { stdio: "ignore" });
+    } else if (process.platform === "win32") {
+      const ps = [
+        "[Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] | Out-Null",
+        `$template = [Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent([Windows.UI.Notifications.ToastTemplateType]::ToastText02)`,
+        `$textNodes = $template.GetElementsByTagName('text')`,
+        `$textNodes.Item(0).AppendChild($template.CreateTextNode('${title}')) | Out-Null`,
+        `$textNodes.Item(1).AppendChild($template.CreateTextNode('${message}')) | Out-Null`,
+        `$toast = [Windows.UI.Notifications.ToastNotification]::new($template)`,
+        `[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('claudesync').Show($toast)`
+      ].join("; ");
+      execFileSync("powershell", ["-Command", ps], { stdio: "ignore" });
+    }
+  } catch {
+  }
+}
+function addPendingNotification(level, message) {
+  const notifications = getPendingNotifications();
+  notifications.push({ level, message, timestamp: (/* @__PURE__ */ new Date()).toISOString() });
+  writeFileSync7(pendingNotificationsPath(), JSON.stringify(notifications, null, 2), "utf-8");
+}
+function getPendingNotifications() {
+  const path = pendingNotificationsPath();
+  if (!existsSync8(path)) return [];
+  try {
+    return JSON.parse(readFileSync5(path, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function clearPendingNotifications() {
+  const path = pendingNotificationsPath();
+  if (existsSync8(path)) unlinkSync4(path);
+}
+
+// src/commands/auto-run.ts
+import { writeFileSync as writeFileSync8, mkdirSync as mkdirSync4, existsSync as existsSync9, copyFileSync as copyFileSync3 } from "fs";
+import { join as join4, dirname as dirname3 } from "path";
+import { hostname as hostname2 } from "os";
+async function runAutoRun() {
+  const autoConfig = loadAutoConfig();
+  if (!autoConfig || !autoConfig.enabled) {
+    return;
+  }
+  const authConfig = loadConfig();
+  if (!authConfig?.token || !authConfig.gist_id) {
+    appendLog(autoConfig.direction, "error", "No auth config or gist_id");
+    return;
+  }
+  if (!acquireLock()) {
+    appendLog(autoConfig.direction, "skipped", "Lock held by another process");
+    return;
+  }
+  try {
+    if (autoConfig.direction === "push") {
+      await autoRunPush(autoConfig, authConfig.token, authConfig.gist_id);
+    } else {
+      await autoRunPull(autoConfig, authConfig.token, authConfig.gist_id);
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    appendLog(autoConfig.direction, "error", message);
+    const failMsg = t("auto_run.failed").replace("{direction}", autoConfig.direction).replace("{message}", message);
+    sendOsNotification("claudesync", failMsg);
+    addPendingNotification("error", failMsg);
+  } finally {
+    releaseLock();
+  }
+}
+async function autoRunPush(autoConfig, token, gistId) {
+  try {
+    const gist = await getGist(token, gistId);
+    const meta = parseMeta(gist);
+    if (meta?.primary_device) {
+      const primary = meta.primary_device;
+      if (primary.machine_id !== getMachineId()) {
+        appendLog("push", "skipped", `Not primary device (primary: ${primary.machine})`);
+        return;
+      }
+    }
+  } catch {
+  }
+  let files = scanFiles();
+  files = files.filter((f) => autoConfig.categories.includes(f.category));
+  if (files.length === 0) {
+    appendLog("push", "skipped", "No files to sync");
+    return;
+  }
+  const processedFiles = files.map((file) => {
+    const secrets = detectSecrets(file.content);
+    if (secrets.length > 0) {
+      return { ...file, content: redactContent(file.content, secrets) };
+    }
+    return file;
+  });
+  const encryptedFiles = /* @__PURE__ */ new Set();
+  const finalFiles = autoConfig.encrypt ? processedFiles.map((f) => {
+    encryptedFiles.add(f.gistFilename);
+    return { ...f, content: encrypt(f.content, token) };
+  }) : processedFiles;
+  try {
+    const gist = await getGist(token, gistId);
+    const changes = compareForPush(finalFiles, gist);
+    const modified = changes.filter((c2) => c2.status !== "unchanged");
+    if (modified.length === 0) {
+      appendLog("push", "skipped", "No changes detected");
+      return;
+    }
+    const deletedFiles = changes.filter((c2) => c2.status === "deleted").map((c2) => c2.gistFilename);
+    const filesToUpload = finalFiles.filter(
+      (f) => changes.some((c2) => c2.gistFilename === f.gistFilename && c2.status !== "unchanged")
+    );
+    const primaryDevice = {
+      machine_id: getMachineId(),
+      machine: machineName(),
+      hostname: hostname2(),
+      platform: platformString(),
+      registered_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await updateGist(token, gistId, filesToUpload, deletedFiles, encryptedFiles, "auto-sync push", primaryDevice);
+    appendLog("push", "success", t("auto_run.push_synced").replace("{count}", String(modified.length)));
+  } catch (err) {
+    if (String(err).includes("404")) {
+      const primaryDevice = {
+        machine: machineName(),
+        hostname: hostname2(),
+        platform: platformString(),
+        registered_at: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      const newGist = await createGist(token, finalFiles, encryptedFiles, "auto-sync push (new gist)", primaryDevice);
+      appendLog("push", "success", `Created new gist: ${newGist.id}`);
+    } else {
+      throw err;
+    }
+  }
+}
+async function autoRunPull(autoConfig, token, gistId) {
+  const gist = await getGist(token, gistId);
+  const localFiles = scanFiles();
+  const filteredLocal = localFiles.filter((f) => autoConfig.categories.includes(f.category));
+  const changes = compareForPull(gist, filteredLocal);
+  const modified = changes.filter((c2) => c2.status !== "unchanged");
+  const meta = parseMeta(gist);
+  const toApply = modified.filter((c2) => autoConfig.categories.includes(c2.category));
+  if (toApply.length === 0) {
+    appendLog("pull", "skipped", "No changes detected");
+    return;
+  }
+  const base = claudeDir();
+  let applied = 0;
+  let skipped = 0;
+  for (const change of toApply) {
+    if (!isPathSafe(change.relativePath)) continue;
+    if (change.status === "deleted") continue;
+    const targetPath = join4(base, change.relativePath);
+    let content = change.remoteContent ?? "";
+    const metaEntry = meta?.file_map[change.gistFilename];
+    const needsDecrypt = metaEntry?.encrypted || isEncrypted(content);
+    if (needsDecrypt) {
+      try {
+        content = decrypt(content, token);
+      } catch {
+        appendLog("pull", "error", `Decrypt failed: ${change.relativePath}`);
+        continue;
+      }
+    }
+    if (change.status === "modified" && autoConfig.conflict_policy) {
+      switch (autoConfig.conflict_policy) {
+        case "skip":
+          if (change.localContent && change.localContent !== content) {
+            skipped++;
+            continue;
+          }
+          break;
+        case "backup":
+          if (existsSync9(targetPath)) {
+            copyFileSync3(targetPath, targetPath + ".bak");
+          }
+          break;
+        case "overwrite":
+          break;
+      }
+    }
+    const dir = dirname3(targetPath);
+    if (!existsSync9(dir)) mkdirSync4(dir, { recursive: true });
+    writeFileSync8(targetPath, content, "utf-8");
+    applied++;
+  }
+  const message = skipped > 0 ? t("auto_run.pull_applied_skipped").replace("{applied}", String(applied)).replace("{skipped}", String(skipped)) : t("auto_run.pull_applied").replace("{applied}", String(applied));
+  appendLog("pull", "success", message);
+}
+
+// src/commands/auto-disable.ts
+async function runAutoDisable() {
+  const config = loadAutoConfig();
+  if (!config) {
+    warn(t("auto.not_configured"));
+    return;
+  }
+  try {
+    unregisterScheduler();
+  } catch {
+  }
+  removeAutoConfig();
+  success(t("auto.disabled"));
+}
+
+// src/commands/auto-status.ts
+function formatInterval2(seconds) {
+  if (seconds < 60) return t("auto.interval_seconds").replace("{n}", String(seconds));
+  if (seconds < 3600) return t("auto.interval_minutes").replace("{n}", String(Math.round(seconds / 60)));
+  if (seconds < 86400) return t("auto.interval_hours").replace("{n}", String(Math.round(seconds / 3600)));
+  return t("auto.interval_days").replace("{n}", String(Math.round(seconds / 86400)));
+}
+async function runAutoStatus() {
+  const autoConfig = loadAutoConfig();
+  heading(t("auto.status_title"));
+  if (!autoConfig) {
+    warn(t("auto.not_configured"));
+    return;
+  }
+  console.log(`  ${c.bold(t("auto.status_label") + ":")}     ${autoConfig.enabled ? c.green(t("auto.status_enabled")) : c.red(t("auto.status_disabled"))}`);
+  console.log(`  ${c.bold(t("auto.summary_direction") + ":")}  ${autoConfig.direction}`);
+  console.log(`  ${c.bold(t("auto.summary_interval") + ":")}   ${formatInterval2(autoConfig.interval_seconds)}`);
+  console.log(`  ${c.bold(t("auto.summary_categories") + ":")} ${autoConfig.categories.join(", ")}`);
+  console.log(`  ${c.bold(t("auto.summary_encrypt") + ":")}    ${autoConfig.encrypt ? t("auto.yes") : t("auto.no")}`);
+  if (autoConfig.conflict_policy) {
+    console.log(`  ${c.bold(t("auto.summary_conflict") + ":")}   ${autoConfig.conflict_policy}`);
+  }
+  console.log(`  ${c.bold(t("auto.created_label") + ":")}    ${autoConfig.created_at}`);
+  const authConfig = loadConfig();
+  if (authConfig?.token && authConfig.gist_id) {
+    try {
+      const gist = await getGist(authConfig.token, authConfig.gist_id);
+      const meta = parseMeta(gist);
+      if (meta?.primary_device) {
+        const pd = meta.primary_device;
+        const isMe = pd.machine_id === getMachineId();
+        console.log();
+        console.log(`  ${c.bold(t("auto.primary_device_label") + ":")}`);
+        console.log(`    ${t("status.machine")}:  ${pd.machine} ${isMe ? c.green(t("auto.this_machine")) : ""}`);
+        console.log(`    ${t("status.host")}: ${pd.hostname}`);
+        console.log(`    ${t("status.platform")}: ${pd.platform}`);
+        console.log(`    ${t("auto.since_label")}:    ${pd.registered_at}`);
+      }
+    } catch {
+    }
+  }
+  const logs = readRecentLogs(5);
+  if (logs.length > 0) {
+    console.log();
+    console.log(`  ${c.bold(t("auto.recent_logs_label") + ":")}`);
+    for (const log of logs) {
+      const colored = log.replace(/\[success\]/g, c.green("[success]")).replace(/\[error\]/g, c.red("[error]")).replace(/\[skipped\]/g, c.yellow("[skipped]"));
+      console.log(`    ${colored}`);
+    }
+  }
+}
+
+// src/cli.ts
+var VERSION = "0.1.0";
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const flags = {};
+  const positional = [];
+  let command;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--")) {
+      const eqIdx = arg.indexOf("=");
+      if (eqIdx !== -1) {
+        flags[arg.slice(2, eqIdx)] = arg.slice(eqIdx + 1);
+      } else if (i + 1 < args.length && !args[i + 1].startsWith("-")) {
+        flags[arg.slice(2)] = args[i + 1];
+        i++;
+      } else {
+        flags[arg.slice(2)] = true;
+      }
+    } else if (arg.startsWith("-") && arg.length === 2) {
+      if (i + 1 < args.length && !args[i + 1].startsWith("-")) {
+        flags[arg.slice(1)] = args[i + 1];
+        i++;
+      } else {
+        flags[arg.slice(1)] = true;
+      }
+    } else {
+      if (!command) {
+        command = arg;
+      } else {
+        positional.push(arg);
+      }
+    }
+  }
+  return { command, flags, positional };
+}
+function printHelp() {
+  console.log(`
+${t("app.name")} v${VERSION}
+${t("app.description")}
+
+${t("help.usage")}
+
+${t("help.commands")}
+  init                 ${t("help.init")}
+  init --token         ${t("help.init_token")}
+  link <gist-id>       ${t("help.link")}
+  push                 ${t("help.push")}
+  pull                 ${t("help.pull")}
+  diff                 ${t("help.diff")}
+  status               ${t("help.status")}
+  list                 ${t("help.list")}
+  history              ${t("help.history")}
+  rollback <version>   ${t("help.rollback")}
+  auto                 ${t("help.auto")}
+  auto disable         ${t("help.auto_disable")}
+  auto status          ${t("help.auto_status")}
+  config <key> <value> ${t("help.config")}
+
+${t("help.options")}
+  -m, --message <msg>  ${t("help.opt_message")}
+  --only <category>    ${t("help.opt_only")}
+  --force              ${t("help.opt_force")}
+  --encrypt            ${t("help.opt_encrypt")}
+  --lang=ko|en         ${t("help.opt_lang")}
+  -h, --help           ${t("help.opt_help")}
+  -v, --version        ${t("help.opt_version")}
+`);
+}
+function parseCategory(value) {
+  if (typeof value === "string" && CATEGORIES.includes(value)) {
+    return value;
+  }
+  return void 0;
+}
+async function main() {
+  const { command, flags, positional } = parseArgs(process.argv);
+  const langFlag = flags["lang"];
+  if (langFlag === "ko" || langFlag === "en") {
+    setLang(langFlag);
+  } else {
+    const saved = loadLangConfig();
+    setLang(saved ?? detectLang());
+  }
+  if (flags["v"] || flags["version"]) {
+    console.log(VERSION);
+    return;
+  }
+  if (!command || flags["h"] || flags["help"]) {
+    printHelp();
+    return;
+  }
+  const only = parseCategory(flags["only"]);
+  const force = !!flags["force"];
+  const encrypt2 = !!flags["encrypt"];
+  const message = typeof flags["m"] === "string" ? flags["m"] : typeof flags["message"] === "string" ? flags["message"] : void 0;
+  try {
+    if (command !== "auto-run") {
+      const notifications = getPendingNotifications();
+      if (notifications.length > 0) {
+        for (const n of notifications) {
+          if (n.level === "error") error(n.message);
+          else if (n.level === "warning") warn(n.message);
+          else info(n.message);
+        }
+        clearPendingNotifications();
+        console.log();
+      }
+    }
+    switch (command) {
+      case "init":
+        await runInit({ useToken: !!flags["token"] });
+        break;
+      case "link":
+        if (!positional[0]) {
+          error(t("cli.link_usage"));
+          process.exit(1);
+        }
+        await runInit({ linkGistId: positional[0] });
+        break;
+      case "push":
+        await runPush({ only, force, encrypt: encrypt2, message });
+        break;
+      case "pull":
+        await runPull({ only, force });
+        break;
+      case "diff":
+        await runDiff({ only });
+        break;
+      case "status":
+        await runStatus();
+        break;
+      case "list": {
+        const { scanFiles: scanFiles2 } = await import("./scanner-M3SQGNTI.js");
+        const files = scanFiles2(only);
+        if (files.length === 0) {
+          console.log(t("cli.list_empty"));
+        } else {
+          for (const f of files) {
+            console.log(`  [${f.category}] ${f.relativePath}`);
+          }
+          console.log(`
+${t("cli.list_total").replace("{count}", String(files.length))}`);
+        }
+        break;
+      }
+      case "history":
+        await runHistory();
+        break;
+      case "rollback":
+        if (!positional[0]) {
+          error(t("cli.rollback_usage"));
+          process.exit(1);
+        }
+        await runRollback(positional[0]);
+        break;
+      case "auto":
+        if (positional[0] === "disable") {
+          await runAutoDisable();
+        } else if (positional[0] === "status") {
+          await runAutoStatus();
+        } else {
+          await runAuto();
+        }
+        break;
+      case "config": {
+        const { runConfig } = await import("./config-7KJ6CZMX.js");
+        runConfig(positional);
+        break;
+      }
+      case "auto-run":
+        await runAutoRun();
+        break;
+      default:
+        error(t("cli.unknown_command").replace("{command}", command));
+        printHelp();
+        process.exit(1);
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+main();
+//# sourceMappingURL=cli.js.map