@narumitw/pi-starship 0.59.2 → 0.60.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/README.md +28 -3
- package/dist/chunks/{chunk-MTFSZ63Q.ts → chunk-KZZKGGFW.ts} +327 -42
- package/dist/chunks/chunk-KZZKGGFW.ts.map +7 -0
- package/dist/chunks/{commands-K6T7PNEM.ts → commands-C2VJ6ZBN.ts} +1279 -111
- package/dist/chunks/commands-C2VJ6ZBN.ts.map +7 -0
- package/dist/index.ts +25 -9
- package/dist/index.ts.map +2 -2
- package/package.json +2 -2
- package/skills/configure-pi-starship/SKILL.md +5 -1
- package/skills/configure-pi-starship/references/configuration.md +122 -11
- package/skills/configure-pi-starship/scripts/apply.mjs +87 -33
- package/skills/configure-pi-starship/scripts/backup.mjs +17 -0
- package/src/command-commit.ts +169 -0
- package/src/command-configuration.ts +78 -34
- package/src/command-gist.ts +11 -3
- package/src/command-preset-picker.ts +6 -2
- package/src/command-profiles.ts +664 -0
- package/src/commands.ts +223 -77
- package/src/config.ts +112 -14
- package/src/format/formatter.ts +8 -4
- package/src/format/style.ts +54 -15
- package/src/format/terminal-safety.ts +80 -0
- package/src/format/theme-colors.ts +69 -0
- package/src/modules/model.ts +1 -1
- package/src/modules/render.ts +75 -5
- package/src/pi-starship.ts +22 -6
- package/src/profile-store.ts +526 -0
- package/dist/chunks/chunk-MTFSZ63Q.ts.map +0 -7
- package/dist/chunks/commands-K6T7PNEM.ts.map +0 -7
|
@@ -2,21 +2,519 @@
|
|
|
2
2
|
// @ts-nocheck -- the generated entry uses a .ts extension for Pi's Jiti loader.
|
|
3
3
|
import {
|
|
4
4
|
BUILT_IN_EXAMPLE,
|
|
5
|
+
ConfigPublicationError,
|
|
5
6
|
MODULE_DEFINITIONS,
|
|
6
7
|
STARSHIP_SUBCOMMANDS,
|
|
8
|
+
assertConfigDocumentUnchanged,
|
|
7
9
|
atomicRestoreConfigDocument,
|
|
8
10
|
atomicSaveConfigDocument,
|
|
9
11
|
completeStarshipArguments,
|
|
10
12
|
inspectUnavailableModules,
|
|
11
13
|
loadStarshipConfig,
|
|
14
|
+
readConfigDocumentSnapshot,
|
|
12
15
|
removeConfigDocumentIfMatches,
|
|
13
16
|
validateConfigDocument
|
|
14
|
-
} from "./chunk-
|
|
17
|
+
} from "./chunk-KZZKGGFW.ts";
|
|
15
18
|
|
|
16
19
|
// src/commands.ts
|
|
17
|
-
import {
|
|
20
|
+
import { isKeyRelease as isKeyRelease2, Key as Key3, matchesKey as matchesKey3 } from "@earendil-works/pi-tui";
|
|
21
|
+
import { defineMenu as defineMenu3, runMenu as runMenu3 } from "@narumitw/pi-tui-kit";
|
|
22
|
+
|
|
23
|
+
// src/command-commit.ts
|
|
24
|
+
import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
|
|
25
|
+
|
|
26
|
+
// src/profile-store.ts
|
|
27
|
+
import { randomUUID } from "node:crypto";
|
|
28
|
+
import {
|
|
29
|
+
closeSync,
|
|
30
|
+
constants,
|
|
31
|
+
fstatSync,
|
|
32
|
+
fsyncSync,
|
|
33
|
+
lstatSync,
|
|
34
|
+
mkdirSync,
|
|
35
|
+
openSync,
|
|
36
|
+
readdirSync,
|
|
37
|
+
readFileSync,
|
|
38
|
+
realpathSync,
|
|
39
|
+
renameSync,
|
|
40
|
+
rmdirSync,
|
|
41
|
+
unlinkSync,
|
|
42
|
+
writeFileSync
|
|
43
|
+
} from "node:fs";
|
|
44
|
+
import { basename, dirname, join, parse, resolve, sep } from "node:path";
|
|
45
|
+
var HISTORY_NAME = /^(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}\.\d{3}Z)-[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.toml$/u;
|
|
46
|
+
var LEGACY_NAME = /^pi-starship-(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})\.toml$/u;
|
|
47
|
+
var RESERVED_NAME = /^(?:con|prn|aux|nul|com[1-9¹²³]|lpt[1-9¹²³]|conin\$|conout\$|clock\$)(?:\.|$)/iu;
|
|
48
|
+
function normalizeProfileName(value) {
|
|
49
|
+
const name = value.normalize("NFC");
|
|
50
|
+
if ([...name].length < 1 || [...name].length > 80 || name !== name.trim() || name.startsWith(".") || name.endsWith(".") || /[\p{Cc}\p{Cf}\p{Cs}<>:"/\\|?*]/u.test(name) || RESERVED_NAME.test(name) || Buffer.byteLength(`${name}.toml`, "utf8") > 255) {
|
|
51
|
+
throw new Error("Invalid profile name: use 1\u201380 characters without controls, path characters, or reserved names");
|
|
52
|
+
}
|
|
53
|
+
return name;
|
|
54
|
+
}
|
|
55
|
+
function trustedDirectory(path) {
|
|
56
|
+
try {
|
|
57
|
+
return realpathSync(path);
|
|
58
|
+
} catch (error) {
|
|
59
|
+
if (!isMissing(error)) throw error;
|
|
60
|
+
const parent = dirname(path);
|
|
61
|
+
if (parent === path) throw error;
|
|
62
|
+
return join(trustedDirectory(parent), basename(path));
|
|
63
|
+
}
|
|
64
|
+
}
|
|
65
|
+
function rootPath(settingsPath) {
|
|
66
|
+
return join(trustedDirectory(dirname(resolve(settingsPath))), "pi-starship");
|
|
67
|
+
}
|
|
68
|
+
function profileDirectory(settingsPath) {
|
|
69
|
+
return join(rootPath(settingsPath), "profiles");
|
|
70
|
+
}
|
|
71
|
+
function historyDirectory(settingsPath) {
|
|
72
|
+
return join(rootPath(settingsPath), "history");
|
|
73
|
+
}
|
|
74
|
+
function isMissing(error) {
|
|
75
|
+
return error.code === "ENOENT";
|
|
76
|
+
}
|
|
77
|
+
function statIfPresent(path) {
|
|
78
|
+
try {
|
|
79
|
+
return lstatSync(path, { bigint: true });
|
|
80
|
+
} catch (error) {
|
|
81
|
+
if (isMissing(error)) return void 0;
|
|
82
|
+
throw error;
|
|
83
|
+
}
|
|
84
|
+
}
|
|
85
|
+
function checkedDirectory(path, create = false) {
|
|
86
|
+
const absolute = resolve(path);
|
|
87
|
+
const root = parse(absolute).root;
|
|
88
|
+
let current3 = root;
|
|
89
|
+
for (const part of absolute.slice(root.length).split(sep).filter(Boolean)) {
|
|
90
|
+
current3 = join(current3, part);
|
|
91
|
+
let stat = statIfPresent(current3);
|
|
92
|
+
let created = false;
|
|
93
|
+
if (!stat && create) {
|
|
94
|
+
try {
|
|
95
|
+
mkdirSync(current3, { mode: 448 });
|
|
96
|
+
} catch (error) {
|
|
97
|
+
if (error.code !== "EEXIST") throw error;
|
|
98
|
+
}
|
|
99
|
+
stat = statIfPresent(current3);
|
|
100
|
+
created = true;
|
|
101
|
+
}
|
|
102
|
+
if (!stat) return false;
|
|
103
|
+
if (!stat.isDirectory() || stat.isSymbolicLink()) throw new Error(`Not a safe directory: ${current3}`);
|
|
104
|
+
if (created) flushDirectory(dirname(current3));
|
|
105
|
+
}
|
|
106
|
+
return true;
|
|
107
|
+
}
|
|
108
|
+
function identity(stat) {
|
|
109
|
+
return Object.freeze({ dev: stat.dev, ino: stat.ino, size: stat.size, mtimeNs: stat.mtimeNs, ctimeNs: stat.ctimeNs });
|
|
110
|
+
}
|
|
111
|
+
function sameIdentity(left, right) {
|
|
112
|
+
return left.dev === right.dev && left.ino === right.ino && left.size === right.size && left.mtimeNs === right.mtimeNs && left.ctimeNs === right.ctimeNs;
|
|
113
|
+
}
|
|
114
|
+
function sameFile(left, right) {
|
|
115
|
+
return left.dev === right.dev && left.ino === right.ino;
|
|
116
|
+
}
|
|
117
|
+
function encodeDocument(rawDocument) {
|
|
118
|
+
const bytes = Buffer.from(rawDocument, "utf8");
|
|
119
|
+
if (bytes.toString("utf8") !== rawDocument) throw new Error("Document is not lossless UTF-8 text");
|
|
120
|
+
return bytes;
|
|
121
|
+
}
|
|
122
|
+
function readBytes(path) {
|
|
123
|
+
if (!checkedDirectory(dirname(path))) throw new Error(`Document directory is missing: ${dirname(path)}`);
|
|
124
|
+
const before = statIfPresent(path);
|
|
125
|
+
if (!before?.isFile() || before.isSymbolicLink()) throw new Error(`Not a regular document: ${path}`);
|
|
126
|
+
const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
|
|
127
|
+
try {
|
|
128
|
+
const opened = fstatSync(fd, { bigint: true });
|
|
129
|
+
if (!opened.isFile() || !sameIdentity(identity(before), identity(opened))) {
|
|
130
|
+
throw new Error(`Document changed while opening: ${path}`);
|
|
131
|
+
}
|
|
132
|
+
const bytes = readFileSync(fd);
|
|
133
|
+
const after = fstatSync(fd, { bigint: true });
|
|
134
|
+
const published = statIfPresent(path);
|
|
135
|
+
if (!sameIdentity(identity(opened), identity(after)) || !published || !sameIdentity(identity(after), identity(published))) {
|
|
136
|
+
throw new Error(`Document changed while reading: ${path}`);
|
|
137
|
+
}
|
|
138
|
+
return { rawBytes: bytes, identity: identity(after) };
|
|
139
|
+
} finally {
|
|
140
|
+
closeSync(fd);
|
|
141
|
+
}
|
|
142
|
+
}
|
|
143
|
+
function readProfile(settingsPath, name) {
|
|
144
|
+
const normalized = normalizeProfileName(name);
|
|
145
|
+
const path = join(profileDirectory(settingsPath), `${normalized}.toml`);
|
|
146
|
+
const document = readBytes(path);
|
|
147
|
+
const decoded = document.rawBytes.toString("utf8");
|
|
148
|
+
const valid = Buffer.from(decoded, "utf8").equals(document.rawBytes);
|
|
149
|
+
return Object.freeze({
|
|
150
|
+
kind: "profile",
|
|
151
|
+
name: normalized,
|
|
152
|
+
path,
|
|
153
|
+
...document,
|
|
154
|
+
rawDocument: valid ? decoded : void 0,
|
|
155
|
+
...valid ? {} : { readError: "Profile document is not valid UTF-8; raw bytes are preserved" }
|
|
156
|
+
});
|
|
157
|
+
}
|
|
158
|
+
function listProfiles(settingsPath) {
|
|
159
|
+
const directory = profileDirectory(settingsPath);
|
|
160
|
+
if (!checkedDirectory(directory)) return [];
|
|
161
|
+
const profiles = [];
|
|
162
|
+
for (const filename of readdirSync(directory).sort()) {
|
|
163
|
+
if (!filename.endsWith(".toml")) continue;
|
|
164
|
+
const name = filename.slice(0, -5);
|
|
165
|
+
try {
|
|
166
|
+
if (normalizeProfileName(name) !== name) continue;
|
|
167
|
+
} catch {
|
|
168
|
+
continue;
|
|
169
|
+
}
|
|
170
|
+
const stat = statIfPresent(join(directory, filename));
|
|
171
|
+
if (!stat?.isFile() || stat.isSymbolicLink()) continue;
|
|
172
|
+
profiles.push(readProfile(settingsPath, name));
|
|
173
|
+
}
|
|
174
|
+
return profiles;
|
|
175
|
+
}
|
|
176
|
+
function mutate(settingsPath, operation) {
|
|
177
|
+
const root = rootPath(settingsPath);
|
|
178
|
+
checkedDirectory(root, true);
|
|
179
|
+
const lock = join(root, ".mutation-lock");
|
|
180
|
+
try {
|
|
181
|
+
mkdirSync(lock, { mode: 448 });
|
|
182
|
+
} catch (error) {
|
|
183
|
+
if (error.code === "EEXIST") {
|
|
184
|
+
throw new Error(`Profile/history storage is locked; inspect the owner before manually removing ${lock}`);
|
|
185
|
+
}
|
|
186
|
+
throw error;
|
|
187
|
+
}
|
|
188
|
+
const owned = lstatSync(lock, { bigint: true });
|
|
189
|
+
let result;
|
|
190
|
+
let operationError;
|
|
191
|
+
let failed = false;
|
|
192
|
+
try {
|
|
193
|
+
result = operation();
|
|
194
|
+
} catch (error) {
|
|
195
|
+
failed = true;
|
|
196
|
+
operationError = error;
|
|
197
|
+
}
|
|
198
|
+
try {
|
|
199
|
+
const current3 = statIfPresent(lock);
|
|
200
|
+
if (current3?.isDirectory() && sameFile(identity(owned), current3)) rmdirSync(lock);
|
|
201
|
+
} catch (error) {
|
|
202
|
+
if (failed) throw new AggregateError([operationError, error], `Mutation and lock cleanup failed at ${lock}`);
|
|
203
|
+
throw new Error(`Mutation completed but lock cleanup failed at ${lock}`, { cause: error });
|
|
204
|
+
}
|
|
205
|
+
if (failed) throw operationError;
|
|
206
|
+
return result;
|
|
207
|
+
}
|
|
208
|
+
function collisionKey(name) {
|
|
209
|
+
return name.normalize("NFC").toUpperCase().toLowerCase().toUpperCase().toLowerCase().normalize("NFC");
|
|
210
|
+
}
|
|
211
|
+
function assertAvailable(directory, filename) {
|
|
212
|
+
const key = collisionKey(filename);
|
|
213
|
+
if (readdirSync(directory).some((entry) => collisionKey(entry) === key)) {
|
|
214
|
+
throw new Error(`Document name already exists: ${filename}`);
|
|
215
|
+
}
|
|
216
|
+
}
|
|
217
|
+
function assertExpected(current3, expected) {
|
|
218
|
+
if (current3.kind !== expected.kind || current3.path !== expected.path || current3.name !== expected.name || current3.rawDocument !== expected.rawDocument || !current3.rawBytes.equals(expected.rawBytes) || !sameIdentity(current3.identity, expected.identity)) {
|
|
219
|
+
throw new Error(`Document changed since review: ${current3.path}`);
|
|
220
|
+
}
|
|
221
|
+
}
|
|
222
|
+
function flushDirectory(path) {
|
|
223
|
+
if (process.platform === "win32") return;
|
|
224
|
+
checkedDirectory(path);
|
|
225
|
+
const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_DIRECTORY);
|
|
226
|
+
try {
|
|
227
|
+
fsyncSync(fd);
|
|
228
|
+
} finally {
|
|
229
|
+
closeSync(fd);
|
|
230
|
+
}
|
|
231
|
+
}
|
|
232
|
+
function flushMutation(directory, path) {
|
|
233
|
+
try {
|
|
234
|
+
flushDirectory(directory);
|
|
235
|
+
} catch (error) {
|
|
236
|
+
throw new Error(`Mutation completed at ${path}, but directory flush failed: ${String(error)}`, { cause: error });
|
|
237
|
+
}
|
|
238
|
+
}
|
|
239
|
+
function publish(directory, filename, bytes, beforeRename) {
|
|
240
|
+
const temporary = join(directory, `.tmp-${randomUUID()}`);
|
|
241
|
+
const fd = openSync(
|
|
242
|
+
temporary,
|
|
243
|
+
constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW,
|
|
244
|
+
384
|
|
245
|
+
);
|
|
246
|
+
const owned = fstatSync(fd, { bigint: true });
|
|
247
|
+
let open = true;
|
|
248
|
+
try {
|
|
249
|
+
writeFileSync(fd, bytes);
|
|
250
|
+
fsyncSync(fd);
|
|
251
|
+
closeSync(fd);
|
|
252
|
+
open = false;
|
|
253
|
+
checkedDirectory(directory);
|
|
254
|
+
beforeRename();
|
|
255
|
+
const destination = join(directory, filename);
|
|
256
|
+
renameSync(temporary, destination);
|
|
257
|
+
flushMutation(directory, destination);
|
|
258
|
+
} finally {
|
|
259
|
+
try {
|
|
260
|
+
if (open) closeSync(fd);
|
|
261
|
+
} finally {
|
|
262
|
+
const current3 = statIfPresent(temporary);
|
|
263
|
+
if (current3 && sameFile(identity(owned), current3)) unlinkSync(temporary);
|
|
264
|
+
}
|
|
265
|
+
}
|
|
266
|
+
}
|
|
267
|
+
function readTextProfile(settingsPath, name) {
|
|
268
|
+
const document = readProfile(settingsPath, name);
|
|
269
|
+
if (document.rawDocument === void 0) throw new Error(document.readError);
|
|
270
|
+
return { ...document, rawDocument: document.rawDocument };
|
|
271
|
+
}
|
|
272
|
+
function createProfile(settingsPath, name, rawDocument) {
|
|
273
|
+
const normalized = normalizeProfileName(name);
|
|
274
|
+
const bytes = encodeDocument(rawDocument);
|
|
275
|
+
return mutate(settingsPath, () => {
|
|
276
|
+
const directory = profileDirectory(settingsPath);
|
|
277
|
+
checkedDirectory(directory, true);
|
|
278
|
+
const filename = `${normalized}.toml`;
|
|
279
|
+
assertAvailable(directory, filename);
|
|
280
|
+
publish(directory, filename, bytes, () => assertAvailable(directory, filename));
|
|
281
|
+
return readTextProfile(settingsPath, normalized);
|
|
282
|
+
});
|
|
283
|
+
}
|
|
284
|
+
function duplicateProfile(settingsPath, name, newName, expected) {
|
|
285
|
+
const normalized = normalizeProfileName(newName);
|
|
286
|
+
return mutate(settingsPath, () => {
|
|
287
|
+
const current3 = readProfile(settingsPath, name);
|
|
288
|
+
assertExpected(current3, expected);
|
|
289
|
+
const directory = profileDirectory(settingsPath);
|
|
290
|
+
const filename = `${normalized}.toml`;
|
|
291
|
+
assertAvailable(directory, filename);
|
|
292
|
+
publish(directory, filename, current3.rawBytes, () => {
|
|
293
|
+
assertExpected(readProfile(settingsPath, name), expected);
|
|
294
|
+
assertAvailable(directory, filename);
|
|
295
|
+
});
|
|
296
|
+
return readProfile(settingsPath, normalized);
|
|
297
|
+
});
|
|
298
|
+
}
|
|
299
|
+
function saveProfile(settingsPath, name, rawDocument, expected) {
|
|
300
|
+
const normalized = normalizeProfileName(name);
|
|
301
|
+
const bytes = encodeDocument(rawDocument);
|
|
302
|
+
return mutate(settingsPath, () => {
|
|
303
|
+
const current3 = readProfile(settingsPath, normalized);
|
|
304
|
+
assertExpected(current3, expected);
|
|
305
|
+
if (current3.rawDocument === rawDocument) return { ...current3, rawDocument };
|
|
306
|
+
publish(profileDirectory(settingsPath), `${normalized}.toml`, bytes, () => {
|
|
307
|
+
assertExpected(readProfile(settingsPath, normalized), expected);
|
|
308
|
+
});
|
|
309
|
+
return readTextProfile(settingsPath, normalized);
|
|
310
|
+
});
|
|
311
|
+
}
|
|
312
|
+
function renameProfile(settingsPath, name, newName, expected) {
|
|
313
|
+
const normalized = normalizeProfileName(newName);
|
|
314
|
+
return mutate(settingsPath, () => {
|
|
315
|
+
const current3 = readProfile(settingsPath, name);
|
|
316
|
+
assertExpected(current3, expected);
|
|
317
|
+
if (current3.name === normalized) return current3;
|
|
318
|
+
if (collisionKey(current3.name) === collisionKey(normalized))
|
|
319
|
+
throw new Error("Case-only profile rename is not supported");
|
|
320
|
+
const directory = profileDirectory(settingsPath);
|
|
321
|
+
assertAvailable(directory, `${normalized}.toml`);
|
|
322
|
+
assertExpected(readProfile(settingsPath, name), expected);
|
|
323
|
+
const destination = join(directory, `${normalized}.toml`);
|
|
324
|
+
renameSync(current3.path, destination);
|
|
325
|
+
flushMutation(directory, destination);
|
|
326
|
+
return readProfile(settingsPath, normalized);
|
|
327
|
+
});
|
|
328
|
+
}
|
|
329
|
+
function deleteProfile(settingsPath, name, expected) {
|
|
330
|
+
mutate(settingsPath, () => {
|
|
331
|
+
const current3 = readProfile(settingsPath, name);
|
|
332
|
+
assertExpected(current3, expected);
|
|
333
|
+
unlinkSync(current3.path);
|
|
334
|
+
flushMutation(dirname(current3.path), current3.path);
|
|
335
|
+
});
|
|
336
|
+
}
|
|
337
|
+
function assertTimestamp(value) {
|
|
338
|
+
const time = Date.parse(value);
|
|
339
|
+
if (!Number.isFinite(time) || new Date(time).toISOString() !== value) throw new Error("Invalid history timestamp");
|
|
340
|
+
}
|
|
341
|
+
function historyLocation(settingsPath, name) {
|
|
342
|
+
const modern = HISTORY_NAME.exec(name);
|
|
343
|
+
if (modern) {
|
|
344
|
+
const createdAt = modern[1].replace(/T(\d{2})-(\d{2})-(\d{2})/u, "T$1:$2:$3");
|
|
345
|
+
assertTimestamp(createdAt);
|
|
346
|
+
return { path: join(historyDirectory(settingsPath), name), legacy: false, createdAt };
|
|
347
|
+
}
|
|
348
|
+
const legacy = LEGACY_NAME.exec(name);
|
|
349
|
+
if (legacy) {
|
|
350
|
+
const createdAt = `${legacy[1]}-${legacy[2]}-${legacy[3]}T${legacy[4]}:${legacy[5]}`;
|
|
351
|
+
assertTimestamp(`${createdAt}:00.000Z`);
|
|
352
|
+
return { path: join(rootPath(settingsPath), name), legacy: true, createdAt };
|
|
353
|
+
}
|
|
354
|
+
throw new Error("Invalid history filename");
|
|
355
|
+
}
|
|
356
|
+
function readHistory(settingsPath, name) {
|
|
357
|
+
const location = historyLocation(settingsPath, name);
|
|
358
|
+
const document = readBytes(location.path);
|
|
359
|
+
const decoded = document.rawBytes.toString("utf8");
|
|
360
|
+
const valid = Buffer.from(decoded, "utf8").equals(document.rawBytes);
|
|
361
|
+
return Object.freeze({
|
|
362
|
+
kind: "history",
|
|
363
|
+
name,
|
|
364
|
+
...location,
|
|
365
|
+
...document,
|
|
366
|
+
rawDocument: valid ? decoded : void 0,
|
|
367
|
+
...valid ? {} : { readError: "Recovery document is not valid UTF-8; raw bytes are preserved" }
|
|
368
|
+
});
|
|
369
|
+
}
|
|
370
|
+
function listHistory(settingsPath) {
|
|
371
|
+
const history = [];
|
|
372
|
+
for (const [directory, pattern] of [
|
|
373
|
+
[historyDirectory(settingsPath), HISTORY_NAME],
|
|
374
|
+
[rootPath(settingsPath), LEGACY_NAME]
|
|
375
|
+
]) {
|
|
376
|
+
if (!checkedDirectory(directory)) continue;
|
|
377
|
+
for (const name of readdirSync(directory).sort()) {
|
|
378
|
+
if (!pattern.test(name)) continue;
|
|
379
|
+
try {
|
|
380
|
+
historyLocation(settingsPath, name);
|
|
381
|
+
} catch (error) {
|
|
382
|
+
if (error instanceof Error && error.message === "Invalid history timestamp") continue;
|
|
383
|
+
throw error;
|
|
384
|
+
}
|
|
385
|
+
const stat = statIfPresent(join(directory, name));
|
|
386
|
+
if (!stat?.isFile() || stat.isSymbolicLink()) continue;
|
|
387
|
+
history.push(readHistory(settingsPath, name));
|
|
388
|
+
}
|
|
389
|
+
}
|
|
390
|
+
return history.sort(
|
|
391
|
+
(left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt) || left.name.localeCompare(right.name)
|
|
392
|
+
);
|
|
393
|
+
}
|
|
394
|
+
function archiveConfigDocument(settingsPath, rawDocument) {
|
|
395
|
+
const bytes = typeof rawDocument === "string" ? encodeDocument(rawDocument) : Buffer.from(rawDocument);
|
|
396
|
+
return mutate(settingsPath, () => {
|
|
397
|
+
const directory = historyDirectory(settingsPath);
|
|
398
|
+
checkedDirectory(directory, true);
|
|
399
|
+
const name = `${(/* @__PURE__ */ new Date()).toISOString().replace(/:/gu, "-")}-${randomUUID()}.toml`;
|
|
400
|
+
publish(directory, name, bytes, () => assertAvailable(directory, name));
|
|
401
|
+
return Object.freeze({ name, path: join(directory, name) });
|
|
402
|
+
});
|
|
403
|
+
}
|
|
404
|
+
function deleteHistory(settingsPath, name, expected) {
|
|
405
|
+
if (historyLocation(settingsPath, name).legacy) throw new Error("Legacy recovery files are read-only");
|
|
406
|
+
mutate(settingsPath, () => {
|
|
407
|
+
const current3 = readHistory(settingsPath, name);
|
|
408
|
+
assertExpected(current3, expected);
|
|
409
|
+
unlinkSync(current3.path);
|
|
410
|
+
flushMutation(dirname(current3.path), current3.path);
|
|
411
|
+
});
|
|
412
|
+
}
|
|
413
|
+
|
|
414
|
+
// src/command-commit.ts
|
|
415
|
+
function captureCommitExpectation(options) {
|
|
416
|
+
return {
|
|
417
|
+
previous: options.getLoaded(),
|
|
418
|
+
revision: options.getLoadedRevision?.(),
|
|
419
|
+
disk: readConfigDocumentSnapshot(options.settingsPath)
|
|
420
|
+
};
|
|
421
|
+
}
|
|
422
|
+
function commitOwnerCurrent(options, owner, expected) {
|
|
423
|
+
const loaded = options.getLoaded();
|
|
424
|
+
return !owner.signal.aborted && owner.isCurrent() && loaded.rawDocument === expected.previous.rawDocument && loaded.source === expected.previous.source && JSON.stringify(loaded.diagnostics) === JSON.stringify(expected.previous.diagnostics) && options.getLoadedRevision?.() === expected.revision;
|
|
425
|
+
}
|
|
426
|
+
async function commitActiveDocument(ctx, options, candidate, owner, expected, allowInvalid = false, checkCandidate) {
|
|
427
|
+
const raw = candidate.rawDocument;
|
|
428
|
+
if (raw === void 0) throw new Error("The candidate settings document is unavailable");
|
|
429
|
+
return withFileMutationQueue(options.settingsPath, async () => {
|
|
430
|
+
if (!commitOwnerCurrent(options, owner, expected)) return "cancel";
|
|
431
|
+
checkCandidate?.();
|
|
432
|
+
assertConfigDocumentUnchanged(options.settingsPath, expected.disk);
|
|
433
|
+
const previousBytes = expected.disk.rawBytes;
|
|
434
|
+
if (expected.previous.rawDocument !== previousBytes?.toString("utf8")) {
|
|
435
|
+
throw new Error(
|
|
436
|
+
"The active file differs from the loaded document. Reload and review it before replacing settings."
|
|
437
|
+
);
|
|
438
|
+
}
|
|
439
|
+
const invalid = expected.previous.diagnostics.some((item) => item.severity === "error");
|
|
440
|
+
if (invalid && !allowInvalid)
|
|
441
|
+
throw new Error("The active settings document is invalid. Use explicit repair or recovery before replacing it.");
|
|
442
|
+
validateConfigDocument(options.settingsPath, raw);
|
|
443
|
+
if (previousBytes?.equals(Buffer.from(raw))) return "applied";
|
|
444
|
+
let recoveryPath;
|
|
445
|
+
if (previousBytes !== void 0) {
|
|
446
|
+
recoveryPath = (options.archive ?? archiveConfigDocument)(options.settingsPath, previousBytes).path;
|
|
447
|
+
}
|
|
448
|
+
try {
|
|
449
|
+
assertConfigDocumentUnchanged(options.settingsPath, expected.disk);
|
|
450
|
+
if (!commitOwnerCurrent(options, owner, expected)) return "cancel";
|
|
451
|
+
checkCandidate?.();
|
|
452
|
+
} catch (error) {
|
|
453
|
+
throw new Error(`${message(error)}.${recoveryNote(recoveryPath)}`);
|
|
454
|
+
}
|
|
455
|
+
let saved;
|
|
456
|
+
try {
|
|
457
|
+
saved = options.save ? options.save(options.settingsPath, raw) : atomicSaveConfigDocument(options.settingsPath, raw, {}, expected.disk);
|
|
458
|
+
} catch (error) {
|
|
459
|
+
if (error instanceof ConfigPublicationError) {
|
|
460
|
+
const rollback = restorePrevious(ctx, options, owner, expected, raw, error.fileIdentity, false);
|
|
461
|
+
throw new Error(`Footer settings were not saved: ${message(error)}. ${rollback}${recoveryNote(recoveryPath)}`);
|
|
462
|
+
}
|
|
463
|
+
throw new Error(
|
|
464
|
+
`Footer settings were not saved: ${message(error)}. The previous footer remains active.${recoveryNote(recoveryPath)}`
|
|
465
|
+
);
|
|
466
|
+
}
|
|
467
|
+
try {
|
|
468
|
+
if (owner.signal.aborted || !(owner.isSessionCurrent?.() ?? owner.isCurrent()) || options.getLoadedRevision?.() !== expected.revision) {
|
|
469
|
+
throw new Error("The configuration owner changed during publication");
|
|
470
|
+
}
|
|
471
|
+
options.apply(saved, ctx);
|
|
472
|
+
} catch (error) {
|
|
473
|
+
const rollback = restorePrevious(ctx, options, owner, expected, raw, saved.fileIdentity, true);
|
|
474
|
+
throw new Error(
|
|
475
|
+
`Footer settings could not be applied: ${message(error)}. ${rollback}${recoveryNote(recoveryPath)}`
|
|
476
|
+
);
|
|
477
|
+
}
|
|
478
|
+
return "applied";
|
|
479
|
+
});
|
|
480
|
+
}
|
|
481
|
+
function restorePrevious(ctx, options, owner, expected, raw, identity2, restoreRuntime) {
|
|
482
|
+
try {
|
|
483
|
+
if (owner.signal.aborted || !(owner.isSessionCurrent?.() ?? owner.isCurrent()))
|
|
484
|
+
throw new Error("The session owner changed; stale restoration was blocked");
|
|
485
|
+
const current3 = options.getLoaded();
|
|
486
|
+
if (current3.rawDocument !== expected.previous.rawDocument && current3.rawDocument !== raw) {
|
|
487
|
+
throw new Error("The active runtime changed; stale restoration was blocked");
|
|
488
|
+
}
|
|
489
|
+
if (!identity2) throw new Error("The saved settings document identity is unavailable");
|
|
490
|
+
assertConfigDocumentUnchanged(options.settingsPath, { rawBytes: Buffer.from(raw), fileIdentity: identity2 });
|
|
491
|
+
if (expected.disk.rawBytes === void 0) {
|
|
492
|
+
removeConfigDocumentIfMatches(options.settingsPath, raw, identity2);
|
|
493
|
+
} else if (options.restore && expected.disk.rawBytes.equals(Buffer.from(expected.previous.rawDocument ?? ""))) {
|
|
494
|
+
options.restore(options.settingsPath, expected.previous.rawDocument ?? "");
|
|
495
|
+
} else {
|
|
496
|
+
atomicRestoreConfigDocument(
|
|
497
|
+
options.settingsPath,
|
|
498
|
+
expected.disk.rawBytes,
|
|
499
|
+
{},
|
|
500
|
+
{ rawBytes: Buffer.from(raw), fileIdentity: identity2 }
|
|
501
|
+
);
|
|
502
|
+
}
|
|
503
|
+
if (restoreRuntime) options.apply(expected.previous, ctx);
|
|
504
|
+
return "The previous configuration was restored.";
|
|
505
|
+
} catch (error) {
|
|
506
|
+
return `Restoring the previous configuration also failed: ${message(error)}. Active path: ${options.settingsPath}.`;
|
|
507
|
+
}
|
|
508
|
+
}
|
|
509
|
+
function recoveryNote(path) {
|
|
510
|
+
return path ? ` Recovery copy retained: ${path}.` : "";
|
|
511
|
+
}
|
|
512
|
+
function message(error) {
|
|
513
|
+
return error instanceof Error ? error.message : String(error);
|
|
514
|
+
}
|
|
18
515
|
|
|
19
516
|
// src/command-configuration.ts
|
|
517
|
+
import { withFileMutationQueue as withFileMutationQueue2 } from "@earendil-works/pi-coding-agent";
|
|
20
518
|
import { sanitizeTerminalText } from "@narumitw/pi-tui-kit/terminal-text";
|
|
21
519
|
|
|
22
520
|
// src/command-preview.ts
|
|
@@ -1083,6 +1581,12 @@ function configurationMenuScreen(loaded) {
|
|
|
1083
1581
|
label: "Import settings from Gist\u2026",
|
|
1084
1582
|
description: "Review and preview remote TOML before replacing settings \xB7 requires gh",
|
|
1085
1583
|
action: "gist-import"
|
|
1584
|
+
},
|
|
1585
|
+
{
|
|
1586
|
+
id: "history",
|
|
1587
|
+
label: "History",
|
|
1588
|
+
description: "Review and restore recovery copies; legacy skill backups are read-only",
|
|
1589
|
+
action: "history"
|
|
1086
1590
|
}
|
|
1087
1591
|
],
|
|
1088
1592
|
hint: "back"
|
|
@@ -1147,6 +1651,13 @@ async function reloadConfiguration(ctx, options, owner) {
|
|
|
1147
1651
|
const previous = options.getLoaded();
|
|
1148
1652
|
const revision = options.getLoadedRevision?.();
|
|
1149
1653
|
const candidate = readReloadCandidate(options);
|
|
1654
|
+
let disk;
|
|
1655
|
+
try {
|
|
1656
|
+
disk = readConfigDocumentSnapshot(options.settingsPath);
|
|
1657
|
+
} catch (error) {
|
|
1658
|
+
ctx.ui.notify(`Footer reload was blocked: ${safeError(error)}`, "error");
|
|
1659
|
+
return "stay";
|
|
1660
|
+
}
|
|
1150
1661
|
if (!candidate.ok) {
|
|
1151
1662
|
ctx.ui.notify(`Footer reload was blocked: ${safeError(candidate.error)}`, "error");
|
|
1152
1663
|
return "stay";
|
|
@@ -1171,42 +1682,58 @@ async function reloadConfiguration(ctx, options, owner) {
|
|
|
1171
1682
|
if (selectedReloadAction(selection) !== RELOAD_ACTIONS.apply) return "stay";
|
|
1172
1683
|
const confirmed = await ctx.ui.confirm(
|
|
1173
1684
|
"Apply configuration from disk?",
|
|
1174
|
-
candidate.loaded.rawDocument === void 0 ? "Use built-in defaults for this session? No settings file will be created." : "Apply the validated settings document to this session without changing its bytes?"
|
|
1685
|
+
candidate.loaded.rawDocument === void 0 ? "Use built-in defaults for this session? No settings file will be created." : "Apply the validated settings document to this session without changing its bytes? The previous loaded document will be kept in History.",
|
|
1686
|
+
{ signal: owner.signal }
|
|
1175
1687
|
);
|
|
1176
1688
|
if (!isCurrentOwner(owner) || activeRevisionChanged(options, revision) || !confirmed) {
|
|
1177
1689
|
return "stay";
|
|
1178
1690
|
}
|
|
1179
|
-
|
|
1180
|
-
if (!fresh.ok) {
|
|
1181
|
-
ctx.ui.notify(
|
|
1182
|
-
`Footer reload was blocked after confirmation: ${safeError(fresh.error)}. The previous footer remains active.`,
|
|
1183
|
-
"error"
|
|
1184
|
-
);
|
|
1185
|
-
return "stay";
|
|
1186
|
-
}
|
|
1187
|
-
if (!sameLoadedDocument(candidate.loaded, fresh.loaded)) {
|
|
1188
|
-
ctx.ui.notify(
|
|
1189
|
-
"The settings document changed after preview. The previous footer remains active; reload again to review the latest version.",
|
|
1190
|
-
"warning"
|
|
1191
|
-
);
|
|
1192
|
-
return "stay";
|
|
1193
|
-
}
|
|
1691
|
+
let warnings = 0;
|
|
1194
1692
|
try {
|
|
1195
|
-
options.
|
|
1693
|
+
const applied = await withFileMutationQueue2(options.settingsPath, async () => {
|
|
1694
|
+
if (!isCurrentOwner(owner) || activeRevisionChanged(options, revision) || !sameLoadedDocument(previous, options.getLoaded()))
|
|
1695
|
+
return false;
|
|
1696
|
+
assertConfigDocumentUnchanged(options.settingsPath, disk);
|
|
1697
|
+
const fresh = readReloadCandidate(options);
|
|
1698
|
+
if (!fresh.ok) throw new Error(fresh.error);
|
|
1699
|
+
if (!sameLoadedDocument(candidate.loaded, fresh.loaded)) {
|
|
1700
|
+
throw new Error(
|
|
1701
|
+
"The settings document changed after preview. The previous footer remains active; reload again to review the latest version."
|
|
1702
|
+
);
|
|
1703
|
+
}
|
|
1704
|
+
let recoveryPath;
|
|
1705
|
+
const previousBytes = previous.rawBytes ?? previous.rawDocument;
|
|
1706
|
+
if (previousBytes !== void 0) {
|
|
1707
|
+
recoveryPath = (options.archive ?? archiveConfigDocument)(options.settingsPath, previousBytes).path;
|
|
1708
|
+
}
|
|
1709
|
+
assertConfigDocumentUnchanged(options.settingsPath, disk);
|
|
1710
|
+
if (!isCurrentOwner(owner) || activeRevisionChanged(options, revision)) return false;
|
|
1711
|
+
try {
|
|
1712
|
+
options.apply(fresh.loaded, ctx);
|
|
1713
|
+
} catch (error) {
|
|
1714
|
+
let rollbackError;
|
|
1715
|
+
try {
|
|
1716
|
+
if (!isCurrentOwner(owner)) throw new Error("The session owner changed; stale restoration was blocked");
|
|
1717
|
+
const current3 = options.getLoaded();
|
|
1718
|
+
if (!sameLoadedDocument(current3, previous) && !sameLoadedDocument(current3, fresh.loaded))
|
|
1719
|
+
throw new Error("The active runtime changed; stale restoration was blocked");
|
|
1720
|
+
options.apply(previous, ctx);
|
|
1721
|
+
} catch (rollback) {
|
|
1722
|
+
rollbackError = rollback;
|
|
1723
|
+
}
|
|
1724
|
+
throw new Error(
|
|
1725
|
+
`Footer reload failed: ${formatError(error)}. ${rollbackError ? `Restoring the previous configuration also failed: ${formatError(rollbackError)}.` : "The previous configuration was restored."}${recoveryPath ? ` Recovery copy retained: ${recoveryPath}.` : ""}`
|
|
1726
|
+
);
|
|
1727
|
+
}
|
|
1728
|
+
warnings = fresh.loaded.diagnostics.length;
|
|
1729
|
+
return true;
|
|
1730
|
+
});
|
|
1731
|
+
if (!isCurrentOwner(owner) || !applied) return "stay";
|
|
1196
1732
|
} catch (error) {
|
|
1197
|
-
|
|
1198
|
-
|
|
1199
|
-
options.apply(previous, ctx);
|
|
1200
|
-
} catch (rollback) {
|
|
1201
|
-
rollbackError = rollback;
|
|
1202
|
-
}
|
|
1203
|
-
ctx.ui.notify(
|
|
1204
|
-
rollbackError ? `Footer reload failed: ${safeError(error)}. Restoring the previous configuration also failed: ${safeError(rollbackError)}.` : `Footer reload failed: ${safeError(error)}. The previous configuration was restored.`,
|
|
1205
|
-
"error"
|
|
1206
|
-
);
|
|
1733
|
+
if (isCurrentOwner(owner))
|
|
1734
|
+
ctx.ui.notify(`Footer reload was blocked after confirmation: ${safeError(error)}`, "error");
|
|
1207
1735
|
return "stay";
|
|
1208
1736
|
}
|
|
1209
|
-
const warnings = fresh.loaded.diagnostics.length;
|
|
1210
1737
|
ctx.ui.notify(
|
|
1211
1738
|
warnings === 0 ? "Footer configuration reloaded and applied." : `Footer configuration reloaded and applied with ${warnings} warning${warnings === 1 ? "" : "s"}.`,
|
|
1212
1739
|
"info"
|
|
@@ -1344,7 +1871,7 @@ function isRecord(value) {
|
|
|
1344
1871
|
}
|
|
1345
1872
|
var executeGhApi = (args, input, signal) => {
|
|
1346
1873
|
signal.throwIfAborted();
|
|
1347
|
-
return new Promise((
|
|
1874
|
+
return new Promise((resolve2, reject) => {
|
|
1348
1875
|
const child = spawn(process.platform === "win32" ? "gh.exe" : "gh", ["api", "--hostname", "github.com", ...args], {
|
|
1349
1876
|
env: { ...process.env, GH_PROMPT_DISABLED: "1", GH_PAGER: "", GH_DEBUG: "" },
|
|
1350
1877
|
stdio: ["pipe", "pipe", "ignore"],
|
|
@@ -1385,7 +1912,7 @@ var executeGhApi = (args, input, signal) => {
|
|
|
1385
1912
|
"Gist request failed. Check gh auth status, Gist access, and connectivity. An upload may already exist."
|
|
1386
1913
|
)
|
|
1387
1914
|
);
|
|
1388
|
-
else
|
|
1915
|
+
else resolve2(Buffer.concat(chunks).toString("utf8"));
|
|
1389
1916
|
});
|
|
1390
1917
|
if (signal.aborted) onAbort();
|
|
1391
1918
|
child.stdin.end(input);
|
|
@@ -1452,8 +1979,10 @@ async function importSettingsGist(ctx, options, owner, reviewImport, api) {
|
|
|
1452
1979
|
const previous = options.getLoaded();
|
|
1453
1980
|
const revision = options.getLoadedRevision?.();
|
|
1454
1981
|
const disk = diskSnapshot(options);
|
|
1982
|
+
const initialDisk = readConfigDocumentSnapshot(options.settingsPath);
|
|
1455
1983
|
const guardedOwner = {
|
|
1456
1984
|
signal: owner.signal,
|
|
1985
|
+
isSessionCurrent: () => owner.isSessionCurrent?.() ?? owner.isCurrent(),
|
|
1457
1986
|
isCurrent: () => current(owner) && options.getLoadedRevision?.() === revision && options.getLoaded().rawDocument === previous.rawDocument && options.getLoaded().source === previous.source
|
|
1458
1987
|
};
|
|
1459
1988
|
const value = await ctx.ui.input("Import pi-starship settings from Gist", "https://gist.github.com/<owner>/<id>", {
|
|
@@ -1494,7 +2023,7 @@ async function importSettingsGist(ctx, options, owner, reviewImport, api) {
|
|
|
1494
2023
|
[
|
|
1495
2024
|
`Source: https://gist.github.com/${id}`,
|
|
1496
2025
|
"Untrusted settings can enable local commands and network requests. Review the complete TOML before applying.",
|
|
1497
|
-
"Import replaces the entire local document, including comments and unknown fields;
|
|
2026
|
+
"Import replaces the entire local document, including comments and unknown fields; its previous bytes will be kept in History."
|
|
1498
2027
|
],
|
|
1499
2028
|
"Preview imported footer\u2026"
|
|
1500
2029
|
);
|
|
@@ -1508,7 +2037,7 @@ async function importSettingsGist(ctx, options, owner, reviewImport, api) {
|
|
|
1508
2037
|
if (!current(guardedOwner) || diskSnapshot(options) !== disk) {
|
|
1509
2038
|
throw new Error("Settings changed during import. Start a new import to review the latest state.");
|
|
1510
2039
|
}
|
|
1511
|
-
return
|
|
2040
|
+
return options.save ? options.save(path, raw) : atomicSaveConfigDocument(path, raw, {}, initialDisk);
|
|
1512
2041
|
}
|
|
1513
2042
|
},
|
|
1514
2043
|
guardedOwner
|
|
@@ -1543,7 +2072,12 @@ async function reviewDocument(ctx, owner, title, content, lines, label) {
|
|
|
1543
2072
|
}
|
|
1544
2073
|
function diskSnapshot(options) {
|
|
1545
2074
|
const loaded = (options.read ?? loadStarshipConfig)(options.settingsPath);
|
|
1546
|
-
return JSON.stringify([
|
|
2075
|
+
return JSON.stringify([
|
|
2076
|
+
loaded.rawDocument,
|
|
2077
|
+
loaded.source,
|
|
2078
|
+
loaded.diagnostics,
|
|
2079
|
+
readConfigDocumentSnapshot(options.settingsPath)
|
|
2080
|
+
]);
|
|
1547
2081
|
}
|
|
1548
2082
|
function current(owner) {
|
|
1549
2083
|
return !owner.signal.aborted && owner.isCurrent();
|
|
@@ -1593,9 +2127,9 @@ function safeDisplayText2(value) {
|
|
|
1593
2127
|
// src/command-preset-picker.ts
|
|
1594
2128
|
import { runLiveChoice } from "@narumitw/pi-tui-kit";
|
|
1595
2129
|
async function showPresetPicker(ctx, options) {
|
|
1596
|
-
const
|
|
2130
|
+
const current3 = options.presets.find((preset) => preset.id === options.activePresetId)?.label ?? "Custom configuration";
|
|
1597
2131
|
const result = await runLiveChoice(ctx, {
|
|
1598
|
-
title: `Presets \xB7 current: ${
|
|
2132
|
+
title: `Presets \xB7 current: ${current3}`,
|
|
1599
2133
|
items: options.presets.map((preset) => ({
|
|
1600
2134
|
id: preset.id,
|
|
1601
2135
|
label: preset.label,
|
|
@@ -1610,7 +2144,10 @@ async function showPresetPicker(ctx, options) {
|
|
|
1610
2144
|
hint: "back",
|
|
1611
2145
|
navigationLabel: "live preview",
|
|
1612
2146
|
confirmLabel: "apply",
|
|
1613
|
-
shortcuts: [
|
|
2147
|
+
shortcuts: [
|
|
2148
|
+
{ id: "customize", keys: ["e", "shift+e"], label: "customize" },
|
|
2149
|
+
{ id: "save-profile", keys: ["s", "shift+s"], label: "save as profile" }
|
|
2150
|
+
],
|
|
1614
2151
|
onSelectionChange: ({ item }) => {
|
|
1615
2152
|
const preset = options.presets.find((candidate) => candidate.id === item.id);
|
|
1616
2153
|
if (preset) options.preview(preset);
|
|
@@ -1620,12 +2157,520 @@ async function showPresetPicker(ctx, options) {
|
|
|
1620
2157
|
});
|
|
1621
2158
|
if (result.kind === "selected") return { kind: "apply", presetId: result.itemId };
|
|
1622
2159
|
if (result.kind === "shortcut") {
|
|
1623
|
-
return { kind: "customize", presetId: result.itemId };
|
|
2160
|
+
return { kind: result.shortcutId === "save-profile" ? "save-profile" : "customize", presetId: result.itemId };
|
|
1624
2161
|
}
|
|
1625
2162
|
if (result.kind === "closed" && result.reason === "back") return { kind: "back" };
|
|
1626
2163
|
return { kind: "close" };
|
|
1627
2164
|
}
|
|
1628
2165
|
|
|
2166
|
+
// src/command-profiles.ts
|
|
2167
|
+
import { isKeyRelease, Key as Key2, matchesKey as matchesKey2 } from "@earendil-works/pi-tui";
|
|
2168
|
+
import { defineMenu as defineMenu2, runLiveChoice as runLiveChoice2, runMenu as runMenu2 } from "@narumitw/pi-tui-kit";
|
|
2169
|
+
import { sanitizeTerminalText as sanitizeTerminalText3 } from "@narumitw/pi-tui-kit/terminal-text";
|
|
2170
|
+
var PREVIEW_NOTICE = "Preview uses the current runtime snapshot only; unavailable module data can be empty.";
|
|
2171
|
+
var SAVE_CURRENT = "save-current";
|
|
2172
|
+
var FlowEnded = class extends Error {
|
|
2173
|
+
};
|
|
2174
|
+
async function showProfiles(ctx, options, owner, applyCandidate) {
|
|
2175
|
+
return browseDocuments(ctx, options, owner, applyCandidate, "profile");
|
|
2176
|
+
}
|
|
2177
|
+
async function showHistory(ctx, options, owner, applyCandidate) {
|
|
2178
|
+
return browseDocuments(ctx, options, owner, applyCandidate, "history");
|
|
2179
|
+
}
|
|
2180
|
+
async function saveAsProfile(ctx, options, owner, raw) {
|
|
2181
|
+
if (!interactive(ctx) || !current2(owner)) return void 0;
|
|
2182
|
+
const flow = createFlow(ctx, options, owner);
|
|
2183
|
+
try {
|
|
2184
|
+
candidateFor(options, raw, true);
|
|
2185
|
+
const saved = await saveNamedCopy(ctx, options, flow, raw);
|
|
2186
|
+
flow.ensure();
|
|
2187
|
+
return saved;
|
|
2188
|
+
} catch (error) {
|
|
2189
|
+
if (flow.signal.aborted || !flow.sessionCurrent()) return "close";
|
|
2190
|
+
report(ctx, flow, error);
|
|
2191
|
+
return void 0;
|
|
2192
|
+
} finally {
|
|
2193
|
+
flow.dispose();
|
|
2194
|
+
}
|
|
2195
|
+
}
|
|
2196
|
+
async function browseDocuments(ctx, options, owner, applyCandidate, kind) {
|
|
2197
|
+
if (!interactive(ctx) || !current2(owner)) return "close";
|
|
2198
|
+
const flow = createFlow(ctx, options, owner);
|
|
2199
|
+
let selectedId;
|
|
2200
|
+
try {
|
|
2201
|
+
while (flow.current()) {
|
|
2202
|
+
let interacted = false;
|
|
2203
|
+
try {
|
|
2204
|
+
const documents = kind === "profile" ? listProfiles(options.settingsPath) : listHistory(options.settingsPath);
|
|
2205
|
+
const active = options.getLoaded();
|
|
2206
|
+
const matches = documents.filter(
|
|
2207
|
+
(document2) => document2.rawDocument !== void 0 && document2.rawDocument === active.rawDocument
|
|
2208
|
+
);
|
|
2209
|
+
const candidates = new Map(
|
|
2210
|
+
documents.map((document2) => [documentId(document2), candidateFor(options, document2.rawDocument)])
|
|
2211
|
+
);
|
|
2212
|
+
const selection = await runLiveChoice2(ctx, {
|
|
2213
|
+
title: kind === "profile" ? "Profiles" : "History",
|
|
2214
|
+
lines: [
|
|
2215
|
+
active.rawDocument === void 0 && active.diagnostics.length === 0 ? "Active: Built-in defaults" : active.diagnostics.some((item) => item.severity === "error") ? "Active: Invalid settings document \xB7 replacement requires explicit recovery" : "Active: Independent settings document",
|
|
2216
|
+
...kind === "profile" && matches.length === 0 ? ["Current settings are not saved as a profile"] : [],
|
|
2217
|
+
PREVIEW_NOTICE
|
|
2218
|
+
],
|
|
2219
|
+
items: [
|
|
2220
|
+
...kind === "profile" ? [
|
|
2221
|
+
{
|
|
2222
|
+
id: SAVE_CURRENT,
|
|
2223
|
+
label: "Save current as\u2026",
|
|
2224
|
+
description: "Copy exact loaded TOML; keep active settings unchanged"
|
|
2225
|
+
}
|
|
2226
|
+
] : [],
|
|
2227
|
+
...documents.map((document2) => ({
|
|
2228
|
+
id: documentId(document2),
|
|
2229
|
+
label: safe(document2.name),
|
|
2230
|
+
description: [
|
|
2231
|
+
...document2.kind === "history" ? [safe(document2.createdAt), ...document2.legacy ? ["Legacy \xB7 read-only"] : []] : [],
|
|
2232
|
+
...document2.rawDocument !== void 0 && document2.rawDocument === active.rawDocument ? ["Matches active settings"] : [],
|
|
2233
|
+
...!candidates.get(documentId(document2))?.loaded ? ["Invalid document \xB7 review or repair"] : []
|
|
2234
|
+
].join(" \xB7 "),
|
|
2235
|
+
details: [
|
|
2236
|
+
`Selected: ${safe(document2.name)}`,
|
|
2237
|
+
`Path: ${safe(document2.path)}`,
|
|
2238
|
+
...candidates.get(documentId(document2))?.lines ?? []
|
|
2239
|
+
]
|
|
2240
|
+
}))
|
|
2241
|
+
],
|
|
2242
|
+
initialItemId: selectedId,
|
|
2243
|
+
enableSearch: true,
|
|
2244
|
+
viewportSize: 10,
|
|
2245
|
+
hint: "back",
|
|
2246
|
+
confirmLabel: "actions",
|
|
2247
|
+
navigationLabel: "live preview",
|
|
2248
|
+
signal: flow.signal,
|
|
2249
|
+
isCurrent: flow.current,
|
|
2250
|
+
onSelectionChange: ({ item, signal }) => {
|
|
2251
|
+
if (signal.aborted || !flow.current()) return;
|
|
2252
|
+
selectedId = item.id;
|
|
2253
|
+
flow.preview(candidates.get(item.id)?.loaded);
|
|
2254
|
+
}
|
|
2255
|
+
});
|
|
2256
|
+
flow.ensure();
|
|
2257
|
+
interacted = true;
|
|
2258
|
+
if (selection.kind !== "selected") {
|
|
2259
|
+
return selection.kind === "closed" && selection.reason === "back" ? "back" : "close";
|
|
2260
|
+
}
|
|
2261
|
+
selectedId = selection.itemId;
|
|
2262
|
+
if (selectedId === SAVE_CURRENT) {
|
|
2263
|
+
flow.preview(void 0);
|
|
2264
|
+
const loaded = options.getLoaded();
|
|
2265
|
+
if (loaded.diagnostics.some((item) => item.severity === "error")) {
|
|
2266
|
+
throw new Error(
|
|
2267
|
+
"Cannot save unreadable or malformed active settings as a profile. Repair the settings document first."
|
|
2268
|
+
);
|
|
2269
|
+
}
|
|
2270
|
+
const raw = loaded.rawDocument ?? BUILT_IN_EXAMPLE;
|
|
2271
|
+
candidateFor(options, raw, true);
|
|
2272
|
+
const saved = await saveNamedCopy(ctx, options, flow, raw);
|
|
2273
|
+
flow.ensure();
|
|
2274
|
+
if (saved) selectedId = documentId(saved);
|
|
2275
|
+
continue;
|
|
2276
|
+
}
|
|
2277
|
+
const document = documents.find((item) => documentId(item) === selectedId);
|
|
2278
|
+
if (!document) continue;
|
|
2279
|
+
flow.ensure(document);
|
|
2280
|
+
const outcome = await documentActions(ctx, options, flow, document, applyCandidate);
|
|
2281
|
+
flow.ensure();
|
|
2282
|
+
if (outcome === "close") return "close";
|
|
2283
|
+
if (outcome) selectedId = documentId(outcome);
|
|
2284
|
+
} catch (error) {
|
|
2285
|
+
if (error instanceof FlowEnded || !flow.current()) return "close";
|
|
2286
|
+
flow.preview(void 0);
|
|
2287
|
+
report(ctx, flow, error);
|
|
2288
|
+
if (!interacted) return "close";
|
|
2289
|
+
}
|
|
2290
|
+
}
|
|
2291
|
+
return "close";
|
|
2292
|
+
} finally {
|
|
2293
|
+
flow.dispose();
|
|
2294
|
+
}
|
|
2295
|
+
}
|
|
2296
|
+
async function documentActions(ctx, options, flow, document, applyCandidate) {
|
|
2297
|
+
const candidate = candidateFor(options, document.rawDocument);
|
|
2298
|
+
const profile = document.kind === "profile";
|
|
2299
|
+
const activeInvalid = profile && options.getLoaded().diagnostics.some((item) => item.severity === "error");
|
|
2300
|
+
const action = await actionScreen(ctx, flow, {
|
|
2301
|
+
title: `${profile ? "Profile" : "Recovery copy"}: ${safe(document.name)}`,
|
|
2302
|
+
lines: [
|
|
2303
|
+
`Path: ${safe(document.path)}`,
|
|
2304
|
+
...document.kind === "history" ? [`Recovery time: ${safe(document.createdAt)}`, "A recovery copy is not proof that an application succeeded."] : [],
|
|
2305
|
+
...document.kind === "history" && document.legacy ? ["Legacy backup \xB7 read-only; restore copies bytes without changing this backup."] : [],
|
|
2306
|
+
...document.readError ? [safe(document.readError)] : [],
|
|
2307
|
+
...candidate.lines,
|
|
2308
|
+
PREVIEW_NOTICE
|
|
2309
|
+
],
|
|
2310
|
+
raw: document.rawDocument,
|
|
2311
|
+
actions: [
|
|
2312
|
+
{
|
|
2313
|
+
id: "apply",
|
|
2314
|
+
label: profile ? "Apply\u2026" : "Restore\u2026",
|
|
2315
|
+
disabled: !candidate.loaded || activeInvalid,
|
|
2316
|
+
disabledReason: activeInvalid ? "Repair active settings or use explicit recovery first" : "Invalid TOML cannot be applied"
|
|
2317
|
+
},
|
|
2318
|
+
...profile ? [
|
|
2319
|
+
{ id: "edit", label: "Edit TOML\u2026" },
|
|
2320
|
+
{ id: "rename", label: "Rename\u2026" },
|
|
2321
|
+
{ id: "duplicate", label: "Duplicate\u2026" }
|
|
2322
|
+
] : [
|
|
2323
|
+
{
|
|
2324
|
+
id: "save-as",
|
|
2325
|
+
label: "Save as a profile\u2026",
|
|
2326
|
+
disabled: !candidate.loaded,
|
|
2327
|
+
disabledReason: "Invalid TOML cannot be saved as a validated profile"
|
|
2328
|
+
}
|
|
2329
|
+
],
|
|
2330
|
+
{
|
|
2331
|
+
id: "delete",
|
|
2332
|
+
label: "Delete\u2026",
|
|
2333
|
+
disabled: document.kind === "history" && document.legacy,
|
|
2334
|
+
disabledReason: "Legacy backups are read-only"
|
|
2335
|
+
}
|
|
2336
|
+
]
|
|
2337
|
+
});
|
|
2338
|
+
flow.ensure(document);
|
|
2339
|
+
if (action === "close") return "close";
|
|
2340
|
+
if (action === "back") return void 0;
|
|
2341
|
+
if (action === "apply" && candidate.loaded) {
|
|
2342
|
+
const result = await applyReviewedCandidate(flow, candidate.loaded, applyCandidate, document);
|
|
2343
|
+
flow.ensure(document);
|
|
2344
|
+
return result === "close" ? "close" : document;
|
|
2345
|
+
}
|
|
2346
|
+
if (action === "edit" && profile) {
|
|
2347
|
+
const result = await editProfile(ctx, options, flow, document, applyCandidate);
|
|
2348
|
+
flow.ensure();
|
|
2349
|
+
return result;
|
|
2350
|
+
}
|
|
2351
|
+
if (action === "rename" && profile) {
|
|
2352
|
+
const name = await flow.dialog(
|
|
2353
|
+
() => ctx.ui.input(`Rename profile: ${safe(document.name)}`, "New profile name", { signal: flow.signal })
|
|
2354
|
+
);
|
|
2355
|
+
flow.ensure(document);
|
|
2356
|
+
if (name === void 0) return document;
|
|
2357
|
+
return renameProfile(options.settingsPath, document.name, name, document);
|
|
2358
|
+
}
|
|
2359
|
+
if (action === "duplicate" || action === "save-as" && document.rawDocument !== void 0) {
|
|
2360
|
+
const saved = await saveNamedCopy(ctx, options, flow, document.rawDocument, document);
|
|
2361
|
+
flow.ensure(document);
|
|
2362
|
+
return action === "duplicate" || document.kind === "history" ? document : saved ?? document;
|
|
2363
|
+
}
|
|
2364
|
+
if (action === "delete" && !(document.kind === "history" && document.legacy)) {
|
|
2365
|
+
const confirmed = await flow.dialog(
|
|
2366
|
+
() => ctx.ui.confirm(
|
|
2367
|
+
`Delete ${profile ? "profile" : "recovery copy"}: ${safe(document.name)}?`,
|
|
2368
|
+
`Path: ${safe(document.path)}
|
|
2369
|
+
${profile ? "This deletes only the saved profile. The active settings copy remains unchanged." : "This permanently deletes only this recovery copy. Active settings remain unchanged."}`,
|
|
2370
|
+
{ signal: flow.signal }
|
|
2371
|
+
)
|
|
2372
|
+
);
|
|
2373
|
+
flow.ensure(document);
|
|
2374
|
+
if (confirmed) {
|
|
2375
|
+
if (document.kind === "profile") deleteProfile(options.settingsPath, document.name, document);
|
|
2376
|
+
else deleteHistory(options.settingsPath, document.name, document);
|
|
2377
|
+
}
|
|
2378
|
+
}
|
|
2379
|
+
return void 0;
|
|
2380
|
+
}
|
|
2381
|
+
async function editProfile(ctx, options, flow, original, applyCandidate) {
|
|
2382
|
+
let draft = original.rawDocument ?? "";
|
|
2383
|
+
if (original.rawDocument === void 0) {
|
|
2384
|
+
const repair = await flow.dialog(
|
|
2385
|
+
() => ctx.ui.confirm(
|
|
2386
|
+
`Repair invalid UTF-8 profile: ${safe(original.name)}?`,
|
|
2387
|
+
`Path: ${safe(original.path)}
|
|
2388
|
+
The original bytes cannot be edited as TOML text. Open an empty repair draft? Saving replaces these invalid bytes; the saved copy stays unchanged until you select Save profile. Duplicate it first to keep the original bytes.`,
|
|
2389
|
+
{ signal: flow.signal }
|
|
2390
|
+
)
|
|
2391
|
+
);
|
|
2392
|
+
flow.ensure(original);
|
|
2393
|
+
if (!repair) return original;
|
|
2394
|
+
}
|
|
2395
|
+
while (flow.current()) {
|
|
2396
|
+
const edited = await flow.dialog(() => ctx.ui.editor(`Edit profile: ${safe(original.name)}`, draft));
|
|
2397
|
+
flow.ensure(original);
|
|
2398
|
+
if (edited === void 0) return original;
|
|
2399
|
+
draft = edited;
|
|
2400
|
+
const candidate = candidateFor(options, draft);
|
|
2401
|
+
flow.preview(candidate.loaded);
|
|
2402
|
+
const action = await actionScreen(ctx, flow, {
|
|
2403
|
+
title: candidate.loaded ? "Profile draft preview" : "Profile draft needs attention",
|
|
2404
|
+
lines: [
|
|
2405
|
+
"Save profile changes only the saved copy, even when it matches active settings.",
|
|
2406
|
+
...candidate.lines,
|
|
2407
|
+
PREVIEW_NOTICE
|
|
2408
|
+
],
|
|
2409
|
+
raw: draft,
|
|
2410
|
+
actions: [
|
|
2411
|
+
{
|
|
2412
|
+
id: "save",
|
|
2413
|
+
label: "Save profile",
|
|
2414
|
+
disabled: !candidate.loaded,
|
|
2415
|
+
disabledReason: "Repair the draft before saving"
|
|
2416
|
+
},
|
|
2417
|
+
{
|
|
2418
|
+
id: "save-apply",
|
|
2419
|
+
label: "Save profile and apply\u2026",
|
|
2420
|
+
description: "Two operations: a failed apply retains the saved profile",
|
|
2421
|
+
disabled: !candidate.loaded,
|
|
2422
|
+
disabledReason: "Repair the draft before saving"
|
|
2423
|
+
},
|
|
2424
|
+
{ id: "continue", label: "Continue editing" },
|
|
2425
|
+
{ id: "discard", label: "Discard draft" }
|
|
2426
|
+
]
|
|
2427
|
+
});
|
|
2428
|
+
flow.ensure(original);
|
|
2429
|
+
if (action === "close") return "close";
|
|
2430
|
+
if (action === "discard") return original;
|
|
2431
|
+
if (action === "continue" || action === "back") continue;
|
|
2432
|
+
if (!candidate.loaded || action !== "save" && action !== "save-apply") continue;
|
|
2433
|
+
const saved = saveProfile(options.settingsPath, original.name, draft, original);
|
|
2434
|
+
ctx.ui.notify(`Profile saved: ${safe(saved.name)}. Active settings are unchanged.`, "info");
|
|
2435
|
+
if (action === "save-apply") {
|
|
2436
|
+
try {
|
|
2437
|
+
const result = await applyReviewedCandidate(flow, candidate.loaded, applyCandidate, saved);
|
|
2438
|
+
flow.ensure(saved);
|
|
2439
|
+
if (result === "close") return "close";
|
|
2440
|
+
if (result !== "applied")
|
|
2441
|
+
ctx.ui.notify(
|
|
2442
|
+
"The profile was saved. Application did not complete; review the configuration result before retrying.",
|
|
2443
|
+
"warning"
|
|
2444
|
+
);
|
|
2445
|
+
} catch (error) {
|
|
2446
|
+
if (!flow.current()) throw error;
|
|
2447
|
+
ctx.ui.notify(
|
|
2448
|
+
`The saved profile was retained, but application did not complete: ${safeError3(error)}. Review active settings before retrying.`,
|
|
2449
|
+
"error"
|
|
2450
|
+
);
|
|
2451
|
+
}
|
|
2452
|
+
}
|
|
2453
|
+
return saved;
|
|
2454
|
+
}
|
|
2455
|
+
throw new FlowEnded();
|
|
2456
|
+
}
|
|
2457
|
+
async function applyReviewedCandidate(flow, loaded, applyCandidate, document) {
|
|
2458
|
+
flow.ensure(document);
|
|
2459
|
+
const result = await applyCandidate(
|
|
2460
|
+
loaded,
|
|
2461
|
+
{
|
|
2462
|
+
signal: flow.signal,
|
|
2463
|
+
// The shared commit policy captures the active revision before applying.
|
|
2464
|
+
// A successful apply changes it; session ownership must remain valid after it.
|
|
2465
|
+
isCurrent: () => !flow.signal.aborted && flow.sessionCurrent(),
|
|
2466
|
+
isSessionCurrent: flow.sessionCurrent
|
|
2467
|
+
},
|
|
2468
|
+
() => flow.ensure(document),
|
|
2469
|
+
document.name
|
|
2470
|
+
);
|
|
2471
|
+
if (result === "applied") flow.adoptAppliedRevision();
|
|
2472
|
+
flow.ensure(document);
|
|
2473
|
+
flow.preview(void 0);
|
|
2474
|
+
return result;
|
|
2475
|
+
}
|
|
2476
|
+
async function saveNamedCopy(ctx, options, flow, raw, source) {
|
|
2477
|
+
while (flow.current()) {
|
|
2478
|
+
const name = await flow.dialog(
|
|
2479
|
+
() => ctx.ui.input("Save as a profile", "Profile name (without .toml)", { signal: flow.signal })
|
|
2480
|
+
);
|
|
2481
|
+
flow.ensure(source);
|
|
2482
|
+
if (name === void 0) return void 0;
|
|
2483
|
+
try {
|
|
2484
|
+
const saved = source?.kind === "profile" ? duplicateProfile(options.settingsPath, source.name, name, source) : createProfile(options.settingsPath, name, requireText(raw));
|
|
2485
|
+
ctx.ui.notify(`Profile saved: ${safe(saved.name)}. Active settings are unchanged.`, "info");
|
|
2486
|
+
return saved;
|
|
2487
|
+
} catch (error) {
|
|
2488
|
+
report(ctx, flow, error);
|
|
2489
|
+
}
|
|
2490
|
+
}
|
|
2491
|
+
throw new FlowEnded();
|
|
2492
|
+
}
|
|
2493
|
+
async function actionScreen(ctx, flow, screen) {
|
|
2494
|
+
let selected;
|
|
2495
|
+
const menu = defineMenu2({
|
|
2496
|
+
start: "actions",
|
|
2497
|
+
screens: {
|
|
2498
|
+
actions: () => ({
|
|
2499
|
+
kind: "actions",
|
|
2500
|
+
title: screen.title,
|
|
2501
|
+
lines: screen.lines,
|
|
2502
|
+
items: [
|
|
2503
|
+
{
|
|
2504
|
+
id: "review",
|
|
2505
|
+
label: "Review TOML",
|
|
2506
|
+
to: "document",
|
|
2507
|
+
disabled: screen.raw === void 0,
|
|
2508
|
+
disabledReason: "The document is not valid UTF-8"
|
|
2509
|
+
},
|
|
2510
|
+
...screen.actions.map((action) => ({ ...action, action: "select" }))
|
|
2511
|
+
],
|
|
2512
|
+
hint: "back"
|
|
2513
|
+
}),
|
|
2514
|
+
document: () => ({
|
|
2515
|
+
kind: "review",
|
|
2516
|
+
title: screen.title,
|
|
2517
|
+
lines: ["Exact UTF-8 text \xB7 display controls sanitized \xB7 read-only"],
|
|
2518
|
+
content: screen.raw ?? "The document is not valid UTF-8; no decoded fallback is shown.",
|
|
2519
|
+
format: { kind: "code", language: "toml" },
|
|
2520
|
+
enableSearch: true,
|
|
2521
|
+
viewportSize: "adaptive",
|
|
2522
|
+
hint: "back"
|
|
2523
|
+
})
|
|
2524
|
+
},
|
|
2525
|
+
actions: {
|
|
2526
|
+
select: ({ itemId }) => {
|
|
2527
|
+
flow.ensure();
|
|
2528
|
+
selected = itemId;
|
|
2529
|
+
return { kind: "close" };
|
|
2530
|
+
}
|
|
2531
|
+
}
|
|
2532
|
+
});
|
|
2533
|
+
const result = await runMenu2(ctx, menu, { getState: () => void 0, signal: flow.signal, isCurrent: flow.current });
|
|
2534
|
+
flow.ensure();
|
|
2535
|
+
return selected ?? (result.kind === "closed" && result.reason === "back" ? "back" : "close");
|
|
2536
|
+
}
|
|
2537
|
+
function createFlow(ctx, options, owner) {
|
|
2538
|
+
const controller = new AbortController();
|
|
2539
|
+
const signal = AbortSignal.any([controller.signal, owner.signal]);
|
|
2540
|
+
let revision = options.getLoadedRevision?.();
|
|
2541
|
+
let activeDocument = activeFingerprint(options.getLoaded());
|
|
2542
|
+
let previewOwned = false;
|
|
2543
|
+
const isCurrent = () => !signal.aborted && owner.isCurrent() && (revision === void 0 ? activeFingerprint(options.getLoaded()) === activeDocument : options.getLoadedRevision?.() === revision);
|
|
2544
|
+
const clearPreview = () => {
|
|
2545
|
+
if (!previewOwned) return;
|
|
2546
|
+
previewOwned = false;
|
|
2547
|
+
if (owner.isSessionCurrent?.() ?? owner.isCurrent()) {
|
|
2548
|
+
try {
|
|
2549
|
+
options.preview?.(void 0, ctx);
|
|
2550
|
+
} catch (error) {
|
|
2551
|
+
ctx.ui.notify(`Could not clear the footer preview: ${safeError3(error)}`, "error");
|
|
2552
|
+
}
|
|
2553
|
+
}
|
|
2554
|
+
};
|
|
2555
|
+
const matches = (expected) => {
|
|
2556
|
+
if (!isCurrent()) return false;
|
|
2557
|
+
if (!expected) return true;
|
|
2558
|
+
try {
|
|
2559
|
+
const fresh = expected.kind === "profile" ? readProfile(options.settingsPath, expected.name) : readHistory(options.settingsPath, expected.name);
|
|
2560
|
+
return fresh.rawDocument === expected.rawDocument && fresh.identity.dev === expected.identity.dev && fresh.identity.ino === expected.identity.ino && fresh.identity.size === expected.identity.size && fresh.identity.mtimeNs === expected.identity.mtimeNs && fresh.identity.ctimeNs === expected.identity.ctimeNs && fresh.rawBytes.equals(expected.rawBytes);
|
|
2561
|
+
} catch {
|
|
2562
|
+
return false;
|
|
2563
|
+
}
|
|
2564
|
+
};
|
|
2565
|
+
const ensure = (expected) => {
|
|
2566
|
+
if (!isCurrent()) throw new FlowEnded();
|
|
2567
|
+
if (!matches(expected))
|
|
2568
|
+
throw new Error("The selected document changed or was removed. Review the latest copy before trying again.");
|
|
2569
|
+
};
|
|
2570
|
+
signal.addEventListener("abort", clearPreview, { once: true });
|
|
2571
|
+
return {
|
|
2572
|
+
signal,
|
|
2573
|
+
current: isCurrent,
|
|
2574
|
+
sessionCurrent: () => owner.isSessionCurrent?.() ?? owner.isCurrent(),
|
|
2575
|
+
ensure,
|
|
2576
|
+
preview(loaded) {
|
|
2577
|
+
ensure();
|
|
2578
|
+
if (!loaded) {
|
|
2579
|
+
clearPreview();
|
|
2580
|
+
return;
|
|
2581
|
+
}
|
|
2582
|
+
previewOwned = true;
|
|
2583
|
+
try {
|
|
2584
|
+
options.preview?.(loaded, ctx);
|
|
2585
|
+
} catch (error) {
|
|
2586
|
+
clearPreview();
|
|
2587
|
+
throw error;
|
|
2588
|
+
}
|
|
2589
|
+
},
|
|
2590
|
+
async dialog(run) {
|
|
2591
|
+
ensure();
|
|
2592
|
+
const unsubscribe = ctx.ui.onTerminalInput((data) => {
|
|
2593
|
+
if (!isKeyRelease(data) && matchesKey2(data, Key2.ctrl("c"))) {
|
|
2594
|
+
queueMicrotask(() => controller.abort());
|
|
2595
|
+
}
|
|
2596
|
+
return void 0;
|
|
2597
|
+
});
|
|
2598
|
+
let released = false;
|
|
2599
|
+
const release = () => {
|
|
2600
|
+
if (released) return;
|
|
2601
|
+
released = true;
|
|
2602
|
+
unsubscribe();
|
|
2603
|
+
};
|
|
2604
|
+
signal.addEventListener("abort", release, { once: true });
|
|
2605
|
+
try {
|
|
2606
|
+
if (signal.aborted) release();
|
|
2607
|
+
ensure();
|
|
2608
|
+
const result = await run();
|
|
2609
|
+
ensure();
|
|
2610
|
+
return result;
|
|
2611
|
+
} finally {
|
|
2612
|
+
signal.removeEventListener("abort", release);
|
|
2613
|
+
release();
|
|
2614
|
+
}
|
|
2615
|
+
},
|
|
2616
|
+
adoptAppliedRevision() {
|
|
2617
|
+
if (signal.aborted || !(owner.isSessionCurrent?.() ?? owner.isCurrent())) throw new FlowEnded();
|
|
2618
|
+
revision = options.getLoadedRevision?.();
|
|
2619
|
+
activeDocument = activeFingerprint(options.getLoaded());
|
|
2620
|
+
},
|
|
2621
|
+
dispose() {
|
|
2622
|
+
try {
|
|
2623
|
+
clearPreview();
|
|
2624
|
+
} finally {
|
|
2625
|
+
signal.removeEventListener("abort", clearPreview);
|
|
2626
|
+
controller.abort();
|
|
2627
|
+
}
|
|
2628
|
+
}
|
|
2629
|
+
};
|
|
2630
|
+
}
|
|
2631
|
+
function candidateFor(options, raw, required = false) {
|
|
2632
|
+
try {
|
|
2633
|
+
if (raw === void 0) throw new Error("The document is not valid UTF-8; no decoded fallback is shown.");
|
|
2634
|
+
const loaded = (options.validate ?? validateConfigDocument)(options.settingsPath, raw);
|
|
2635
|
+
if (loaded.diagnostics.some((item) => item.severity === "error"))
|
|
2636
|
+
throw new Error(loaded.diagnostics.map((item) => item.message).join("; "));
|
|
2637
|
+
return {
|
|
2638
|
+
loaded,
|
|
2639
|
+
lines: loaded.diagnostics.length === 0 ? ["No configuration warnings."] : loaded.diagnostics.map((item) => `${safe(item.path || "root")}: ${safe(item.message)}`)
|
|
2640
|
+
};
|
|
2641
|
+
} catch (error) {
|
|
2642
|
+
if (required) throw error;
|
|
2643
|
+
return { lines: [`Invalid TOML: ${safeError3(error)}`, "No candidate footer preview is shown."] };
|
|
2644
|
+
}
|
|
2645
|
+
}
|
|
2646
|
+
function requireText(raw) {
|
|
2647
|
+
if (raw === void 0) throw new Error("The document is not valid UTF-8; no decoded fallback can be saved.");
|
|
2648
|
+
return raw;
|
|
2649
|
+
}
|
|
2650
|
+
function activeFingerprint(loaded) {
|
|
2651
|
+
return JSON.stringify([loaded.source, loaded.rawDocument, loaded.diagnostics]);
|
|
2652
|
+
}
|
|
2653
|
+
function current2(owner) {
|
|
2654
|
+
return !owner.signal.aborted && owner.isCurrent();
|
|
2655
|
+
}
|
|
2656
|
+
function interactive(ctx) {
|
|
2657
|
+
if (ctx.mode === "tui" && ctx.hasUI) return true;
|
|
2658
|
+
if (ctx.hasUI) ctx.ui.notify("Profiles and History require TUI mode.", "info");
|
|
2659
|
+
return false;
|
|
2660
|
+
}
|
|
2661
|
+
function documentId(document) {
|
|
2662
|
+
return `${document.kind}:${document.name}`;
|
|
2663
|
+
}
|
|
2664
|
+
function report(ctx, flow, error) {
|
|
2665
|
+
if (!(error instanceof FlowEnded) && flow.current()) ctx.ui.notify(safeError3(error), "error");
|
|
2666
|
+
}
|
|
2667
|
+
function safeError3(error) {
|
|
2668
|
+
return safe(error instanceof Error ? error.message : String(error));
|
|
2669
|
+
}
|
|
2670
|
+
function safe(value) {
|
|
2671
|
+
return sanitizeTerminalText3(value);
|
|
2672
|
+
}
|
|
2673
|
+
|
|
1629
2674
|
// src/commands.ts
|
|
1630
2675
|
var MAIN_ACTIONS = {
|
|
1631
2676
|
customize: "customize",
|
|
@@ -1634,12 +2679,14 @@ var MAIN_ACTIONS = {
|
|
|
1634
2679
|
modules: "modules",
|
|
1635
2680
|
configuration: "configuration",
|
|
1636
2681
|
help: "help",
|
|
1637
|
-
restore: "restore"
|
|
2682
|
+
restore: "restore",
|
|
2683
|
+
profiles: "profiles"
|
|
1638
2684
|
};
|
|
1639
2685
|
var PREVIEW_ACTIONS = {
|
|
1640
2686
|
continue: "continue",
|
|
1641
2687
|
edit: "edit",
|
|
1642
|
-
cancel: "cancel"
|
|
2688
|
+
cancel: "cancel",
|
|
2689
|
+
saveProfile: "save-profile"
|
|
1643
2690
|
};
|
|
1644
2691
|
function registerStarshipCommand(pi, options) {
|
|
1645
2692
|
pi.registerCommand("starship", {
|
|
@@ -1649,6 +2696,38 @@ function registerStarshipCommand(pi, options) {
|
|
|
1649
2696
|
});
|
|
1650
2697
|
}
|
|
1651
2698
|
async function handleStarshipCommand(args, ctx, options) {
|
|
2699
|
+
if (ctx.mode !== "tui") return runStarshipCommand(args, ctx, options);
|
|
2700
|
+
const base = workflowOwner(options);
|
|
2701
|
+
if (!isCurrentOwner2(base)) return;
|
|
2702
|
+
const controller = new AbortController();
|
|
2703
|
+
const signal = AbortSignal.any([base.signal, controller.signal]);
|
|
2704
|
+
const owner = {
|
|
2705
|
+
signal,
|
|
2706
|
+
isCurrent: () => !signal.aborted && base.isCurrent(),
|
|
2707
|
+
isSessionCurrent: () => base.isSessionCurrent?.() ?? base.isCurrent()
|
|
2708
|
+
};
|
|
2709
|
+
const unsubscribe = ctx.ui.onTerminalInput((data) => {
|
|
2710
|
+
if (!isKeyRelease2(data) && matchesKey3(data, Key3.ctrl("c"))) {
|
|
2711
|
+
queueMicrotask(() => controller.abort());
|
|
2712
|
+
}
|
|
2713
|
+
return void 0;
|
|
2714
|
+
});
|
|
2715
|
+
let listening = true;
|
|
2716
|
+
const release = () => {
|
|
2717
|
+
if (!listening) return;
|
|
2718
|
+
listening = false;
|
|
2719
|
+
unsubscribe();
|
|
2720
|
+
};
|
|
2721
|
+
signal.addEventListener("abort", release, { once: true });
|
|
2722
|
+
try {
|
|
2723
|
+
return await runStarshipCommand(args, ctx, { ...options, getMenuOwner: () => owner });
|
|
2724
|
+
} finally {
|
|
2725
|
+
signal.removeEventListener("abort", release);
|
|
2726
|
+
release();
|
|
2727
|
+
controller.abort();
|
|
2728
|
+
}
|
|
2729
|
+
}
|
|
2730
|
+
async function runStarshipCommand(args, ctx, options) {
|
|
1652
2731
|
const normalized = args.trim();
|
|
1653
2732
|
if (!normalized) {
|
|
1654
2733
|
if (ctx.mode === "tui") await showMainMenu(ctx, options);
|
|
@@ -1682,7 +2761,7 @@ async function showMainMenu(ctx, options) {
|
|
|
1682
2761
|
signal: fallbackController.signal,
|
|
1683
2762
|
isCurrent: () => !fallbackController.signal.aborted
|
|
1684
2763
|
};
|
|
1685
|
-
const menu =
|
|
2764
|
+
const menu = defineMenu3({
|
|
1686
2765
|
start: "main",
|
|
1687
2766
|
screens: {
|
|
1688
2767
|
main: () => {
|
|
@@ -1735,6 +2814,12 @@ async function showMainMenu(ctx, options) {
|
|
|
1735
2814
|
description: presentation.restoreDescription,
|
|
1736
2815
|
disabled: presentation.restoreDisabled,
|
|
1737
2816
|
action: "restore"
|
|
2817
|
+
},
|
|
2818
|
+
{
|
|
2819
|
+
id: MAIN_ACTIONS.profiles,
|
|
2820
|
+
label: "Profiles",
|
|
2821
|
+
description: "Save, edit, manage, and live-preview named TOML documents",
|
|
2822
|
+
action: "profiles"
|
|
1738
2823
|
}
|
|
1739
2824
|
],
|
|
1740
2825
|
hint: "close"
|
|
@@ -1784,7 +2869,9 @@ async function showMainMenu(ctx, options) {
|
|
|
1784
2869
|
title: "pi-starship help",
|
|
1785
2870
|
lines: [
|
|
1786
2871
|
"Customize footer opens the TOML editor, then previews and confirms before saving.",
|
|
1787
|
-
"Presets live-previews the cursor in the footer; Enter confirms apply
|
|
2872
|
+
"Presets live-previews the cursor in the footer; Enter confirms apply, e customizes, and s saves a profile when available.",
|
|
2873
|
+
"Profiles manages named TOML copies; selecting a document previews it without saving.",
|
|
2874
|
+
"Configuration History reviews and restores recovery copies; external edits are not fully tracked.",
|
|
1788
2875
|
"Explain footer breaks down the modules currently showing from the existing snapshot.",
|
|
1789
2876
|
"Modules searches every supported module and explains its current read-only state.",
|
|
1790
2877
|
"Configuration includes disk reload plus unlisted Gist sharing and reviewed Gist import through gh.",
|
|
@@ -1803,6 +2890,36 @@ async function showMainMenu(ctx, options) {
|
|
|
1803
2890
|
const result = await choosePreset(ctx, options, owner);
|
|
1804
2891
|
return result === "applied" || result === "close" ? { kind: "close" } : { kind: "stay" };
|
|
1805
2892
|
},
|
|
2893
|
+
profiles: async () => {
|
|
2894
|
+
const result = await showProfiles(ctx, options, owner, async (loaded, guardedOwner, checkCandidate, name) => {
|
|
2895
|
+
const applied = await reviewAndApply(
|
|
2896
|
+
ctx,
|
|
2897
|
+
options,
|
|
2898
|
+
loaded,
|
|
2899
|
+
{ kind: "profile", name },
|
|
2900
|
+
guardedOwner,
|
|
2901
|
+
false,
|
|
2902
|
+
checkCandidate
|
|
2903
|
+
);
|
|
2904
|
+
return applied === "applied" ? "applied" : applied === "close" ? "close" : "stay";
|
|
2905
|
+
});
|
|
2906
|
+
return result === "close" ? { kind: "close" } : { kind: "stay" };
|
|
2907
|
+
},
|
|
2908
|
+
history: async () => {
|
|
2909
|
+
const result = await showHistory(ctx, options, owner, async (loaded, guardedOwner, checkCandidate, name) => {
|
|
2910
|
+
const applied = await reviewAndApply(
|
|
2911
|
+
ctx,
|
|
2912
|
+
options,
|
|
2913
|
+
loaded,
|
|
2914
|
+
{ kind: "history", name },
|
|
2915
|
+
guardedOwner,
|
|
2916
|
+
false,
|
|
2917
|
+
checkCandidate
|
|
2918
|
+
);
|
|
2919
|
+
return applied === "applied" ? "applied" : applied === "close" ? "close" : "stay";
|
|
2920
|
+
});
|
|
2921
|
+
return result === "close" ? { kind: "close" } : { kind: "stay" };
|
|
2922
|
+
},
|
|
1806
2923
|
"gist-share": async () => {
|
|
1807
2924
|
const result = await shareSettingsGist(ctx, options, owner, options.gistApi);
|
|
1808
2925
|
return result === "close" ? { kind: "close" } : { kind: "stay" };
|
|
@@ -1836,7 +2953,7 @@ async function showMainMenu(ctx, options) {
|
|
|
1836
2953
|
}
|
|
1837
2954
|
});
|
|
1838
2955
|
try {
|
|
1839
|
-
await
|
|
2956
|
+
await runMenu3(ctx, menu, {
|
|
1840
2957
|
getState: () => void 0,
|
|
1841
2958
|
signal: owner.signal,
|
|
1842
2959
|
isCurrent: owner.isCurrent
|
|
@@ -1852,10 +2969,12 @@ async function editSettings(ctx, options) {
|
|
|
1852
2969
|
if (ctx.hasUI) ctx.ui.notify(`Edit settings manually: ${options.settingsPath}`, "info");
|
|
1853
2970
|
return "cancel";
|
|
1854
2971
|
}
|
|
1855
|
-
|
|
2972
|
+
const expected = captureExpectation(ctx, options);
|
|
2973
|
+
if (!expected) return "cancel";
|
|
2974
|
+
let draft = expected.previous.rawDocument ?? BUILT_IN_EXAMPLE;
|
|
1856
2975
|
while (true) {
|
|
1857
2976
|
const edited = await ctx.ui.editor("Customize footer \u2014 close to preview", draft);
|
|
1858
|
-
if (!
|
|
2977
|
+
if (!commitOwnerCurrent(options, owner, expected) || edited === void 0) return "cancel";
|
|
1859
2978
|
draft = edited;
|
|
1860
2979
|
let validated;
|
|
1861
2980
|
try {
|
|
@@ -1873,18 +2992,29 @@ async function editSettings(ctx, options) {
|
|
|
1873
2992
|
owner.signal,
|
|
1874
2993
|
owner.isCurrent
|
|
1875
2994
|
);
|
|
1876
|
-
if (!
|
|
2995
|
+
if (!commitOwnerCurrent(options, owner, expected)) return "cancel";
|
|
1877
2996
|
if (action?.kind === "closed") return "close";
|
|
1878
2997
|
if (selectedPreviewAction(action) === PREVIEW_ACTIONS.edit) continue;
|
|
1879
2998
|
return "cancel";
|
|
1880
2999
|
}
|
|
1881
|
-
const result = await reviewAndApply(
|
|
3000
|
+
const result = await reviewAndApply(
|
|
3001
|
+
ctx,
|
|
3002
|
+
options,
|
|
3003
|
+
validated,
|
|
3004
|
+
{ kind: "customize" },
|
|
3005
|
+
owner,
|
|
3006
|
+
false,
|
|
3007
|
+
void 0,
|
|
3008
|
+
expected
|
|
3009
|
+
);
|
|
1882
3010
|
if (result === "edit") continue;
|
|
1883
3011
|
return result;
|
|
1884
3012
|
}
|
|
1885
3013
|
}
|
|
1886
3014
|
async function choosePreset(ctx, options, owner) {
|
|
1887
|
-
const
|
|
3015
|
+
const expected = captureExpectation(ctx, options);
|
|
3016
|
+
if (!expected) return "cancel";
|
|
3017
|
+
const activePreset = presetForDocument(expected.previous.rawDocument);
|
|
1888
3018
|
const selection = await showPresetPicker(ctx, {
|
|
1889
3019
|
presets: STARSHIP_PRESETS,
|
|
1890
3020
|
activePresetId: activePreset?.id,
|
|
@@ -1896,28 +3026,41 @@ async function choosePreset(ctx, options, owner) {
|
|
|
1896
3026
|
options.preview?.(loaded, ctx);
|
|
1897
3027
|
}
|
|
1898
3028
|
});
|
|
1899
|
-
if (!
|
|
1900
|
-
|
|
3029
|
+
if (!commitOwnerCurrent(options, owner, expected)) {
|
|
3030
|
+
clearSessionPreview(ctx, options, owner);
|
|
1901
3031
|
return "cancel";
|
|
1902
3032
|
}
|
|
1903
3033
|
if (selection.kind === "back" || selection.kind === "close") {
|
|
1904
|
-
|
|
3034
|
+
clearSessionPreview(ctx, options, owner);
|
|
1905
3035
|
return selection.kind === "close" ? "close" : "cancel";
|
|
1906
3036
|
}
|
|
1907
3037
|
const preset = getStarshipPreset(selection.presetId);
|
|
1908
3038
|
try {
|
|
1909
|
-
|
|
3039
|
+
if (selection.kind === "save-profile") {
|
|
3040
|
+
const saved = await saveAsProfile(ctx, options, owner, preset.rawDocument);
|
|
3041
|
+
return saved === "close" ? "close" : "cancel";
|
|
3042
|
+
}
|
|
3043
|
+
return await applyPreset(
|
|
3044
|
+
ctx,
|
|
3045
|
+
options,
|
|
3046
|
+
preset,
|
|
3047
|
+
selection.kind === "customize" ? "customize" : "confirm",
|
|
3048
|
+
expected,
|
|
3049
|
+
owner
|
|
3050
|
+
);
|
|
1910
3051
|
} finally {
|
|
1911
|
-
|
|
3052
|
+
clearSessionPreview(ctx, options, owner);
|
|
1912
3053
|
}
|
|
1913
3054
|
}
|
|
1914
|
-
async function applyPreset(ctx, options, preset, start = "review") {
|
|
1915
|
-
const owner = workflowOwner(options);
|
|
3055
|
+
async function applyPreset(ctx, options, preset, start = "review", captured, capturedOwner) {
|
|
3056
|
+
const owner = capturedOwner ?? workflowOwner(options);
|
|
1916
3057
|
if (!isCurrentOwner2(owner)) return "cancel";
|
|
3058
|
+
const expected = captured ?? captureExpectation(ctx, options);
|
|
3059
|
+
if (!expected) return "cancel";
|
|
1917
3060
|
let draft = preset.rawDocument;
|
|
1918
3061
|
if (start === "customize") {
|
|
1919
3062
|
const edited = await ctx.ui.editor(`Customize ${preset.label} preset`, draft);
|
|
1920
|
-
if (!
|
|
3063
|
+
if (!commitOwnerCurrent(options, owner, expected) || edited === void 0) return "cancel";
|
|
1921
3064
|
draft = edited;
|
|
1922
3065
|
}
|
|
1923
3066
|
while (true) {
|
|
@@ -1937,11 +3080,11 @@ async function applyPreset(ctx, options, preset, start = "review") {
|
|
|
1937
3080
|
owner.signal,
|
|
1938
3081
|
owner.isCurrent
|
|
1939
3082
|
);
|
|
1940
|
-
if (!
|
|
3083
|
+
if (!commitOwnerCurrent(options, owner, expected)) return "cancel";
|
|
1941
3084
|
if (action?.kind === "closed") return "close";
|
|
1942
3085
|
if (selectedPreviewAction(action) !== PREVIEW_ACTIONS.edit) return "cancel";
|
|
1943
3086
|
const edited2 = await ctx.ui.editor(`Customize ${preset.label} preset`, draft);
|
|
1944
|
-
if (!
|
|
3087
|
+
if (!commitOwnerCurrent(options, owner, expected) || edited2 === void 0) return "cancel";
|
|
1945
3088
|
draft = edited2;
|
|
1946
3089
|
continue;
|
|
1947
3090
|
}
|
|
@@ -1951,11 +3094,13 @@ async function applyPreset(ctx, options, preset, start = "review") {
|
|
|
1951
3094
|
validated,
|
|
1952
3095
|
{ kind: "preset", preset },
|
|
1953
3096
|
owner,
|
|
1954
|
-
start === "confirm"
|
|
3097
|
+
start === "confirm",
|
|
3098
|
+
void 0,
|
|
3099
|
+
expected
|
|
1955
3100
|
);
|
|
1956
3101
|
if (result !== "edit") return result;
|
|
1957
3102
|
const edited = await ctx.ui.editor(`Customize ${preset.label} preset`, draft);
|
|
1958
|
-
if (!
|
|
3103
|
+
if (!commitOwnerCurrent(options, owner, expected) || edited === void 0) return "cancel";
|
|
1959
3104
|
draft = edited;
|
|
1960
3105
|
}
|
|
1961
3106
|
}
|
|
@@ -1966,7 +3111,10 @@ async function restoreBuiltIn(ctx, options) {
|
|
|
1966
3111
|
const result = await reviewAndApply(ctx, options, validated, { kind: "restore" }, owner);
|
|
1967
3112
|
return result === "edit" ? "cancel" : result;
|
|
1968
3113
|
}
|
|
1969
|
-
async function reviewAndApply(ctx, options, validated, intent, owner, skipReview = false) {
|
|
3114
|
+
async function reviewAndApply(ctx, options, validated, intent, owner, skipReview = false, checkCandidate, captured) {
|
|
3115
|
+
if (ctx.mode !== "tui" || !isCurrentOwner2(owner)) return "cancel";
|
|
3116
|
+
const expected = captured ?? captureExpectation(ctx, options);
|
|
3117
|
+
if (!expected) return "cancel";
|
|
1970
3118
|
let reviewRequired = !skipReview;
|
|
1971
3119
|
while (true) {
|
|
1972
3120
|
const directAttempt = !reviewRequired;
|
|
@@ -1977,7 +3125,7 @@ async function reviewAndApply(ctx, options, validated, intent, owner, skipReview
|
|
|
1977
3125
|
(width) => reviewPreviewBody(ctx, options, validated, width, intent),
|
|
1978
3126
|
[
|
|
1979
3127
|
{ value: PREVIEW_ACTIONS.continue, label: continueLabel(intent) },
|
|
1980
|
-
...intent.kind
|
|
3128
|
+
...intent.kind !== "customize" && intent.kind !== "preset" ? [] : [
|
|
1981
3129
|
{
|
|
1982
3130
|
value: PREVIEW_ACTIONS.edit,
|
|
1983
3131
|
label: intent.kind === "preset" ? "Customize before applying" : "Continue editing"
|
|
@@ -1986,53 +3134,53 @@ async function reviewAndApply(ctx, options, validated, intent, owner, skipReview
|
|
|
1986
3134
|
{
|
|
1987
3135
|
value: PREVIEW_ACTIONS.cancel,
|
|
1988
3136
|
label: intent.kind === "restore" ? "Cancel" : intent.kind === "preset" ? "Choose another preset" : "Discard draft"
|
|
1989
|
-
}
|
|
3137
|
+
},
|
|
3138
|
+
...intent.kind === "customize" || intent.kind === "preset" || intent.kind === "import" ? [{ value: PREVIEW_ACTIONS.saveProfile, label: "Save as profile\u2026" }] : []
|
|
1990
3139
|
],
|
|
1991
3140
|
owner.signal,
|
|
1992
3141
|
owner.isCurrent
|
|
1993
3142
|
);
|
|
1994
|
-
if (!
|
|
3143
|
+
if (!commitOwnerCurrent(options, owner, expected)) return "cancel";
|
|
1995
3144
|
if (selection?.kind === "closed") return "close";
|
|
1996
3145
|
const selected = selectedPreviewAction(selection);
|
|
1997
3146
|
if (selected === PREVIEW_ACTIONS.edit) return "edit";
|
|
3147
|
+
if (selected === PREVIEW_ACTIONS.saveProfile) {
|
|
3148
|
+
const saved = await saveAsProfile(ctx, options, owner, validated.rawDocument ?? BUILT_IN_EXAMPLE);
|
|
3149
|
+
if (saved === "close") return "close";
|
|
3150
|
+
if (!commitOwnerCurrent(options, owner, expected)) return "cancel";
|
|
3151
|
+
continue;
|
|
3152
|
+
}
|
|
1998
3153
|
if (selected !== PREVIEW_ACTIONS.continue) return "cancel";
|
|
1999
3154
|
}
|
|
2000
3155
|
reviewRequired = true;
|
|
2001
3156
|
const confirmed = await ctx.ui.confirm(
|
|
2002
3157
|
confirmationTitle(intent),
|
|
2003
|
-
confirmationMessage(options.settingsPath, intent),
|
|
3158
|
+
confirmationMessage(options.settingsPath, intent, expected.previous),
|
|
2004
3159
|
{ signal: owner.signal }
|
|
2005
3160
|
);
|
|
2006
|
-
if (!
|
|
3161
|
+
if (!commitOwnerCurrent(options, owner, expected)) return "cancel";
|
|
2007
3162
|
if (!confirmed) {
|
|
2008
3163
|
if (directAttempt) return "cancel";
|
|
2009
3164
|
continue;
|
|
2010
3165
|
}
|
|
2011
|
-
const save = options.save ?? atomicSaveConfigDocument;
|
|
2012
|
-
const previous = options.getLoaded();
|
|
2013
|
-
let saved;
|
|
2014
3166
|
try {
|
|
2015
|
-
|
|
2016
|
-
|
|
2017
|
-
|
|
2018
|
-
|
|
2019
|
-
|
|
3167
|
+
const result = await commitActiveDocument(
|
|
3168
|
+
ctx,
|
|
3169
|
+
options,
|
|
3170
|
+
validated,
|
|
3171
|
+
owner,
|
|
3172
|
+
expected,
|
|
3173
|
+
intent.kind === "restore" || intent.kind === "history" || intent.kind === "customize",
|
|
3174
|
+
checkCandidate
|
|
2020
3175
|
);
|
|
2021
|
-
if (
|
|
2022
|
-
continue;
|
|
2023
|
-
}
|
|
2024
|
-
try {
|
|
2025
|
-
options.apply(saved, ctx);
|
|
3176
|
+
if (!isSessionOwnerCurrent(owner) || result === "cancel") return "cancel";
|
|
2026
3177
|
} catch (error) {
|
|
2027
|
-
|
|
2028
|
-
ctx.ui.notify(
|
|
2029
|
-
rollbackError ? `Footer settings could not be applied: ${safeText(formatError2(error))}. Restoring the previous configuration also failed: ${safeText(formatError2(rollbackError))}.` : `Footer settings could not be applied: ${safeText(formatError2(error))}. The previous configuration was restored.`,
|
|
2030
|
-
"error"
|
|
2031
|
-
);
|
|
3178
|
+
if (!isSessionOwnerCurrent(owner)) return "cancel";
|
|
3179
|
+
ctx.ui.notify(safeText(formatError2(error)), "error");
|
|
2032
3180
|
if (directAttempt) return "cancel";
|
|
2033
3181
|
continue;
|
|
2034
3182
|
}
|
|
2035
|
-
const warningSuffix =
|
|
3183
|
+
const warningSuffix = validated.diagnostics.length > 0 ? ` (${validated.diagnostics.length} warning${validated.diagnostics.length === 1 ? "" : "s"})` : "";
|
|
2036
3184
|
ctx.ui.notify(`${successMessage(intent)}${warningSuffix}.`, "info");
|
|
2037
3185
|
return "applied";
|
|
2038
3186
|
}
|
|
@@ -2045,6 +3193,10 @@ function reviewTitle(intent) {
|
|
|
2045
3193
|
return "Restore preview";
|
|
2046
3194
|
case "import":
|
|
2047
3195
|
return "Gist footer preview";
|
|
3196
|
+
case "profile":
|
|
3197
|
+
return `${safeText(intent.name)} profile preview`;
|
|
3198
|
+
case "history":
|
|
3199
|
+
return "History recovery preview";
|
|
2048
3200
|
case "preset":
|
|
2049
3201
|
return `${intent.preset.label} preset preview`;
|
|
2050
3202
|
}
|
|
@@ -2057,6 +3209,10 @@ function continueLabel(intent) {
|
|
|
2057
3209
|
return "Replace with built-in\u2026";
|
|
2058
3210
|
case "import":
|
|
2059
3211
|
return "Replace with Gist settings\u2026";
|
|
3212
|
+
case "profile":
|
|
3213
|
+
return `Apply ${safeText(intent.name)} profile\u2026`;
|
|
3214
|
+
case "history":
|
|
3215
|
+
return "Restore history document\u2026";
|
|
2060
3216
|
case "preset":
|
|
2061
3217
|
return `Apply ${intent.preset.label} preset\u2026`;
|
|
2062
3218
|
}
|
|
@@ -2069,14 +3225,22 @@ function confirmationTitle(intent) {
|
|
|
2069
3225
|
return "Restore built-in footer?";
|
|
2070
3226
|
case "import":
|
|
2071
3227
|
return "Replace settings with Gist?";
|
|
3228
|
+
case "profile":
|
|
3229
|
+
return `Apply ${safeText(intent.name)} profile?`;
|
|
3230
|
+
case "history":
|
|
3231
|
+
return "Restore settings from history?";
|
|
2072
3232
|
case "preset":
|
|
2073
3233
|
return `Apply ${intent.preset.label} preset?`;
|
|
2074
3234
|
}
|
|
2075
3235
|
}
|
|
2076
|
-
function confirmationMessage(settingsPath, intent) {
|
|
2077
|
-
if (
|
|
2078
|
-
|
|
2079
|
-
|
|
3236
|
+
function confirmationMessage(settingsPath, intent, previous) {
|
|
3237
|
+
if (previous.diagnostics.some((item) => item.severity === "error")) {
|
|
3238
|
+
return `Explicit recovery: replace the invalid settings file ${safeText(settingsPath)} entirely with the reviewed document? Its exact original bytes will be kept in History before replacement.`;
|
|
3239
|
+
}
|
|
3240
|
+
if (intent.kind === "customize")
|
|
3241
|
+
return "Replace the entire settings document and apply it immediately? Its previous bytes will be kept in History.";
|
|
3242
|
+
const replacement = intent.kind === "restore" ? "the built-in configuration" : intent.kind === "import" ? "the reviewed Gist settings" : intent.kind === "profile" ? `the ${safeText(intent.name)} profile` : intent.kind === "history" ? "the reviewed history document" : `the ${intent.preset.label} preset`;
|
|
3243
|
+
return `Replace ${safeText(settingsPath)} entirely with ${replacement}? All custom settings, unknown fields, and comments will be replaced. The previous document will be kept in History.`;
|
|
2080
3244
|
}
|
|
2081
3245
|
function successMessage(intent) {
|
|
2082
3246
|
switch (intent.kind) {
|
|
@@ -2086,6 +3250,10 @@ function successMessage(intent) {
|
|
|
2086
3250
|
return "Built-in footer restored and applied";
|
|
2087
3251
|
case "import":
|
|
2088
3252
|
return "Gist settings saved and applied";
|
|
3253
|
+
case "profile":
|
|
3254
|
+
return `${safeText(intent.name)} profile applied`;
|
|
3255
|
+
case "history":
|
|
3256
|
+
return "History document restored and applied";
|
|
2089
3257
|
case "preset":
|
|
2090
3258
|
return `${intent.preset.label} preset saved and applied`;
|
|
2091
3259
|
}
|
|
@@ -2102,43 +3270,42 @@ function workflowOwner(options) {
|
|
|
2102
3270
|
function isCurrentOwner2(owner) {
|
|
2103
3271
|
return !owner.signal.aborted && owner.isCurrent();
|
|
2104
3272
|
}
|
|
2105
|
-
function
|
|
3273
|
+
function isSessionOwnerCurrent(owner) {
|
|
3274
|
+
return !owner.signal.aborted && (owner.isSessionCurrent?.() ?? owner.isCurrent());
|
|
3275
|
+
}
|
|
3276
|
+
function clearSessionPreview(ctx, options, owner) {
|
|
3277
|
+
if (owner.isSessionCurrent?.() ?? owner.isCurrent()) options.preview?.(void 0, ctx);
|
|
3278
|
+
}
|
|
3279
|
+
function captureExpectation(ctx, options) {
|
|
2106
3280
|
try {
|
|
2107
|
-
|
|
2108
|
-
throw new Error("The saved settings document identity is unavailable");
|
|
2109
|
-
}
|
|
2110
|
-
removeConfigDocumentIfMatches(options.settingsPath, saved.rawDocument, saved.fileIdentity);
|
|
2111
|
-
if (previous.rawDocument !== void 0) {
|
|
2112
|
-
(options.restore ?? atomicRestoreConfigDocument)(options.settingsPath, previous.rawDocument);
|
|
2113
|
-
}
|
|
2114
|
-
options.apply(previous, ctx);
|
|
2115
|
-
return void 0;
|
|
3281
|
+
return captureCommitExpectation(options);
|
|
2116
3282
|
} catch (error) {
|
|
2117
|
-
|
|
3283
|
+
ctx.ui.notify(`Footer settings were not saved: ${safeText(formatError2(error))}`, "error");
|
|
3284
|
+
return void 0;
|
|
2118
3285
|
}
|
|
2119
3286
|
}
|
|
2120
3287
|
function reviewPreviewBody(ctx, options, loaded, width, intent) {
|
|
2121
3288
|
if (intent.kind === "restore") return restorePreviewBody(ctx, options, loaded, width);
|
|
2122
|
-
if (intent.kind
|
|
2123
|
-
const
|
|
3289
|
+
if (intent.kind !== "preset") return previewBody(ctx, options, loaded, width);
|
|
3290
|
+
const current3 = configurationPresentation(options.getLoaded());
|
|
2124
3291
|
return [
|
|
2125
3292
|
`Preset: ${intent.preset.label}`,
|
|
2126
3293
|
`Requirement: ${intent.preset.requiresNerdFont ? "Nerd Font" : "No special font"}`,
|
|
2127
|
-
`Current: ${
|
|
3294
|
+
`Current: ${current3.state}`,
|
|
2128
3295
|
`Path: ${safeText(options.settingsPath)}`,
|
|
2129
3296
|
"Applying replaces the entire settings document, including custom settings, unknown fields, and comments.",
|
|
2130
|
-
"
|
|
3297
|
+
"The previous document will be kept in History before replacement.",
|
|
2131
3298
|
"",
|
|
2132
3299
|
...previewBody(ctx, options, loaded, width)
|
|
2133
3300
|
];
|
|
2134
3301
|
}
|
|
2135
3302
|
function restorePreviewBody(ctx, options, loaded, width) {
|
|
2136
|
-
const
|
|
3303
|
+
const current3 = configurationPresentation(options.getLoaded());
|
|
2137
3304
|
return [
|
|
2138
|
-
`Current: ${
|
|
3305
|
+
`Current: ${current3.state}`,
|
|
2139
3306
|
`Path: ${safeText(options.settingsPath)}`,
|
|
2140
3307
|
"The entire settings document will be replaced, including custom settings, unknown fields, and comments.",
|
|
2141
|
-
"
|
|
3308
|
+
"The previous document will be kept in History before replacement.",
|
|
2142
3309
|
"",
|
|
2143
3310
|
...previewBody(ctx, options, loaded, width)
|
|
2144
3311
|
];
|
|
@@ -2176,7 +3343,7 @@ function showHelp(ctx, settingsPath) {
|
|
|
2176
3343
|
if (!canNotify(ctx)) return;
|
|
2177
3344
|
ctx.ui.notify(
|
|
2178
3345
|
[
|
|
2179
|
-
"/starship \u2014
|
|
3346
|
+
"/starship \u2014 manage profiles, live-preview presets, recover history, explain, or inspect the footer in TUI mode",
|
|
2180
3347
|
"/starship settings \u2014 customize, preview, and apply TOML",
|
|
2181
3348
|
"/starship status \u2014 show source, path, and warnings",
|
|
2182
3349
|
"/starship help \u2014 show this help",
|
|
@@ -2201,6 +3368,7 @@ function formatError2(error) {
|
|
|
2201
3368
|
}
|
|
2202
3369
|
export {
|
|
2203
3370
|
handleStarshipCommand,
|
|
2204
|
-
registerStarshipCommand
|
|
3371
|
+
registerStarshipCommand,
|
|
3372
|
+
reviewAndApply
|
|
2205
3373
|
};
|
|
2206
|
-
//# sourceMappingURL=commands-
|
|
3374
|
+
//# sourceMappingURL=commands-C2VJ6ZBN.ts.map
|