castle-web-cli 0.4.215 → 0.4.216
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/dist/api.d.ts +14 -0
- package/dist/api.js +31 -0
- package/dist/cloudGit.d.ts +112 -1
- package/dist/cloudGit.js +1442 -73
- package/dist/cloudGitServe.js +2 -2
- package/dist/gitRemote.d.ts +1 -0
- package/dist/gitRemote.js +1 -0
- package/dist/ide.js +2 -2
- package/dist/index.js +25 -4
- package/dist/shell/assets/{index-DIRq6YrV.js → index-BZebTIjR.js} +2 -2
- package/dist/shell/index.html +1 -1
- package/package.json +1 -1
package/dist/cloudGit.js
CHANGED
|
@@ -1,8 +1,9 @@
|
|
|
1
|
-
import { execFile } from 'child_process';
|
|
2
|
-
import { randomUUID } from 'crypto';
|
|
1
|
+
import { execFile, spawn } from 'child_process';
|
|
2
|
+
import { createHash, randomUUID } from 'crypto';
|
|
3
3
|
import * as fs from 'fs';
|
|
4
4
|
import * as os from 'os';
|
|
5
5
|
import * as path from 'path';
|
|
6
|
+
import { fileURLToPath } from 'url';
|
|
6
7
|
import { GIT_HOSTS, GIT_REMOTE_NAME, isSandboxToken, runGit } from './gitRemote.js';
|
|
7
8
|
import { COVER_FILE } from './localPaths.js';
|
|
8
9
|
export const COMMIT_REASONS = ['turn', 'task', 'leave', 'manual', 'sync'];
|
|
@@ -29,6 +30,13 @@ export const EXIT_ERROR = 1;
|
|
|
29
30
|
export const EXIT_NOT_ENABLED = 2;
|
|
30
31
|
/** A merge with the remote is waiting on the agent; nothing was committed. */
|
|
31
32
|
export const EXIT_CONFLICT = 3;
|
|
33
|
+
/**
|
|
34
|
+
* GIT_HISTORY_UNAVAILABLE: the deck's refs name commits whose objects are gone (a cold resume,
|
|
35
|
+
* whose checkpoint carries no `.git/objects`) and neither the Castle remote, the S3 mirror nor
|
|
36
|
+
* the snapshot bundle could bring them back. Nothing was changed; the next command retries.
|
|
37
|
+
*/
|
|
38
|
+
export const EXIT_HISTORY_UNAVAILABLE = 4;
|
|
39
|
+
export const HISTORY_UNAVAILABLE_CODE = 'GIT_HISTORY_UNAVAILABLE';
|
|
32
40
|
export class CloudGitError extends Error {
|
|
33
41
|
exitCode;
|
|
34
42
|
constructor(message, exitCode = EXIT_ERROR) {
|
|
@@ -40,8 +48,9 @@ export class CloudGitError extends Error {
|
|
|
40
48
|
// Castle's excludes, in .git/info/exclude rather than a .gitignore, so they apply whatever
|
|
41
49
|
// the deck's own .gitignore says and never show up as a change to the deck.
|
|
42
50
|
export const CLOUD_EXCLUDES = ['node_modules/', 'dist/', '/imports/', '.castle/', '.vite/'];
|
|
43
|
-
// More loose objects than this and a commit packs the repo
|
|
44
|
-
//
|
|
51
|
+
// More loose objects than this and a commit packs the repo. Draft checkpoints no longer carry
|
|
52
|
+
// `.git/objects` (history is rebuilt from the remote, the S3 mirror and the snapshot bundle on
|
|
53
|
+
// a cold resume), but a pile of loose objects still slows every git command and the bundle.
|
|
45
54
|
export const LOOSE_OBJECT_LIMIT = 200;
|
|
46
55
|
const PACK_TIMEOUT_MS = 90_000;
|
|
47
56
|
// A command that has already run this long leaves packing to the next one, so a caller's
|
|
@@ -68,8 +77,13 @@ const PUSH_RETRIES = 2;
|
|
|
68
77
|
export const CONFLICT_MARKER_FILE = path.join('.castle', 'agent', 'git-conflict.json');
|
|
69
78
|
/** Written by `git attach` when it took the remote's version over a differing cloud copy. */
|
|
70
79
|
export const ADOPTED_MARKER_FILE = path.join('.castle', 'agent', 'git-adopted.json');
|
|
80
|
+
/** Written when a rehydrate gave up local commits nobody had (see recoverLostHistory). */
|
|
81
|
+
export const HISTORY_RECOVERED_FILE = path.join('.castle', 'agent', 'git-history-recovered.json');
|
|
82
|
+
export const RECOVERED_COMMIT_MESSAGE = 'Edits restored after lost history';
|
|
83
|
+
/** Written with it, once: the notice and instruction the serve turns into an agent turn. */
|
|
84
|
+
export const HISTORY_LOST_MARKER_FILE = path.join('.castle', 'agent', 'git-history-lost.json');
|
|
71
85
|
/** Every marker the serve turns into an agent turn. */
|
|
72
|
-
export const AGENT_MARKER_FILES = [CONFLICT_MARKER_FILE, ADOPTED_MARKER_FILE];
|
|
86
|
+
export const AGENT_MARKER_FILES = [CONFLICT_MARKER_FILE, ADOPTED_MARKER_FILE, HISTORY_LOST_MARKER_FILE];
|
|
73
87
|
/** The serve's note that task agents (or the router) are working in the deck; see deckBusy. */
|
|
74
88
|
export const BUSY_FILE = path.join('.castle', 'agent', 'git-busy.json');
|
|
75
89
|
/** The remote has (or may have) work that waits to be merged until the deck is idle. */
|
|
@@ -143,8 +157,9 @@ function cloudGitEnv(baseEnv) {
|
|
|
143
157
|
export function cloudGitRunner(baseEnv = process.env) {
|
|
144
158
|
const env = cloudGitEnv(baseEnv);
|
|
145
159
|
return (args, cwd, opts) => runGit(args, cwd, {
|
|
146
|
-
env: opts?.indexFile ? {
|
|
160
|
+
env: { ...env, ...(opts?.indexFile ? { GIT_INDEX_FILE: opts.indexFile } : {}), ...opts?.env },
|
|
147
161
|
timeoutMs: opts?.timeoutMs,
|
|
162
|
+
input: opts?.input,
|
|
148
163
|
});
|
|
149
164
|
}
|
|
150
165
|
// The async form, for the serve and the IDE server: their event loop must never wait on git.
|
|
@@ -167,7 +182,57 @@ function runGitAsync(args, cwd, baseEnv) {
|
|
|
167
182
|
});
|
|
168
183
|
});
|
|
169
184
|
}
|
|
170
|
-
|
|
185
|
+
// A bundle URL is a presigned S3 GET: https only (plain http is allowed to this machine alone,
|
|
186
|
+
// which is what the tests serve from).
|
|
187
|
+
function allowedBundleUrl(url) {
|
|
188
|
+
try {
|
|
189
|
+
const parsed = new URL(url);
|
|
190
|
+
if (parsed.protocol === 'https:')
|
|
191
|
+
return true;
|
|
192
|
+
return parsed.protocol === 'http:' && ['127.0.0.1', 'localhost', '[::1]'].includes(parsed.hostname);
|
|
193
|
+
}
|
|
194
|
+
catch {
|
|
195
|
+
return false;
|
|
196
|
+
}
|
|
197
|
+
}
|
|
198
|
+
/**
|
|
199
|
+
* Downloads `url` to `dest`, checking its exact size and SHA-256 where the mirror recorded them
|
|
200
|
+
* (a bundle listed by an older mirror run has neither); removes `dest` on any failure.
|
|
201
|
+
*/
|
|
202
|
+
// A bundle listed without its size (an older mirror run) is still bounded.
|
|
203
|
+
export const UNSIZED_DOWNLOAD_MAX_BYTES = 2 * 1024 * 1024 * 1024;
|
|
204
|
+
export async function downloadVerified(url, dest, opts) {
|
|
205
|
+
if (!allowedBundleUrl(url))
|
|
206
|
+
throw new Error('refusing a bundle URL that is not https');
|
|
207
|
+
const limit = opts.bytes ?? UNSIZED_DOWNLOAD_MAX_BYTES;
|
|
208
|
+
const handle = await fs.promises.open(dest, 'w');
|
|
209
|
+
try {
|
|
210
|
+
const res = await fetch(url, { signal: AbortSignal.timeout(opts.timeoutMs) });
|
|
211
|
+
if (!res.ok || !res.body)
|
|
212
|
+
throw new Error(`download failed: HTTP ${res.status}`);
|
|
213
|
+
const hash = createHash('sha256');
|
|
214
|
+
let size = 0;
|
|
215
|
+
for await (const chunk of res.body) {
|
|
216
|
+
size += chunk.byteLength;
|
|
217
|
+
if (size > limit)
|
|
218
|
+
throw new Error(`download is larger than the ${limit} bytes allowed`);
|
|
219
|
+
hash.update(chunk);
|
|
220
|
+
await handle.write(chunk);
|
|
221
|
+
}
|
|
222
|
+
if (opts.bytes !== null && size !== opts.bytes)
|
|
223
|
+
throw new Error(`download is ${size} bytes, expected ${opts.bytes}`);
|
|
224
|
+
const digest = hash.digest('hex');
|
|
225
|
+
if (opts.sha256 !== null && digest !== opts.sha256.toLowerCase())
|
|
226
|
+
throw new Error('download does not match its sha256');
|
|
227
|
+
}
|
|
228
|
+
catch (e) {
|
|
229
|
+
await handle.close().catch(() => undefined);
|
|
230
|
+
fs.rmSync(dest, { force: true });
|
|
231
|
+
throw e;
|
|
232
|
+
}
|
|
233
|
+
await handle.close();
|
|
234
|
+
}
|
|
235
|
+
export function defaultCloudGitDeps(whoAmI, extra = {}) {
|
|
171
236
|
// A caller's time limit arrives as SIGTERM: the command stops at its next safe point (never
|
|
172
237
|
// inside a git command) instead of dying wherever it happens to be.
|
|
173
238
|
let stopping = false;
|
|
@@ -186,6 +251,8 @@ export function defaultCloudGitDeps(whoAmI) {
|
|
|
186
251
|
hostname: () => os.hostname(),
|
|
187
252
|
isAlive: pidIsAlive,
|
|
188
253
|
stopRequested: () => new Promise((resolve) => setImmediate(() => resolve(stopping))),
|
|
254
|
+
download: downloadVerified,
|
|
255
|
+
...extra,
|
|
189
256
|
};
|
|
190
257
|
}
|
|
191
258
|
// A git step's timeout: its own, capped by the time left before the caller's deadline. A step
|
|
@@ -235,9 +302,38 @@ function localConfig(ctx, key) {
|
|
|
235
302
|
function gitDir(dir) {
|
|
236
303
|
return path.join(dir, '.git');
|
|
237
304
|
}
|
|
305
|
+
// A deck restored from a draft checkpoint has its `.git` without `.git/objects`: the capture
|
|
306
|
+
// leaves that directory out and stores files only, so every empty directory is gone too. Git
|
|
307
|
+
// does not even take such a directory for a repo ("not a git repository"). This puts back the
|
|
308
|
+
// empty directories git requires -- nothing else; the objects themselves are rehydrated under
|
|
309
|
+
// the deck lock (`castle-web git rehydrate`). Only for a real `.git` directory with a HEAD file.
|
|
310
|
+
export function repairGitSkeleton(dir) {
|
|
311
|
+
const root = gitDir(dir);
|
|
312
|
+
try {
|
|
313
|
+
if (!fs.lstatSync(root).isDirectory() || !fs.lstatSync(path.join(root, 'HEAD')).isFile())
|
|
314
|
+
return;
|
|
315
|
+
}
|
|
316
|
+
catch {
|
|
317
|
+
return;
|
|
318
|
+
}
|
|
319
|
+
for (const sub of [['objects', 'info'], ['objects', 'pack'], ['refs', 'heads'], ['refs', 'tags']]) {
|
|
320
|
+
const full = path.join(root, ...sub);
|
|
321
|
+
try {
|
|
322
|
+
if (!fs.existsSync(full))
|
|
323
|
+
fs.mkdirSync(full, { recursive: true, mode: 0o755 });
|
|
324
|
+
}
|
|
325
|
+
catch {
|
|
326
|
+
/* best effort: git reports what is still wrong */
|
|
327
|
+
}
|
|
328
|
+
}
|
|
329
|
+
}
|
|
238
330
|
export function mergeInProgress(dir) {
|
|
239
331
|
return fs.existsSync(path.join(gitDir(dir), 'MERGE_HEAD'));
|
|
240
332
|
}
|
|
333
|
+
/** A merge (or a recovered one's conflict markers) waits on the agent: only `--resolve` commits. */
|
|
334
|
+
export function mergeWaiting(dir) {
|
|
335
|
+
return mergeInProgress(dir) || readMergeState(dir)?.recovered === true;
|
|
336
|
+
}
|
|
241
337
|
function lines(text) {
|
|
242
338
|
return text.split('\n').map((l) => l.trim()).filter(Boolean);
|
|
243
339
|
}
|
|
@@ -263,6 +359,7 @@ export function isAttached(dir, git = cloudGitRunner()) {
|
|
|
263
359
|
catch {
|
|
264
360
|
return false;
|
|
265
361
|
}
|
|
362
|
+
repairGitSkeleton(dir);
|
|
266
363
|
const result = git(['config', '--local', '--get', 'castle.cloud'], dir);
|
|
267
364
|
return result.status === 0 && result.stdout.trim() === 'true';
|
|
268
365
|
}
|
|
@@ -284,6 +381,7 @@ export async function cloudGitModeAsync(dir, env = process.env) {
|
|
|
284
381
|
catch {
|
|
285
382
|
return false;
|
|
286
383
|
}
|
|
384
|
+
repairGitSkeleton(dir);
|
|
287
385
|
const result = await runGitAsync(['config', '--local', '--get', 'castle.cloud'], dir, env);
|
|
288
386
|
return result.status === 0 && result.stdout.trim() === 'true';
|
|
289
387
|
}
|
|
@@ -582,7 +680,8 @@ export function safeAuthorName(username) {
|
|
|
582
680
|
// a placeholder rather than failing, and the next one asks again. The value goes after the
|
|
583
681
|
// key, where git config takes it literally whatever it starts with.
|
|
584
682
|
async function identityArgs(ctx) {
|
|
585
|
-
|
|
683
|
+
const set = run(ctx, ['config', '--local', '--get-regexp', '^user\\.(name|email)$']);
|
|
684
|
+
if (set.status === 0 && lines(set.stdout).length >= 2)
|
|
586
685
|
return [];
|
|
587
686
|
let user = null;
|
|
588
687
|
try {
|
|
@@ -781,14 +880,17 @@ function commitMessageArgs(opts, reason) {
|
|
|
781
880
|
args.push('--trailer', AGENT_TRAILER);
|
|
782
881
|
return args;
|
|
783
882
|
}
|
|
784
|
-
|
|
785
|
-
|
|
786
|
-
|
|
883
|
+
// Fetches land as packs (unpackLimit=1), so packs pile up as loose objects used to.
|
|
884
|
+
const PACK_COUNT_LIMIT = 30;
|
|
885
|
+
function objectCounts(ctx) {
|
|
886
|
+
const out = must(ctx, ['count-objects', '-v']);
|
|
887
|
+
return { loose: Number(/^count: (\d+)$/m.exec(out)?.[1] ?? 0), packs: Number(/^packs: (\d+)$/m.exec(out)?.[1] ?? 0) };
|
|
787
888
|
}
|
|
788
889
|
// Geometric repacking rolls the loose objects into a new pack and merges only small packs,
|
|
789
890
|
// so it stays cheap as history grows (unlike rewriting one big pack every time).
|
|
790
891
|
export function packIfNeeded(ctx) {
|
|
791
|
-
|
|
892
|
+
const counts = objectCounts(ctx);
|
|
893
|
+
if (counts.loose <= LOOSE_OBJECT_LIMIT && counts.packs <= PACK_COUNT_LIMIT)
|
|
792
894
|
return false;
|
|
793
895
|
const geometric = run(ctx, ['repack', '-d', '-q', '--geometric=2'], { timeoutMs: PACK_TIMEOUT_MS });
|
|
794
896
|
if (geometric.status !== 0)
|
|
@@ -810,6 +912,1138 @@ async function packAfterCommit(ctx, reason) {
|
|
|
810
912
|
ctx.deps.warn(`Packing the repo failed (the commit is fine): ${e instanceof Error ? e.message : String(e)}`);
|
|
811
913
|
}
|
|
812
914
|
}
|
|
915
|
+
// --- snapshot bundle and rehydrate ------------------------------------------
|
|
916
|
+
//
|
|
917
|
+
// castle-sandboxes docs/git-remotes-snapshot-without-history.md, sections 2 and 3. Draft
|
|
918
|
+
// checkpoints no longer carry `.git/objects`. History lives on the Castle remote (code.storage)
|
|
919
|
+
// and in the deck's S3 mirror; what neither is known to hold yet -- local commits, and pushed
|
|
920
|
+
// ones the mirror has not caught up with -- goes in `.git/castle-snapshot.bundle`, which a
|
|
921
|
+
// checkpoint does carry. A cold resume rebuilds the objects with `castle-web git rehydrate`,
|
|
922
|
+
// which attach, sync and commits start in the background (exiting GIT_HISTORY_UNAVAILABLE at
|
|
923
|
+
// once: the host's checkpoint keeps the files whatever git does); the leave commit never does.
|
|
924
|
+
// Nothing here touches the working tree.
|
|
925
|
+
/** Every object the deck's local state reaches that the S3 mirror is not known to have. */
|
|
926
|
+
export const SNAPSHOT_BUNDLE_FILE = path.join('.git', 'castle-snapshot.bundle');
|
|
927
|
+
// What the snapshot was written from (so an unchanged one is not rewritten every turn), and
|
|
928
|
+
// the tips left out of it for being too big.
|
|
929
|
+
export const SNAPSHOT_KEY_FILE = path.join('.git', 'castle-snapshot.json');
|
|
930
|
+
/** main as ghost last reported the deck's S3 mirror had it: the bundle's floor. Only moves forward. */
|
|
931
|
+
export const MIRRORED_REF = 'refs/castle/mirrored';
|
|
932
|
+
/**
|
|
933
|
+
* One rehydrate at a time. Not named `*.lock`: clearStaleGitLocks removes those at the top of
|
|
934
|
+
* .git after a minute, and a rehydrate runs far longer than that.
|
|
935
|
+
*/
|
|
936
|
+
export const REHYDRATE_LOCK_FILE = path.join('.git', 'castle-rehydrate-lock');
|
|
937
|
+
/** Failed rehydrates and when the next background one may start (exponential backoff). */
|
|
938
|
+
export const REHYDRATE_STATE_FILE = path.join('.git', 'castle-rehydrate-state.json');
|
|
939
|
+
/** Where a background rehydrate writes its output. */
|
|
940
|
+
export const REHYDRATE_LOG_FILE = path.join('.castle', 'agent', 'git-rehydrate.log');
|
|
941
|
+
/** `off` stops commands from starting a background rehydrate (tests). */
|
|
942
|
+
export const BACKGROUND_REHYDRATE_ENV = 'CASTLE_GIT_BACKGROUND_REHYDRATE';
|
|
943
|
+
// The host's capture refuses any file over 32 MiB and fails the whole checkpoint with it. The
|
|
944
|
+
// snapshot and one set-aside lost snapshot stay under 48 MiB together.
|
|
945
|
+
export const SNAPSHOT_CAP_BYTES = 24 * 1024 * 1024;
|
|
946
|
+
/** A smaller cap, for tests. */
|
|
947
|
+
export const SNAPSHOT_CAP_ENV = 'CASTLE_GIT_SNAPSHOT_CAP_BYTES';
|
|
948
|
+
// Older builds split big snapshots into parts; whatever they left is removed.
|
|
949
|
+
const OLD_PART_FILE_RE = /^castle-snapshot-\d+\.bundle$/;
|
|
950
|
+
const OLD_PART_REF_PREFIX = 'refs/castle-snapshot-parts/';
|
|
951
|
+
const LOST_BUNDLE_RE = /^castle-lost-\d+-\d+\.bundle$/;
|
|
952
|
+
const SCRATCH_PREFIX = 'castle-rehydrate-';
|
|
953
|
+
const REHYDRATE_BUDGET_MS = 15 * 60_000;
|
|
954
|
+
const REHYDRATE_STEP_MS = 10 * 60_000;
|
|
955
|
+
const BACKOFF_MIN_MS = 60_000;
|
|
956
|
+
const BACKOFF_MAX_MS = 30 * 60_000;
|
|
957
|
+
const MIRROR_STATE_TIMEOUT_MS = 3_000;
|
|
958
|
+
const MIRROR_BUNDLES_TIMEOUT_MS = 15_000;
|
|
959
|
+
const CONNECTIVITY_TIMEOUT_MS = 120_000;
|
|
960
|
+
const BUNDLE_TIMEOUT_MS = 30_000;
|
|
961
|
+
// The host bounds the whole leave commit at 10 seconds.
|
|
962
|
+
const LEAVE_BUNDLE_TIMEOUT_MS = 4_000;
|
|
963
|
+
const REHYDRATE_LOG_MAX_BYTES = 256 * 1024;
|
|
964
|
+
const FREE_SPACE_MARGIN_BYTES = 256 * 1024 * 1024;
|
|
965
|
+
const OBJECT_ID_RE = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/;
|
|
966
|
+
// Every command in the scratch repo: its gc must never judge the deck's objects (it sees none of
|
|
967
|
+
// the deck's refs), and a fetch lands as one pack, so a killed one leaves nothing half-there.
|
|
968
|
+
const SCRATCH_CONFIG = [
|
|
969
|
+
'-c', 'gc.auto=0',
|
|
970
|
+
'-c', 'maintenance.auto=false',
|
|
971
|
+
'-c', 'fetch.unpackLimit=1',
|
|
972
|
+
'-c', 'transfer.unpackLimit=1',
|
|
973
|
+
'-c', 'core.createObject=rename',
|
|
974
|
+
];
|
|
975
|
+
function withTimeout(promise, ms, what) {
|
|
976
|
+
let timer;
|
|
977
|
+
const timeout = new Promise((_, reject) => {
|
|
978
|
+
timer = setTimeout(() => reject(new Error(`${what} timed out`)), ms);
|
|
979
|
+
timer.unref();
|
|
980
|
+
});
|
|
981
|
+
return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
|
|
982
|
+
}
|
|
983
|
+
function errorText(e) {
|
|
984
|
+
return e instanceof Error ? e.message : String(e);
|
|
985
|
+
}
|
|
986
|
+
// A ref's value without looking at the object: `revParse` peels to a commit, which fails when
|
|
987
|
+
// the commit's object is missing -- exactly the state this section has to see through.
|
|
988
|
+
function refValue(ctx, ref) {
|
|
989
|
+
const result = run(ctx, ['rev-parse', '--verify', '--quiet', ref]);
|
|
990
|
+
const sha = result.status === 0 ? result.stdout.trim() : '';
|
|
991
|
+
return OBJECT_ID_RE.test(sha) ? sha : null;
|
|
992
|
+
}
|
|
993
|
+
function remoteDeckId(ctx) {
|
|
994
|
+
const url = configuredRemoteUrl(ctx);
|
|
995
|
+
return (url ? CASTLE_REMOTE_RE.exec(url)?.[2] : undefined) ?? null;
|
|
996
|
+
}
|
|
997
|
+
function deckIdFor(ctx) {
|
|
998
|
+
return remoteDeckId(ctx) ?? readDeckId(ctx.dir);
|
|
999
|
+
}
|
|
1000
|
+
function snapshotCap(ctx) {
|
|
1001
|
+
const override = Number(ctx.deps.env[SNAPSHOT_CAP_ENV]);
|
|
1002
|
+
return Number.isInteger(override) && override > 0 ? override : SNAPSHOT_CAP_BYTES;
|
|
1003
|
+
}
|
|
1004
|
+
function fileSize(file) {
|
|
1005
|
+
try {
|
|
1006
|
+
return fs.statSync(file).size;
|
|
1007
|
+
}
|
|
1008
|
+
catch {
|
|
1009
|
+
return 0;
|
|
1010
|
+
}
|
|
1011
|
+
}
|
|
1012
|
+
// Castle's own refs and remote-tracking ones are not the deck's local state.
|
|
1013
|
+
function isCastleRef(name) {
|
|
1014
|
+
return name.startsWith('refs/castle/') || name.startsWith('refs/castle-') || name.startsWith('refs/remotes/');
|
|
1015
|
+
}
|
|
1016
|
+
// A local branch, HEAD or MERGE_HEAD: the tips a rehydrate must bring back or deliberately give
|
|
1017
|
+
// up. Every other ref (tags, stash, remote-tracking, Castle's own) can simply go when its
|
|
1018
|
+
// object is gone.
|
|
1019
|
+
function isBranchTip(name) {
|
|
1020
|
+
return name === 'HEAD' || name === 'MERGE_HEAD' || name.startsWith('refs/heads/');
|
|
1021
|
+
}
|
|
1022
|
+
function allRefs(ctx) {
|
|
1023
|
+
const args = ['for-each-ref', '--format=%(objectname) %(refname)'];
|
|
1024
|
+
const listed = run(ctx, args);
|
|
1025
|
+
if (listed.status !== 0)
|
|
1026
|
+
throw new CloudGitError(describeFailure(args, listed));
|
|
1027
|
+
const out = [];
|
|
1028
|
+
for (const line of lines(listed.stdout)) {
|
|
1029
|
+
const space = line.indexOf(' ');
|
|
1030
|
+
const sha = line.slice(0, space);
|
|
1031
|
+
const name = line.slice(space + 1);
|
|
1032
|
+
if (OBJECT_ID_RE.test(sha) && name)
|
|
1033
|
+
out.push({ name, sha });
|
|
1034
|
+
}
|
|
1035
|
+
return out;
|
|
1036
|
+
}
|
|
1037
|
+
function readShaFile(file) {
|
|
1038
|
+
try {
|
|
1039
|
+
const sha = fs.readFileSync(file, 'utf-8').split('\n')[0].trim();
|
|
1040
|
+
return OBJECT_ID_RE.test(sha) ? sha : null;
|
|
1041
|
+
}
|
|
1042
|
+
catch {
|
|
1043
|
+
return null;
|
|
1044
|
+
}
|
|
1045
|
+
}
|
|
1046
|
+
function readRefState(ctx) {
|
|
1047
|
+
const refs = allRefs(ctx);
|
|
1048
|
+
const root = gitDir(ctx.dir);
|
|
1049
|
+
let head = null;
|
|
1050
|
+
try {
|
|
1051
|
+
const text = fs.readFileSync(path.join(root, 'HEAD'), 'utf-8').trim();
|
|
1052
|
+
if (text.startsWith('ref: ')) {
|
|
1053
|
+
const target = text.slice('ref: '.length).trim();
|
|
1054
|
+
head = refs.find((ref) => ref.name === target)?.sha ?? null;
|
|
1055
|
+
}
|
|
1056
|
+
else if (OBJECT_ID_RE.test(text)) {
|
|
1057
|
+
head = text;
|
|
1058
|
+
}
|
|
1059
|
+
}
|
|
1060
|
+
catch {
|
|
1061
|
+
head = null;
|
|
1062
|
+
}
|
|
1063
|
+
return { refs, head, mergeHead: readShaFile(path.join(root, 'MERGE_HEAD')), origHead: readShaFile(path.join(root, 'ORIG_HEAD')) };
|
|
1064
|
+
}
|
|
1065
|
+
function stateRef(state, name) {
|
|
1066
|
+
return state.refs.find((ref) => ref.name === name)?.sha ?? null;
|
|
1067
|
+
}
|
|
1068
|
+
/** The deck's local state: HEAD, MERGE_HEAD, ORIG_HEAD and every ref but Castle's and remote ones. */
|
|
1069
|
+
function localTips(state) {
|
|
1070
|
+
const tips = [];
|
|
1071
|
+
if (state.head)
|
|
1072
|
+
tips.push({ name: 'HEAD', sha: state.head });
|
|
1073
|
+
if (state.mergeHead)
|
|
1074
|
+
tips.push({ name: 'MERGE_HEAD', sha: state.mergeHead });
|
|
1075
|
+
if (state.origHead)
|
|
1076
|
+
tips.push({ name: 'ORIG_HEAD', sha: state.origHead });
|
|
1077
|
+
return [...tips, ...state.refs.filter((tip) => !isCastleRef(tip.name))];
|
|
1078
|
+
}
|
|
1079
|
+
/** The tips whose history the deck needs: its local state (ORIG_HEAD aside) and castle/main. */
|
|
1080
|
+
function requiredTips(state) {
|
|
1081
|
+
const tips = localTips(state).filter((tip) => tip.name !== 'ORIG_HEAD');
|
|
1082
|
+
const remote = stateRef(state, REMOTE_MAIN);
|
|
1083
|
+
if (remote)
|
|
1084
|
+
tips.push({ name: REMOTE_MAIN, sha: remote });
|
|
1085
|
+
return tips;
|
|
1086
|
+
}
|
|
1087
|
+
/**
|
|
1088
|
+
* The tips whose object is not in the object store -- one `cat-file` for all of them. A
|
|
1089
|
+
* branch-like tip must be a commit; a tag may name any object, so only its existence counts.
|
|
1090
|
+
* An error other than a missing object throws.
|
|
1091
|
+
*/
|
|
1092
|
+
function missingTips(ctx, tips) {
|
|
1093
|
+
if (tips.length === 0)
|
|
1094
|
+
return [];
|
|
1095
|
+
const args = ['cat-file', '--batch-check=%(objectname)'];
|
|
1096
|
+
const input = tips.map((tip) => (isBranchTip(tip.name) || tip.name === REMOTE_MAIN ? `${tip.sha}^{commit}` : tip.sha));
|
|
1097
|
+
const result = run(ctx, args, { input: input.join('\n') + '\n' });
|
|
1098
|
+
if (result.status !== 0)
|
|
1099
|
+
throw new CloudGitError(describeFailure(args, result));
|
|
1100
|
+
const out = result.stdout.split('\n');
|
|
1101
|
+
return tips.filter((_, i) => {
|
|
1102
|
+
const line = (out[i] ?? '').trim();
|
|
1103
|
+
if (OBJECT_ID_RE.test(line))
|
|
1104
|
+
return false;
|
|
1105
|
+
if (/ missing$/.test(line))
|
|
1106
|
+
return true;
|
|
1107
|
+
throw new CloudGitError(`Could not check the deck's git objects: unexpected \`git cat-file\` output ${JSON.stringify(line)}`);
|
|
1108
|
+
});
|
|
1109
|
+
}
|
|
1110
|
+
function historyMissing(ctx, state = readRefState(ctx)) {
|
|
1111
|
+
return missingTips(ctx, requiredTips(state));
|
|
1112
|
+
}
|
|
1113
|
+
/** Whether the deck's history is being rebuilt: refs name objects that are not here. */
|
|
1114
|
+
export function historyLoading(dir, git = cloudGitRunner()) {
|
|
1115
|
+
try {
|
|
1116
|
+
repairGitSkeleton(dir);
|
|
1117
|
+
const ctx = { dir, deps: { git }, startedAt: 0 };
|
|
1118
|
+
return historyMissing(ctx).length > 0;
|
|
1119
|
+
}
|
|
1120
|
+
catch {
|
|
1121
|
+
return false;
|
|
1122
|
+
}
|
|
1123
|
+
}
|
|
1124
|
+
// The full test, after a rehydrate: every object reachable from the tips is here. The object
|
|
1125
|
+
// list is streamed, never held. Git 2.39 (the sandbox image's) exits with "Could not read" /
|
|
1126
|
+
// "Failed to traverse parents" on a missing commit where newer ones print `?<id>`; both mean
|
|
1127
|
+
// incomplete. Any other failure throws.
|
|
1128
|
+
async function historyIncomplete(ctx, shas) {
|
|
1129
|
+
const wanted = [...new Set(shas)];
|
|
1130
|
+
if (wanted.length === 0)
|
|
1131
|
+
return false;
|
|
1132
|
+
const args = ['rev-list', '--objects', '--no-object-names', '--missing=print', ...wanted];
|
|
1133
|
+
const timeoutMs = stepTimeout(ctx, args.slice(0, 4), CONNECTIVITY_TIMEOUT_MS) ?? CONNECTIVITY_TIMEOUT_MS;
|
|
1134
|
+
return new Promise((resolve, reject) => {
|
|
1135
|
+
const child = spawn('git', args, {
|
|
1136
|
+
cwd: ctx.dir,
|
|
1137
|
+
env: { ...cloudGitEnv(ctx.deps.env), LC_ALL: 'C', LANGUAGE: 'C' },
|
|
1138
|
+
stdio: ['ignore', 'pipe', 'pipe'],
|
|
1139
|
+
});
|
|
1140
|
+
let missing = false;
|
|
1141
|
+
let tail = '';
|
|
1142
|
+
let stderr = '';
|
|
1143
|
+
child.stdout.setEncoding('utf-8');
|
|
1144
|
+
child.stdout.on('data', (chunk) => {
|
|
1145
|
+
const text = tail + chunk;
|
|
1146
|
+
if (/(?:^|\n)\?/.test(text))
|
|
1147
|
+
missing = true;
|
|
1148
|
+
tail = text.slice(text.lastIndexOf('\n') + 1);
|
|
1149
|
+
});
|
|
1150
|
+
child.stderr.setEncoding('utf-8');
|
|
1151
|
+
child.stderr.on('data', (chunk) => {
|
|
1152
|
+
stderr = (stderr + chunk).slice(-4000);
|
|
1153
|
+
});
|
|
1154
|
+
const timer = setTimeout(() => child.kill('SIGKILL'), timeoutMs);
|
|
1155
|
+
child.on('error', (e) => {
|
|
1156
|
+
clearTimeout(timer);
|
|
1157
|
+
reject(e);
|
|
1158
|
+
});
|
|
1159
|
+
child.on('close', (code, signal) => {
|
|
1160
|
+
clearTimeout(timer);
|
|
1161
|
+
if (tail.startsWith('?'))
|
|
1162
|
+
missing = true;
|
|
1163
|
+
if (code === 0)
|
|
1164
|
+
return resolve(missing);
|
|
1165
|
+
if (/could not read|failed to traverse|bad object|missing/i.test(stderr))
|
|
1166
|
+
return resolve(true);
|
|
1167
|
+
reject(new CloudGitError(`\`git rev-list --objects\` failed: ${signal ? 'timed out' : stderr.trim() || `exit ${String(code)}`}`));
|
|
1168
|
+
});
|
|
1169
|
+
});
|
|
1170
|
+
}
|
|
1171
|
+
function historyUnavailable(missing, why) {
|
|
1172
|
+
const names = [...new Set(missing.map((tip) => tip.name))].join(', ');
|
|
1173
|
+
return new CloudGitError(`${HISTORY_UNAVAILABLE_CODE}: this deck's git history is not available yet${names ? ` (missing: ${names})` : ''}. ${why} ` +
|
|
1174
|
+
"Nothing was changed: the deck's files are fine, and git picks up again once the history is back.", EXIT_HISTORY_UNAVAILABLE);
|
|
1175
|
+
}
|
|
1176
|
+
function readSnapshotKey(dir) {
|
|
1177
|
+
try {
|
|
1178
|
+
return JSON.parse(fs.readFileSync(path.join(dir, SNAPSHOT_KEY_FILE), 'utf-8'));
|
|
1179
|
+
}
|
|
1180
|
+
catch {
|
|
1181
|
+
return null;
|
|
1182
|
+
}
|
|
1183
|
+
}
|
|
1184
|
+
function sameSnapshotKey(a, b) {
|
|
1185
|
+
return JSON.stringify([a.tips, a.mirrored, a.remoteMain, a.cap]) === JSON.stringify([b.tips, b.mirrored, b.remoteMain, b.cap]);
|
|
1186
|
+
}
|
|
1187
|
+
// Temp bundles are written inside .git/objects: the host's capture leaves that directory out
|
|
1188
|
+
// (an oversized temp file can never fail a checkpoint), it is on the same filesystem as the
|
|
1189
|
+
// snapshot for the rename, and git ignores a directory there it does not know.
|
|
1190
|
+
const SNAPSHOT_TMP_DIR = path.join('.git', 'objects', 'castle-tmp');
|
|
1191
|
+
// Temp and lock files a killed write left, split parts and their refs from older builds (only
|
|
1192
|
+
// ever ours: the deck lock is held).
|
|
1193
|
+
function cleanSnapshotLeftovers(ctx, state) {
|
|
1194
|
+
const root = gitDir(ctx.dir);
|
|
1195
|
+
let names = [];
|
|
1196
|
+
try {
|
|
1197
|
+
names = fs.readdirSync(root);
|
|
1198
|
+
}
|
|
1199
|
+
catch {
|
|
1200
|
+
names = [];
|
|
1201
|
+
}
|
|
1202
|
+
for (const name of names) {
|
|
1203
|
+
const leftover = name.startsWith('castle-snapshot') && (/\.tmp/.test(name) || name.endsWith('.lock'));
|
|
1204
|
+
if (leftover || OLD_PART_FILE_RE.test(name))
|
|
1205
|
+
fs.rmSync(path.join(root, name), { force: true });
|
|
1206
|
+
}
|
|
1207
|
+
fs.rmSync(path.join(ctx.dir, SNAPSHOT_TMP_DIR), { recursive: true, force: true });
|
|
1208
|
+
for (const ref of state.refs) {
|
|
1209
|
+
if (ref.name.startsWith(OLD_PART_REF_PREFIX))
|
|
1210
|
+
run(ctx, ['update-ref', '-d', ref.name]);
|
|
1211
|
+
}
|
|
1212
|
+
}
|
|
1213
|
+
function createBundle(ctx, file, refs, not, timeoutMs) {
|
|
1214
|
+
fs.rmSync(file, { force: true });
|
|
1215
|
+
const args = ['bundle', 'create', '--quiet', file, ...refs, ...(not.length ? ['--not', ...not] : [])];
|
|
1216
|
+
let result;
|
|
1217
|
+
try {
|
|
1218
|
+
result = run(ctx, args, { timeoutMs });
|
|
1219
|
+
}
|
|
1220
|
+
catch (e) {
|
|
1221
|
+
fs.rmSync(file, { force: true });
|
|
1222
|
+
throw e;
|
|
1223
|
+
}
|
|
1224
|
+
if (result.status === 0)
|
|
1225
|
+
return 'ok';
|
|
1226
|
+
fs.rmSync(file, { force: true });
|
|
1227
|
+
if (/empty bundle/i.test(result.stderr))
|
|
1228
|
+
return 'empty';
|
|
1229
|
+
ctx.deps.warn(`Could not write the snapshot bundle (the previous one is kept): ${describeFailure(args, result)}`);
|
|
1230
|
+
return 'failed';
|
|
1231
|
+
}
|
|
1232
|
+
/**
|
|
1233
|
+
* Writes the snapshot: HEAD, MERGE_HEAD, ORIG_HEAD and every local ref, minus what the floor
|
|
1234
|
+
* reaches -- refs/castle/mirrored, or castle/main when that one comes out over the cap (pushed
|
|
1235
|
+
* objects are on code.storage). Still over the cap: no snapshot at all, and the key file says
|
|
1236
|
+
* which tips were left out. Nothing it is written from changed: nothing is done at all, not
|
|
1237
|
+
* even a git command. A new bundle is renamed over the old one (never removed first), and the
|
|
1238
|
+
* key is written last. Only for a deck whose history is known to be here.
|
|
1239
|
+
*/
|
|
1240
|
+
function writeSnapshotBundle(ctx, timeoutMs, state) {
|
|
1241
|
+
cleanSnapshotLeftovers(ctx, state);
|
|
1242
|
+
let tips = localTips(state);
|
|
1243
|
+
const mirrored = stateRef(state, MIRRORED_REF);
|
|
1244
|
+
const remoteMain = stateRef(state, REMOTE_MAIN);
|
|
1245
|
+
const cap = snapshotCap(ctx);
|
|
1246
|
+
const keyOf = (list) => ({ tips: list.map((t) => `${t.sha} ${t.name}`), mirrored, remoteMain, cap });
|
|
1247
|
+
let key = keyOf(tips);
|
|
1248
|
+
const file = path.join(ctx.dir, SNAPSHOT_BUNDLE_FILE);
|
|
1249
|
+
const old = readSnapshotKey(ctx.dir);
|
|
1250
|
+
const unchanged = () => old && sameSnapshotKey(old, key) && (old.skipped || fs.existsSync(file) === Boolean(old.written));
|
|
1251
|
+
if (unchanged())
|
|
1252
|
+
return 'unchanged';
|
|
1253
|
+
// ORIG_HEAD is only a convenience: one naming a missing object would fail every bundle write.
|
|
1254
|
+
if (state.origHead && missingTips(ctx, [{ name: 'ORIG_HEAD', sha: state.origHead }]).length > 0) {
|
|
1255
|
+
fs.rmSync(path.join(gitDir(ctx.dir), 'ORIG_HEAD'), { force: true });
|
|
1256
|
+
tips = tips.filter((tip) => tip.name !== 'ORIG_HEAD');
|
|
1257
|
+
key = keyOf(tips);
|
|
1258
|
+
if (unchanged())
|
|
1259
|
+
return 'unchanged';
|
|
1260
|
+
}
|
|
1261
|
+
const keyFile = path.join(ctx.dir, SNAPSHOT_KEY_FILE);
|
|
1262
|
+
if (tips.length === 0) {
|
|
1263
|
+
fs.rmSync(file, { force: true });
|
|
1264
|
+
writeJsonAtomic(keyFile, { ...key, written: false });
|
|
1265
|
+
return 'empty';
|
|
1266
|
+
}
|
|
1267
|
+
// A floor already found too low for these tips' growing set is not tried again.
|
|
1268
|
+
const mirrorOverCap = old?.mirrorOverCap && old.mirrorOverCap === mirrored ? mirrored : undefined;
|
|
1269
|
+
const floors = [];
|
|
1270
|
+
if (mirrored && !mirrorOverCap)
|
|
1271
|
+
floors.push(MIRRORED_REF);
|
|
1272
|
+
if (remoteMain && remoteMain !== mirrored)
|
|
1273
|
+
floors.push(REMOTE_MAIN);
|
|
1274
|
+
if (floors.length === 0 && mirrored)
|
|
1275
|
+
floors.push(MIRRORED_REF);
|
|
1276
|
+
const attempts = floors.length ? floors : [null];
|
|
1277
|
+
fs.mkdirSync(path.join(ctx.dir, SNAPSHOT_TMP_DIR), { recursive: true });
|
|
1278
|
+
const tmp = path.join(ctx.dir, SNAPSHOT_TMP_DIR, 'castle-snapshot.bundle.tmp');
|
|
1279
|
+
let overMirror = mirrorOverCap ?? undefined;
|
|
1280
|
+
try {
|
|
1281
|
+
for (const floor of attempts) {
|
|
1282
|
+
const result = createBundle(ctx, tmp, tips.map((t) => t.name), floor ? [floor] : [], timeoutMs);
|
|
1283
|
+
if (result === 'failed')
|
|
1284
|
+
return 'failed';
|
|
1285
|
+
if (result === 'empty') {
|
|
1286
|
+
fs.rmSync(file, { force: true });
|
|
1287
|
+
writeJsonAtomic(keyFile, { ...key, written: false, ...(overMirror ? { mirrorOverCap: overMirror } : {}) });
|
|
1288
|
+
return 'empty';
|
|
1289
|
+
}
|
|
1290
|
+
if (fileSize(tmp) <= cap) {
|
|
1291
|
+
fs.renameSync(tmp, file);
|
|
1292
|
+
writeJsonAtomic(keyFile, { ...key, written: true, ...(overMirror ? { mirrorOverCap: overMirror } : {}) });
|
|
1293
|
+
return 'written';
|
|
1294
|
+
}
|
|
1295
|
+
if (floor === MIRRORED_REF && mirrored)
|
|
1296
|
+
overMirror = mirrored;
|
|
1297
|
+
fs.rmSync(tmp, { force: true });
|
|
1298
|
+
}
|
|
1299
|
+
}
|
|
1300
|
+
finally {
|
|
1301
|
+
fs.rmSync(path.join(ctx.dir, SNAPSHOT_TMP_DIR), { recursive: true, force: true });
|
|
1302
|
+
}
|
|
1303
|
+
fs.rmSync(file, { force: true });
|
|
1304
|
+
writeJsonAtomic(keyFile, {
|
|
1305
|
+
...key,
|
|
1306
|
+
written: false,
|
|
1307
|
+
...(overMirror ? { mirrorOverCap: overMirror } : {}),
|
|
1308
|
+
skipped: { tips: Object.fromEntries(tips.map((t) => [t.name, t.sha])), reason: 'over_cap', at: new Date(ctx.deps.now()).toISOString() },
|
|
1309
|
+
});
|
|
1310
|
+
ctx.deps.warn(`The snapshot bundle would be over ${Math.round(cap / 1024 / 1024)} MB even above castle/main, so there is none: unpushed commits are safe once pushed.`);
|
|
1311
|
+
return 'skipped';
|
|
1312
|
+
}
|
|
1313
|
+
/**
|
|
1314
|
+
* Moves refs/castle/mirrored to what ghost says the mirror has, when that commit is here and
|
|
1315
|
+
* either follows the current floor or is part of castle/main (a force-push from a laptop can
|
|
1316
|
+
* leave the old floor off the remote's line; a floor that moves back only makes the bundle
|
|
1317
|
+
* bigger, never unsafe). True when it moved.
|
|
1318
|
+
*/
|
|
1319
|
+
function advanceMirrorFloor(ctx, mainSha, state) {
|
|
1320
|
+
if (!mainSha || !OBJECT_ID_RE.test(mainSha))
|
|
1321
|
+
return false;
|
|
1322
|
+
const old = stateRef(state, MIRRORED_REF);
|
|
1323
|
+
if (old === mainSha)
|
|
1324
|
+
return false;
|
|
1325
|
+
if (!ok(ctx, ['cat-file', '-e', `${mainSha}^{commit}`]))
|
|
1326
|
+
return false;
|
|
1327
|
+
const remote = stateRef(state, REMOTE_MAIN);
|
|
1328
|
+
const forward = old !== null && ok(ctx, ['merge-base', '--is-ancestor', old, mainSha]);
|
|
1329
|
+
const onRemote = remote !== null && ok(ctx, ['merge-base', '--is-ancestor', mainSha, remote]);
|
|
1330
|
+
// Never backwards: a commit off the current floor's line only replaces a floor that is itself
|
|
1331
|
+
// off castle/main's.
|
|
1332
|
+
if (old && !forward && (!onRemote || (remote !== null && ok(ctx, ['merge-base', '--is-ancestor', old, remote]))))
|
|
1333
|
+
return false;
|
|
1334
|
+
return ok(ctx, ['update-ref', '-m', 'castle: mirror state', MIRRORED_REF, mainSha, old ?? '']);
|
|
1335
|
+
}
|
|
1336
|
+
// Before a command's git work: the deck's refs, read once and handed on. With history missing
|
|
1337
|
+
// it starts a background rehydrate -- never on leave -- and throws GIT_HISTORY_UNAVAILABLE.
|
|
1338
|
+
function requireHistory(ctx, opts) {
|
|
1339
|
+
repairGitSkeleton(ctx.dir);
|
|
1340
|
+
const state = readRefState(ctx);
|
|
1341
|
+
const missing = historyMissing(ctx, state);
|
|
1342
|
+
if (missing.length === 0)
|
|
1343
|
+
return state;
|
|
1344
|
+
if (opts.leave)
|
|
1345
|
+
throw historyUnavailable(missing, 'The leave commit does not rebuild history, so it was skipped.');
|
|
1346
|
+
throw historyUnavailable(missing, startBackgroundRehydrate(ctx));
|
|
1347
|
+
}
|
|
1348
|
+
// When castle/main moved since the last question, or it has been a while: ghost's
|
|
1349
|
+
// gitMirrorState. Asked before the deck lock is taken -- never while holding it -- from what
|
|
1350
|
+
// the last snapshot key recorded; the answer is applied under the lock. `always` for a sync
|
|
1351
|
+
// (ghost pokes the sync route after each mirror run). Undefined: not asked.
|
|
1352
|
+
const MIRROR_QUERY_FILE = path.join('.git', 'castle-mirror-query.json');
|
|
1353
|
+
const MIRROR_QUERY_INTERVAL_MS = 5 * 60_000;
|
|
1354
|
+
async function askMirrorIfDue(ctx, opts) {
|
|
1355
|
+
const mirror = ctx.deps.mirrorState;
|
|
1356
|
+
if (!mirror)
|
|
1357
|
+
return undefined;
|
|
1358
|
+
const key = readSnapshotKey(ctx.dir);
|
|
1359
|
+
if (!key?.remoteMain || key.mirrored === key.remoteMain)
|
|
1360
|
+
return undefined;
|
|
1361
|
+
let last = null;
|
|
1362
|
+
try {
|
|
1363
|
+
last = JSON.parse(fs.readFileSync(path.join(ctx.dir, MIRROR_QUERY_FILE), 'utf-8'));
|
|
1364
|
+
}
|
|
1365
|
+
catch {
|
|
1366
|
+
last = null;
|
|
1367
|
+
}
|
|
1368
|
+
const due = opts.always || !last || last.remoteMain !== key.remoteMain || ctx.deps.now() - (last.at ?? 0) >= MIRROR_QUERY_INTERVAL_MS;
|
|
1369
|
+
if (!due)
|
|
1370
|
+
return undefined;
|
|
1371
|
+
const deckId = readDeckId(ctx.dir);
|
|
1372
|
+
if (!deckId)
|
|
1373
|
+
return undefined;
|
|
1374
|
+
try {
|
|
1375
|
+
writeJsonAtomic(path.join(ctx.dir, MIRROR_QUERY_FILE), { remoteMain: key.remoteMain, at: ctx.deps.now() });
|
|
1376
|
+
return await withTimeout(mirror(deckId, { includeBundles: false, timeoutMs: MIRROR_STATE_TIMEOUT_MS }), MIRROR_STATE_TIMEOUT_MS + 500, 'gitMirrorState');
|
|
1377
|
+
}
|
|
1378
|
+
catch (e) {
|
|
1379
|
+
ctx.deps.log(`Could not ask for the deck's mirror state (the snapshot keeps its floor): ${errorText(e)}`);
|
|
1380
|
+
return undefined;
|
|
1381
|
+
}
|
|
1382
|
+
}
|
|
1383
|
+
// The key file tells the host's checkpoint it may leave `.git/objects` out. A write that fails
|
|
1384
|
+
// leaves the previous bundle and key in place (and creates no key where there was none): a
|
|
1385
|
+
// checkpoint that carried the objects could trip the host's per-file limit and lose the deck's
|
|
1386
|
+
// files, while a stale bundle risks only the newest commits' history -- which the leave commit
|
|
1387
|
+
// usually pushes, and a recovery keeps the files of.
|
|
1388
|
+
// After a command's git work: apply the mirror answer asked for before the lock, then rewrite
|
|
1389
|
+
// the bundle if anything it is written from changed. `state` is the command's own when it
|
|
1390
|
+
// changed no ref. Never fails the command.
|
|
1391
|
+
function refreshSnapshot(ctx, leave, opts = {}) {
|
|
1392
|
+
try {
|
|
1393
|
+
let state = opts.state ?? readRefState(ctx);
|
|
1394
|
+
if (!leave && opts.mirror && advanceMirrorFloor(ctx, opts.mirror.mainSha, state))
|
|
1395
|
+
state = readRefState(ctx);
|
|
1396
|
+
if (writeSnapshotBundle(ctx, leave ? LEAVE_BUNDLE_TIMEOUT_MS : BUNDLE_TIMEOUT_MS, state) === 'failed') {
|
|
1397
|
+
ctx.deps.warn('The snapshot bundle was not updated; the previous one (and its key file) stay.');
|
|
1398
|
+
}
|
|
1399
|
+
}
|
|
1400
|
+
catch (e) {
|
|
1401
|
+
ctx.deps.warn(`Could not refresh the snapshot bundle (the previous one and its key file stay): ${errorText(e)}`);
|
|
1402
|
+
}
|
|
1403
|
+
}
|
|
1404
|
+
function bootId() {
|
|
1405
|
+
try {
|
|
1406
|
+
return fs.readFileSync('/proc/sys/kernel/random/boot_id', 'utf-8').trim() || null;
|
|
1407
|
+
}
|
|
1408
|
+
catch {
|
|
1409
|
+
return null;
|
|
1410
|
+
}
|
|
1411
|
+
}
|
|
1412
|
+
/** This container's rehydrate backoff; state another host (or boot) wrote does not count. */
|
|
1413
|
+
export function readRehydrateState(dir, host = os.hostname()) {
|
|
1414
|
+
try {
|
|
1415
|
+
const state = JSON.parse(fs.readFileSync(path.join(dir, REHYDRATE_STATE_FILE), 'utf-8'));
|
|
1416
|
+
if (typeof state.failures !== 'number' || typeof state.nextAttemptAt !== 'number')
|
|
1417
|
+
return null;
|
|
1418
|
+
if (state.host !== host)
|
|
1419
|
+
return null;
|
|
1420
|
+
const boot = bootId();
|
|
1421
|
+
if (state.bootId && boot && state.bootId !== boot)
|
|
1422
|
+
return null;
|
|
1423
|
+
return state;
|
|
1424
|
+
}
|
|
1425
|
+
catch {
|
|
1426
|
+
return null;
|
|
1427
|
+
}
|
|
1428
|
+
}
|
|
1429
|
+
function recordRehydrateFailure(ctx, message) {
|
|
1430
|
+
try {
|
|
1431
|
+
const host = ctx.deps.hostname();
|
|
1432
|
+
const failures = (readRehydrateState(ctx.dir, host)?.failures ?? 0) + 1;
|
|
1433
|
+
const delay = Math.min(BACKOFF_MAX_MS, BACKOFF_MIN_MS * 2 ** Math.min(failures - 1, 10));
|
|
1434
|
+
writeJsonAtomic(path.join(ctx.dir, REHYDRATE_STATE_FILE), {
|
|
1435
|
+
failures,
|
|
1436
|
+
lastFailureAt: new Date(ctx.deps.now()).toISOString(),
|
|
1437
|
+
nextAttemptAt: ctx.deps.now() + delay,
|
|
1438
|
+
lastError: message.slice(0, 2000),
|
|
1439
|
+
host,
|
|
1440
|
+
bootId: bootId(),
|
|
1441
|
+
});
|
|
1442
|
+
}
|
|
1443
|
+
catch {
|
|
1444
|
+
/* best effort */
|
|
1445
|
+
}
|
|
1446
|
+
}
|
|
1447
|
+
function rehydrateRunning(ctx) {
|
|
1448
|
+
try {
|
|
1449
|
+
const seen = inspectLock(path.join(ctx.dir, REHYDRATE_LOCK_FILE));
|
|
1450
|
+
return seen !== null && !holderIsGone(ctx.deps, seen);
|
|
1451
|
+
}
|
|
1452
|
+
catch {
|
|
1453
|
+
return false;
|
|
1454
|
+
}
|
|
1455
|
+
}
|
|
1456
|
+
function tryRehydrateLock(ctx) {
|
|
1457
|
+
try {
|
|
1458
|
+
return acquireLockFile(path.join(ctx.dir, REHYDRATE_LOCK_FILE), ctx.deps, 0);
|
|
1459
|
+
}
|
|
1460
|
+
catch (e) {
|
|
1461
|
+
if (e instanceof CloudGitError)
|
|
1462
|
+
return null;
|
|
1463
|
+
throw e;
|
|
1464
|
+
}
|
|
1465
|
+
}
|
|
1466
|
+
const CLI_ENTRY = path.join(path.dirname(fileURLToPath(import.meta.url)), 'index.js');
|
|
1467
|
+
/** Starts `castle-web git rehydrate` for the deck in its own session, its output to REHYDRATE_LOG_FILE. */
|
|
1468
|
+
export function spawnDetachedRehydrate(dir, env) {
|
|
1469
|
+
const log = path.join(dir, REHYDRATE_LOG_FILE);
|
|
1470
|
+
fs.mkdirSync(path.dirname(log), { recursive: true });
|
|
1471
|
+
if (fileSize(log) > REHYDRATE_LOG_MAX_BYTES)
|
|
1472
|
+
fs.rmSync(log, { force: true });
|
|
1473
|
+
const fd = fs.openSync(log, 'a');
|
|
1474
|
+
try {
|
|
1475
|
+
const childEnv = { ...env };
|
|
1476
|
+
// Not this command's deadline: the rehydrate has its own budget.
|
|
1477
|
+
delete childEnv[DEADLINE_ENV];
|
|
1478
|
+
const child = spawn(process.execPath, [CLI_ENTRY, 'git', 'rehydrate', '--dir', dir], {
|
|
1479
|
+
cwd: dir,
|
|
1480
|
+
env: childEnv,
|
|
1481
|
+
detached: true,
|
|
1482
|
+
stdio: ['ignore', fd, fd],
|
|
1483
|
+
});
|
|
1484
|
+
child.on('error', () => undefined);
|
|
1485
|
+
child.unref();
|
|
1486
|
+
}
|
|
1487
|
+
finally {
|
|
1488
|
+
fs.closeSync(fd);
|
|
1489
|
+
}
|
|
1490
|
+
}
|
|
1491
|
+
// Starts a background rehydrate unless one is running, the last failure's backoff has not
|
|
1492
|
+
// passed, or it is switched off. Says which, for the error message.
|
|
1493
|
+
function startBackgroundRehydrate(ctx) {
|
|
1494
|
+
if (ctx.deps.env[BACKGROUND_REHYDRATE_ENV] === 'off')
|
|
1495
|
+
return 'Background rehydrate is switched off here.';
|
|
1496
|
+
if (rehydrateRunning(ctx))
|
|
1497
|
+
return 'A rehydrate is already fetching it.';
|
|
1498
|
+
const state = readRehydrateState(ctx.dir, ctx.deps.hostname());
|
|
1499
|
+
if (state && state.nextAttemptAt > ctx.deps.now()) {
|
|
1500
|
+
return `The last rehydrate failed (${state.lastError.slice(0, 200)}); the next try is after ${new Date(state.nextAttemptAt).toISOString()}.`;
|
|
1501
|
+
}
|
|
1502
|
+
try {
|
|
1503
|
+
(ctx.deps.spawnRehydrate ?? spawnDetachedRehydrate)(ctx.dir, ctx.deps.env);
|
|
1504
|
+
return `A rehydrate started in the background (log: ${REHYDRATE_LOG_FILE}).`;
|
|
1505
|
+
}
|
|
1506
|
+
catch (e) {
|
|
1507
|
+
return `Could not start a rehydrate: ${errorText(e)}.`;
|
|
1508
|
+
}
|
|
1509
|
+
}
|
|
1510
|
+
// Scratch directories a killed rehydrate left in the temp dir: named for their process, removed
|
|
1511
|
+
// once that process is gone and they are older than a whole rehydrate.
|
|
1512
|
+
function sweepScratchDirs(ctx) {
|
|
1513
|
+
const root = os.tmpdir();
|
|
1514
|
+
let names;
|
|
1515
|
+
try {
|
|
1516
|
+
names = fs.readdirSync(root);
|
|
1517
|
+
}
|
|
1518
|
+
catch {
|
|
1519
|
+
return;
|
|
1520
|
+
}
|
|
1521
|
+
for (const name of names) {
|
|
1522
|
+
if (!name.startsWith(SCRATCH_PREFIX))
|
|
1523
|
+
continue;
|
|
1524
|
+
const pid = Number(name.slice(SCRATCH_PREFIX.length).split('-')[0]);
|
|
1525
|
+
const full = path.join(root, name);
|
|
1526
|
+
try {
|
|
1527
|
+
if (Number.isInteger(pid) && pid > 0 && ctx.deps.isAlive(pid))
|
|
1528
|
+
continue;
|
|
1529
|
+
if (ctx.deps.now() - fs.statSync(full).mtimeMs < REHYDRATE_BUDGET_MS)
|
|
1530
|
+
continue;
|
|
1531
|
+
fs.rmSync(full, { recursive: true, force: true });
|
|
1532
|
+
}
|
|
1533
|
+
catch {
|
|
1534
|
+
/* best effort */
|
|
1535
|
+
}
|
|
1536
|
+
}
|
|
1537
|
+
}
|
|
1538
|
+
// Room for a download in the temp dir and for its pack in the deck's object store.
|
|
1539
|
+
function requireFreeSpace(dirs, bytes) {
|
|
1540
|
+
for (const dir of dirs) {
|
|
1541
|
+
let free;
|
|
1542
|
+
try {
|
|
1543
|
+
const stat = fs.statfsSync(dir);
|
|
1544
|
+
free = stat.bavail * stat.bsize;
|
|
1545
|
+
}
|
|
1546
|
+
catch {
|
|
1547
|
+
continue;
|
|
1548
|
+
}
|
|
1549
|
+
if (free < bytes + FREE_SPACE_MARGIN_BYTES)
|
|
1550
|
+
throw new Error(`not enough free disk in ${dir} for a ${bytes}-byte mirror bundle`);
|
|
1551
|
+
}
|
|
1552
|
+
}
|
|
1553
|
+
// Brings back objects only -- into the deck's object store, through a scratch repo with refs of
|
|
1554
|
+
// its own (the deck's refs name missing objects, which git's fetch and bundle checks refuse). No
|
|
1555
|
+
// ref of the deck changes here, and the deck lock is not held; finishRehydrate takes it.
|
|
1556
|
+
async function rehydrateObjects(ctx, budgetEnd) {
|
|
1557
|
+
const within = (cap) => {
|
|
1558
|
+
const left = budgetEnd - ctx.deps.now();
|
|
1559
|
+
if (left < MIN_STEP_MS)
|
|
1560
|
+
throw new Error('the rehydrate ran out of time');
|
|
1561
|
+
return Math.min(cap, left);
|
|
1562
|
+
};
|
|
1563
|
+
const result = {
|
|
1564
|
+
checkpointRemoteMain: refValue(ctx, REMOTE_MAIN),
|
|
1565
|
+
checkpointIntegrated: refValue(ctx, INTEGRATED_REF),
|
|
1566
|
+
remoteFetched: false,
|
|
1567
|
+
remoteMain: null,
|
|
1568
|
+
mirror: 'skipped',
|
|
1569
|
+
mirrorMain: null,
|
|
1570
|
+
snapshotOk: true,
|
|
1571
|
+
aborted: false,
|
|
1572
|
+
notes: [],
|
|
1573
|
+
used: [],
|
|
1574
|
+
};
|
|
1575
|
+
// Outside the deck: a draft checkpoint taken meanwhile must not carry downloads or scratch refs.
|
|
1576
|
+
const scratchRoot = fs.mkdtempSync(path.join(os.tmpdir(), `${SCRATCH_PREFIX}${ctx.deps.pid}-`));
|
|
1577
|
+
const scratch = path.join(scratchRoot, 'repo.git');
|
|
1578
|
+
const objects = path.join(gitDir(ctx.dir), 'objects');
|
|
1579
|
+
const inScratch = (args, timeoutMs) => run(ctx, ['--git-dir', scratch, ...SCRATCH_CONFIG, ...args], { timeoutMs, env: { GIT_OBJECT_DIRECTORY: objects } });
|
|
1580
|
+
const scratchRef = (ref) => {
|
|
1581
|
+
const r = inScratch(['rev-parse', '--verify', '--quiet', `${ref}^{commit}`]);
|
|
1582
|
+
return r.status === 0 ? r.stdout.trim() : null;
|
|
1583
|
+
};
|
|
1584
|
+
const stillMissing = () => historyMissing(ctx).length > 0;
|
|
1585
|
+
let pins = 0;
|
|
1586
|
+
// A bundle's prerequisites count only when a ref of the repo reaches them.
|
|
1587
|
+
const pinPresent = () => {
|
|
1588
|
+
const tips = requiredTips(readRefState(ctx));
|
|
1589
|
+
const gone = new Set(missingTips(ctx, tips).map((tip) => tip.sha));
|
|
1590
|
+
for (const tip of tips)
|
|
1591
|
+
if (!gone.has(tip.sha))
|
|
1592
|
+
inScratch(['update-ref', `refs/castle-local/${pins++}`, tip.sha]);
|
|
1593
|
+
};
|
|
1594
|
+
// Unbundled, not fetched: a fetch skips a bundle whose refs are all here already, and would
|
|
1595
|
+
// leave MERGE_HEAD's objects behind with it.
|
|
1596
|
+
const applySnapshot = () => {
|
|
1597
|
+
const file = path.join(ctx.dir, SNAPSHOT_BUNDLE_FILE);
|
|
1598
|
+
if (!fs.existsSync(file))
|
|
1599
|
+
return true;
|
|
1600
|
+
pinPresent();
|
|
1601
|
+
const unbundled = inScratch(['bundle', 'unbundle', file], within(REHYDRATE_STEP_MS));
|
|
1602
|
+
if (unbundled.status !== 0) {
|
|
1603
|
+
result.notes.push(describeFailure(['bundle', 'unbundle', path.basename(file)], unbundled));
|
|
1604
|
+
return false;
|
|
1605
|
+
}
|
|
1606
|
+
if (!result.used.includes('the snapshot bundle'))
|
|
1607
|
+
result.used.push('the snapshot bundle');
|
|
1608
|
+
return true;
|
|
1609
|
+
};
|
|
1610
|
+
try {
|
|
1611
|
+
must(ctx, ['init', '--quiet', '--bare', scratch]);
|
|
1612
|
+
// 1. The Castle remote (code.storage, through the llm-proxy).
|
|
1613
|
+
const url = configuredRemoteUrl(ctx);
|
|
1614
|
+
if (url) {
|
|
1615
|
+
const fetched = inScratch(['fetch', '--quiet', '--no-tags', url, '+refs/heads/*:refs/castle-remote/*'], within(REHYDRATE_STEP_MS));
|
|
1616
|
+
if (fetched.status === 0) {
|
|
1617
|
+
result.remoteFetched = true;
|
|
1618
|
+
result.remoteMain = scratchRef('refs/castle-remote/main');
|
|
1619
|
+
result.used.push('the Castle remote');
|
|
1620
|
+
}
|
|
1621
|
+
else {
|
|
1622
|
+
result.notes.push(describeFailure(['fetch', GIT_REMOTE_NAME], fetched));
|
|
1623
|
+
}
|
|
1624
|
+
}
|
|
1625
|
+
else {
|
|
1626
|
+
result.notes.push('no Castle remote is configured');
|
|
1627
|
+
}
|
|
1628
|
+
// 2. Local work nobody else has: the snapshot bundle.
|
|
1629
|
+
if (stillMissing())
|
|
1630
|
+
result.snapshotOk = applySnapshot();
|
|
1631
|
+
// 3. Still missing: the S3 mirror's chain, then the snapshot again on top of it.
|
|
1632
|
+
if (stillMissing()) {
|
|
1633
|
+
result.mirror = 'failed';
|
|
1634
|
+
const deckId = deckIdFor(ctx);
|
|
1635
|
+
const mirror = ctx.deps.mirrorState;
|
|
1636
|
+
const download = ctx.deps.download;
|
|
1637
|
+
if (!deckId || !mirror || !download) {
|
|
1638
|
+
result.notes.push('the S3 mirror cannot be asked from here');
|
|
1639
|
+
}
|
|
1640
|
+
else {
|
|
1641
|
+
const timeoutMs = within(MIRROR_BUNDLES_TIMEOUT_MS);
|
|
1642
|
+
const state = await withTimeout(mirror(deckId, { includeBundles: true, timeoutMs }), timeoutMs + 500, 'gitMirrorState');
|
|
1643
|
+
const bundles = state?.bundles ?? [];
|
|
1644
|
+
if (state && !state.mainSha && bundles.length === 0) {
|
|
1645
|
+
result.mirror = 'none';
|
|
1646
|
+
result.notes.push('the S3 mirror has nothing for this deck yet');
|
|
1647
|
+
}
|
|
1648
|
+
else if (bundles.length === 0) {
|
|
1649
|
+
result.notes.push('the S3 mirror listed no bundles');
|
|
1650
|
+
}
|
|
1651
|
+
else {
|
|
1652
|
+
for (const [i, entry] of bundles.entries()) {
|
|
1653
|
+
const file = path.join(scratchRoot, `mirror-${i}.bundle`);
|
|
1654
|
+
const stepMs = within(REHYDRATE_STEP_MS);
|
|
1655
|
+
// The download lands in the temp dir, its pack in the deck's object store.
|
|
1656
|
+
requireFreeSpace([scratchRoot, objects], entry.bytes ?? 0);
|
|
1657
|
+
await withTimeout(download(entry.url, file, { timeoutMs: stepMs, bytes: entry.bytes, sha256: entry.sha256 }), stepMs + 500, `downloading mirror bundle ${i + 1}`);
|
|
1658
|
+
// One fetch per chain entry; its prerequisites are the refs the earlier ones left.
|
|
1659
|
+
const fetched = inScratch(['fetch', '--quiet', '--no-tags', '--no-write-fetch-head', file, `refs/*:refs/castle-mirror/${i}/*`], within(REHYDRATE_STEP_MS));
|
|
1660
|
+
fs.rmSync(file, { force: true });
|
|
1661
|
+
if (fetched.status !== 0)
|
|
1662
|
+
throw new Error(describeFailure(['fetch', `<mirror bundle ${i + 1}>`], fetched));
|
|
1663
|
+
}
|
|
1664
|
+
for (let i = bundles.length - 1; i >= 0 && !result.mirrorMain; i--) {
|
|
1665
|
+
result.mirrorMain = scratchRef(`refs/castle-mirror/${i}/heads/main`);
|
|
1666
|
+
}
|
|
1667
|
+
result.mirror = 'complete';
|
|
1668
|
+
result.used.push(`the S3 mirror (${bundles.length} bundle${bundles.length === 1 ? '' : 's'})`);
|
|
1669
|
+
}
|
|
1670
|
+
if (result.mirror !== 'failed')
|
|
1671
|
+
result.snapshotOk = applySnapshot();
|
|
1672
|
+
}
|
|
1673
|
+
}
|
|
1674
|
+
}
|
|
1675
|
+
catch (e) {
|
|
1676
|
+
result.aborted = true;
|
|
1677
|
+
result.notes.push(errorText(e));
|
|
1678
|
+
}
|
|
1679
|
+
finally {
|
|
1680
|
+
fs.rmSync(scratchRoot, { recursive: true, force: true });
|
|
1681
|
+
}
|
|
1682
|
+
return result;
|
|
1683
|
+
}
|
|
1684
|
+
// --- rehydrate: settling the deck's refs
|
|
1685
|
+
// Index entries (stage 0; conflict stages come from commits) whose blob is gone are hashed again
|
|
1686
|
+
// from the file on disk. A file that is gone, or no longer a file, leaves the index. Only the
|
|
1687
|
+
// index changes, never the file.
|
|
1688
|
+
function repairIndexBlobs(ctx) {
|
|
1689
|
+
const listed = run(ctx, ['ls-files', '--stage', '-z']);
|
|
1690
|
+
if (listed.status !== 0)
|
|
1691
|
+
return [];
|
|
1692
|
+
const entries = [];
|
|
1693
|
+
for (const record of listed.stdout.split('\0')) {
|
|
1694
|
+
const tab = record.indexOf('\t');
|
|
1695
|
+
if (tab < 0)
|
|
1696
|
+
continue;
|
|
1697
|
+
const [mode, sha, stage] = record.slice(0, tab).split(' ');
|
|
1698
|
+
if (stage === '0' && mode !== '160000' && sha)
|
|
1699
|
+
entries.push({ mode, sha, path: record.slice(tab + 1) });
|
|
1700
|
+
}
|
|
1701
|
+
if (entries.length === 0)
|
|
1702
|
+
return [];
|
|
1703
|
+
const check = run(ctx, ['cat-file', '--batch-check=%(objectname)'], { input: entries.map((e) => e.sha).join('\n') + '\n' });
|
|
1704
|
+
if (check.status !== 0)
|
|
1705
|
+
return [];
|
|
1706
|
+
const out = check.stdout.split('\n');
|
|
1707
|
+
const repaired = [];
|
|
1708
|
+
entries.forEach((entry, i) => {
|
|
1709
|
+
if (OBJECT_ID_RE.test((out[i] ?? '').trim()))
|
|
1710
|
+
return;
|
|
1711
|
+
let stat = null;
|
|
1712
|
+
try {
|
|
1713
|
+
stat = fs.lstatSync(path.join(ctx.dir, entry.path));
|
|
1714
|
+
}
|
|
1715
|
+
catch {
|
|
1716
|
+
stat = null;
|
|
1717
|
+
}
|
|
1718
|
+
let sha = null;
|
|
1719
|
+
let mode = entry.mode;
|
|
1720
|
+
if (stat?.isSymbolicLink()) {
|
|
1721
|
+
sha = must(ctx, ['hash-object', '-w', '--stdin'], { input: fs.readlinkSync(path.join(ctx.dir, entry.path)) }).trim();
|
|
1722
|
+
mode = '120000';
|
|
1723
|
+
}
|
|
1724
|
+
else if (stat?.isFile()) {
|
|
1725
|
+
sha = must(ctx, ['hash-object', '-w', '--', entry.path]).trim();
|
|
1726
|
+
if (mode === '120000')
|
|
1727
|
+
mode = '100644';
|
|
1728
|
+
}
|
|
1729
|
+
if (sha !== entry.sha) {
|
|
1730
|
+
if (sha)
|
|
1731
|
+
must(ctx, ['update-index', '--cacheinfo', `${mode},${sha},${entry.path}`]);
|
|
1732
|
+
else
|
|
1733
|
+
must(ctx, ['update-index', '--force-remove', '--', entry.path]);
|
|
1734
|
+
}
|
|
1735
|
+
repaired.push(entry.path);
|
|
1736
|
+
});
|
|
1737
|
+
return repaired;
|
|
1738
|
+
}
|
|
1739
|
+
// The snapshot that could not help is kept aside -- one generation, and only if it is under the
|
|
1740
|
+
// cap, so the snapshot and it stay under twice the cap together -- before the deck goes on
|
|
1741
|
+
// without it.
|
|
1742
|
+
function setAsideSnapshot(ctx) {
|
|
1743
|
+
const root = gitDir(ctx.dir);
|
|
1744
|
+
for (const name of fs.readdirSync(root))
|
|
1745
|
+
if (LOST_BUNDLE_RE.test(name))
|
|
1746
|
+
fs.rmSync(path.join(root, name), { force: true });
|
|
1747
|
+
const file = path.join(ctx.dir, SNAPSHOT_BUNDLE_FILE);
|
|
1748
|
+
fs.rmSync(path.join(ctx.dir, SNAPSHOT_KEY_FILE), { force: true });
|
|
1749
|
+
if (!fs.existsSync(file))
|
|
1750
|
+
return null;
|
|
1751
|
+
if (fileSize(file) > snapshotCap(ctx)) {
|
|
1752
|
+
fs.rmSync(file, { force: true });
|
|
1753
|
+
return null;
|
|
1754
|
+
}
|
|
1755
|
+
const to = path.join(root, `castle-lost-${ctx.deps.now()}-0.bundle`);
|
|
1756
|
+
fs.renameSync(file, to);
|
|
1757
|
+
return path.relative(ctx.dir, to);
|
|
1758
|
+
}
|
|
1759
|
+
function readHistoryRecovered(dir) {
|
|
1760
|
+
try {
|
|
1761
|
+
return JSON.parse(fs.readFileSync(path.join(dir, HISTORY_RECOVERED_FILE), 'utf-8'));
|
|
1762
|
+
}
|
|
1763
|
+
catch {
|
|
1764
|
+
return null;
|
|
1765
|
+
}
|
|
1766
|
+
}
|
|
1767
|
+
export function recoveredConflictInstruction(files) {
|
|
1768
|
+
return [
|
|
1769
|
+
"[Castle] This deck's local git history was lost -- it was never pushed and could not be found anywhere -- while a merge with changes from another computer was waiting to be resolved. Every file is exactly as it was.",
|
|
1770
|
+
...(files
|
|
1771
|
+
? ['These files still have conflict markers (<<<<<<< / ||||||| / ======= / >>>>>>>):', files.map((f) => ` - ${f}`).join('\n') || ' (none listed)']
|
|
1772
|
+
: ['Which files still have conflict markers (<<<<<<< / ||||||| / ======= / >>>>>>>) could not be checked: look through every file of the deck for them.']),
|
|
1773
|
+
"Resolve it now. Spawn one task agent to open each file, remove every marker so the file is whole and working again, preferring the other computer's side. Do not run git reset, rebase, checkout, merge or push. When no markers remain, finish with `castle-web commit --resolve -m \"Edits restored after lost history\"`; if it exits 3, it names the files that still have markers.",
|
|
1774
|
+
'Then tell the user briefly that some unsaved history was lost but their files were kept.',
|
|
1775
|
+
].join('\n');
|
|
1776
|
+
}
|
|
1777
|
+
export function historyLostInstruction(lost) {
|
|
1778
|
+
return [
|
|
1779
|
+
`[Castle] Part of this deck's git history was lost: commits that were never pushed (${lost.join(', ')}) were in neither the Castle remote, its backup nor the snapshot the sandbox keeps. No file was lost -- every file is exactly as it was. The next save commits them and brings in anything pushed from elsewhere since; where both sides changed the same thing, that comes back as an ordinary merge conflict to resolve.`,
|
|
1780
|
+
'Nothing needs fixing now. Tell the user in one plain sentence that some of the in-between save points from their last session could not be restored, but their current work is intact.',
|
|
1781
|
+
].join('\n');
|
|
1782
|
+
}
|
|
1783
|
+
// Text files of the deck (tracked or not, excludes respected) with conflict-marker lines, for a
|
|
1784
|
+
// merge whose record is gone. Bounded in time and count.
|
|
1785
|
+
const MARKER_SCAN_LIMIT = 200;
|
|
1786
|
+
// A file counts when it has both an opening and a closing marker line. Null: the scan itself
|
|
1787
|
+
// failed or ran out of time -- unknown, never "no conflict".
|
|
1788
|
+
function filesWithConflictMarkers(ctx) {
|
|
1789
|
+
let result;
|
|
1790
|
+
try {
|
|
1791
|
+
result = run(ctx, ['grep', '-l', '-I', '--untracked', '-E', '^<{7}( |$)'], { timeoutMs: 10_000 });
|
|
1792
|
+
}
|
|
1793
|
+
catch {
|
|
1794
|
+
return null;
|
|
1795
|
+
}
|
|
1796
|
+
if (result.status === 1)
|
|
1797
|
+
return [];
|
|
1798
|
+
if (result.status !== 0)
|
|
1799
|
+
return null;
|
|
1800
|
+
const out = [];
|
|
1801
|
+
for (const file of lines(result.stdout).slice(0, MARKER_SCAN_LIMIT)) {
|
|
1802
|
+
let text;
|
|
1803
|
+
try {
|
|
1804
|
+
text = fs.readFileSync(path.join(ctx.dir, file), 'utf-8');
|
|
1805
|
+
}
|
|
1806
|
+
catch {
|
|
1807
|
+
continue;
|
|
1808
|
+
}
|
|
1809
|
+
if (/^>{7}( |$)/m.test(text))
|
|
1810
|
+
out.push({ path: file, stages: {}, kind: 'text', resolution: 'markers' });
|
|
1811
|
+
}
|
|
1812
|
+
return out;
|
|
1813
|
+
}
|
|
1814
|
+
// The terminal case (see finishRehydrate for when it may run): local commits nobody has. main
|
|
1815
|
+
// goes back to refs/castle/integrated -- the last remote version local main is known to have
|
|
1816
|
+
// contained, so the next sync is a real three-way merge with whatever came after it (never
|
|
1817
|
+
// castle/main: that may have been fetched and not merged, and starting from it would revert
|
|
1818
|
+
// what came in with it) -- and any other lost branch goes. Without that commit (gone, or a deck
|
|
1819
|
+
// from before it was recorded) main starts again unborn: the kept files are committed as a root
|
|
1820
|
+
// and merged with the remote's main as unrelated histories, so pushed work conflicts rather
|
|
1821
|
+
// than being overwritten. The index follows HEAD; the working tree
|
|
1822
|
+
// is never touched. A merge in progress whose side is lost leaves its conflicted files to the
|
|
1823
|
+
// agent (castle-merge.json), rather than having markers committed.
|
|
1824
|
+
async function recoverLostHistory(ctx, missing, result) {
|
|
1825
|
+
const integrated = result.checkpointIntegrated;
|
|
1826
|
+
const checkpointBase = integrated &&
|
|
1827
|
+
missingTips(ctx, [{ name: REMOTE_MAIN, sha: integrated }]).length === 0 &&
|
|
1828
|
+
!(await historyIncomplete(ctx, [integrated]))
|
|
1829
|
+
? integrated
|
|
1830
|
+
: null;
|
|
1831
|
+
const skipped = readSnapshotKey(ctx.dir)?.skipped?.tips ?? {};
|
|
1832
|
+
const keptBundle = setAsideSnapshot(ctx);
|
|
1833
|
+
const lost = new Set(missing.map((tip) => tip.name));
|
|
1834
|
+
const headRef = run(ctx, ['symbolic-ref', '--quiet', 'HEAD']);
|
|
1835
|
+
const headBranch = headRef.status === 0 ? headRef.stdout.trim() : null;
|
|
1836
|
+
for (const tip of missing) {
|
|
1837
|
+
if (!tip.name.startsWith('refs/'))
|
|
1838
|
+
continue;
|
|
1839
|
+
if (tip.name === `refs/heads/${MAIN}` && checkpointBase)
|
|
1840
|
+
must(ctx, ['update-ref', '-m', 'castle: lost history', tip.name, checkpointBase]);
|
|
1841
|
+
else
|
|
1842
|
+
must(ctx, ['update-ref', '-d', tip.name]);
|
|
1843
|
+
}
|
|
1844
|
+
if (lost.has('HEAD') && headBranch !== `refs/heads/${MAIN}`) {
|
|
1845
|
+
must(ctx, ['symbolic-ref', 'HEAD', `refs/heads/${MAIN}`]);
|
|
1846
|
+
if (checkpointBase && !revParse(ctx, `refs/heads/${MAIN}`))
|
|
1847
|
+
must(ctx, ['update-ref', `refs/heads/${MAIN}`, checkpointBase]);
|
|
1848
|
+
}
|
|
1849
|
+
// Without a base the next merge with the remote's main finds no common commit, and joins the
|
|
1850
|
+
// histories as unrelated (integrate): both sides' changes meet as conflicts.
|
|
1851
|
+
const orig = refValue(ctx, 'ORIG_HEAD');
|
|
1852
|
+
if (orig && missingTips(ctx, [{ name: 'ORIG_HEAD', sha: orig }]).length > 0) {
|
|
1853
|
+
fs.rmSync(path.join(gitDir(ctx.dir), 'ORIG_HEAD'), { force: true });
|
|
1854
|
+
}
|
|
1855
|
+
const mergeLost = mergeInProgress(ctx.dir) && (lost.has('MERGE_HEAD') || lost.has('HEAD'));
|
|
1856
|
+
const state = mergeLost ? readMergeState(ctx.dir) : null;
|
|
1857
|
+
if (mergeLost) {
|
|
1858
|
+
for (const name of ['MERGE_HEAD', 'MERGE_MSG', 'MERGE_MODE', 'AUTO_MERGE']) {
|
|
1859
|
+
fs.rmSync(path.join(gitDir(ctx.dir), name), { force: true });
|
|
1860
|
+
}
|
|
1861
|
+
}
|
|
1862
|
+
const head = revParse(ctx, 'HEAD');
|
|
1863
|
+
must(ctx, head ? ['read-tree', head] : ['read-tree', '--empty']);
|
|
1864
|
+
let marked = (state?.files ?? [])
|
|
1865
|
+
.filter((f) => f.resolution === 'markers' || f.resolution === 'manual')
|
|
1866
|
+
.filter((f) => stillHasMarkers(ctx, f));
|
|
1867
|
+
// A merge whose record is gone: the files that still carry markers, found by looking. A scan
|
|
1868
|
+
// that failed leaves the whole deck to the agent.
|
|
1869
|
+
let unknown = false;
|
|
1870
|
+
if (mergeLost && !state) {
|
|
1871
|
+
const found = filesWithConflictMarkers(ctx);
|
|
1872
|
+
unknown = found === null;
|
|
1873
|
+
marked = found ?? [];
|
|
1874
|
+
}
|
|
1875
|
+
const conflict = marked.length > 0 || unknown;
|
|
1876
|
+
if (conflict) {
|
|
1877
|
+
const instruction = recoveredConflictInstruction(unknown ? null : marked.map((f) => f.path));
|
|
1878
|
+
const base = state ?? { at: new Date(ctx.deps.now()).toISOString(), head: '', mergeHead: '', files: [], instruction };
|
|
1879
|
+
writeJsonAtomic(mergeStatePath(ctx.dir), { ...base, files: marked, instruction, recovered: true });
|
|
1880
|
+
writeJsonAtomic(path.join(ctx.dir, CONFLICT_MARKER_FILE), {
|
|
1881
|
+
at: new Date(ctx.deps.now()).toISOString(),
|
|
1882
|
+
files: marked.map((f) => f.path),
|
|
1883
|
+
theirs: [],
|
|
1884
|
+
ours: [],
|
|
1885
|
+
instruction,
|
|
1886
|
+
});
|
|
1887
|
+
}
|
|
1888
|
+
else if (mergeLost) {
|
|
1889
|
+
fs.rmSync(mergeStatePath(ctx.dir), { force: true });
|
|
1890
|
+
}
|
|
1891
|
+
const at = new Date(ctx.deps.now()).toISOString();
|
|
1892
|
+
writeJsonAtomic(path.join(ctx.dir, HISTORY_RECOVERED_FILE), {
|
|
1893
|
+
at,
|
|
1894
|
+
lost: missing.map((tip) => ({ ref: tip.name, sha: tip.sha })),
|
|
1895
|
+
newHead: head,
|
|
1896
|
+
skippedOverCap: missing.filter((tip) => skipped[tip.name] === tip.sha).map((tip) => tip.name),
|
|
1897
|
+
conflict,
|
|
1898
|
+
keptBundle,
|
|
1899
|
+
reason: 'These commits were in neither the Castle remote (which answered), the S3 mirror nor the snapshot bundle. ' +
|
|
1900
|
+
"The deck's files were kept exactly as they were and are committed on top of the last pushed version.",
|
|
1901
|
+
tried: result.notes,
|
|
1902
|
+
committed: false,
|
|
1903
|
+
});
|
|
1904
|
+
// Told once, the way a conflict or an adopt is (a conflict's own notice already covers it).
|
|
1905
|
+
if (!conflict) {
|
|
1906
|
+
const shortLost = missing.filter((t) => isBranchTip(t.name)).map((t) => t.sha.slice(0, 10));
|
|
1907
|
+
writeJsonAtomic(path.join(ctx.dir, HISTORY_LOST_MARKER_FILE), {
|
|
1908
|
+
at,
|
|
1909
|
+
notice: 'Some unsaved history of this deck could not be restored; the files are intact.',
|
|
1910
|
+
instruction: historyLostInstruction([...new Set(shortLost)]),
|
|
1911
|
+
});
|
|
1912
|
+
}
|
|
1913
|
+
ctx.deps.warn(`Local git history was lost and could not be found anywhere (${missing.map((t) => `${t.name} ${t.sha.slice(0, 10)}`).join(', ')}). ` +
|
|
1914
|
+
`The deck's files are unchanged and will be committed on top of ${checkpointBase ? `the last pushed version this deck had (${checkpointBase.slice(0, 10)})` : "a new history, merged with the remote's main"}` +
|
|
1915
|
+
`${conflict ? ' once the agent resolves the conflict markers left in them' : ''}; details in ${HISTORY_RECOVERED_FILE}.`);
|
|
1916
|
+
}
|
|
1917
|
+
// Every sweep-able ref (tags, stash, remote-tracking, Castle's own) whose object is gone goes,
|
|
1918
|
+
// so no later fetch trips over it ("fatal: bad object").
|
|
1919
|
+
function dropBrokenRefs(ctx) {
|
|
1920
|
+
const refs = allRefs(ctx).filter((tip) => !isBranchTip(tip.name));
|
|
1921
|
+
for (const tip of missingTips(ctx, refs)) {
|
|
1922
|
+
run(ctx, ['update-ref', '-d', tip.name, tip.sha]);
|
|
1923
|
+
ctx.deps.warn(`Removed ${tip.name}: its object ${tip.sha.slice(0, 10)} is gone.`);
|
|
1924
|
+
}
|
|
1925
|
+
// ORIG_HEAD too: the snapshot bundles it, and cannot while it names nothing.
|
|
1926
|
+
const orig = readShaFile(path.join(gitDir(ctx.dir), 'ORIG_HEAD'));
|
|
1927
|
+
if (orig && missingTips(ctx, [{ name: 'ORIG_HEAD', sha: orig }]).length > 0) {
|
|
1928
|
+
fs.rmSync(path.join(gitDir(ctx.dir), 'ORIG_HEAD'), { force: true });
|
|
1929
|
+
}
|
|
1930
|
+
}
|
|
1931
|
+
// Under the deck lock, after rehydrateObjects: give up lost local commits only when every
|
|
1932
|
+
// source answered cleanly, settle castle/main and the other refs, check the history is whole,
|
|
1933
|
+
// and re-hash staged blobs. Throws GIT_HISTORY_UNAVAILABLE (nothing changed) otherwise.
|
|
1934
|
+
async function finishRehydrate(ctx, result) {
|
|
1935
|
+
const tried = () => `Tried: ${result.notes.join('; ') || 'nothing could be tried'}.`;
|
|
1936
|
+
const branches = historyMissing(ctx).filter((tip) => isBranchTip(tip.name));
|
|
1937
|
+
// Clean: the remote answered (an outage says nothing), the mirror applied its whole chain or
|
|
1938
|
+
// said it has none, the snapshot applied -- and the remote did not come back without a main
|
|
1939
|
+
// that the mirror or the checkpoint says it had.
|
|
1940
|
+
const clean = result.remoteFetched &&
|
|
1941
|
+
!result.aborted &&
|
|
1942
|
+
(result.mirror === 'complete' || result.mirror === 'none' || result.mirror === 'skipped') &&
|
|
1943
|
+
result.snapshotOk &&
|
|
1944
|
+
!(result.remoteMain === null && (result.mirrorMain !== null || result.checkpointRemoteMain !== null));
|
|
1945
|
+
const others = historyMissing(ctx).filter((tip) => !isBranchTip(tip.name));
|
|
1946
|
+
const localOnly = others.filter((tip) => !isCastleRef(tip.name));
|
|
1947
|
+
if ((branches.length > 0 || localOnly.length > 0) && !clean) {
|
|
1948
|
+
throw historyUnavailable([...branches, ...localOnly], tried());
|
|
1949
|
+
}
|
|
1950
|
+
if (branches.length > 0) {
|
|
1951
|
+
if (result.remoteMain && (await historyIncomplete(ctx, [result.remoteMain]))) {
|
|
1952
|
+
throw historyUnavailable(branches, `The remote's main is incomplete. ${tried()}`);
|
|
1953
|
+
}
|
|
1954
|
+
await recoverLostHistory(ctx, branches, result);
|
|
1955
|
+
}
|
|
1956
|
+
// castle/main is where the remote was last seen: kept while its commit is here (the next
|
|
1957
|
+
// sync fetches), else what was just fetched, else the mirror's main.
|
|
1958
|
+
const remote = refValue(ctx, REMOTE_MAIN);
|
|
1959
|
+
if (remote && missingTips(ctx, [{ name: REMOTE_MAIN, sha: remote }]).length > 0) {
|
|
1960
|
+
const to = result.remoteMain ?? result.mirrorMain;
|
|
1961
|
+
if (to)
|
|
1962
|
+
must(ctx, ['update-ref', '-m', 'castle: rehydrate', REMOTE_MAIN, to]);
|
|
1963
|
+
}
|
|
1964
|
+
else if (!remote && result.remoteMain) {
|
|
1965
|
+
must(ctx, ['update-ref', '-m', 'castle: rehydrate', REMOTE_MAIN, result.remoteMain]);
|
|
1966
|
+
}
|
|
1967
|
+
dropBrokenRefs(ctx);
|
|
1968
|
+
const tips = requiredTips(readRefState(ctx));
|
|
1969
|
+
const left = missingTips(ctx, tips);
|
|
1970
|
+
if (left.length > 0)
|
|
1971
|
+
throw historyUnavailable(left, tried());
|
|
1972
|
+
if (await historyIncomplete(ctx, tips.map((t) => t.sha))) {
|
|
1973
|
+
throw historyUnavailable([], `Some older commits or files are still missing. ${tried()}`);
|
|
1974
|
+
}
|
|
1975
|
+
const reindexed = repairIndexBlobs(ctx);
|
|
1976
|
+
// A snapshot of the rebuilt state (and its key file, which a recovery took away).
|
|
1977
|
+
refreshSnapshot(ctx, false);
|
|
1978
|
+
ctx.deps.log(`Rebuilt this deck's git history from ${result.used.join(', ') || 'what was already here'}` +
|
|
1979
|
+
(reindexed.length ? `; re-hashed ${reindexed.length} staged file(s) from disk.` : '.'));
|
|
1980
|
+
}
|
|
1981
|
+
// The whole rehydrate, under REHYDRATE_LOCK_FILE: objects first, without the deck lock, then
|
|
1982
|
+
// the deck's refs under it. Any failure is recorded for the backoff and surfaces as
|
|
1983
|
+
// GIT_HISTORY_UNAVAILABLE.
|
|
1984
|
+
async function runRehydrate(ctx) {
|
|
1985
|
+
repairGitSkeleton(ctx.dir);
|
|
1986
|
+
const release = tryRehydrateLock(ctx);
|
|
1987
|
+
if (!release)
|
|
1988
|
+
throw historyUnavailable(historyMissing(ctx), 'A rehydrate is already running for this deck.');
|
|
1989
|
+
try {
|
|
1990
|
+
sweepScratchDirs(ctx);
|
|
1991
|
+
const own = readDeckId(ctx.dir);
|
|
1992
|
+
const remoteId = remoteDeckId(ctx);
|
|
1993
|
+
if (own && remoteId && own !== remoteId) {
|
|
1994
|
+
// A copied deck: its history is another deck's. `git attach` starts it afresh instead.
|
|
1995
|
+
throw historyUnavailable(historyMissing(ctx), `Its Castle remote is deck ${remoteId}'s but this deck is ${own}; it is not rebuilt from there. Attach it to its own remote.`);
|
|
1996
|
+
}
|
|
1997
|
+
if (historyMissing(ctx).length === 0) {
|
|
1998
|
+
fs.rmSync(path.join(ctx.dir, REHYDRATE_STATE_FILE), { force: true });
|
|
1999
|
+
return 'complete';
|
|
2000
|
+
}
|
|
2001
|
+
const budgetEnd = ctx.deadline ?? ctx.deps.now() + REHYDRATE_BUDGET_MS;
|
|
2002
|
+
const result = await rehydrateObjects(ctx, budgetEnd);
|
|
2003
|
+
await withDeckLock(ctx, () => finishRehydrate(ctx, result));
|
|
2004
|
+
fs.rmSync(path.join(ctx.dir, REHYDRATE_STATE_FILE), { force: true });
|
|
2005
|
+
return 'rebuilt';
|
|
2006
|
+
}
|
|
2007
|
+
catch (e) {
|
|
2008
|
+
const error = e instanceof CloudGitError && e.exitCode === EXIT_HISTORY_UNAVAILABLE
|
|
2009
|
+
? e
|
|
2010
|
+
: historyUnavailable([], `The rehydrate failed: ${errorText(e)}`);
|
|
2011
|
+
recordRehydrateFailure(ctx, error.message);
|
|
2012
|
+
throw error;
|
|
2013
|
+
}
|
|
2014
|
+
finally {
|
|
2015
|
+
release();
|
|
2016
|
+
}
|
|
2017
|
+
}
|
|
2018
|
+
// A copied deck (attached to another deck's remote) whose objects are gone: its history was the
|
|
2019
|
+
// other deck's, and is not rebuilt from there. Its refs and merge state go, the index empties,
|
|
2020
|
+
// and the attach goes on as for a fresh deck. The files are untouched.
|
|
2021
|
+
function dropForeignHistory(ctx, original) {
|
|
2022
|
+
for (const ref of allRefs(ctx))
|
|
2023
|
+
run(ctx, ['update-ref', '--no-deref', '-d', ref.name]);
|
|
2024
|
+
for (const name of ['MERGE_HEAD', 'MERGE_MSG', 'MERGE_MODE', 'AUTO_MERGE', 'ORIG_HEAD', 'FETCH_HEAD', MERGE_STATE_FILE]) {
|
|
2025
|
+
fs.rmSync(path.join(gitDir(ctx.dir), name), { force: true });
|
|
2026
|
+
}
|
|
2027
|
+
for (const rel of [LEAVE_PENDING_FILE, SNAPSHOT_KEY_FILE, REHYDRATE_STATE_FILE, SNAPSHOT_BUNDLE_FILE]) {
|
|
2028
|
+
fs.rmSync(path.join(ctx.dir, rel), { force: true });
|
|
2029
|
+
}
|
|
2030
|
+
must(ctx, ['symbolic-ref', 'HEAD', `refs/heads/${MAIN}`]);
|
|
2031
|
+
must(ctx, ['read-tree', '--empty']);
|
|
2032
|
+
ctx.deps.warn(`This copied deck's git history (deck ${original}'s) was not in its checkpoint; it starts a fresh history instead. Its files are unchanged.`);
|
|
2033
|
+
}
|
|
2034
|
+
/** `castle-web git rehydrate --dir <deck>`: rebuild a cold-resumed deck's git history. */
|
|
2035
|
+
export async function cloudRehydrate(dir, deps) {
|
|
2036
|
+
requireSandbox(deps, 'git rehydrate');
|
|
2037
|
+
const ctx = contextFor(dir, deps);
|
|
2038
|
+
try {
|
|
2039
|
+
if (!fs.lstatSync(gitDir(ctx.dir)).isDirectory())
|
|
2040
|
+
throw new Error('not a directory');
|
|
2041
|
+
}
|
|
2042
|
+
catch {
|
|
2043
|
+
throw new CloudGitError(`${ctx.dir} has no git repo to rehydrate.`, EXIT_NOT_ENABLED);
|
|
2044
|
+
}
|
|
2045
|
+
return runRehydrate(ctx);
|
|
2046
|
+
}
|
|
813
2047
|
// Concludes the merge in progress as one whole commit -- only when no conflicted file still
|
|
814
2048
|
// has markers. Git refuses a partial commit mid-merge, so named paths are not used.
|
|
815
2049
|
function concludeMerge(ctx, opts, reason, identity) {
|
|
@@ -821,15 +2055,20 @@ function concludeMerge(ctx, opts, reason, identity) {
|
|
|
821
2055
|
ctx.deps.warn('Concluding a merge commits the whole deck; the paths given were not needed.');
|
|
822
2056
|
// Anything a leave commit could not save mid-merge is on disk still, and goes in with it.
|
|
823
2057
|
must(ctx, ['add', '-A']);
|
|
824
|
-
// No message of our own keeps git's "Merge changes from another computer" one.
|
|
2058
|
+
// No message of our own keeps git's "Merge changes from another computer" one. A recovered
|
|
2059
|
+
// conflict has no merge left, so no message of git's either.
|
|
825
2060
|
const trailer = AGENT_REASONS.has(reason) ? ['--trailer', AGENT_TRAILER] : [];
|
|
2061
|
+
const merging = mergeInProgress(ctx.dir);
|
|
2062
|
+
const message = opts.message?.trim() || (merging ? '' : RECOVERED_COMMIT_MESSAGE);
|
|
826
2063
|
must(ctx, [
|
|
827
2064
|
...identity,
|
|
828
2065
|
'commit',
|
|
829
2066
|
'--quiet',
|
|
830
2067
|
'--no-verify',
|
|
831
|
-
...(
|
|
2068
|
+
...(message ? commitMessageArgs({ ...opts, message }, reason) : ['--no-edit', ...trailer]),
|
|
832
2069
|
]);
|
|
2070
|
+
if (!merging)
|
|
2071
|
+
markRecoveredCommitted(ctx);
|
|
833
2072
|
fs.rmSync(mergeStatePath(ctx.dir), { force: true });
|
|
834
2073
|
fs.rmSync(path.join(ctx.dir, LEAVE_PENDING_FILE), { force: true });
|
|
835
2074
|
}
|
|
@@ -857,9 +2096,15 @@ function recordLeavePending(ctx) {
|
|
|
857
2096
|
ctx.deps.warn(`Could not note the uncommitted edits: ${e instanceof Error ? e.message : String(e)}`);
|
|
858
2097
|
}
|
|
859
2098
|
}
|
|
2099
|
+
function markRecoveredCommitted(ctx) {
|
|
2100
|
+
const recovered = readHistoryRecovered(ctx.dir);
|
|
2101
|
+
if (recovered && !recovered.committed) {
|
|
2102
|
+
writeJsonAtomic(path.join(ctx.dir, HISTORY_RECOVERED_FILE), { ...recovered, committed: true });
|
|
2103
|
+
}
|
|
2104
|
+
}
|
|
860
2105
|
async function commitLocked(ctx, opts) {
|
|
861
2106
|
const reason = opts.reason ?? 'manual';
|
|
862
|
-
if (
|
|
2107
|
+
if (mergeWaiting(ctx.dir)) {
|
|
863
2108
|
// Nothing but an explicit --resolve lands mid-merge: a turn, task, leave or manual
|
|
864
2109
|
// commit would otherwise conclude a merge nobody has checked.
|
|
865
2110
|
if (!opts.resolve) {
|
|
@@ -873,8 +2118,17 @@ async function commitLocked(ctx, opts) {
|
|
|
873
2118
|
// Left behind by a merge concluded (or aborted) some other way.
|
|
874
2119
|
fs.rmSync(mergeStatePath(ctx.dir), { force: true });
|
|
875
2120
|
fs.rmSync(path.join(ctx.dir, LEAVE_PENDING_FILE), { force: true });
|
|
876
|
-
|
|
877
|
-
const
|
|
2121
|
+
// The first commit after a rehydrate gave up lost history says so.
|
|
2122
|
+
const recovered = readHistoryRecovered(ctx.dir);
|
|
2123
|
+
if (recovered && !recovered.committed && !opts.message?.trim())
|
|
2124
|
+
opts = { ...opts, message: RECOVERED_COMMIT_MESSAGE };
|
|
2125
|
+
// Looked up only once there is something to commit.
|
|
2126
|
+
const commit = async (extra) => {
|
|
2127
|
+
const identity = await identityArgs(ctx);
|
|
2128
|
+
must(ctx, [...identity, 'commit', '--quiet', '--no-verify', ...extra]);
|
|
2129
|
+
if (recovered && !recovered.committed)
|
|
2130
|
+
markRecoveredCommitted(ctx);
|
|
2131
|
+
};
|
|
878
2132
|
if (opts.paths && opts.paths.length > 0) {
|
|
879
2133
|
const specs = commitPathspecs(ctx, opts.paths);
|
|
880
2134
|
if (specs.length === 0)
|
|
@@ -882,13 +2136,13 @@ async function commitLocked(ctx, opts) {
|
|
|
882
2136
|
must(ctx, ['add', '-A', '--', ...specs]);
|
|
883
2137
|
if (ok(ctx, ['diff', '--cached', '--quiet', '--', ...specs]))
|
|
884
2138
|
return { sha: null };
|
|
885
|
-
commit([...commitMessageArgs(opts, reason), '--', ...specs]);
|
|
2139
|
+
await commit([...commitMessageArgs(opts, reason), '--', ...specs]);
|
|
886
2140
|
}
|
|
887
2141
|
else {
|
|
888
2142
|
must(ctx, ['add', '-A']);
|
|
889
2143
|
if (ok(ctx, ['diff', '--cached', '--quiet']))
|
|
890
2144
|
return { sha: null };
|
|
891
|
-
commit(commitMessageArgs(opts, reason));
|
|
2145
|
+
await commit(commitMessageArgs(opts, reason));
|
|
892
2146
|
}
|
|
893
2147
|
return { sha: revParse(ctx, 'HEAD') };
|
|
894
2148
|
}
|
|
@@ -899,7 +2153,11 @@ function requireMainBranch(ctx) {
|
|
|
899
2153
|
}
|
|
900
2154
|
}
|
|
901
2155
|
function fetchRemote(ctx) {
|
|
902
|
-
|
|
2156
|
+
// One pack per fetch: all or nothing, even when a fetch is killed partway.
|
|
2157
|
+
const args = ['fetch', '--quiet', '--prune', '--no-tags', GIT_REMOTE_NAME];
|
|
2158
|
+
const fetched = run(ctx, ['-c', 'fetch.unpackLimit=1', '-c', 'transfer.unpackLimit=1', ...args], { timeoutMs: NETWORK_TIMEOUT_MS });
|
|
2159
|
+
if (fetched.status !== 0)
|
|
2160
|
+
throw new CloudGitError(describeFailure(args, fetched));
|
|
903
2161
|
return revParse(ctx, REMOTE_MAIN);
|
|
904
2162
|
}
|
|
905
2163
|
// Bring castle/main into local main. Local work is already committed by the caller.
|
|
@@ -912,7 +2170,17 @@ function deferIfBusy(ctx) {
|
|
|
912
2170
|
ctx.deps.warn('Task agents started working in the deck; the remote\'s changes are merged once it is idle.');
|
|
913
2171
|
return true;
|
|
914
2172
|
}
|
|
2173
|
+
// A recovery that had no base left main unborn over files that are the deck's only copy of its
|
|
2174
|
+
// work: they are committed first, as a root commit, so the remote's main is merged with them
|
|
2175
|
+
// (unrelated histories: both sides meet as conflicts) instead of an adopt replacing them.
|
|
2176
|
+
async function commitRecoveredRoot(ctx) {
|
|
2177
|
+
const recovered = readHistoryRecovered(ctx.dir);
|
|
2178
|
+
if (!recovered || recovered.committed || revParse(ctx, 'HEAD'))
|
|
2179
|
+
return;
|
|
2180
|
+
await commitLocked(ctx, { reason: 'sync' });
|
|
2181
|
+
}
|
|
915
2182
|
async function integrate(ctx, remote) {
|
|
2183
|
+
await commitRecoveredRoot(ctx);
|
|
916
2184
|
const head = revParse(ctx, 'HEAD');
|
|
917
2185
|
if (!head) {
|
|
918
2186
|
if (deferIfBusy(ctx))
|
|
@@ -930,12 +2198,17 @@ async function integrate(ctx, remote) {
|
|
|
930
2198
|
return 'fast-forward';
|
|
931
2199
|
}
|
|
932
2200
|
const identity = await identityArgs(ctx);
|
|
2201
|
+
// No common commit at all -- a recovery that had to start the deck's history afresh: the
|
|
2202
|
+
// histories are joined, and both sides' changes meet as conflicts rather than one replacing
|
|
2203
|
+
// the other.
|
|
2204
|
+
const unrelated = run(ctx, ['merge-base', 'HEAD', REMOTE_MAIN]).status === 1;
|
|
933
2205
|
const merge = run(ctx, [
|
|
934
2206
|
...identity,
|
|
935
2207
|
'merge',
|
|
936
2208
|
'--no-edit',
|
|
937
2209
|
'--no-ff',
|
|
938
2210
|
'--quiet',
|
|
2211
|
+
...(unrelated ? ['--allow-unrelated-histories'] : []),
|
|
939
2212
|
'-X',
|
|
940
2213
|
'diff-algorithm=histogram',
|
|
941
2214
|
'-m',
|
|
@@ -962,10 +2235,21 @@ const PUSH_ARGS = ['push', '--quiet', GIT_REMOTE_NAME, `${MAIN}:refs/heads/${MAI
|
|
|
962
2235
|
// sync's comparisons hold.
|
|
963
2236
|
function pushMain(ctx, local) {
|
|
964
2237
|
const push = run(ctx, PUSH_ARGS, { timeoutMs: NETWORK_TIMEOUT_MS });
|
|
965
|
-
if (push.status === 0)
|
|
2238
|
+
if (push.status === 0) {
|
|
966
2239
|
run(ctx, ['update-ref', REMOTE_MAIN, local]);
|
|
2240
|
+
markIntegrated(ctx, local);
|
|
2241
|
+
}
|
|
967
2242
|
return push;
|
|
968
2243
|
}
|
|
2244
|
+
/**
|
|
2245
|
+
* The remote's main as local main last took it in: what a recovery may start the deck again
|
|
2246
|
+
* from. castle/main can be ahead of it -- fetched, but its merge deferred while tasks were busy,
|
|
2247
|
+
* or refused -- and starting from castle/main would revert whatever came in with it.
|
|
2248
|
+
*/
|
|
2249
|
+
export const INTEGRATED_REF = 'refs/castle/integrated';
|
|
2250
|
+
function markIntegrated(ctx, sha) {
|
|
2251
|
+
run(ctx, ['update-ref', '-m', 'castle: integrated', INTEGRATED_REF, sha]);
|
|
2252
|
+
}
|
|
969
2253
|
function pushOnly(ctx) {
|
|
970
2254
|
const local = revParse(ctx, 'HEAD');
|
|
971
2255
|
if (!local || local === revParse(ctx, REMOTE_MAIN))
|
|
@@ -983,7 +2267,7 @@ async function syncLocked(ctx, opts) {
|
|
|
983
2267
|
requireMainBranch(ctx);
|
|
984
2268
|
if (opts.commitFirst)
|
|
985
2269
|
await commitLocked(ctx, { reason: 'sync' });
|
|
986
|
-
if (
|
|
2270
|
+
if (mergeWaiting(ctx.dir))
|
|
987
2271
|
throw mergeWaitingError(ctx);
|
|
988
2272
|
if (opts.mode === 'push-only')
|
|
989
2273
|
return pushOnly(ctx);
|
|
@@ -996,6 +2280,7 @@ async function syncLocked(ctx, opts) {
|
|
|
996
2280
|
const step = await integrate(ctx, remote);
|
|
997
2281
|
if (step === 'conflict' || step === 'deferred')
|
|
998
2282
|
return { merge: step, pushed: false };
|
|
2283
|
+
markIntegrated(ctx, remote);
|
|
999
2284
|
if (merge === 'none' || step !== 'none')
|
|
1000
2285
|
merge = step;
|
|
1001
2286
|
}
|
|
@@ -1239,13 +2524,20 @@ function adoptRemote(ctx) {
|
|
|
1239
2524
|
return { backup: backup?.dir ?? null };
|
|
1240
2525
|
}
|
|
1241
2526
|
// --- the commands -----------------------------------------------------------
|
|
2527
|
+
// A deadline that cannot be meant (not epoch milliseconds, or more than a day out -- a caller
|
|
2528
|
+
// whose `date` misbehaved) counts as none, rather than having every step refuse to start. One
|
|
2529
|
+
// already past is kept: the caller's kill is about to land, and refusing every step is exactly
|
|
2530
|
+
// what the deadline is for.
|
|
2531
|
+
const MAX_DEADLINE_AHEAD_MS = 24 * 60 * 60_000;
|
|
1242
2532
|
function contextFor(dir, deps) {
|
|
1243
2533
|
const deadline = Number(deps.env[DEADLINE_ENV]);
|
|
2534
|
+
const startedAt = deps.now();
|
|
2535
|
+
const plausible = Number.isFinite(deadline) && deadline >= 1e12 && deadline <= startedAt + MAX_DEADLINE_AHEAD_MS;
|
|
1244
2536
|
return {
|
|
1245
2537
|
dir: path.resolve(dir),
|
|
1246
2538
|
deps,
|
|
1247
|
-
startedAt
|
|
1248
|
-
...(
|
|
2539
|
+
startedAt,
|
|
2540
|
+
...(plausible ? { deadline } : {}),
|
|
1249
2541
|
};
|
|
1250
2542
|
}
|
|
1251
2543
|
function syncModeFor(ctx, namedPaths) {
|
|
@@ -1273,21 +2565,44 @@ async function syncAfterCommit(ctx, mode) {
|
|
|
1273
2565
|
export async function cloudCommit(dir, opts, deps) {
|
|
1274
2566
|
const ctx = contextFor(dir, deps);
|
|
1275
2567
|
requireAttached(ctx, 'commit');
|
|
2568
|
+
const reason = opts.reason ?? 'manual';
|
|
2569
|
+
const leave = reason === 'leave';
|
|
2570
|
+
// Never on the way out of a deck, and never while holding the deck lock.
|
|
2571
|
+
const mirror = leave ? undefined : await askMirrorIfDue(ctx, { always: false });
|
|
1276
2572
|
return withDeckLock(ctx, async () => {
|
|
1277
|
-
|
|
1278
|
-
|
|
1279
|
-
|
|
1280
|
-
|
|
1281
|
-
|
|
1282
|
-
|
|
1283
|
-
|
|
1284
|
-
|
|
1285
|
-
|
|
1286
|
-
|
|
1287
|
-
|
|
1288
|
-
|
|
1289
|
-
|
|
1290
|
-
|
|
2573
|
+
// History missing: a background rehydrate starts (never on the way out of a deck) and this
|
|
2574
|
+
// stops at once. The host's checkpoint keeps the files meanwhile.
|
|
2575
|
+
const state = requireHistory(ctx, { leave });
|
|
2576
|
+
let outcome;
|
|
2577
|
+
try {
|
|
2578
|
+
outcome = await commitLocked(ctx, opts);
|
|
2579
|
+
}
|
|
2580
|
+
finally {
|
|
2581
|
+
// On the way out of a deck the bundle comes first, before any network.
|
|
2582
|
+
if (leave)
|
|
2583
|
+
refreshSnapshot(ctx, true, { state: outcome && !outcome.sha ? state : undefined });
|
|
2584
|
+
}
|
|
2585
|
+
// Whether no ref has moved since `state` was read.
|
|
2586
|
+
let untouched = !outcome.sha;
|
|
2587
|
+
try {
|
|
2588
|
+
if (reason === 'sync')
|
|
2589
|
+
return { ...outcome, sync: null };
|
|
2590
|
+
const quiet = QUIET_REASONS.has(reason) &&
|
|
2591
|
+
!opts.resolve &&
|
|
2592
|
+
!outcome.sha &&
|
|
2593
|
+
state.head === stateRef(state, REMOTE_MAIN) &&
|
|
2594
|
+
!syncPending(ctx);
|
|
2595
|
+
if (quiet)
|
|
2596
|
+
return { ...outcome, sync: null };
|
|
2597
|
+
untouched = false;
|
|
2598
|
+
const after = await syncAfterCommit(ctx, syncModeFor(ctx, (opts.paths?.length ?? 0) > 0));
|
|
2599
|
+
await packAfterCommit(ctx, reason);
|
|
2600
|
+
return { ...outcome, ...after };
|
|
2601
|
+
}
|
|
2602
|
+
finally {
|
|
2603
|
+
if (!leave)
|
|
2604
|
+
refreshSnapshot(ctx, false, { mirror, state: untouched ? state : undefined });
|
|
2605
|
+
}
|
|
1291
2606
|
});
|
|
1292
2607
|
}
|
|
1293
2608
|
/**
|
|
@@ -1297,12 +2612,21 @@ export async function cloudCommit(dir, opts, deps) {
|
|
|
1297
2612
|
export async function cloudSync(dir, deps) {
|
|
1298
2613
|
const ctx = contextFor(dir, deps);
|
|
1299
2614
|
requireAttached(ctx, 'git sync');
|
|
2615
|
+
// Ghost pokes this route after each mirror run: always asked (before the lock).
|
|
2616
|
+
const mirror = await askMirrorIfDue(ctx, { always: true });
|
|
1300
2617
|
return withDeckLock(ctx, async () => {
|
|
1301
|
-
|
|
1302
|
-
|
|
1303
|
-
|
|
2618
|
+
// History missing: the background rehydrate (which takes this lock only at its end).
|
|
2619
|
+
requireHistory(ctx, { leave: false });
|
|
2620
|
+
try {
|
|
2621
|
+
if (deckBusy(ctx)) {
|
|
2622
|
+
markSyncPending(ctx);
|
|
2623
|
+
return { merge: 'deferred', pushed: false };
|
|
2624
|
+
}
|
|
2625
|
+
return await syncLocked(ctx, { commitFirst: true, mode: 'full' });
|
|
2626
|
+
}
|
|
2627
|
+
finally {
|
|
2628
|
+
refreshSnapshot(ctx, false, { mirror });
|
|
1304
2629
|
}
|
|
1305
|
-
return syncLocked(ctx, { commitFirst: true, mode: 'full' });
|
|
1306
2630
|
});
|
|
1307
2631
|
}
|
|
1308
2632
|
/**
|
|
@@ -1313,31 +2637,41 @@ export async function cloudSync(dir, deps) {
|
|
|
1313
2637
|
export async function cloudRestore(dir, target, deps) {
|
|
1314
2638
|
const ctx = contextFor(dir, deps);
|
|
1315
2639
|
requireAttached(ctx, 'restore-version');
|
|
2640
|
+
const mirror = await askMirrorIfDue(ctx, { always: false });
|
|
1316
2641
|
return withDeckLock(ctx, async () => {
|
|
1317
|
-
|
|
1318
|
-
|
|
1319
|
-
|
|
1320
|
-
|
|
1321
|
-
|
|
1322
|
-
|
|
1323
|
-
|
|
1324
|
-
|
|
1325
|
-
|
|
1326
|
-
|
|
1327
|
-
|
|
1328
|
-
|
|
1329
|
-
|
|
1330
|
-
|
|
1331
|
-
|
|
1332
|
-
|
|
1333
|
-
|
|
1334
|
-
|
|
1335
|
-
const
|
|
1336
|
-
|
|
1337
|
-
|
|
1338
|
-
}
|
|
1339
|
-
|
|
2642
|
+
requireHistory(ctx, { leave: false });
|
|
2643
|
+
try {
|
|
2644
|
+
return await restoreLocked(ctx, target);
|
|
2645
|
+
}
|
|
2646
|
+
finally {
|
|
2647
|
+
refreshSnapshot(ctx, false, { mirror });
|
|
2648
|
+
}
|
|
2649
|
+
});
|
|
2650
|
+
}
|
|
2651
|
+
async function restoreLocked(ctx, target) {
|
|
2652
|
+
requireMainBranch(ctx);
|
|
2653
|
+
const sha = revParse(ctx, target);
|
|
2654
|
+
if (!sha || !ok(ctx, ['merge-base', '--is-ancestor', sha, 'HEAD'])) {
|
|
2655
|
+
throw new CloudGitError(`No such version in this deck's history: ${target}`);
|
|
2656
|
+
}
|
|
2657
|
+
// Rewriting the files under a task agent at work would mix its edits into the old version:
|
|
2658
|
+
// asked before anything is done, and again right before the files are rewritten.
|
|
2659
|
+
const refuseIfBusy = () => {
|
|
2660
|
+
const busy = ctx.deps.env[AGENT_ROLE_ENV] === 'router' ? deckTasksBusy(ctx) : deckBusy(ctx);
|
|
2661
|
+
if (busy) {
|
|
2662
|
+
throw new CloudGitError('Task agents are working in this deck, so it was not restored. Restore it once they finish.');
|
|
2663
|
+
}
|
|
2664
|
+
};
|
|
2665
|
+
refuseIfBusy();
|
|
2666
|
+
await commitLocked(ctx, { reason: 'manual', message: 'Work in progress before restoring a version' });
|
|
2667
|
+
const subject = must(ctx, ['log', '-1', '--format=%s', sha]).trim();
|
|
2668
|
+
refuseIfBusy();
|
|
2669
|
+
must(ctx, ['read-tree', '-u', '--reset', sha]);
|
|
2670
|
+
const outcome = await commitLocked(ctx, {
|
|
2671
|
+
reason: 'manual',
|
|
2672
|
+
message: `Restore version ${sha.slice(0, 7)}${subject ? `: ${subject}` : ''}`,
|
|
1340
2673
|
});
|
|
2674
|
+
return { ...outcome, ...(await syncAfterCommit(ctx, syncModeFor(ctx, false))) };
|
|
1341
2675
|
}
|
|
1342
2676
|
// --- attach -----------------------------------------------------------------
|
|
1343
2677
|
const CASTLE_REMOTE_RE = /^https:\/\/([a-z0-9.-]+)\/([A-Za-z0-9_-]{1,64})\.git$/;
|
|
@@ -1381,6 +2715,10 @@ function ensureOwnRepo(ctx) {
|
|
|
1381
2715
|
if (stat && !stat.isDirectory()) {
|
|
1382
2716
|
throw new CloudGitError(`${dotGit} is not a directory (a gitdir file or link); refusing to attach.`);
|
|
1383
2717
|
}
|
|
2718
|
+
// A restored deck's .git lacks its objects directory; with it back, a failure below means a
|
|
2719
|
+
// repo git really cannot read, not one waiting to be rehydrated.
|
|
2720
|
+
if (stat)
|
|
2721
|
+
repairGitSkeleton(ctx.dir);
|
|
1384
2722
|
const top = run(ctx, ['rev-parse', '--show-toplevel']);
|
|
1385
2723
|
if (stat) {
|
|
1386
2724
|
if (top.status !== 0)
|
|
@@ -1418,6 +2756,12 @@ function forgetOtherDecksRemote(ctx, deckId) {
|
|
|
1418
2756
|
run(ctx, ['config', '--local', '--unset-all', key]);
|
|
1419
2757
|
}
|
|
1420
2758
|
fs.rmSync(mergeStatePath(ctx.dir), { force: true });
|
|
2759
|
+
// The other deck's mirror floor says nothing about what this deck's mirror has.
|
|
2760
|
+
for (const ref of [MIRRORED_REF, INTEGRATED_REF]) {
|
|
2761
|
+
const sha = refValue(ctx, ref);
|
|
2762
|
+
if (sha)
|
|
2763
|
+
run(ctx, ['update-ref', '-d', ref, sha]);
|
|
2764
|
+
}
|
|
1421
2765
|
return other;
|
|
1422
2766
|
}
|
|
1423
2767
|
// Local main, whatever the repo started on: an unborn HEAD is pointed at main; a born one on
|
|
@@ -1511,9 +2855,12 @@ export async function cloudAttach(dir, remoteUrl, deps) {
|
|
|
1511
2855
|
must(ctx, ['--version']);
|
|
1512
2856
|
const repo = ensureOwnRepo(ctx);
|
|
1513
2857
|
const original = forgetOtherDecksRemote(ctx, deckId);
|
|
1514
|
-
if (original)
|
|
2858
|
+
if (original) {
|
|
1515
2859
|
deps.warn(`This repo was attached to deck ${original}'s remote (a copied deck); attaching it to ${deckId}'s instead.`);
|
|
1516
|
-
|
|
2860
|
+
// Its history is the other deck's: not rebuilt from there, and not "recovered" either.
|
|
2861
|
+
if (historyMissing(ctx).length > 0)
|
|
2862
|
+
dropForeignHistory(ctx, original);
|
|
2863
|
+
}
|
|
1517
2864
|
setCastleRemote(ctx, remoteUrl);
|
|
1518
2865
|
const stripped = stripEmptyCredentialHelpers(ctx);
|
|
1519
2866
|
if (stripped.length)
|
|
@@ -1526,12 +2873,23 @@ export async function cloudAttach(dir, remoteUrl, deps) {
|
|
|
1526
2873
|
// The base in conflict markers is what lets the agent see what each side changed.
|
|
1527
2874
|
must(ctx, ['config', '--local', 'merge.conflictStyle', 'diff3']);
|
|
1528
2875
|
return withDeckLock(ctx, async () => {
|
|
1529
|
-
|
|
1530
|
-
//
|
|
1531
|
-
|
|
1532
|
-
|
|
1533
|
-
|
|
1534
|
-
|
|
2876
|
+
// A cold resume's repo has refs but no objects: the rehydrate runs in the background, and
|
|
2877
|
+
// this attach stops at once (castle-www runs it in the background on open).
|
|
2878
|
+
requireHistory(ctx, { leave: false });
|
|
2879
|
+
try {
|
|
2880
|
+
ensureMainBranch(ctx);
|
|
2881
|
+
const outcome = await firstSync(ctx, repo);
|
|
2882
|
+
// Marked attached only once the repo shares history with the remote: a deck whose
|
|
2883
|
+
// first fetch failed must not start a local history of its own, which the next attach
|
|
2884
|
+
// could not merge. The next open retries the whole attach.
|
|
2885
|
+
must(ctx, ['config', '--local', 'castle.cloud', 'true']);
|
|
2886
|
+
return outcome;
|
|
2887
|
+
}
|
|
2888
|
+
finally {
|
|
2889
|
+
// Only for a deck attach has set up: the key file lets the host leave its objects out.
|
|
2890
|
+
if (localConfig(ctx, 'castle.cloud') === 'true')
|
|
2891
|
+
refreshSnapshot(ctx, false);
|
|
2892
|
+
}
|
|
1535
2893
|
});
|
|
1536
2894
|
}
|
|
1537
2895
|
// The seed commit an attach made for an empty remote, until it is pushed. Should the push
|
|
@@ -1553,6 +2911,7 @@ function undoUnpushedSeed(ctx) {
|
|
|
1553
2911
|
}
|
|
1554
2912
|
async function firstSync(ctx, repo) {
|
|
1555
2913
|
undoUnpushedSeed(ctx);
|
|
2914
|
+
await commitRecoveredRoot(ctx);
|
|
1556
2915
|
const remote = fetchRemote(ctx);
|
|
1557
2916
|
const head = revParse(ctx, 'HEAD');
|
|
1558
2917
|
if (!remote) {
|
|
@@ -1672,6 +3031,7 @@ function readGitLog(ctx, from, limit) {
|
|
|
1672
3031
|
* refresh never holds the index lock a commit needs.
|
|
1673
3032
|
*/
|
|
1674
3033
|
export async function gitVersionHistory(dir, env = process.env) {
|
|
3034
|
+
repairGitSkeleton(dir);
|
|
1675
3035
|
const git = async (args) => {
|
|
1676
3036
|
const result = await runGitAsync(['--no-optional-locks', ...args], dir, env);
|
|
1677
3037
|
if (result.status !== 0)
|
|
@@ -1679,6 +3039,10 @@ export async function gitVersionHistory(dir, env = process.env) {
|
|
|
1679
3039
|
return result.stdout;
|
|
1680
3040
|
};
|
|
1681
3041
|
const head = await runGitAsync(['rev-parse', '--verify', '--quiet', 'HEAD^{commit}'], dir, env);
|
|
3042
|
+
// HEAD names a commit that is not here: a cold resume whose history is being rehydrated.
|
|
3043
|
+
if (head.status !== 0 && (await runGitAsync(['rev-parse', '--verify', '--quiet', 'HEAD'], dir, env)).status === 0) {
|
|
3044
|
+
return { versions: [], pending: [], loading: true };
|
|
3045
|
+
}
|
|
1682
3046
|
const versions = head.status === 0 ? parseGitLog(await git(logArgs('HEAD', LOG_LIMIT))) : [];
|
|
1683
3047
|
const status = await git(['status', '--porcelain=v1', '-z', '--untracked-files=all']);
|
|
1684
3048
|
return { versions, pending: parseStatus(status) };
|
|
@@ -1687,7 +3051,12 @@ export async function gitVersionHistory(dir, env = process.env) {
|
|
|
1687
3051
|
// agent working out what recent work did.
|
|
1688
3052
|
export function printGitLog(dir, from, git = cloudGitRunner()) {
|
|
1689
3053
|
const ctx = { dir, deps: { git }, startedAt: 0 };
|
|
3054
|
+
repairGitSkeleton(dir);
|
|
1690
3055
|
if (!revParse(ctx, from ?? 'HEAD')) {
|
|
3056
|
+
if (!from && refValue(ctx, 'HEAD')) {
|
|
3057
|
+
console.log("History is loading: this deck's git history is being rebuilt after the sandbox restarted. Try again in a minute.");
|
|
3058
|
+
return;
|
|
3059
|
+
}
|
|
1691
3060
|
console.log(from ? `No such version: ${from}` : 'No versions yet.');
|
|
1692
3061
|
return;
|
|
1693
3062
|
}
|