micloud-cli 0.0.0-stage → 0.5.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +661 -0
- package/README.en.md +118 -0
- package/README.md +117 -2
- package/dist/cli.js +59 -0
- package/dist/commands/account.js +76 -0
- package/dist/core/account.js +22 -0
- package/dist/core/auth.js +338 -0
- package/dist/core/config.js +75 -0
- package/dist/core/http.js +172 -0
- package/dist/core/lock.js +90 -0
- package/dist/core/output.js +137 -0
- package/dist/core/template.js +39 -0
- package/dist/core/utils.js +205 -0
- package/dist/note/client.js +298 -0
- package/dist/note/commands/create.js +44 -0
- package/dist/note/commands/delete.js +32 -0
- package/dist/note/commands/export.js +20 -0
- package/dist/note/commands/folder.js +101 -0
- package/dist/note/commands/get.js +35 -0
- package/dist/note/commands/list.js +57 -0
- package/dist/note/commands/move.js +37 -0
- package/dist/note/commands/pin.js +41 -0
- package/dist/note/commands/search.js +45 -0
- package/dist/note/commands/shared.js +37 -0
- package/dist/note/commands/sync.js +203 -0
- package/dist/note/commands/update.js +61 -0
- package/dist/note/commands/upload-image.js +27 -0
- package/dist/note/config.js +157 -0
- package/dist/note/converter.js +664 -0
- package/dist/note/extra-info.js +23 -0
- package/dist/note/images.js +100 -0
- package/dist/note/register.js +172 -0
- package/dist/note/sync-diff.js +143 -0
- package/dist/note/sync.js +744 -0
- package/dist/note/text-diff.js +71 -0
- package/dist/note/types.js +2 -0
- package/dist/recording/client.js +115 -0
- package/dist/recording/commands/config.js +73 -0
- package/dist/recording/commands/delete.js +171 -0
- package/dist/recording/commands/list.js +161 -0
- package/dist/recording/commands/shared.js +47 -0
- package/dist/recording/commands/transfer.js +192 -0
- package/dist/recording/commands/trash.js +140 -0
- package/dist/recording/config.js +104 -0
- package/dist/recording/dates.js +61 -0
- package/dist/recording/download.js +308 -0
- package/dist/recording/progress.js +77 -0
- package/dist/recording/pull.js +433 -0
- package/dist/recording/recording.js +294 -0
- package/dist/recording/register.js +202 -0
- package/dist/recording/template.js +44 -0
- package/dist/recording/types.js +2 -0
- package/package.json +53 -4
|
@@ -0,0 +1,338 @@
|
|
|
1
|
+
import { readFile, writeFile, rm, chmod, readdir, mkdir, copyFile } from "node:fs/promises";
|
|
2
|
+
import { join } from "node:path";
|
|
3
|
+
import { getCacheDir, getLegacyCacheDir, fileExists, ensureDir } from "./utils.js";
|
|
4
|
+
import { isJsonMode, logInfo } from "./output.js";
|
|
5
|
+
/** 未登录时会跳转到小米账号登录页的 i.mi.com 页面:交互登录与静默续期都打开它 */
|
|
6
|
+
const LOGIN_URL = "https://i.mi.com/note/h5#/";
|
|
7
|
+
/** 校验 cookie 用的轻量接口(账号昵称),对所有 i.mi.com 服务通用 */
|
|
8
|
+
const VALIDATE_URL = "https://i.mi.com/status/lite/profile";
|
|
9
|
+
/** 首次使用时只读沿用其登录状态的旧版工具 */
|
|
10
|
+
const LEGACY_APPS = ["mi-note-cli"];
|
|
11
|
+
const LOGIN_TIMEOUT = 300_000;
|
|
12
|
+
const POLL_INTERVAL = 2_000;
|
|
13
|
+
const REFRESH_TIMEOUT = 20_000;
|
|
14
|
+
const VALIDATE_TIMEOUT = 10_000;
|
|
15
|
+
const CHROME_VERSION = "131";
|
|
16
|
+
/** 复制浏览器数据时跳过:可重建的缓存目录与单实例锁 */
|
|
17
|
+
const SKIPPED_PROFILE_ENTRIES = new Set([
|
|
18
|
+
"Cache",
|
|
19
|
+
"Code Cache",
|
|
20
|
+
"GPUCache",
|
|
21
|
+
"GrShaderCache",
|
|
22
|
+
"ShaderCache",
|
|
23
|
+
"GraphiteDawnCache",
|
|
24
|
+
"DawnGraphiteCache",
|
|
25
|
+
"DawnWebGPUCache",
|
|
26
|
+
"BrowserMetrics",
|
|
27
|
+
"component_crx_cache",
|
|
28
|
+
"extensions_crx_cache",
|
|
29
|
+
"SingletonLock",
|
|
30
|
+
"SingletonSocket",
|
|
31
|
+
"SingletonCookie",
|
|
32
|
+
]);
|
|
33
|
+
function cookieFile() {
|
|
34
|
+
return join(getCacheDir(), "cookie");
|
|
35
|
+
}
|
|
36
|
+
function browserDataDir() {
|
|
37
|
+
return join(getCacheDir(), "browser-data");
|
|
38
|
+
}
|
|
39
|
+
let refreshInFlight = null;
|
|
40
|
+
let bootstrapChecked = false;
|
|
41
|
+
/**
|
|
42
|
+
* 命令使用的登录态:
|
|
43
|
+
* - 交互式终端:缓存失效时先静默续期,仍失败才打开浏览器登录;
|
|
44
|
+
* - --json 或非交互(被 AI / 脚本调用):不弹浏览器,续期失败直接报「请先登录」,避免进程挂起等人。
|
|
45
|
+
*/
|
|
46
|
+
export async function resolveAuth() {
|
|
47
|
+
const nonInteractive = isJsonMode() || !process.stdout.isTTY;
|
|
48
|
+
if (!nonInteractive)
|
|
49
|
+
return await ensureAuth();
|
|
50
|
+
const auth = await peekOrRefreshAuth();
|
|
51
|
+
if (!auth) {
|
|
52
|
+
throw new Error("未登录或登录态已过期。请先在交互式终端运行 `micloud login` 完成登录。");
|
|
53
|
+
}
|
|
54
|
+
return auth;
|
|
55
|
+
}
|
|
56
|
+
/**
|
|
57
|
+
* 确保拥有有效的认证信息(cookie + serviceToken + userId)。
|
|
58
|
+
*
|
|
59
|
+
* 解析顺序:
|
|
60
|
+
* 1. forceLogin=true → 直接浏览器登录。
|
|
61
|
+
* 2. 缓存 cookie 有效 → 使用。
|
|
62
|
+
* 3. 缓存失效但长效登录态可续期 → 静默续期。
|
|
63
|
+
* 4. 否则 → 浏览器登录。
|
|
64
|
+
*/
|
|
65
|
+
export async function ensureAuth(forceLogin = false) {
|
|
66
|
+
if (!forceLogin) {
|
|
67
|
+
const auth = await peekOrRefreshAuth();
|
|
68
|
+
if (auth)
|
|
69
|
+
return auth;
|
|
70
|
+
}
|
|
71
|
+
const cookie = await loginAndGetCookie();
|
|
72
|
+
await saveCookie(cookie);
|
|
73
|
+
return buildAuthInfo(cookie);
|
|
74
|
+
}
|
|
75
|
+
/** 仅读取当前缓存的认证信息,不触发登录与续期。无有效缓存时返回 null。 */
|
|
76
|
+
export async function peekAuth() {
|
|
77
|
+
await bootstrapFromLegacy();
|
|
78
|
+
const cached = await loadCachedCookie();
|
|
79
|
+
if (cached && (await validateCookie(cached)))
|
|
80
|
+
return buildAuthInfo(cached);
|
|
81
|
+
return null;
|
|
82
|
+
}
|
|
83
|
+
/** 先读有效缓存,失效时再静默续期;不触发交互式登录。 */
|
|
84
|
+
export async function peekOrRefreshAuth() {
|
|
85
|
+
return (await peekAuth()) ?? (await refreshAuth());
|
|
86
|
+
}
|
|
87
|
+
/**
|
|
88
|
+
* 清除登录态(cookie + 浏览器数据)。
|
|
89
|
+
* 保留缓存目录本身:它的存在表示「已初始化」,之后不会再从旧版工具自动沿用登录状态。
|
|
90
|
+
*/
|
|
91
|
+
export async function clearAuthCache() {
|
|
92
|
+
const dir = getCacheDir();
|
|
93
|
+
await rm(cookieFile(), { force: true });
|
|
94
|
+
await rm(browserDataDir(), { recursive: true, force: true });
|
|
95
|
+
await ensurePrivateDir(dir);
|
|
96
|
+
return dir;
|
|
97
|
+
}
|
|
98
|
+
/**
|
|
99
|
+
* 静默续期并落盘,返回新的 AuthInfo;长效登录态已失效时返回 null。
|
|
100
|
+
* 供客户端在请求遇 401 时作为续期回调调用;并发调用共享同一次续期。
|
|
101
|
+
*/
|
|
102
|
+
export async function refreshAuth() {
|
|
103
|
+
refreshInFlight ??= doRefreshAuth().finally(() => {
|
|
104
|
+
refreshInFlight = null;
|
|
105
|
+
});
|
|
106
|
+
return await refreshInFlight;
|
|
107
|
+
}
|
|
108
|
+
async function doRefreshAuth() {
|
|
109
|
+
await bootstrapFromLegacy();
|
|
110
|
+
const cookie = await silentRefreshCookie();
|
|
111
|
+
if (!cookie) {
|
|
112
|
+
// 其他进程可能刚刚完成续期并落盘;失败前再读一次缓存。
|
|
113
|
+
const cached = await loadCachedCookie();
|
|
114
|
+
return cached && (await validateCookie(cached)) ? buildAuthInfo(cached) : null;
|
|
115
|
+
}
|
|
116
|
+
await saveCookie(cookie);
|
|
117
|
+
return buildAuthInfo(cookie);
|
|
118
|
+
}
|
|
119
|
+
/**
|
|
120
|
+
* 首次使用(缓存目录尚不存在)时,从旧版工具(mi-note-cli)只读复制浏览器登录数据与 cookie,
|
|
121
|
+
* 升级后不必再登录一次。复制后各自独立续期、互不影响,绝不修改旧版工具的任何文件。
|
|
122
|
+
* 只尝试一次:无论成败都会建立缓存目录。用环境变量指定缓存目录时(测试隔离)不沿用。
|
|
123
|
+
*/
|
|
124
|
+
async function bootstrapFromLegacy() {
|
|
125
|
+
if (bootstrapChecked)
|
|
126
|
+
return;
|
|
127
|
+
bootstrapChecked = true;
|
|
128
|
+
if (process.env.MICLOUD_CACHE_DIR)
|
|
129
|
+
return;
|
|
130
|
+
const dir = getCacheDir();
|
|
131
|
+
if (await fileExists(dir))
|
|
132
|
+
return;
|
|
133
|
+
await ensurePrivateDir(dir);
|
|
134
|
+
for (const app of LEGACY_APPS) {
|
|
135
|
+
const source = getLegacyCacheDir(app);
|
|
136
|
+
const sourceBrowser = join(source, "browser-data");
|
|
137
|
+
if (!(await fileExists(sourceBrowser)))
|
|
138
|
+
continue;
|
|
139
|
+
try {
|
|
140
|
+
await copyProfile(sourceBrowser, browserDataDir());
|
|
141
|
+
const sourceCookie = join(source, "cookie");
|
|
142
|
+
if (await fileExists(sourceCookie)) {
|
|
143
|
+
const cookie = (await readFile(sourceCookie, "utf-8")).trim();
|
|
144
|
+
if (cookie)
|
|
145
|
+
await saveCookie(cookie);
|
|
146
|
+
}
|
|
147
|
+
logInfo(`ℹ️ 已沿用 ${app} 的登录状态`);
|
|
148
|
+
return;
|
|
149
|
+
}
|
|
150
|
+
catch {
|
|
151
|
+
await rm(browserDataDir(), { recursive: true, force: true });
|
|
152
|
+
await rm(cookieFile(), { force: true });
|
|
153
|
+
}
|
|
154
|
+
}
|
|
155
|
+
}
|
|
156
|
+
/** 递归复制浏览器数据目录,跳过缓存、锁文件与符号链接 */
|
|
157
|
+
async function copyProfile(src, dst) {
|
|
158
|
+
await mkdir(dst, { recursive: true, mode: 0o700 });
|
|
159
|
+
for (const entry of await readdir(src, { withFileTypes: true })) {
|
|
160
|
+
if (SKIPPED_PROFILE_ENTRIES.has(entry.name))
|
|
161
|
+
continue;
|
|
162
|
+
const from = join(src, entry.name);
|
|
163
|
+
const to = join(dst, entry.name);
|
|
164
|
+
if (entry.isDirectory())
|
|
165
|
+
await copyProfile(from, to);
|
|
166
|
+
else if (entry.isFile())
|
|
167
|
+
await copyFile(from, to);
|
|
168
|
+
}
|
|
169
|
+
}
|
|
170
|
+
/** 从 cookie 字符串构造 AuthInfo(提取 serviceToken / userId) */
|
|
171
|
+
function buildAuthInfo(cookie) {
|
|
172
|
+
return {
|
|
173
|
+
cookie,
|
|
174
|
+
serviceToken: extractCookieValue(cookie, "serviceToken"),
|
|
175
|
+
userId: extractCookieValue(cookie, "userId", false),
|
|
176
|
+
};
|
|
177
|
+
}
|
|
178
|
+
/** 从 cookie 字符串中提取某字段值 */
|
|
179
|
+
export function extractCookieValue(cookie, key, required = true) {
|
|
180
|
+
const match = cookie.match(new RegExp(`(?:^|;\\s*)${key}=([^;]+)`));
|
|
181
|
+
if (!match) {
|
|
182
|
+
if (required) {
|
|
183
|
+
throw new Error(`Cookie 中未找到 ${key},请重新登录(micloud login)`);
|
|
184
|
+
}
|
|
185
|
+
return "";
|
|
186
|
+
}
|
|
187
|
+
return match[1];
|
|
188
|
+
}
|
|
189
|
+
/**
|
|
190
|
+
* 用持久化上下文启动浏览器。
|
|
191
|
+
* 浏览器策略:优先系统 Chrome,回退 Playwright Chromium。
|
|
192
|
+
* @param headless 是否无头(静默续期用 true,交互登录用 false)
|
|
193
|
+
*/
|
|
194
|
+
async function launchPersistentBrowser(headless) {
|
|
195
|
+
const { chromium } = await import("playwright");
|
|
196
|
+
// 启用沙箱并移除 Playwright 默认追加的 --no-sandbox,
|
|
197
|
+
// 避免浏览器顶部出现「您使用的是不受支持的命令行标记 --no-sandbox」警告条。
|
|
198
|
+
const launchOptions = {
|
|
199
|
+
headless,
|
|
200
|
+
chromiumSandbox: true,
|
|
201
|
+
ignoreDefaultArgs: ["--no-sandbox", "--enable-automation"],
|
|
202
|
+
};
|
|
203
|
+
try {
|
|
204
|
+
return await chromium.launchPersistentContext(browserDataDir(), {
|
|
205
|
+
...launchOptions,
|
|
206
|
+
channel: "chrome",
|
|
207
|
+
});
|
|
208
|
+
}
|
|
209
|
+
catch {
|
|
210
|
+
if (!headless)
|
|
211
|
+
logInfo("⚠️ 未检测到系统 Chrome,回退到 Playwright 自带 Chromium");
|
|
212
|
+
try {
|
|
213
|
+
return await chromium.launchPersistentContext(browserDataDir(), {
|
|
214
|
+
...launchOptions,
|
|
215
|
+
channel: "chromium",
|
|
216
|
+
});
|
|
217
|
+
}
|
|
218
|
+
catch (err) {
|
|
219
|
+
throw new Error("无法启动浏览器:未检测到系统 Chrome,也没有 Playwright 自带的 Chromium。" +
|
|
220
|
+
"请安装 Google Chrome,或运行 `npx playwright install chromium` 后重试。" +
|
|
221
|
+
`\n 原始错误:${err.message.split("\n")[0]}`);
|
|
222
|
+
}
|
|
223
|
+
}
|
|
224
|
+
}
|
|
225
|
+
/**
|
|
226
|
+
* 静默续期:复用持久化的浏览器数据目录,无头打开 i.mi.com,
|
|
227
|
+
* 让浏览器用 account 域的长效 passToken 自动换发新的 serviceToken,提取并返回新 cookie。
|
|
228
|
+
*
|
|
229
|
+
* 仅当 browser-data 里的长效登录态仍有效时成功;失效则返回 null,由调用方回退到交互式 login。
|
|
230
|
+
*/
|
|
231
|
+
export async function silentRefreshCookie() {
|
|
232
|
+
if (!(await fileExists(browserDataDir())))
|
|
233
|
+
return null;
|
|
234
|
+
let context;
|
|
235
|
+
try {
|
|
236
|
+
context = await launchPersistentBrowser(true);
|
|
237
|
+
const page = context.pages()[0] || (await context.newPage());
|
|
238
|
+
const deadline = Date.now() + REFRESH_TIMEOUT;
|
|
239
|
+
await page.goto(LOGIN_URL, { waitUntil: "load", timeout: REFRESH_TIMEOUT }).catch(() => undefined);
|
|
240
|
+
while (true) {
|
|
241
|
+
const cookieStr = await extractCookies(context);
|
|
242
|
+
if (cookieStr && (await validateCookie(cookieStr)))
|
|
243
|
+
return cookieStr;
|
|
244
|
+
const remaining = deadline - Date.now();
|
|
245
|
+
if (remaining <= 0)
|
|
246
|
+
return null;
|
|
247
|
+
await new Promise((r) => setTimeout(r, Math.min(POLL_INTERVAL, remaining)));
|
|
248
|
+
}
|
|
249
|
+
}
|
|
250
|
+
catch {
|
|
251
|
+
return null;
|
|
252
|
+
}
|
|
253
|
+
finally {
|
|
254
|
+
await context?.close();
|
|
255
|
+
}
|
|
256
|
+
}
|
|
257
|
+
/** 通过 Playwright 打开浏览器让用户登录,获取 Cookie */
|
|
258
|
+
async function loginAndGetCookie() {
|
|
259
|
+
logInfo("🌐 正在打开浏览器,请在浏览器中登录小米账号...");
|
|
260
|
+
await ensurePrivateDir(getCacheDir());
|
|
261
|
+
const context = await launchPersistentBrowser(false);
|
|
262
|
+
try {
|
|
263
|
+
const page = context.pages()[0] || (await context.newPage());
|
|
264
|
+
await page.goto(LOGIN_URL).catch(() => undefined);
|
|
265
|
+
logInfo("⏳ 等待登录完成...(登录成功后会自动检测)");
|
|
266
|
+
const startTime = Date.now();
|
|
267
|
+
while (Date.now() - startTime < LOGIN_TIMEOUT) {
|
|
268
|
+
const cookieStr = await extractCookies(context).catch(() => "");
|
|
269
|
+
if (cookieStr && (await validateCookie(cookieStr))) {
|
|
270
|
+
logInfo("✅ 登录成功");
|
|
271
|
+
return cookieStr;
|
|
272
|
+
}
|
|
273
|
+
await new Promise((r) => setTimeout(r, POLL_INTERVAL));
|
|
274
|
+
}
|
|
275
|
+
throw new Error("登录超时(5 分钟),请重试");
|
|
276
|
+
}
|
|
277
|
+
finally {
|
|
278
|
+
await context.close().catch(() => undefined);
|
|
279
|
+
}
|
|
280
|
+
}
|
|
281
|
+
async function extractCookies(context) {
|
|
282
|
+
const cookies = await context.cookies("https://i.mi.com");
|
|
283
|
+
return cookies.map((c) => `${c.name}=${c.value}`).join("; ");
|
|
284
|
+
}
|
|
285
|
+
/** 校验 cookie 是否有效(能访问 i.mi.com 的账号接口) */
|
|
286
|
+
export async function validateCookie(cookie) {
|
|
287
|
+
if (!/(?:^|;\s*)serviceToken=/.test(cookie))
|
|
288
|
+
return false;
|
|
289
|
+
try {
|
|
290
|
+
const resp = await fetch(`${VALIDATE_URL}?ts=${Date.now()}`, {
|
|
291
|
+
headers: buildHeaders(cookie),
|
|
292
|
+
signal: AbortSignal.timeout(VALIDATE_TIMEOUT),
|
|
293
|
+
});
|
|
294
|
+
if (!resp.ok)
|
|
295
|
+
return false;
|
|
296
|
+
const data = (await resp.json());
|
|
297
|
+
return data.code === 0 || data.result === "ok";
|
|
298
|
+
}
|
|
299
|
+
catch {
|
|
300
|
+
return false;
|
|
301
|
+
}
|
|
302
|
+
}
|
|
303
|
+
/** 构建请求头;referer 取发起请求的服务页面(笔记 / 录音),与网页端一致 */
|
|
304
|
+
export function buildHeaders(cookie, referer = "https://i.mi.com/") {
|
|
305
|
+
return {
|
|
306
|
+
Cookie: cookie,
|
|
307
|
+
Referer: referer,
|
|
308
|
+
Origin: "https://i.mi.com",
|
|
309
|
+
"User-Agent": `Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${CHROME_VERSION}.0.0.0 Safari/537.36`,
|
|
310
|
+
Accept: "application/json, text/plain, */*",
|
|
311
|
+
"Accept-Language": "zh-CN,zh;q=0.9,en;q=0.8",
|
|
312
|
+
"sec-ch-ua": `"Google Chrome";v="${CHROME_VERSION}", "Chromium";v="${CHROME_VERSION}", "Not_A Brand";v="24"`,
|
|
313
|
+
"sec-ch-ua-mobile": "?0",
|
|
314
|
+
"sec-ch-ua-platform": '"macOS"',
|
|
315
|
+
"Sec-Fetch-Dest": "empty",
|
|
316
|
+
"Sec-Fetch-Mode": "cors",
|
|
317
|
+
"Sec-Fetch-Site": "same-origin",
|
|
318
|
+
};
|
|
319
|
+
}
|
|
320
|
+
async function loadCachedCookie() {
|
|
321
|
+
try {
|
|
322
|
+
const content = await readFile(cookieFile(), "utf-8");
|
|
323
|
+
return content.trim() || null;
|
|
324
|
+
}
|
|
325
|
+
catch {
|
|
326
|
+
return null;
|
|
327
|
+
}
|
|
328
|
+
}
|
|
329
|
+
async function saveCookie(cookie) {
|
|
330
|
+
await ensurePrivateDir(getCacheDir());
|
|
331
|
+
await writeFile(cookieFile(), cookie, { encoding: "utf-8", mode: 0o600 });
|
|
332
|
+
// mode 只对新建文件生效,已存在的旧文件需显式收紧
|
|
333
|
+
await chmod(cookieFile(), 0o600);
|
|
334
|
+
}
|
|
335
|
+
async function ensurePrivateDir(dir) {
|
|
336
|
+
await ensureDir(dir);
|
|
337
|
+
await chmod(dir, 0o700);
|
|
338
|
+
}
|
|
@@ -0,0 +1,75 @@
|
|
|
1
|
+
import { readFile } from "node:fs/promises";
|
|
2
|
+
import { isAbsolute, join, resolve } from "node:path";
|
|
3
|
+
import { fileExists, writeFileAtomic } from "./utils.js";
|
|
4
|
+
/**
|
|
5
|
+
* 项目配置:`<项目根>/.micloud/config.json`,按服务分节,各节由对应服务定义和解释:
|
|
6
|
+
*
|
|
7
|
+
* ```json
|
|
8
|
+
* { "note": { "output": "inbox/mi-notes", "syncMode": "two-way" }, "recording": { "output": "recordings" } }
|
|
9
|
+
* ```
|
|
10
|
+
*
|
|
11
|
+
* 项目根默认是当前目录,`MICLOUD_CONFIG_DIR` 可覆盖(测试隔离用)。
|
|
12
|
+
* 旧版的笔记配置 `.mi-note-cli/config.json` 在新配置没有笔记节时继续读取,写入时迁到新位置。
|
|
13
|
+
*/
|
|
14
|
+
export const CONFIG_DIRNAME = ".micloud";
|
|
15
|
+
const CONFIG_FILENAME = "config.json";
|
|
16
|
+
const LEGACY_NOTE_CONFIG = join(".mi-note-cli", "config.json");
|
|
17
|
+
/** 项目根目录(配置与默认输出目录的基准) */
|
|
18
|
+
export function getProjectRoot() {
|
|
19
|
+
return process.env.MICLOUD_CONFIG_DIR || process.cwd();
|
|
20
|
+
}
|
|
21
|
+
/** 项目配置文件绝对路径:`<root>/.micloud/config.json` */
|
|
22
|
+
export function getConfigPath() {
|
|
23
|
+
return join(getProjectRoot(), CONFIG_DIRNAME, CONFIG_FILENAME);
|
|
24
|
+
}
|
|
25
|
+
/** 某个服务的默认输出目录:`<root>/.micloud/<service>/` */
|
|
26
|
+
export function getDefaultOutputDir(service) {
|
|
27
|
+
return join(getProjectRoot(), CONFIG_DIRNAME, service);
|
|
28
|
+
}
|
|
29
|
+
/** 读取完整项目配置;不存在或解析失败时返回空对象 */
|
|
30
|
+
export async function loadProjectConfig() {
|
|
31
|
+
const parsed = await readJson(getConfigPath());
|
|
32
|
+
return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
|
|
33
|
+
}
|
|
34
|
+
/** 读取某个服务的配置节(原样返回,由服务自己校验字段);笔记节缺失时回落到旧版配置 */
|
|
35
|
+
export async function loadSection(service) {
|
|
36
|
+
const section = (await loadProjectConfig())[service];
|
|
37
|
+
if (section && typeof section === "object" && !Array.isArray(section))
|
|
38
|
+
return section;
|
|
39
|
+
if (service === "note") {
|
|
40
|
+
const legacy = await readJson(join(getProjectRoot(), LEGACY_NOTE_CONFIG));
|
|
41
|
+
if (legacy && typeof legacy === "object" && !Array.isArray(legacy))
|
|
42
|
+
return legacy;
|
|
43
|
+
}
|
|
44
|
+
return {};
|
|
45
|
+
}
|
|
46
|
+
/** 写回某个服务的配置节(其他服务的配置原样保留) */
|
|
47
|
+
export async function saveSection(service, section) {
|
|
48
|
+
const config = await loadProjectConfig();
|
|
49
|
+
config[service] = section;
|
|
50
|
+
await writeFileAtomic(getConfigPath(), JSON.stringify(config, null, 2) + "\n");
|
|
51
|
+
}
|
|
52
|
+
/**
|
|
53
|
+
* 解析生效的输出目录(绝对路径)。
|
|
54
|
+
* 优先级:命令行 `-o`(相对当前目录)> 配置 output(相对项目根)> `<root>/.micloud/<service>/`
|
|
55
|
+
*
|
|
56
|
+
* 两种相对基准刻意不同:命令行参数遵循终端当前位置的直觉,配置字段遵循「相对配置文件」的直觉。
|
|
57
|
+
*/
|
|
58
|
+
export function resolveOutputPath(service, cliOutput, configured) {
|
|
59
|
+
if (cliOutput)
|
|
60
|
+
return resolve(cliOutput);
|
|
61
|
+
if (typeof configured === "string" && configured.trim()) {
|
|
62
|
+
return isAbsolute(configured) ? configured : resolve(getProjectRoot(), configured);
|
|
63
|
+
}
|
|
64
|
+
return getDefaultOutputDir(service);
|
|
65
|
+
}
|
|
66
|
+
async function readJson(file) {
|
|
67
|
+
if (!(await fileExists(file)))
|
|
68
|
+
return undefined;
|
|
69
|
+
try {
|
|
70
|
+
return JSON.parse(await readFile(file, "utf-8"));
|
|
71
|
+
}
|
|
72
|
+
catch {
|
|
73
|
+
return undefined;
|
|
74
|
+
}
|
|
75
|
+
}
|
|
@@ -0,0 +1,172 @@
|
|
|
1
|
+
import { buildHeaders } from "./auth.js";
|
|
2
|
+
import { delay } from "./utils.js";
|
|
3
|
+
export const API_BASE = "https://i.mi.com";
|
|
4
|
+
const REQUEST_TIMEOUT = 30_000;
|
|
5
|
+
/** 只读 GET 遇网络错误 / 5xx / 非 JSON 响应时的重试次数 */
|
|
6
|
+
const GET_RETRIES = 2;
|
|
7
|
+
/** 小米云服务返回的业务错误或 HTTP 错误 */
|
|
8
|
+
export class MiApiError extends Error {
|
|
9
|
+
code;
|
|
10
|
+
retriable;
|
|
11
|
+
constructor(message, code, retriable = false) {
|
|
12
|
+
super(message);
|
|
13
|
+
this.code = code;
|
|
14
|
+
this.retriable = retriable;
|
|
15
|
+
this.name = "MiApiError";
|
|
16
|
+
}
|
|
17
|
+
}
|
|
18
|
+
/** 登录态失效且无法静默续期:后续请求都会失败,批量操作应立即停止 */
|
|
19
|
+
export class AuthExpiredError extends Error {
|
|
20
|
+
constructor() {
|
|
21
|
+
super("登录态已过期,请重新登录(micloud login)");
|
|
22
|
+
this.name = "AuthExpiredError";
|
|
23
|
+
}
|
|
24
|
+
}
|
|
25
|
+
/** 批量操作遇到这类错误时应立即停止:登录态失效后续请求都会失败 */
|
|
26
|
+
export function isFatalError(err) {
|
|
27
|
+
return err instanceof AuthExpiredError;
|
|
28
|
+
}
|
|
29
|
+
/**
|
|
30
|
+
* i.mi.com 带登录态的请求层(各服务的客户端共用):
|
|
31
|
+
* - 请求带 cookie 与浏览器请求头,30 秒超时;
|
|
32
|
+
* - 遇 401 时用 refresher 静默续期并重试一次,仍失败抛 AuthExpiredError;
|
|
33
|
+
* - GET 只读,遇网络错误、超时、5xx、非 JSON 响应自动重试;POST 是写操作,不重试;
|
|
34
|
+
* - POST 为 application/x-www-form-urlencoded,body 自动带上当前的 serviceToken(续期后随之更新)。
|
|
35
|
+
*/
|
|
36
|
+
export class MiCloudHttp {
|
|
37
|
+
auth;
|
|
38
|
+
refresher;
|
|
39
|
+
referer;
|
|
40
|
+
constructor(auth, refresher, referer = `${API_BASE}/`) {
|
|
41
|
+
this.auth = auth;
|
|
42
|
+
this.refresher = refresher;
|
|
43
|
+
this.referer = referer;
|
|
44
|
+
}
|
|
45
|
+
get userId() {
|
|
46
|
+
return this.auth.userId;
|
|
47
|
+
}
|
|
48
|
+
/**
|
|
49
|
+
* GET 并解析 JSON;query 自动带 ts 防缓存。
|
|
50
|
+
* parse 在重试范围内执行:抛出 retriable 的 MiApiError(如信封里 retriable: true)时同样会重试。
|
|
51
|
+
*/
|
|
52
|
+
async getJson(path, query = {}, parse = (json) => json) {
|
|
53
|
+
const params = new URLSearchParams();
|
|
54
|
+
for (const [key, value] of Object.entries(query))
|
|
55
|
+
params.set(key, String(value));
|
|
56
|
+
for (let attempt = 0;; attempt++) {
|
|
57
|
+
params.set("ts", String(Date.now()));
|
|
58
|
+
const url = `${API_BASE}${path}?${params}`;
|
|
59
|
+
try {
|
|
60
|
+
const resp = await this.send(() => fetch(url, { headers: this.headers(), signal: AbortSignal.timeout(REQUEST_TIMEOUT) }));
|
|
61
|
+
if (!resp.ok) {
|
|
62
|
+
await discardBody(resp);
|
|
63
|
+
throw new MiApiError(`请求失败 ${resp.status} ${resp.statusText}`, undefined, resp.status >= 500);
|
|
64
|
+
}
|
|
65
|
+
return parse(await parseJsonResponse(resp));
|
|
66
|
+
}
|
|
67
|
+
catch (err) {
|
|
68
|
+
if (attempt >= GET_RETRIES || !isRetriable(err))
|
|
69
|
+
throw err;
|
|
70
|
+
await delay(500 * 3 ** attempt);
|
|
71
|
+
}
|
|
72
|
+
}
|
|
73
|
+
}
|
|
74
|
+
/** 表单 POST 并解析 JSON;body 自动带上 serviceToken */
|
|
75
|
+
async postForm(path, params = {}) {
|
|
76
|
+
const resp = await this.send(() => {
|
|
77
|
+
// serviceToken 随 cookie 续期一起更新,故每次发送时重新取值构造 body
|
|
78
|
+
const body = Object.entries({ ...params, serviceToken: this.auth.serviceToken })
|
|
79
|
+
.map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
|
|
80
|
+
.join("&");
|
|
81
|
+
return fetch(`${API_BASE}${path}`, {
|
|
82
|
+
method: "POST",
|
|
83
|
+
headers: { ...this.headers(), "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8" },
|
|
84
|
+
body,
|
|
85
|
+
signal: AbortSignal.timeout(REQUEST_TIMEOUT),
|
|
86
|
+
});
|
|
87
|
+
});
|
|
88
|
+
if (!resp.ok) {
|
|
89
|
+
const text = await resp.text().catch(() => "");
|
|
90
|
+
throw new MiApiError(`请求失败 ${resp.status}: ${text.slice(0, 200)}`);
|
|
91
|
+
}
|
|
92
|
+
return (await parseJsonResponse(resp));
|
|
93
|
+
}
|
|
94
|
+
/** 带登录态请求任意地址(如附件下载),返回原始响应;不设超时、不重试 */
|
|
95
|
+
async fetchRaw(url, init = {}) {
|
|
96
|
+
return await this.send(() => fetch(url, { ...init, headers: { ...this.headers(), ...init.headers } }));
|
|
97
|
+
}
|
|
98
|
+
headers() {
|
|
99
|
+
return buildHeaders(this.auth.cookie, this.referer);
|
|
100
|
+
}
|
|
101
|
+
/** 发送一次请求;遇 401 且有 refresher 时静默续期并用新登录态重试一次 */
|
|
102
|
+
async send(request) {
|
|
103
|
+
let resp = await request();
|
|
104
|
+
if (resp.status === 401 && this.refresher) {
|
|
105
|
+
await discardBody(resp);
|
|
106
|
+
const fresh = await this.refresher();
|
|
107
|
+
if (fresh) {
|
|
108
|
+
this.auth = fresh;
|
|
109
|
+
resp = await request();
|
|
110
|
+
}
|
|
111
|
+
}
|
|
112
|
+
if (resp.status === 401) {
|
|
113
|
+
await discardBody(resp);
|
|
114
|
+
throw new AuthExpiredError();
|
|
115
|
+
}
|
|
116
|
+
return resp;
|
|
117
|
+
}
|
|
118
|
+
}
|
|
119
|
+
/**
|
|
120
|
+
* 拆开 `{ code, data }` 信封:code 为 0 返回 data,否则抛 MiApiError(与网页端请求层一致)。
|
|
121
|
+
* @param knownErrors 服务特有错误码的可读说明
|
|
122
|
+
*/
|
|
123
|
+
export function unwrapEnvelope(json, knownErrors = {}) {
|
|
124
|
+
if (!json || typeof json !== "object") {
|
|
125
|
+
throw new MiApiError(`服务端返回了无法识别的响应:${String(json).slice(0, 120)}`);
|
|
126
|
+
}
|
|
127
|
+
const env = json;
|
|
128
|
+
if (typeof env.code === "number") {
|
|
129
|
+
if (env.code === 0)
|
|
130
|
+
return (env.data ?? {});
|
|
131
|
+
if (env.code === 308) {
|
|
132
|
+
const target = env.data?.redirectUrl ?? "其他区域";
|
|
133
|
+
throw new MiApiError(`该账号的数据位于其他区域的小米云服务(${target}),本工具目前只支持 i.mi.com`, 308);
|
|
134
|
+
}
|
|
135
|
+
const known = knownErrors[env.code];
|
|
136
|
+
const detail = env.description || env.reason || env.result || "未知错误";
|
|
137
|
+
throw new MiApiError(known ?? `小米云服务返回错误 ${env.code}:${detail}`, env.code, env.retriable === true);
|
|
138
|
+
}
|
|
139
|
+
if (env.result === "ok")
|
|
140
|
+
return (env.data ?? {});
|
|
141
|
+
return json;
|
|
142
|
+
}
|
|
143
|
+
function isRetriable(err) {
|
|
144
|
+
if (err instanceof MiApiError)
|
|
145
|
+
return err.retriable;
|
|
146
|
+
if (!(err instanceof Error))
|
|
147
|
+
return false;
|
|
148
|
+
// fetch 网络层失败(TypeError: fetch failed)与超时
|
|
149
|
+
return err.name === "TypeError" || err.name === "TimeoutError" || err.name === "AbortError";
|
|
150
|
+
}
|
|
151
|
+
/**
|
|
152
|
+
* 解析响应体为 JSON。服务端降级 / 网关错误时可能返回 HTML 而非 JSON,
|
|
153
|
+
* 此时 resp.json() 会抛出晦涩的 SyntaxError,这里转成可读错误。
|
|
154
|
+
*/
|
|
155
|
+
async function parseJsonResponse(resp) {
|
|
156
|
+
const text = await resp.text();
|
|
157
|
+
try {
|
|
158
|
+
return JSON.parse(text);
|
|
159
|
+
}
|
|
160
|
+
catch {
|
|
161
|
+
const preview = text.slice(0, 120).replace(/\s+/g, " ").trim();
|
|
162
|
+
throw new MiApiError(`服务端返回了非 JSON 响应(可能是登录态失效或服务异常):${preview}`, undefined, true);
|
|
163
|
+
}
|
|
164
|
+
}
|
|
165
|
+
async function discardBody(resp) {
|
|
166
|
+
try {
|
|
167
|
+
await resp.body?.cancel();
|
|
168
|
+
}
|
|
169
|
+
catch {
|
|
170
|
+
// ignore cleanup errors
|
|
171
|
+
}
|
|
172
|
+
}
|
|
@@ -0,0 +1,90 @@
|
|
|
1
|
+
import { rmSync } from "node:fs";
|
|
2
|
+
import { open, readFile, rm, stat } from "node:fs/promises";
|
|
3
|
+
import { join } from "node:path";
|
|
4
|
+
import { hostname } from "node:os";
|
|
5
|
+
import { ensureDir } from "./utils.js";
|
|
6
|
+
const LOCK_FILENAME = ".micloud.lock";
|
|
7
|
+
/** 读不出内容的锁文件超过这个时间仍没写完,视为持锁进程已异常退出 */
|
|
8
|
+
const ABANDONED_AFTER = 60_000;
|
|
9
|
+
/**
|
|
10
|
+
* 独占输出目录:同一目录同时只允许一个会写入它的命令运行,
|
|
11
|
+
* 避免两个进程各自持有旧状态、互相覆盖,或并发写同一个文件。
|
|
12
|
+
* 持锁进程已退出(同一台机器上 pid 不存在)时自动接管残留的锁。返回释放函数。
|
|
13
|
+
*/
|
|
14
|
+
export async function lockDir(dir) {
|
|
15
|
+
await ensureDir(dir);
|
|
16
|
+
const file = join(dir, LOCK_FILENAME);
|
|
17
|
+
for (let attempt = 0; attempt < 2; attempt++) {
|
|
18
|
+
let handle;
|
|
19
|
+
try {
|
|
20
|
+
handle = await open(file, "wx");
|
|
21
|
+
}
|
|
22
|
+
catch (err) {
|
|
23
|
+
if (err.code !== "EEXIST")
|
|
24
|
+
throw err;
|
|
25
|
+
const holder = await readLock(file);
|
|
26
|
+
if (holder ? isStale(holder) : await isAbandoned(file)) {
|
|
27
|
+
await rm(file, { force: true });
|
|
28
|
+
continue;
|
|
29
|
+
}
|
|
30
|
+
const who = holder ? `(pid ${holder.pid}${holder.host && holder.host !== hostname() ? `@${holder.host}` : ""})` : "";
|
|
31
|
+
throw new Error(`目录正被另一个 micloud 进程使用${who}:${dir}。请等它结束;确认没有在运行时可删除 ${file}`);
|
|
32
|
+
}
|
|
33
|
+
// 一创建就登记退出清理,之后任何一步失败(含被 Ctrl+C 结束)都不会留下锁
|
|
34
|
+
let released = false;
|
|
35
|
+
const onExit = () => {
|
|
36
|
+
if (released)
|
|
37
|
+
return;
|
|
38
|
+
try {
|
|
39
|
+
rmSync(file, { force: true });
|
|
40
|
+
}
|
|
41
|
+
catch {
|
|
42
|
+
// ignore
|
|
43
|
+
}
|
|
44
|
+
};
|
|
45
|
+
process.once("exit", onExit);
|
|
46
|
+
const release = async () => {
|
|
47
|
+
if (released)
|
|
48
|
+
return;
|
|
49
|
+
released = true;
|
|
50
|
+
process.off("exit", onExit);
|
|
51
|
+
await rm(file, { force: true });
|
|
52
|
+
};
|
|
53
|
+
try {
|
|
54
|
+
await handle.writeFile(JSON.stringify({ pid: process.pid, host: hostname(), startedAt: Date.now() }));
|
|
55
|
+
await handle.close();
|
|
56
|
+
}
|
|
57
|
+
catch (err) {
|
|
58
|
+
await handle.close().catch(() => undefined);
|
|
59
|
+
await release();
|
|
60
|
+
throw err;
|
|
61
|
+
}
|
|
62
|
+
return release;
|
|
63
|
+
}
|
|
64
|
+
throw new Error(`无法锁定目录:${dir}`);
|
|
65
|
+
}
|
|
66
|
+
async function readLock(file) {
|
|
67
|
+
try {
|
|
68
|
+
const parsed = JSON.parse(await readFile(file, "utf-8"));
|
|
69
|
+
return typeof parsed.pid === "number" ? parsed : null;
|
|
70
|
+
}
|
|
71
|
+
catch {
|
|
72
|
+
return null;
|
|
73
|
+
}
|
|
74
|
+
}
|
|
75
|
+
/** 同一台机器上持锁进程已不存在 */
|
|
76
|
+
function isStale(lock) {
|
|
77
|
+
if (lock.host && lock.host !== hostname())
|
|
78
|
+
return false;
|
|
79
|
+
try {
|
|
80
|
+
process.kill(lock.pid, 0);
|
|
81
|
+
return false;
|
|
82
|
+
}
|
|
83
|
+
catch (err) {
|
|
84
|
+
return err.code === "ESRCH";
|
|
85
|
+
}
|
|
86
|
+
}
|
|
87
|
+
async function isAbandoned(file) {
|
|
88
|
+
const st = await stat(file).catch(() => null);
|
|
89
|
+
return !st || Date.now() - st.mtimeMs > ABANDONED_AFTER;
|
|
90
|
+
}
|