@amerged/ohmyhost-cli 0.1.75 → 0.1.76
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/README.md +1 -1
- package/dist/bin.js +1 -1
- package/dist/{chunk-2APPOPVY.js → chunk-N6LDQC3B.js} +1184 -493
- package/dist/index.js +26 -140
- package/package.json +1 -1
- package/src/apps/product-cli/package.json +1 -1
- package/src/apps/product-cli/src/cli.ts +180 -60
- package/src/apps/product-cli/src/composition.ts +132 -48
- package/src/apps/product-cli/src/credential-refresh.ts +65 -0
- package/src/apps/product-cli/src/file-credential-store.ts +131 -57
- package/src/apps/product-cli/src/index.ts +2 -0
- package/src/apps/product-cli/src/login-ownership.ts +291 -0
- package/src/apps/product-cli/src/profile-store.ts +303 -39
- package/src/apps/product-cli/src/runtime-contract.ts +12 -1
- package/src/apps/product-cli/src/workspace.ts +41 -27
- package/src/packages/contracts/src/problem-policy.ts +6 -6
- package/src/packages/sdk-ts/package.json +1 -1
- package/src/packages/sdk-ts/src/generated/mcp-remote.gen.ts +1 -1
|
@@ -1,6 +1,8 @@
|
|
|
1
|
-
import {
|
|
2
|
-
import {
|
|
1
|
+
import { randomUUID } from "node:crypto";
|
|
2
|
+
import { chmod, constants, lstat, mkdir, open, readdir, rename, unlink } from "node:fs/promises";
|
|
3
|
+
import { dirname, join, relative, sep } from "node:path";
|
|
3
4
|
|
|
5
|
+
import { quietly } from "./login-ownership.js";
|
|
4
6
|
import {
|
|
5
7
|
CredentialStoreUnavailableError,
|
|
6
8
|
parseCredential,
|
|
@@ -12,44 +14,94 @@ import {
|
|
|
12
14
|
|
|
13
15
|
const DIRECTORY_MODE = 0o700;
|
|
14
16
|
const FILE_MODE = 0o600;
|
|
17
|
+
/** The credential file and every temporary file a writer may have left. */
|
|
18
|
+
const ARTIFACT = /^(?:credentials\.json|\.credentials(?:\..+)?\.next)$/u;
|
|
19
|
+
|
|
20
|
+
/** Why a file store is refused; the reasons are fixed so that no text depends on an error message. */
|
|
21
|
+
export type FileStoreRefusalReason =
|
|
22
|
+
| "symbolic_link"
|
|
23
|
+
| "another_owner"
|
|
24
|
+
| "wrong_mode"
|
|
25
|
+
| "not_writable";
|
|
26
|
+
|
|
27
|
+
/** A directory or file of the store is not the one this store may use; nothing was changed. */
|
|
28
|
+
export class FileCredentialStoreRefusedError extends CredentialStoreUnavailableError {
|
|
29
|
+
public constructor(
|
|
30
|
+
/** The refused path, relative to the home directory. */
|
|
31
|
+
readonly path: string,
|
|
32
|
+
readonly reason: FileStoreRefusalReason,
|
|
33
|
+
) {
|
|
34
|
+
super();
|
|
35
|
+
this.name = "FileCredentialStoreRefusedError";
|
|
36
|
+
}
|
|
37
|
+
}
|
|
38
|
+
|
|
39
|
+
/** Where a store lives: which directories it owns and which it only requires to be safe. */
|
|
40
|
+
export interface FileCredentialStoreLocation {
|
|
41
|
+
/** Directories above the store: the user's own, no symbolic link, not writable by others. */
|
|
42
|
+
readonly ancestors?: readonly string[];
|
|
43
|
+
/** The first directory the store owns; it and every directory below it have exactly mode 700. */
|
|
44
|
+
readonly root?: string;
|
|
45
|
+
/** Refusals name their path relative to this directory. */
|
|
46
|
+
readonly home?: string;
|
|
47
|
+
}
|
|
15
48
|
|
|
16
49
|
export class OwnerOnlyFileCredentialStore implements CredentialStore {
|
|
17
50
|
readonly #credentialPath: string;
|
|
18
|
-
readonly #
|
|
51
|
+
readonly #ancestors: readonly string[];
|
|
52
|
+
readonly #owned: readonly string[];
|
|
53
|
+
readonly #home: string | undefined;
|
|
19
54
|
|
|
20
55
|
public constructor(
|
|
21
56
|
private readonly directory: string,
|
|
22
57
|
private readonly ownerId: number,
|
|
58
|
+
location: FileCredentialStoreLocation = {},
|
|
23
59
|
) {
|
|
24
60
|
this.#credentialPath = join(directory, "credentials.json");
|
|
25
|
-
this.#
|
|
61
|
+
this.#ancestors = location.ancestors ?? [];
|
|
62
|
+
this.#home = location.home;
|
|
63
|
+
const root = location.root ?? directory;
|
|
64
|
+
const below = relative(root, directory).split(sep).filter(Boolean);
|
|
65
|
+
this.#owned = below.reduce<string[]>(
|
|
66
|
+
(paths, segment) => [...paths, join(paths.at(-1) ?? root, segment)],
|
|
67
|
+
[root],
|
|
68
|
+
);
|
|
69
|
+
}
|
|
70
|
+
|
|
71
|
+
/** Creates the store's directories with their exact modes; refuses any that already differ. */
|
|
72
|
+
public async prepare(): Promise<void> {
|
|
73
|
+
try {
|
|
74
|
+
await this.checkDirectories(true);
|
|
75
|
+
} catch (error) {
|
|
76
|
+
throw this.refused(error);
|
|
77
|
+
}
|
|
26
78
|
}
|
|
27
79
|
|
|
28
80
|
public async read(): Promise<StoredCredential | undefined> {
|
|
29
81
|
try {
|
|
30
|
-
await this.
|
|
31
|
-
await this.recoverTemporary();
|
|
82
|
+
if (!(await this.checkDirectories(false))) return undefined;
|
|
32
83
|
if (!(await this.validateFile())) return undefined;
|
|
33
84
|
const handle = await open(this.#credentialPath, constants.O_RDONLY | constants.O_NOFOLLOW);
|
|
34
85
|
try {
|
|
35
86
|
const status = await handle.stat();
|
|
36
|
-
this.assertOwnedStatus(status, FILE_MODE, false);
|
|
87
|
+
this.assertOwnedStatus(this.#credentialPath, status, FILE_MODE, false);
|
|
37
88
|
return parseCredential(await handle.readFile("utf8"));
|
|
38
89
|
} finally {
|
|
39
90
|
await handle.close();
|
|
40
91
|
}
|
|
41
|
-
} catch {
|
|
42
|
-
throw
|
|
92
|
+
} catch (error) {
|
|
93
|
+
throw this.refused(error);
|
|
43
94
|
}
|
|
44
95
|
}
|
|
45
96
|
|
|
46
97
|
public async replace(credential: CurrentCredential): Promise<void> {
|
|
98
|
+
// Each writer has a temporary name of its own, so two writers never share or delete one.
|
|
99
|
+
const temporaryPath = join(this.directory, `.credentials.${randomUUID()}.next`);
|
|
47
100
|
try {
|
|
48
|
-
await this.
|
|
49
|
-
await this.recoverTemporary();
|
|
101
|
+
await this.checkDirectories(true);
|
|
50
102
|
await this.validateFile();
|
|
51
103
|
const handle = await open(
|
|
52
|
-
|
|
104
|
+
temporaryPath,
|
|
53
105
|
constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW,
|
|
54
106
|
FILE_MODE,
|
|
55
107
|
);
|
|
@@ -59,23 +111,24 @@ export class OwnerOnlyFileCredentialStore implements CredentialStore {
|
|
|
59
111
|
} finally {
|
|
60
112
|
await handle.close();
|
|
61
113
|
}
|
|
62
|
-
await this.validateOwnedPath(
|
|
63
|
-
await rename(
|
|
114
|
+
await this.validateOwnedPath(temporaryPath, FILE_MODE, false);
|
|
115
|
+
await rename(temporaryPath, this.#credentialPath);
|
|
64
116
|
await this.syncDirectory();
|
|
65
117
|
await this.validateOwnedPath(this.#credentialPath, FILE_MODE, false);
|
|
66
|
-
} catch {
|
|
67
|
-
await unlink(
|
|
68
|
-
throw
|
|
118
|
+
} catch (error) {
|
|
119
|
+
await quietly(unlink(temporaryPath));
|
|
120
|
+
throw this.refused(error);
|
|
69
121
|
}
|
|
70
122
|
}
|
|
71
123
|
|
|
72
124
|
public async clear(): Promise<void> {
|
|
73
125
|
try {
|
|
74
|
-
await this.
|
|
126
|
+
if (!(await this.checkDirectories(false))) return;
|
|
75
127
|
let failed = false;
|
|
76
|
-
for (const
|
|
128
|
+
for (const name of await readdir(this.directory)) {
|
|
129
|
+
if (!ARTIFACT.test(name)) continue;
|
|
77
130
|
try {
|
|
78
|
-
await unlink(
|
|
131
|
+
await unlink(join(this.directory, name));
|
|
79
132
|
} catch (error) {
|
|
80
133
|
if (!isMissing(error)) failed = true;
|
|
81
134
|
}
|
|
@@ -85,39 +138,47 @@ export class OwnerOnlyFileCredentialStore implements CredentialStore {
|
|
|
85
138
|
} catch {
|
|
86
139
|
failed = true;
|
|
87
140
|
}
|
|
88
|
-
|
|
89
|
-
try {
|
|
90
|
-
await lstat(path);
|
|
91
|
-
failed = true;
|
|
92
|
-
} catch (error) {
|
|
93
|
-
if (!isMissing(error)) failed = true;
|
|
94
|
-
}
|
|
95
|
-
}
|
|
141
|
+
if ((await readdir(this.directory)).some((name) => ARTIFACT.test(name))) failed = true;
|
|
96
142
|
if (failed) throw new Error("Credential artifact cleanup failed");
|
|
97
|
-
} catch {
|
|
98
|
-
throw
|
|
143
|
+
} catch (error) {
|
|
144
|
+
throw this.refused(error);
|
|
99
145
|
}
|
|
100
146
|
}
|
|
101
147
|
|
|
102
|
-
|
|
103
|
-
|
|
104
|
-
|
|
148
|
+
/** `false` when a directory is missing and none may be created. */
|
|
149
|
+
private async checkDirectories(create: boolean): Promise<boolean> {
|
|
150
|
+
for (const path of this.#ancestors) {
|
|
151
|
+
const status = await this.statDirectory(path, create);
|
|
152
|
+
if (status === undefined) return false;
|
|
153
|
+
if (status.isSymbolicLink()) throw this.refusal(path, "symbolic_link");
|
|
154
|
+
if (!status.isDirectory()) throw this.refusal(path, "wrong_mode");
|
|
155
|
+
if (status.uid !== this.ownerId) throw this.refusal(path, "another_owner");
|
|
156
|
+
if ((status.mode & 0o022) !== 0) throw this.refusal(path, "wrong_mode");
|
|
157
|
+
}
|
|
158
|
+
for (const path of this.#owned) {
|
|
159
|
+
const status = await this.statDirectory(path, create, true);
|
|
160
|
+
if (status === undefined) return false;
|
|
161
|
+
this.assertOwnedStatus(path, status, DIRECTORY_MODE, true);
|
|
162
|
+
}
|
|
163
|
+
return true;
|
|
105
164
|
}
|
|
106
165
|
|
|
107
|
-
private async
|
|
166
|
+
private async statDirectory(path: string, create: boolean, exact = false) {
|
|
108
167
|
try {
|
|
109
|
-
|
|
110
|
-
const invalid =
|
|
111
|
-
status.isSymbolicLink() ||
|
|
112
|
-
!status.isFile() ||
|
|
113
|
-
status.uid !== this.ownerId ||
|
|
114
|
-
(status.mode & 0o777) !== FILE_MODE;
|
|
115
|
-
await unlink(this.#temporaryPath);
|
|
116
|
-
await this.syncDirectory();
|
|
117
|
-
if (invalid) throw new Error("Temporary credential artifact was invalid");
|
|
168
|
+
return await lstat(path);
|
|
118
169
|
} catch (error) {
|
|
119
170
|
if (!isMissing(error)) throw error;
|
|
171
|
+
if (!create) return undefined;
|
|
120
172
|
}
|
|
173
|
+
try {
|
|
174
|
+
await mkdir(path, { mode: DIRECTORY_MODE });
|
|
175
|
+
// The process umask cannot widen a mode, but it can narrow one; the store's own directories
|
|
176
|
+
// have exactly 700.
|
|
177
|
+
if (exact) await chmod(path, DIRECTORY_MODE);
|
|
178
|
+
} catch (error) {
|
|
179
|
+
if (errorCode(error) !== "EEXIST") throw error;
|
|
180
|
+
}
|
|
181
|
+
return await lstat(path);
|
|
121
182
|
}
|
|
122
183
|
|
|
123
184
|
private async validateFile(): Promise<boolean> {
|
|
@@ -131,25 +192,36 @@ export class OwnerOnlyFileCredentialStore implements CredentialStore {
|
|
|
131
192
|
}
|
|
132
193
|
|
|
133
194
|
private async validateOwnedPath(path: string, mode: number, directory: boolean): Promise<void> {
|
|
134
|
-
|
|
135
|
-
if (status.isSymbolicLink()) {
|
|
136
|
-
throw new Error("Credential path ownership or mode is invalid");
|
|
137
|
-
}
|
|
138
|
-
this.assertOwnedStatus(status, mode, directory);
|
|
195
|
+
this.assertOwnedStatus(path, await lstat(path), mode, directory);
|
|
139
196
|
}
|
|
140
197
|
|
|
141
198
|
private assertOwnedStatus(
|
|
199
|
+
path: string,
|
|
142
200
|
status: Awaited<ReturnType<typeof lstat>>,
|
|
143
201
|
mode: number,
|
|
144
202
|
directory: boolean,
|
|
145
203
|
): void {
|
|
146
|
-
if (
|
|
147
|
-
|
|
148
|
-
|
|
149
|
-
|
|
150
|
-
)
|
|
151
|
-
|
|
152
|
-
|
|
204
|
+
if (status.isSymbolicLink()) throw this.refusal(path, "symbolic_link");
|
|
205
|
+
if (directory ? !status.isDirectory() : !status.isFile())
|
|
206
|
+
throw this.refusal(path, "wrong_mode");
|
|
207
|
+
if (status.uid !== this.ownerId) throw this.refusal(path, "another_owner");
|
|
208
|
+
if ((Number(status.mode) & 0o777) !== mode) throw this.refusal(path, "wrong_mode");
|
|
209
|
+
}
|
|
210
|
+
|
|
211
|
+
private refusal(path: string, reason: FileStoreRefusalReason): FileCredentialStoreRefusedError {
|
|
212
|
+
return new FileCredentialStoreRefusedError(
|
|
213
|
+
this.#home === undefined ? path : relative(this.#home, path),
|
|
214
|
+
reason,
|
|
215
|
+
);
|
|
216
|
+
}
|
|
217
|
+
|
|
218
|
+
/** A refusal keeps its path and reason; a denied write names the directory it could not use. */
|
|
219
|
+
private refused(error: unknown): CredentialStoreUnavailableError {
|
|
220
|
+
if (error instanceof CredentialStoreUnavailableError) return error;
|
|
221
|
+
const code = errorCode(error);
|
|
222
|
+
if (code === "EACCES" || code === "EPERM" || code === "EROFS")
|
|
223
|
+
return this.refusal(this.directory, "not_writable");
|
|
224
|
+
return new CredentialStoreUnavailableError();
|
|
153
225
|
}
|
|
154
226
|
|
|
155
227
|
private async syncDirectory(): Promise<void> {
|
|
@@ -162,5 +234,7 @@ export class OwnerOnlyFileCredentialStore implements CredentialStore {
|
|
|
162
234
|
}
|
|
163
235
|
}
|
|
164
236
|
|
|
165
|
-
const
|
|
166
|
-
typeof error === "object" && error !== null && "code" in error
|
|
237
|
+
const errorCode = (error: unknown): string | undefined =>
|
|
238
|
+
typeof error === "object" && error !== null && "code" in error ? String(error.code) : undefined;
|
|
239
|
+
|
|
240
|
+
const isMissing = (error: unknown): boolean => errorCode(error) === "ENOENT";
|
|
@@ -3,6 +3,8 @@ export * from "./command.js";
|
|
|
3
3
|
export * from "./composition.js";
|
|
4
4
|
export * from "./credential-store.js";
|
|
5
5
|
export * from "./file-credential-store.js";
|
|
6
|
+
export * from "./login-ownership.js";
|
|
7
|
+
export * from "./credential-refresh.js";
|
|
6
8
|
export * from "./product-api.js";
|
|
7
9
|
export * from "./profile-store.js";
|
|
8
10
|
export * from "./project-link-store.js";
|
|
@@ -0,0 +1,291 @@
|
|
|
1
|
+
import { randomUUID } from "node:crypto";
|
|
2
|
+
import { link, open, readFile, readdir, readlink, unlink } from "node:fs/promises";
|
|
3
|
+
import { hostname } from "node:os";
|
|
4
|
+
import { join } from "node:path";
|
|
5
|
+
import { setTimeout as sleep } from "node:timers/promises";
|
|
6
|
+
|
|
7
|
+
/** Who holds a login: enough to prove that the holder is gone, never enough to resume it. */
|
|
8
|
+
export interface OwnerIdentity {
|
|
9
|
+
readonly host: string;
|
|
10
|
+
/** The PID namespace; absent where this platform cannot name it. */
|
|
11
|
+
readonly namespace: string | undefined;
|
|
12
|
+
readonly pid: number;
|
|
13
|
+
/** When the process started, in the platform's own unit; absent when it cannot be read. */
|
|
14
|
+
readonly start: string | undefined;
|
|
15
|
+
}
|
|
16
|
+
|
|
17
|
+
export type OwnerState = "alive" | "gone" | "unknown";
|
|
18
|
+
|
|
19
|
+
export interface ProcessProbe {
|
|
20
|
+
self(): Promise<OwnerIdentity>;
|
|
21
|
+
/** `gone` only when the owner provably cannot resume: same host, same PID namespace, no process. */
|
|
22
|
+
state(owner: OwnerIdentity): Promise<OwnerState>;
|
|
23
|
+
}
|
|
24
|
+
|
|
25
|
+
/** The login is held by a process that is still running, or whose fate cannot be read. */
|
|
26
|
+
export class LoginOwnershipTimeoutError extends Error {
|
|
27
|
+
public constructor(
|
|
28
|
+
/** The record that holds the login, relative to the login's directory. */
|
|
29
|
+
readonly record: string,
|
|
30
|
+
) {
|
|
31
|
+
super("The login is held by another process");
|
|
32
|
+
this.name = "LoginOwnershipTimeoutError";
|
|
33
|
+
}
|
|
34
|
+
}
|
|
35
|
+
|
|
36
|
+
/** Runs a cleanup step whose failure changes nothing: a leftover file is ignored by every reader. */
|
|
37
|
+
export const quietly = async (operation: Promise<unknown>): Promise<void> => {
|
|
38
|
+
try {
|
|
39
|
+
await operation;
|
|
40
|
+
} catch {
|
|
41
|
+
// Cleanup only.
|
|
42
|
+
}
|
|
43
|
+
};
|
|
44
|
+
|
|
45
|
+
/** The value of a read that may legitimately fail, or `undefined`. */
|
|
46
|
+
const attempt = async <Value>(operation: Promise<Value>): Promise<Value | undefined> => {
|
|
47
|
+
try {
|
|
48
|
+
return await operation;
|
|
49
|
+
} catch {
|
|
50
|
+
return undefined;
|
|
51
|
+
}
|
|
52
|
+
};
|
|
53
|
+
|
|
54
|
+
const RECORD = /^owner-([1-9][0-9]{0,14})\.json$/u;
|
|
55
|
+
const RELEASED = /^owner-([1-9][0-9]{0,14})\.released$/u;
|
|
56
|
+
const DEFAULT_POLL_MS = 100;
|
|
57
|
+
|
|
58
|
+
const recordName = (number: number): string => `owner-${String(number)}.json`;
|
|
59
|
+
const releasedName = (number: number): string => `owner-${String(number)}.released`;
|
|
60
|
+
|
|
61
|
+
/** The start time of a process in clock ticks since boot, or `undefined` when it does not exist. */
|
|
62
|
+
const linuxStartTime = async (pid: number): Promise<string | undefined> => {
|
|
63
|
+
let stat: string;
|
|
64
|
+
try {
|
|
65
|
+
stat = await readFile(`/proc/${String(pid)}/stat`, "utf8");
|
|
66
|
+
} catch (error) {
|
|
67
|
+
if (errorCode(error) === "ENOENT" || errorCode(error) === "ESRCH") return undefined;
|
|
68
|
+
throw error;
|
|
69
|
+
}
|
|
70
|
+
// The command name is in parentheses and may hold spaces; the start time is field 22.
|
|
71
|
+
const fields = stat.slice(stat.lastIndexOf(")") + 2).split(" ");
|
|
72
|
+
const start = fields[19];
|
|
73
|
+
if (start === undefined || !/^[0-9]+$/u.test(start)) throw new Error("Unreadable process stat");
|
|
74
|
+
return start;
|
|
75
|
+
};
|
|
76
|
+
|
|
77
|
+
/** Reads the host, PID namespace and start time that Linux exposes; other platforms never say `gone`. */
|
|
78
|
+
export const linuxProcessProbe = (): ProcessProbe => {
|
|
79
|
+
const self = async (): Promise<OwnerIdentity> => {
|
|
80
|
+
const namespace = await attempt(readlink("/proc/self/ns/pid"));
|
|
81
|
+
const start = await attempt(linuxStartTime(process.pid));
|
|
82
|
+
return { host: hostname(), namespace, pid: process.pid, start };
|
|
83
|
+
};
|
|
84
|
+
return {
|
|
85
|
+
self,
|
|
86
|
+
state: async (owner) => {
|
|
87
|
+
const own = await self();
|
|
88
|
+
if (
|
|
89
|
+
owner.host !== own.host ||
|
|
90
|
+
owner.namespace === undefined ||
|
|
91
|
+
owner.namespace !== own.namespace ||
|
|
92
|
+
owner.start === undefined
|
|
93
|
+
)
|
|
94
|
+
return "unknown";
|
|
95
|
+
try {
|
|
96
|
+
const start = await linuxStartTime(owner.pid);
|
|
97
|
+
return start === owner.start ? "alive" : "gone";
|
|
98
|
+
} catch {
|
|
99
|
+
return "unknown";
|
|
100
|
+
}
|
|
101
|
+
},
|
|
102
|
+
};
|
|
103
|
+
};
|
|
104
|
+
|
|
105
|
+
export interface LoginOwnershipOptions {
|
|
106
|
+
readonly probe?: ProcessProbe;
|
|
107
|
+
/** The longest a process waits to become the owner; the provider's request timeout. */
|
|
108
|
+
readonly waitMs: number;
|
|
109
|
+
readonly pollMs?: number;
|
|
110
|
+
}
|
|
111
|
+
|
|
112
|
+
export interface LoginOwnershipHold {
|
|
113
|
+
/** The record that names this owner. */
|
|
114
|
+
readonly record: string;
|
|
115
|
+
release(): Promise<void>;
|
|
116
|
+
}
|
|
117
|
+
|
|
118
|
+
/**
|
|
119
|
+
* One owner per login, as numbered records in the login's own directory. A process becomes the
|
|
120
|
+
* owner by an exclusive hard link of the next number, so exactly one of any number of competitors
|
|
121
|
+
* wins, and the highest number is the current record. A record never expires: an owner can hold a
|
|
122
|
+
* renewed credential it has not saved yet, so only a process that provably cannot resume may be
|
|
123
|
+
* replaced. A suspended owner therefore resumes as the owner and nothing it writes can overwrite a
|
|
124
|
+
* later login. What is bounded is the wait, not the ownership.
|
|
125
|
+
*/
|
|
126
|
+
export class LoginOwnership {
|
|
127
|
+
readonly #probe: ProcessProbe;
|
|
128
|
+
readonly #waitMs: number;
|
|
129
|
+
readonly #pollMs: number;
|
|
130
|
+
|
|
131
|
+
public constructor(
|
|
132
|
+
private readonly directory: string,
|
|
133
|
+
options: LoginOwnershipOptions,
|
|
134
|
+
) {
|
|
135
|
+
this.#probe = options.probe ?? linuxProcessProbe();
|
|
136
|
+
this.#waitMs = options.waitMs;
|
|
137
|
+
this.#pollMs = options.pollMs ?? DEFAULT_POLL_MS;
|
|
138
|
+
}
|
|
139
|
+
|
|
140
|
+
public async acquire(signal?: AbortSignal): Promise<LoginOwnershipHold> {
|
|
141
|
+
const self = await this.#probe.self();
|
|
142
|
+
const deadline = Date.now() + this.#waitMs;
|
|
143
|
+
for (;;) {
|
|
144
|
+
signal?.throwIfAborted();
|
|
145
|
+
const newest = await this.#newest();
|
|
146
|
+
if (newest > 0) {
|
|
147
|
+
const state = await this.#state(newest);
|
|
148
|
+
// A record that is listed but cannot be read waits like a held one, so it never spins.
|
|
149
|
+
if (state === "missing" && (await this.#listed(newest))) {
|
|
150
|
+
if (Date.now() >= deadline) throw new LoginOwnershipTimeoutError(recordName(newest));
|
|
151
|
+
await sleep(this.#pollMs);
|
|
152
|
+
continue;
|
|
153
|
+
}
|
|
154
|
+
if (state === "missing") continue;
|
|
155
|
+
if (state !== "released" && state !== "gone") {
|
|
156
|
+
if (Date.now() >= deadline) throw new LoginOwnershipTimeoutError(recordName(newest));
|
|
157
|
+
await sleep(this.#pollMs);
|
|
158
|
+
continue;
|
|
159
|
+
}
|
|
160
|
+
}
|
|
161
|
+
const candidate = newest + 1;
|
|
162
|
+
if (await this.#claim(candidate, self)) {
|
|
163
|
+
await this.#prune(candidate);
|
|
164
|
+
return { record: recordName(candidate), release: () => this.#release(candidate) };
|
|
165
|
+
}
|
|
166
|
+
if (Date.now() >= deadline) throw new LoginOwnershipTimeoutError(recordName(candidate));
|
|
167
|
+
}
|
|
168
|
+
}
|
|
169
|
+
|
|
170
|
+
/** Whether the current record is released, held by a gone process, or still held. */
|
|
171
|
+
async #state(number: number): Promise<OwnerState | "released" | "missing"> {
|
|
172
|
+
let serialized: string;
|
|
173
|
+
try {
|
|
174
|
+
serialized = await readFile(join(this.directory, recordName(number)), "utf8");
|
|
175
|
+
} catch (error) {
|
|
176
|
+
return errorCode(error) === "ENOENT" ? "missing" : "unknown";
|
|
177
|
+
}
|
|
178
|
+
const owner = parseOwner(serialized);
|
|
179
|
+
if (owner === undefined) return "unknown";
|
|
180
|
+
try {
|
|
181
|
+
await readFile(join(this.directory, releasedName(number)));
|
|
182
|
+
return "released";
|
|
183
|
+
} catch (error) {
|
|
184
|
+
if (errorCode(error) !== "ENOENT") return "unknown";
|
|
185
|
+
}
|
|
186
|
+
return await this.#probe.state(owner);
|
|
187
|
+
}
|
|
188
|
+
|
|
189
|
+
/** Links the next number; losing the race, or finding a newer record, means nothing was taken. */
|
|
190
|
+
async #claim(number: number, self: OwnerIdentity): Promise<boolean> {
|
|
191
|
+
const temporary = join(this.directory, `.owner-${randomUUID()}.tmp`);
|
|
192
|
+
const target = join(this.directory, recordName(number));
|
|
193
|
+
try {
|
|
194
|
+
const handle = await open(temporary, "wx", 0o600);
|
|
195
|
+
try {
|
|
196
|
+
await handle.writeFile(JSON.stringify({ version: 1, number, ...self }), "utf8");
|
|
197
|
+
await handle.sync();
|
|
198
|
+
} finally {
|
|
199
|
+
await handle.close();
|
|
200
|
+
}
|
|
201
|
+
await link(temporary, target);
|
|
202
|
+
} catch (error) {
|
|
203
|
+
if (errorCode(error) === "EEXIST") return false;
|
|
204
|
+
throw error;
|
|
205
|
+
} finally {
|
|
206
|
+
await quietly(unlink(temporary));
|
|
207
|
+
}
|
|
208
|
+
// A competitor delayed since its read can link a number that newer owners already pruned; it
|
|
209
|
+
// is then not the current record, and its stale file is removed again.
|
|
210
|
+
if ((await this.#newest()) === number) return true;
|
|
211
|
+
await quietly(unlink(target));
|
|
212
|
+
return false;
|
|
213
|
+
}
|
|
214
|
+
|
|
215
|
+
/** The owner of the highest number removes the lower ones; a failure leaves harmless leftovers. */
|
|
216
|
+
async #prune(current: number): Promise<void> {
|
|
217
|
+
let names: string[];
|
|
218
|
+
try {
|
|
219
|
+
names = await readdir(this.directory);
|
|
220
|
+
} catch {
|
|
221
|
+
return;
|
|
222
|
+
}
|
|
223
|
+
for (const name of names) {
|
|
224
|
+
const number = Number((RECORD.exec(name) ?? RELEASED.exec(name))?.[1] ?? 0);
|
|
225
|
+
if (number === 0 || number >= current) continue;
|
|
226
|
+
await quietly(unlink(join(this.directory, name)));
|
|
227
|
+
}
|
|
228
|
+
}
|
|
229
|
+
|
|
230
|
+
/** Whether the record's file is still listed although it could not be read. */
|
|
231
|
+
async #listed(number: number): Promise<boolean> {
|
|
232
|
+
try {
|
|
233
|
+
return (await readdir(this.directory)).includes(recordName(number));
|
|
234
|
+
} catch {
|
|
235
|
+
return false;
|
|
236
|
+
}
|
|
237
|
+
}
|
|
238
|
+
|
|
239
|
+
async #release(number: number): Promise<void> {
|
|
240
|
+
// A full disk or a passing fault must not leave a live process holding the login for good.
|
|
241
|
+
for (let attempt = 0; attempt < 3; attempt += 1) {
|
|
242
|
+
try {
|
|
243
|
+
const handle = await open(join(this.directory, releasedName(number)), "wx", 0o600);
|
|
244
|
+
await handle.close();
|
|
245
|
+
return;
|
|
246
|
+
} catch (error) {
|
|
247
|
+
if (errorCode(error) === "EEXIST") return;
|
|
248
|
+
await sleep(this.#pollMs);
|
|
249
|
+
}
|
|
250
|
+
}
|
|
251
|
+
// The record stays; this process still owns it until it exits, which a waiter can see.
|
|
252
|
+
}
|
|
253
|
+
|
|
254
|
+
async #newest(): Promise<number> {
|
|
255
|
+
let names: string[];
|
|
256
|
+
try {
|
|
257
|
+
names = await readdir(this.directory);
|
|
258
|
+
} catch {
|
|
259
|
+
return 0;
|
|
260
|
+
}
|
|
261
|
+
return names.reduce((newest, name) => Math.max(newest, Number(RECORD.exec(name)?.[1] ?? 0)), 0);
|
|
262
|
+
}
|
|
263
|
+
}
|
|
264
|
+
|
|
265
|
+
const parseOwner = (serialized: string): OwnerIdentity | undefined => {
|
|
266
|
+
try {
|
|
267
|
+
const value: unknown = JSON.parse(serialized);
|
|
268
|
+
if (
|
|
269
|
+
typeof value !== "object" ||
|
|
270
|
+
value === null ||
|
|
271
|
+
!("host" in value) ||
|
|
272
|
+
!("pid" in value) ||
|
|
273
|
+
typeof value.host !== "string" ||
|
|
274
|
+
typeof value.pid !== "number"
|
|
275
|
+
)
|
|
276
|
+
return undefined;
|
|
277
|
+
const namespace = "namespace" in value ? value.namespace : undefined;
|
|
278
|
+
const start = "start" in value ? value.start : undefined;
|
|
279
|
+
return {
|
|
280
|
+
host: value.host,
|
|
281
|
+
namespace: typeof namespace === "string" ? namespace : undefined,
|
|
282
|
+
pid: value.pid,
|
|
283
|
+
start: typeof start === "string" ? start : undefined,
|
|
284
|
+
};
|
|
285
|
+
} catch {
|
|
286
|
+
return undefined;
|
|
287
|
+
}
|
|
288
|
+
};
|
|
289
|
+
|
|
290
|
+
const errorCode = (error: unknown): string | undefined =>
|
|
291
|
+
typeof error === "object" && error !== null && "code" in error ? String(error.code) : undefined;
|