1import fs from "node:fs";
2import path from "node:path";
3import os from "node:os";
4 
5export type StrictHostKeyChecking = "yes" | "no" | "accept-new";
6 
7export interface WechatAccount {
8  name: string;
9  alias: string;
10  default?: boolean;
11  default_publish_method?: string;
12  default_author?: string;
13  need_open_comment?: number;
14  only_fans_can_comment?: number;
15  app_id?: string;
16  app_secret?: string;
17  chrome_profile_path?: string;
18  remote_publish_host?: string;
19  remote_publish_user?: string;
20  remote_publish_port?: number;
21  remote_publish_identity_file?: string;
22  remote_publish_known_hosts_file?: string;
23  remote_publish_strict_host_key_checking?: StrictHostKeyChecking;
24  remote_publish_connect_timeout?: number;
25  remote_publish_proxy_jump?: string;
26}
27 
28export interface WechatExtendConfig {
29  default_theme?: string;
30  default_color?: string;
31  default_publish_method?: string;
32  default_author?: string;
33  need_open_comment?: number;
34  only_fans_can_comment?: number;
35  chrome_profile_path?: string;
36  remote_publish_host?: string;
37  remote_publish_user?: string;
38  remote_publish_port?: number;
39  remote_publish_identity_file?: string;
40  remote_publish_known_hosts_file?: string;
41  remote_publish_strict_host_key_checking?: StrictHostKeyChecking;
42  remote_publish_connect_timeout?: number;
43  remote_publish_proxy_jump?: string;
44  accounts?: WechatAccount[];
45}
46 
47export interface ResolvedAccount {
48  name?: string;
49  alias?: string;
50  default_publish_method?: string;
51  default_author?: string;
52  need_open_comment: number;
53  only_fans_can_comment: number;
54  app_id?: string;
55  app_secret?: string;
56  chrome_profile_path?: string;
57  remote_publish_host?: string;
58  remote_publish_user?: string;
59  remote_publish_port?: number;
60  remote_publish_identity_file?: string;
61  remote_publish_known_hosts_file?: string;
62  remote_publish_strict_host_key_checking?: StrictHostKeyChecking;
63  remote_publish_connect_timeout?: number;
64  remote_publish_proxy_jump?: string;
65}
66 
67function stripQuotes(s: string): string {
68  return s.replace(/^['"]|['"]$/g, "");
69}
70 
71function toBool01(v: string): number {
72  return v === "1" || v === "true" ? 1 : 0;
73}
74 
75function homeDir(): string {
76  return process.env.HOME || process.env.USERPROFILE || os.homedir();
77}
78 
79function parsePort(key: string, v: string): number {
80  const n = Number.parseInt(v, 10);
81  if (!Number.isFinite(n) || String(n) !== v.trim() || n < 1 || n > 65535) {
82    throw new Error(`Invalid ${key}: ${v} (expected integer 1-65535)`);
83  }
84  return n;
85}
86 
87function parsePositiveInt(key: string, v: string): number {
88  const n = Number.parseInt(v, 10);
89  if (!Number.isFinite(n) || String(n) !== v.trim() || n <= 0) {
90    throw new Error(`Invalid ${key}: ${v} (expected positive integer)`);
91  }
92  return n;
93}
94 
95function parseStrictHostKeyChecking(key: string, v: string): StrictHostKeyChecking {
96  const lower = v.toLowerCase();
97  if (lower === "yes" || lower === "no" || lower === "accept-new") {
98    return lower;
99  }
100  throw new Error(`Invalid ${key}: ${v} (expected yes|no|accept-new)`);
101}
102 
103function parseWechatExtend(content: string): WechatExtendConfig {
104  const config: WechatExtendConfig = {};
105  const lines = content.split("\n");
106  let inAccounts = false;
107  let current: Record<string, string> | null = null;
108  const rawAccounts: Record<string, string>[] = [];
109 
110  for (const raw of lines) {
111    const trimmed = raw.trim();
112    if (!trimmed || trimmed.startsWith("#")) continue;
113 
114    if (trimmed === "accounts:") {
115      inAccounts = true;
116      continue;
117    }
118 
119    if (inAccounts) {
120      const listMatch = raw.match(/^\s+-\s+(.+)$/);
121      if (listMatch) {
122        if (current) rawAccounts.push(current);
123        current = {};
124        const kv = listMatch[1]!;
125        const ci = kv.indexOf(":");
126        if (ci > 0) {
127          current[kv.slice(0, ci).trim()] = stripQuotes(kv.slice(ci + 1).trim());
128        }
129        continue;
130      }
131 
132      if (current && /^\s{2,}/.test(raw) && !trimmed.startsWith("-")) {
133        const ci = trimmed.indexOf(":");
134        if (ci > 0) {
135          current[trimmed.slice(0, ci).trim()] = stripQuotes(trimmed.slice(ci + 1).trim());
136        }
137        continue;
138      }
139 
140      if (!/^\s/.test(raw)) {
141        if (current) rawAccounts.push(current);
142        current = null;
143        inAccounts = false;
144      } else {
145        continue;
146      }
147    }
148 
149    const ci = trimmed.indexOf(":");
150    if (ci < 0) continue;
151    const key = trimmed.slice(0, ci).trim();
152    const val = stripQuotes(trimmed.slice(ci + 1).trim());
153    if (val === "null" || val === "") continue;
154 
155    switch (key) {
156      case "default_theme": config.default_theme = val; break;
157      case "default_color": config.default_color = val; break;
158      case "default_publish_method": config.default_publish_method = val; break;
159      case "default_author": config.default_author = val; break;
160      case "need_open_comment": config.need_open_comment = toBool01(val); break;
161      case "only_fans_can_comment": config.only_fans_can_comment = toBool01(val); break;
162      case "chrome_profile_path": config.chrome_profile_path = val; break;
163      case "remote_publish_host": config.remote_publish_host = val; break;
164      case "remote_publish_user": config.remote_publish_user = val; break;
165      case "remote_publish_port": config.remote_publish_port = parsePort("remote_publish_port", val); break;
166      case "remote_publish_identity_file": config.remote_publish_identity_file = val; break;
167      case "remote_publish_known_hosts_file": config.remote_publish_known_hosts_file = val; break;
168      case "remote_publish_strict_host_key_checking": config.remote_publish_strict_host_key_checking = parseStrictHostKeyChecking("remote_publish_strict_host_key_checking", val); break;
169      case "remote_publish_connect_timeout": config.remote_publish_connect_timeout = parsePositiveInt("remote_publish_connect_timeout", val); break;
170      case "remote_publish_proxy_jump": config.remote_publish_proxy_jump = val; break;
171    }
172  }
173 
174  if (current) rawAccounts.push(current);
175 
176  if (rawAccounts.length > 0) {
177    config.accounts = rawAccounts.map(a => ({
178      name: a.name || "",
179      alias: a.alias || "",
180      default: a.default === "true" || a.default === "1",
181      default_publish_method: a.default_publish_method || undefined,
182      default_author: a.default_author || undefined,
183      need_open_comment: a.need_open_comment ? toBool01(a.need_open_comment) : undefined,
184      only_fans_can_comment: a.only_fans_can_comment ? toBool01(a.only_fans_can_comment) : undefined,
185      app_id: a.app_id || undefined,
186      app_secret: a.app_secret || undefined,
187      chrome_profile_path: a.chrome_profile_path || undefined,
188      remote_publish_host: a.remote_publish_host || undefined,
189      remote_publish_user: a.remote_publish_user || undefined,
190      remote_publish_port: a.remote_publish_port ? parsePort("remote_publish_port", a.remote_publish_port) : undefined,
191      remote_publish_identity_file: a.remote_publish_identity_file || undefined,
192      remote_publish_known_hosts_file: a.remote_publish_known_hosts_file || undefined,
193      remote_publish_strict_host_key_checking: a.remote_publish_strict_host_key_checking
194        ? parseStrictHostKeyChecking("remote_publish_strict_host_key_checking", a.remote_publish_strict_host_key_checking)
195        : undefined,
196      remote_publish_connect_timeout: a.remote_publish_connect_timeout
197        ? parsePositiveInt("remote_publish_connect_timeout", a.remote_publish_connect_timeout)
198        : undefined,
199      remote_publish_proxy_jump: a.remote_publish_proxy_jump || undefined,
200    }));
201  }
202 
203  return config;
204}
205 
206export function loadWechatExtendConfig(): WechatExtendConfig {
207  const paths = [
208    path.join(process.cwd(), ".baoyu-skills", "baoyu-post-to-wechat", "EXTEND.md"),
209    path.join(
210      process.env.XDG_CONFIG_HOME || path.join(homeDir(), ".config"),
211      "baoyu-skills", "baoyu-post-to-wechat", "EXTEND.md"
212    ),
213    path.join(homeDir(), ".baoyu-skills", "baoyu-post-to-wechat", "EXTEND.md"),
214  ];
215  for (const p of paths) {
216    let content: string;
217    try {
218      content = fs.readFileSync(p, "utf-8");
219    } catch {
220      continue;
221    }
222    return parseWechatExtend(content);
223  }
224  return {};
225}
226 
227function selectAccount(config: WechatExtendConfig, alias?: string): WechatAccount | undefined {
228  if (!config.accounts || config.accounts.length === 0) return undefined;
229  if (alias) return config.accounts.find(a => a.alias === alias);
230  if (config.accounts.length === 1) return config.accounts[0];
231  return config.accounts.find(a => a.default);
232}
233 
234export function resolveAccount(config: WechatExtendConfig, alias?: string): ResolvedAccount {
235  const acct = selectAccount(config, alias);
236  return {
237    name: acct?.name,
238    alias: acct?.alias,
239    default_publish_method: acct?.default_publish_method ?? config.default_publish_method,
240    default_author: acct?.default_author ?? config.default_author,
241    need_open_comment: acct?.need_open_comment ?? config.need_open_comment ?? 1,
242    only_fans_can_comment: acct?.only_fans_can_comment ?? config.only_fans_can_comment ?? 0,
243    app_id: acct?.app_id,
244    app_secret: acct?.app_secret,
245    chrome_profile_path: acct?.chrome_profile_path ?? config.chrome_profile_path,
246    remote_publish_host: acct?.remote_publish_host ?? config.remote_publish_host,
247    remote_publish_user: acct?.remote_publish_user ?? config.remote_publish_user,
248    remote_publish_port: acct?.remote_publish_port ?? config.remote_publish_port,
249    remote_publish_identity_file: acct?.remote_publish_identity_file ?? config.remote_publish_identity_file,
250    remote_publish_known_hosts_file: acct?.remote_publish_known_hosts_file ?? config.remote_publish_known_hosts_file,
251    remote_publish_strict_host_key_checking:
252      acct?.remote_publish_strict_host_key_checking ?? config.remote_publish_strict_host_key_checking,
253    remote_publish_connect_timeout: acct?.remote_publish_connect_timeout ?? config.remote_publish_connect_timeout,
254    remote_publish_proxy_jump: acct?.remote_publish_proxy_jump ?? config.remote_publish_proxy_jump,
255  };
256}
257 
258function loadEnvFile(envPath: string): Record<string, string> {
259  const env: Record<string, string> = {};
260  if (!fs.existsSync(envPath)) return env;
261  const content = fs.readFileSync(envPath, "utf-8");
262  for (const line of content.split("\n")) {
263    const trimmed = line.trim();
264    if (!trimmed || trimmed.startsWith("#")) continue;
265    const eqIdx = trimmed.indexOf("=");
266    if (eqIdx > 0) {
267      const key = trimmed.slice(0, eqIdx).trim();
268      let value = trimmed.slice(eqIdx + 1).trim();
269      if ((value.startsWith('"') && value.endsWith('"')) ||
270          (value.startsWith("'") && value.endsWith("'"))) {
271        value = value.slice(1, -1);
272      }
273      env[key] = value;
274    }
275  }
276  return env;
277}
278 
279function aliasToEnvKey(alias: string): string {
280  return alias.toUpperCase().replace(/-/g, "_");
281}
282 
283interface CredentialSource {
284  name: string;
285  appIdKey: string;
286  appSecretKey: string;
287  appId?: string;
288  appSecret?: string;
289}
290 
291export interface LoadedCredentials {
292  appId: string;
293  appSecret: string;
294  source: string;
295  skippedSources: string[];
296}
297 
298function normalizeCredentialValue(value?: string): string | undefined {
299  const trimmed = value?.trim();
300  return trimmed ? trimmed : undefined;
301}
302 
303function describeMissingKeys(source: CredentialSource): string {
304  const missingKeys: string[] = [];
305  if (!source.appId) missingKeys.push(source.appIdKey);
306  if (!source.appSecret) missingKeys.push(source.appSecretKey);
307  return `${source.name} missing ${missingKeys.join(" and ")}`;
308}
309 
310function buildCredentialSource(
311  name: string,
312  values: Record<string, string | undefined>,
313  appIdKey: string,
314  appSecretKey: string,
315): CredentialSource {
316  return {
317    name,
318    appIdKey,
319    appSecretKey,
320    appId: normalizeCredentialValue(values[appIdKey]),
321    appSecret: normalizeCredentialValue(values[appSecretKey]),
322  };
323}
324 
325function resolveCredentialSource(
326  sources: CredentialSource[],
327  account?: ResolvedAccount,
328): LoadedCredentials {
329  const skippedSources: string[] = [];
330 
331  for (const source of sources) {
332    if (source.appId && source.appSecret) {
333      return {
334        appId: source.appId,
335        appSecret: source.appSecret,
336        source: source.name,
337        skippedSources,
338      };
339    }
340 
341    if (source.appId || source.appSecret) {
342      skippedSources.push(describeMissingKeys(source));
343    }
344  }
345 
346  const hint = account?.alias ? ` (account: ${account.alias})` : "";
347  const partialHint = skippedSources.length > 0
348    ? `\nIncomplete credential sources skipped:\n- ${skippedSources.join("\n- ")}`
349    : "";
350 
351  throw new Error(
352    `Missing WECHAT_APP_ID or WECHAT_APP_SECRET${hint}.\n` +
353    "Set via EXTEND.md account config, environment variables, or .baoyu-skills/.env file." +
354    partialHint
355  );
356}
357 
358export function loadCredentials(account?: ResolvedAccount): LoadedCredentials {
359  const cwdEnvPath = path.join(process.cwd(), ".baoyu-skills", ".env");
360  const homeEnvPath = path.join(homeDir(), ".baoyu-skills", ".env");
361  const cwdEnv = loadEnvFile(cwdEnvPath);
362  const homeEnv = loadEnvFile(homeEnvPath);
363 
364  const sources: CredentialSource[] = [];
365 
366  if (account?.app_id || account?.app_secret) {
367    sources.push({
368      name: account.alias ? `EXTEND.md account "${account.alias}"` : "EXTEND.md account config",
369      appIdKey: "app_id",
370      appSecretKey: "app_secret",
371      appId: normalizeCredentialValue(account.app_id),
372      appSecret: normalizeCredentialValue(account.app_secret),
373    });
374  }
375 
376  const prefix = account?.alias ? `WECHAT_${aliasToEnvKey(account.alias)}_` : "";
377  if (prefix) {
378    const prefixedKeyLabel = `${prefix}APP_ID/${prefix}APP_SECRET`;
379    sources.push(
380      buildCredentialSource(`process.env (${prefixedKeyLabel})`, process.env, `${prefix}APP_ID`, `${prefix}APP_SECRET`),
381      buildCredentialSource(`<cwd>/.baoyu-skills/.env (${prefixedKeyLabel})`, cwdEnv, `${prefix}APP_ID`, `${prefix}APP_SECRET`),
382      buildCredentialSource(`~/.baoyu-skills/.env (${prefixedKeyLabel})`, homeEnv, `${prefix}APP_ID`, `${prefix}APP_SECRET`),
383    );
384  }
385 
386  sources.push(
387    buildCredentialSource("process.env", process.env, "WECHAT_APP_ID", "WECHAT_APP_SECRET"),
388    buildCredentialSource("<cwd>/.baoyu-skills/.env", cwdEnv, "WECHAT_APP_ID", "WECHAT_APP_SECRET"),
389    buildCredentialSource("~/.baoyu-skills/.env", homeEnv, "WECHAT_APP_ID", "WECHAT_APP_SECRET"),
390  );
391 
392  return resolveCredentialSource(sources, account);
393}
394 
395export function listAccounts(config: WechatExtendConfig): string[] {
396  return (config.accounts || []).map(a => a.alias);
397}
398