@stelfield/cli 0.0.0-stage → 0.12.0

package/src/local-media-refs.js

@@ -0,0 +1,228 @@
+// Local image/video references inside a Markdown intro (v0.19.0 M3 / CLI 0.10.0).
+//
+// An agent may write  ![说明](./img/a.jpg)  or  ![封面](a.jpg#list)  in a .md file. Before the intro
+// is written, `set-profile-intro --file` uploads those local files and swaps the path for the
+// platform address (linger://media/<id>, linger://video/<id>), keeping the #list (cover) suffix.
+//
+// SECURITY (the point of this file): the agent may have been prompt-injected into pointing at
+// "~/.ssh/id_rsa" or "../../secret.png". So a path from Markdown is only accepted when
+//   - it is a plain relative path (no absolute path, "~", file://, Windows drive / UNC, backslash),
+//   - it carries an allowed image/video extension,
+//   - after resolving "..", it stays inside the sub-tree of the Markdown file's directory,
+//   - after resolving symlinks (realpath), it STILL stays inside that sub-tree,
+//   - it is a regular file.
+// Error messages say what is wrong and how to fix it, and never print the real (resolved)
+// location of a path that escaped the sub-tree.
+//
+// http(s) image addresses are left untouched on purpose: the server drops them by its existing rule
+// and nothing is ever fetched from a web address.
+
+import { realpathSync } from 'node:fs';
+import { dirname, extname, isAbsolute, relative, resolve, sep } from 'node:path';
+import { ALLOWED_EXT_TEXT, MAX_FILES_PER_COMMAND, MEDIA_EXTENSIONS, prepareFile } from './media-upload.js';
+
+// ![alt](target "title") - the target is either <...> or a run without spaces / ")".
+const IMAGE_RE = /!\[([^\]\n]*)\]\(\s*(<[^>\n]*>|[^)\s]*)((?:\s+(?:"[^"\n]*"|'[^'\n]*'))?)\s*\)/gd;
+
+const HOW_TO_FIX = '图片请放在这个 .md 文件所在目录或其子目录里，并用相对路径（如 ./img/a.jpg）引用。';
+
+/**
+ * Same-length copy of the text where fenced code blocks and inline code spans are blanked out,
+ * so an image syntax shown as an example inside code is never treated as a real reference.
+ */
+function maskCode(text) {
+  const out = [];
+  let fence = null;
+  for (const line of text.split('\n')) {
+    const m = /^\s{0,3}(`{3,}|~{3,})/.exec(line);
+    if (fence) {
+      out.push(' '.repeat(line.length));
+      if (m && m[1][0] === fence[0] && m[1].length >= fence.length && /^\s{0,3}[`~]+\s*$/.test(line)) fence = null;
+      continue;
+    }
+    if (m) {
+      fence = m[1];
+      out.push(' '.repeat(line.length));
+      continue;
+    }
+    out.push(line.replace(/(`+)[^\n]*?\1/g, (s) => ' '.repeat(s.length)));
+  }
+  return out.join('\n');
+}
+
+function lineOf(text, index) {
+  let n = 1;
+  for (let i = 0; i < index && i < text.length; i++) if (text.charCodeAt(i) === 10) n++;
+  return n;
+}
+
+/**
+ * Decide what a Markdown image target is.
+ * @returns {{kind:'keep'}|{kind:'local', rel:string, fragment:string}|{kind:'reject', reason:string}}
+ *   keep   - linger:// reference, http(s) address or another scheme: not ours to touch
+ *   local  - a candidate local path (still to be checked against the directory rule)
+ *   reject - a path form that is never allowed, with the reason
+ */
+export function classifyTarget(rawTarget) {
+  let t = String(rawTarget ?? '').trim();
+  if (t.startsWith('<') && t.endsWith('>')) t = t.slice(1, -1).trim();
+  if (t === '') return { kind: 'keep' };
+  if (/^stelfield:\/\//i.test(t)) return { kind: 'keep' };
+  if (/^https?:\/\//i.test(t)) return { kind: 'keep' };
+  if (/^file:/i.test(t)) return { kind: 'reject', reason: `不允许 file:// 地址。${HOW_TO_FIX}` };
+  if (/^[A-Za-z]:/.test(t)) return { kind: 'reject', reason: `不允许 Windows 盘符路径。${HOW_TO_FIX}` };
+  if (/^[/\\]{2}/.test(t)) return { kind: 'reject', reason: `不允许网络共享（UNC）或以 // 开头的地址。${HOW_TO_FIX}` };
+  if (/^[a-z][a-z0-9+.-]*:/i.test(t)) return { kind: 'keep' }; // data:, ftp: ... never read from disk
+  if (t.startsWith('~')) return { kind: 'reject', reason: `不允许 ~ 开头的路径（主目录）。${HOW_TO_FIX}` };
+  if (t.startsWith('/') || t.startsWith('\\')) return { kind: 'reject', reason: `不允许绝对路径。${HOW_TO_FIX}` };
+
+  // Only the "#list" fragment means something (cover flag); any other fragment is a mistake.
+  let fragment = '';
+  const hash = t.indexOf('#');
+  if (hash >= 0) {
+    fragment = t.slice(hash + 1);
+    t = t.slice(0, hash);
+    if (fragment !== 'list') return { kind: 'reject', reason: '路径后面的 # 只支持 #list（设为列表封面）。' };
+    fragment = '#list';
+  }
+  if (t === '') return { kind: 'reject', reason: '路径为空。' };
+
+  let decoded = t;
+  try {
+    decoded = decodeURIComponent(t);
+  } catch {
+    return { kind: 'reject', reason: '路径里的 % 转义不合法。' };
+  }
+  // Decoding may reveal what the raw form hid (%2e%2e, %2F ...): run the hard rules again.
+  if (decoded.includes('\0')) return { kind: 'reject', reason: '路径里有不合法的字符。' };
+  if (decoded.includes('\\')) return { kind: 'reject', reason: `路径里不要用反斜杠 \\，请用 / 分隔。${HOW_TO_FIX}` };
+  if (decoded.startsWith('~') || decoded.startsWith('/') || /^[A-Za-z]:/.test(decoded) || /^file:/i.test(decoded)) {
+    return { kind: 'reject', reason: `不允许绝对路径、~ 或盘符。${HOW_TO_FIX}` };
+  }
+  return { kind: 'local', rel: decoded, fragment };
+}
+
+/** true when `child` (already resolved) lies strictly inside `base` (resolved). */
+function isInside(base, child) {
+  const r = relative(base, child);
+  if (r === '' || isAbsolute(r)) return false;
+  return !(r === '..' || r.startsWith('..' + sep));
+}
+
+/**
+ * Resolve one relative path against the Markdown directory and check it stays inside.
+ * @returns {{ok:true, real:string}|{ok:false, error:string}}
+ */
+export function resolveInsideBase(baseReal, rel) {
+  const ext = extname(rel).toLowerCase();
+  if (!MEDIA_EXTENSIONS[ext]) {
+    return { ok: false, error: `格式不支持（${ext || '没有扩展名'}）。只支持：${ALLOWED_EXT_TEXT}。` };
+  }
+  const lexical = resolve(baseReal, rel);
+  if (!isInside(baseReal, lexical)) {
+    return { ok: false, error: `路径跑出了 .md 文件所在的目录。${HOW_TO_FIX}` };
+  }
+  let real;
+  try {
+    real = realpathSync(lexical);
+  } catch {
+    return { ok: false, error: `找不到这个文件。请检查路径是否写对（相对 .md 文件所在目录）。` };
+  }
+  if (!isInside(baseReal, real)) {
+    // Do not print where the link points: that is exactly what must not leak.
+    return { ok: false, error: `这个路径经符号链接指向了目录之外，已拒绝。${HOW_TO_FIX}` };
+  }
+  return { ok: true, real };
+}
+
+/**
+ * Scan Markdown for local image/video references and check every one of them.
+ * Nothing is uploaded or written here.
+ *
+ * @param {string} contentMd  the intro text
+ * @param {string} mdFilePath path of the .md file (its directory is the allowed sub-tree)
+ * @param {{keepLocation?:boolean}} [opts] keepLocation: allow JPEGs that carry GPS data
+ * @returns {{refs:object[], files:object[], errors:string[]}}
+ *   refs  - each local reference: { start, end, fragment, realPath, label }  (start/end = target span)
+ *   files - unique prepared files (output of prepareFile().file), in first-seen order
+ *   errors- ready-to-print Chinese lines, one per bad reference (plus a count-limit line)
+ */
+export function collectLocalMediaRefs(contentMd, mdFilePath, opts = {}) {
+  const refs = [];
+  const files = [];
+  const errors = [];
+  const byReal = new Map();
+
+  let baseReal;
+  try {
+    baseReal = realpathSync(dirname(resolve(mdFilePath)));
+  } catch {
+    return { refs, files, errors: ['读不到正文文件所在的目录。'] };
+  }
+
+  const masked = maskCode(contentMd);
+  IMAGE_RE.lastIndex = 0;
+  let m;
+  while ((m = IMAGE_RE.exec(masked)) !== null) {
+    const [tStart, tEnd] = m.indices[2];
+    const rawTarget = contentMd.slice(tStart, tEnd);
+    const cls = classifyTarget(rawTarget);
+    if (cls.kind === 'keep') continue;
+    const where = `第 ${lineOf(contentMd, m.index)} 行 ${m[0].length > 60 ? m[0].slice(0, 57) + '...' : m[0]}`;
+    if (cls.kind === 'reject') { errors.push(`${where}：${cls.reason}`); continue; }
+
+    const label = cls.rel;
+    const inside = resolveInsideBase(baseReal, cls.rel);
+    if (!inside.ok) { errors.push(`${where}：${inside.error}`); continue; }
+
+    let entry = byReal.get(inside.real);
+    if (!entry) {
+      const prep = prepareFile(inside.real, label, { keepLocation: !!opts.keepLocation });
+      if (!prep.ok) { errors.push(`${where}：${prep.error}`); continue; }
+      entry = prep.file;
+      byReal.set(inside.real, entry);
+      files.push(entry);
+    }
+    refs.push({ start: tStart, end: tEnd, fragment: cls.fragment, realPath: inside.real, label });
+  }
+
+  if (files.length > MAX_FILES_PER_COMMAND) {
+    errors.push(`正文里引用了 ${files.length} 个不同的本地文件，一次最多 ${MAX_FILES_PER_COMMAND} 个。请分批：先 stelfield media upload 传一部分，把正文里的路径换成 linger:// 地址。`);
+  }
+  return { refs, files, errors };
+}
+
+/**
+ * Replace the target of each local reference with its platform address.
+ * @param {string}   contentMd
+ * @param {object[]} refs        from collectLocalMediaRefs
+ * @param {Map<string,string>} refByRealPath realPath -> "linger://media/<id>" | "linger://video/<id>"
+ */
+export function applyUploadedRefs(contentMd, refs, refByRealPath) {
+  let out = contentMd;
+  // Back to front so earlier offsets stay valid.
+  for (const r of [...refs].sort((a, b) => b.start - a.start)) {
+    const ref = refByRealPath.get(r.realPath);
+    if (!ref) continue;
+    out = out.slice(0, r.start) + ref + r.fragment + out.slice(r.end);
+  }
+  return out;
+}
+
+/**
+ * For --stdin and inline text: list image targets that look like local paths. Those inputs have no
+ * directory to anchor a relative path to, so the command refuses instead of guessing.
+ * @returns {string[]} the targets as written (empty = nothing local)
+ */
+export function findLocalLikeTargets(contentMd) {
+  const found = [];
+  const masked = maskCode(contentMd);
+  IMAGE_RE.lastIndex = 0;
+  let m;
+  while ((m = IMAGE_RE.exec(masked)) !== null) {
+    const [s, e] = m.indices[2];
+    const raw = contentMd.slice(s, e);
+    if (classifyTarget(raw).kind !== 'keep') found.push(raw);
+  }
+  return found;
+}

package/src/media-commands.js

@@ -0,0 +1,121 @@
+// Command-level glue for the two upload entry points (v0.19.0 M3 / CLI 0.10.0):
+//   1. `stelfield media upload <files...>`   - upload the files the user named
+//   2. `stelfield set-profile-intro --file`  - upload the local images/videos referenced in the Markdown
+//
+// Both share one rule: check EVERYTHING locally first, only then start uploading, and stop at the
+// first failure. The intro text is written only when every upload succeeded.
+
+import { realpathSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { formatMediaUpload } from './format.js';
+import { MAX_FILES_PER_COMMAND, MediaUploadError, prepareFile, uploadFiles } from './media-upload.js';
+import { applyUploadedRefs, collectLocalMediaRefs } from './local-media-refs.js';
+import { isInsideOrSame, isSensitivePath } from './media-safety.js';
+
+/** Print "what already got uploaded" so a failed run does not leave the agent guessing. */
+function describeUploaded(uploaded) {
+  if (!uploaded || uploaded.length === 0) return ['还没有任何文件上传成功。'];
+  return [
+    '已上传成功的文件（会保留在媒体库，可用 stelfield get-profile-intro --media 查看）：',
+    ...uploaded.map((r) => `  ${r.file}  ->  ${r.ref}`),
+  ];
+}
+
+function reportUploadFailure(e, err, { introUntouched }) {
+  if (e instanceof MediaUploadError) {
+    err(`上传失败${e.file ? `（${e.file}）` : ''}：${e.message}`);
+    for (const l of describeUploaded(e.uploaded)) err(l);
+  } else {
+    err(`上传失败：${e && e.message ? e.message : e}`);
+  }
+  if (introUntouched) err('主页介绍没有被改动。处理好上面的问题后重新运行同一条命令即可（已上传的文件会再传一遍，多占媒体库名额；也可以先把已成功的换成上面的 linger:// 地址）。');
+}
+
+/**
+ * `stelfield media upload <files...> [--json]`
+ * @returns {Promise<number>} exit code (0 ok / 2 bad input, nothing sent / 1 upload failed)
+ */
+export async function runMediaUpload({ paths, json, baseUrl, credOpts, fetchImpl, log, err, allowOutside = false, keepLocation = false }) {
+  if (!paths || paths.length === 0) {
+    err('缺少文件。用法：stelfield media upload <图片或视频文件…> [--json]');
+    return 2;
+  }
+  if (paths.length > MAX_FILES_PER_COMMAND) {
+    err(`一次最多上传 ${MAX_FILES_PER_COMMAND} 个文件（你给了 ${paths.length} 个）。请分批运行。`);
+    return 2;
+  }
+
+  // Files named directly: the real location (after symlinks) must not be in a sensitive folder
+  // (always), and must be inside the current folder unless --allow-outside is given. Then the
+  // usual checks: regular file, extension, size, file header, JPEG location data.
+  let cwdReal = process.cwd();
+  try { cwdReal = realpathSync(cwdReal); } catch { /* keep the plain path */ }
+  const files = [];
+  const problems = [];
+  for (const p of paths) {
+    const abs = resolve(p);
+    let real = null;
+    try { real = realpathSync(abs); } catch { /* prepareFile reports "not found" */ }
+    if (real && isSensitivePath(real)) {
+      problems.push(`${p} 位于敏感目录（密钥、配置、系统目录等），任何情况下都不允许上传。`);
+      continue;
+    }
+    if (real && !allowOutside && !isInsideOrSame(cwdReal, real)) {
+      problems.push(`${p} 在当前目录之外。为防止 agent 被诱导上传电脑里的私人图片，默认只允许当前目录里的文件；确认这是商户本人指定的文件后，再加 --allow-outside。`);
+      continue;
+    }
+    const prep = prepareFile(abs, p, { keepLocation });
+    if (prep.ok) files.push(prep.file); else problems.push(prep.error);
+  }
+  if (problems.length) {
+    err('有文件不能上传，所有文件都没有发送：');
+    for (const p of problems) err(`  - ${p}`);
+    return 2;
+  }
+
+  try {
+    const results = await uploadFiles(files, { baseUrl, credOpts, fetchImpl, onProgress: (m) => err(m) });
+    log(formatMediaUpload(results, { json }));
+    return 0;
+  } catch (e) {
+    reportUploadFailure(e, err, { introUntouched: false });
+    if (json && e instanceof MediaUploadError) {
+      log(JSON.stringify({
+        error: e.message,
+        failed_file: e.file,
+        uploaded: (e.uploaded || []).map((r) => ({ file: r.file, ref: r.ref, media_id: r.mediaId })),
+      }, null, 2));
+    }
+    return 1;
+  }
+}
+
+/**
+ * For `set-profile-intro --file`: find, check and upload the local media referenced in the text,
+ * then swap the paths for platform addresses.
+ *
+ * @returns {Promise<{contentMd:string, uploaded:object[]}|{exit:number}>}
+ *   `exit` means "stop with this code, nothing was written".
+ */
+export async function prepareIntroMedia({ contentMd, mdFile, baseUrl, credOpts, fetchImpl, err, keepLocation = false }) {
+  const scan = collectLocalMediaRefs(contentMd, mdFile, { keepLocation });
+  if (scan.errors.length) {
+    err('正文里的本地图片 / 视频有问题，什么都没有上传，主页介绍也没有改：');
+    for (const e of scan.errors) err(`  - ${e}`);
+    return { exit: 2 };
+  }
+  if (scan.refs.length === 0) return { contentMd, uploaded: [] };
+
+  let results;
+  try {
+    results = await uploadFiles(scan.files, { baseUrl, credOpts, fetchImpl, onProgress: (m) => err(m) });
+  } catch (e) {
+    reportUploadFailure(e, err, { introUntouched: true });
+    return { exit: 1 };
+  }
+
+  // results[i] belongs to scan.files[i] (same order, duplicates included).
+  const refByRealPath = new Map();
+  scan.files.forEach((f, i) => refByRealPath.set(f.absPath, results[i].ref));
+  return { contentMd: applyUploadedRefs(contentMd, scan.refs, refByRealPath), uploaded: results };
+}

package/src/media-safety.js

@@ -0,0 +1,160 @@
+// Local safety checks for media upload (v0.19.0 M6 fixes L-2 / L-3).
+//
+// What this does for the user: before any byte of a file leaves the computer, the command checks
+//   1. the file really is a picture / video (by its first bytes, not by its name),
+//   2. a path typed directly (`media upload <file>`) is inside the current folder, or the user
+//      explicitly allowed otherwise (--allow-outside), and is not in a sensitive folder,
+//   3. a JPEG does not carry GPS (shooting location) data, unless the user confirmed (--keep-location).
+// Nothing here sends anything to the network.
+
+import { BRAND } from './brand.js';
+import { realpathSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { isAbsolute, join, relative, sep } from 'node:path';
+
+// ============================================================
+// magic numbers (same table as backend profile_media_service.sniff_magic)
+// ============================================================
+
+/**
+ * @param {'image'|'video'} mediaType
+ * @param {Buffer} head first bytes of the file
+ * @returns {string|null} the MIME type the bytes look like, or null
+ */
+export function sniffMagic(mediaType, head) {
+  if (!head || head.length === 0) return null;
+  if (mediaType === 'image') {
+    if (head.length >= 3 && head[0] === 0xff && head[1] === 0xd8 && head[2] === 0xff) return 'image/jpeg';
+    if (head.length >= 8 && head.subarray(0, 8).equals(Buffer.from('89504e470d0a1a0a', 'hex'))) return 'image/png';
+    if (head.length >= 6) {
+      const g = head.toString('latin1', 0, 6);
+      if (g === 'GIF87a' || g === 'GIF89a') return 'image/gif';
+    }
+    if (head.length >= 12 && head.toString('latin1', 0, 4) === 'RIFF' && head.toString('latin1', 8, 12) === 'WEBP') return 'image/webp';
+    return null;
+  }
+  // Video: mp4/mov carry "ftyp" at bytes 4-7, webm starts with the EBML header.
+  if (head.length >= 8 && head.toString('latin1', 4, 8) === 'ftyp') return 'video/mp4';
+  if (head.length >= 4 && head[0] === 0x1a && head[1] === 0x45 && head[2] === 0xdf && head[3] === 0xa3) return 'video/webm';
+  return null;
+}
+
+// ============================================================
+// JPEG GPS detection (EXIF APP1 -> IFD0 -> GPSInfo pointer 0x8825)
+// ============================================================
+
+const TAG_GPS_POINTER = 0x8825;
+
+/**
+ * true when the JPEG carries GPS position data in its EXIF block.
+ * Conservative: a GPS pointer whose block cannot be read counts as "has GPS".
+ * @param {Buffer} buf the first bytes of the JPEG (the EXIF block sits right after the SOI marker)
+ */
+export function jpegHasGps(buf) {
+  if (!buf || buf.length < 4 || buf[0] !== 0xff || buf[1] !== 0xd8) return false;
+  let pos = 2;
+  while (pos + 4 <= buf.length) {
+    if (buf[pos] !== 0xff) return false;
+    const marker = buf[pos + 1];
+    if (marker === 0xff) { pos++; continue; } // fill byte
+    if (marker === 0xda || marker === 0xd9) return false; // start of scan / end: no more headers
+    if (marker === 0x01 || (marker >= 0xd0 && marker <= 0xd8)) { pos += 2; continue; } // no length
+    const len = buf.readUInt16BE(pos + 2);
+    if (len < 2) return false;
+    const segStart = pos + 4;
+    const segEnd = pos + 2 + len;
+    if (marker === 0xe1 && segStart + 6 <= buf.length && buf.toString('latin1', segStart, segStart + 6) === 'Exif\0\0') {
+      const tiffStart = segStart + 6;
+      const tiff = buf.subarray(tiffStart, Math.min(segEnd, buf.length));
+      const truncated = segEnd > buf.length;
+      const r = exifHasGps(tiff);
+      if (r === true) return true;
+      if (r === 'unreadable' && truncated) return true;
+    }
+    pos = segEnd;
+  }
+  return false;
+}
+
+/** @returns {boolean|'unreadable'} */
+function exifHasGps(tiff) {
+  if (tiff.length < 8) return false;
+  const bo = tiff.toString('latin1', 0, 2);
+  if (bo !== 'II' && bo !== 'MM') return false;
+  const le = bo === 'II';
+  const u16 = (o) => (le ? tiff.readUInt16LE(o) : tiff.readUInt16BE(o));
+  const u32 = (o) => (le ? tiff.readUInt32LE(o) : tiff.readUInt32BE(o));
+  if (u16(2) !== 0x2a) return false;
+  const ifd0 = u32(4);
+  if (ifd0 + 2 > tiff.length) return 'unreadable';
+  const n0 = u16(ifd0);
+  let gpsOffset = null;
+  for (let i = 0; i < n0; i++) {
+    const e = ifd0 + 2 + i * 12;
+    if (e + 12 > tiff.length) return 'unreadable';
+    if (u16(e) === TAG_GPS_POINTER) { gpsOffset = u32(e + 8); break; }
+  }
+  if (gpsOffset == null) return false;
+  if (gpsOffset + 2 > tiff.length) return true; // pointer exists but block unreadable: be careful
+  const ng = u16(gpsOffset);
+  if (ng === 0) return false;
+  // GPSVersionID alone (tag 0) carries no position; latitude (2) / longitude (4) do.
+  let readable = true;
+  for (let i = 0; i < ng; i++) {
+    const e = gpsOffset + 2 + i * 12;
+    if (e + 12 > tiff.length) { readable = false; break; }
+    const tag = u16(e);
+    if (tag === 2 || tag === 4) return true;
+  }
+  return readable ? false : true;
+}
+
+// ============================================================
+// path rules for directly typed paths
+// ============================================================
+
+/** true when `child` lies inside (or is) `base`; both already resolved. */
+export function isInsideOrSame(base, child) {
+  const r = relative(base, child);
+  if (r === '') return true;
+  if (isAbsolute(r)) return false;
+  return !(r === '..' || r.startsWith('..' + sep));
+}
+
+function realOrSelf(p) {
+  try { return realpathSync(p); } catch { return p; }
+}
+
+/**
+ * Sensitive folders that are never uploaded from, even with --allow-outside.
+ * @returns {string[]} absolute paths (both the plain and the symlink-resolved spelling)
+ */
+export function sensitiveDirs() {
+  const home = homedir();
+  const rel = [
+    '.ssh', '.aws', '.gnupg', '.config', '.claude', '.kube', '.docker',
+    'Library/Keychains', 'Library/Application Support',
+  ];
+  const out = new Set();
+  for (const r of rel) { const p = join(home, r); out.add(p); out.add(realOrSelf(p)); }
+  for (const p of ['/etc', '/var/root']) { out.add(p); out.add(realOrSelf(p)); }
+  return [...out];
+}
+
+/** true when the real path is inside a sensitive folder (or any config / credential folder). */
+export function isSensitivePath(realPath) {
+  for (const d of sensitiveDirs()) if (isInsideOrSame(d, realPath)) return true;
+  for (const h of new Set([homedir(), realOrSelf(homedir())])) {
+    const r = relative(h, realPath);
+    // Both the current config folder and the pre-rename one: a machine that has not re-bound yet
+    // still keeps real credentials in ~/.linger, so uploading from there must stay refused.
+    const top = r && !isAbsolute(r) && !r.startsWith('..') ? r.split(sep)[0] : '';
+    if (top && (top.startsWith(BRAND.configDirName) || top.startsWith(LEGACY_CONFIG_DIR))) return true;
+  }
+  return false;
+}
+
+/** Config folder used before the brand rename; its credentials are still real. */
+const LEGACY_CONFIG_DIR = '.linger';
+
+export const GPS_REJECT_TEXT = '这张照片带有拍摄位置信息，上传会让位置随主页公开。请先去掉位置信息，或加 --keep-location 确认公开';