@fro.bot/systematic 3.22.3 → 3.22.4
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/cli.js +3 -3
- package/dist/{index-99dtcz5j.js → index-0sc6c1vd.js} +55 -19
- package/dist/index.js +759 -154
- package/dist/lib/opencode-operation-observer.d.ts +61 -2
- package/dist/pi.js +55 -19
- package/package.json +2 -2
- package/skills/ce-review/scripts/validate-review.mjs +67 -32
package/dist/index.js
CHANGED
|
@@ -19,7 +19,7 @@ import {
|
|
|
19
19
|
extractCommandFrontmatter,
|
|
20
20
|
findSkillsInDir,
|
|
21
21
|
discoverSkills
|
|
22
|
-
} from "./index-
|
|
22
|
+
} from "./index-0sc6c1vd.js";
|
|
23
23
|
|
|
24
24
|
// src/index.ts
|
|
25
25
|
import { createHash as createHash4 } from "crypto";
|
|
@@ -752,16 +752,27 @@ function normalizePath(path) {
|
|
|
752
752
|
import { spawnSync } from "child_process";
|
|
753
753
|
import { createHash } from "crypto";
|
|
754
754
|
import fs6 from "fs";
|
|
755
|
+
import os3 from "os";
|
|
755
756
|
import path5 from "path";
|
|
756
757
|
var DEFAULT_LIMITS = {
|
|
757
758
|
maxCommandOutputBytes: 8388608,
|
|
758
759
|
maxCommandTimeoutMs: 5000,
|
|
759
760
|
maxFiles: 20000,
|
|
761
|
+
maxGitlinks: 32,
|
|
760
762
|
maxRemoteCommandOutputBytes: 1048576,
|
|
761
763
|
maxRemoteItems: 4096,
|
|
762
764
|
maxTotalFileBytes: 134217728,
|
|
763
765
|
maxPathBytes: 4096
|
|
764
766
|
};
|
|
767
|
+
var GIT_OBJECT_ID = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/i;
|
|
768
|
+
var STAGE_LIST_ARGS = [
|
|
769
|
+
"ls-files",
|
|
770
|
+
"--stage",
|
|
771
|
+
"--full-name",
|
|
772
|
+
"-z",
|
|
773
|
+
"--",
|
|
774
|
+
":/"
|
|
775
|
+
];
|
|
765
776
|
var UNTRACKED_FILES_ARGS = [
|
|
766
777
|
"ls-files",
|
|
767
778
|
"--others",
|
|
@@ -771,6 +782,30 @@ var UNTRACKED_FILES_ARGS = [
|
|
|
771
782
|
"--",
|
|
772
783
|
":/"
|
|
773
784
|
];
|
|
785
|
+
var FORCED_GIT_PREFIX = [
|
|
786
|
+
"--no-replace-objects",
|
|
787
|
+
"-c",
|
|
788
|
+
"core.ignorecase=false",
|
|
789
|
+
"-c",
|
|
790
|
+
"core.fsmonitor=false"
|
|
791
|
+
];
|
|
792
|
+
var STRICT_UTF8_DECODER = new TextDecoder("utf-8", {
|
|
793
|
+
fatal: true,
|
|
794
|
+
ignoreBOM: true
|
|
795
|
+
});
|
|
796
|
+
var WORKTREE_DIGEST_DOMAIN = "systematic:opencode-observer:worktree:v3\x00";
|
|
797
|
+
var IGNORED_GITIGNORE_ARGS = [
|
|
798
|
+
"ls-files",
|
|
799
|
+
"-o",
|
|
800
|
+
"-i",
|
|
801
|
+
"--exclude-standard",
|
|
802
|
+
"--directory",
|
|
803
|
+
"--full-name",
|
|
804
|
+
"-z",
|
|
805
|
+
"--",
|
|
806
|
+
":(top,glob)**/.gitignore"
|
|
807
|
+
];
|
|
808
|
+
var MAX_IGNORE_SOURCE_BYTES = 1048576;
|
|
774
809
|
function unavailable(result) {
|
|
775
810
|
return { status: "unavailable", reasonCode: result.reasonCode };
|
|
776
811
|
}
|
|
@@ -795,25 +830,42 @@ function sanitizedEnvironment() {
|
|
|
795
830
|
}
|
|
796
831
|
return env;
|
|
797
832
|
}
|
|
833
|
+
function decodeCommandStdout(raw) {
|
|
834
|
+
if (typeof raw === "string")
|
|
835
|
+
return { text: raw, invalid: false };
|
|
836
|
+
if (raw instanceof Uint8Array) {
|
|
837
|
+
try {
|
|
838
|
+
return { text: STRICT_UTF8_DECODER.decode(raw), invalid: false };
|
|
839
|
+
} catch {
|
|
840
|
+
return { text: "", invalid: true };
|
|
841
|
+
}
|
|
842
|
+
}
|
|
843
|
+
return { text: "", invalid: raw !== null && raw !== undefined };
|
|
844
|
+
}
|
|
798
845
|
function defaultCommandRunner(args2, cwd, maxOutputBytes, timeoutMs) {
|
|
799
846
|
try {
|
|
800
847
|
const result = spawnSync("git", [...args2], {
|
|
801
848
|
cwd,
|
|
802
849
|
env: sanitizedEnvironment(),
|
|
803
|
-
encoding: "
|
|
850
|
+
encoding: "buffer",
|
|
804
851
|
maxBuffer: maxOutputBytes,
|
|
805
852
|
timeout: timeoutMs
|
|
806
853
|
});
|
|
854
|
+
const stdout = decodeCommandStdout(result.stdout);
|
|
807
855
|
return {
|
|
808
856
|
status: result.status ?? -1,
|
|
809
|
-
stdout:
|
|
810
|
-
stderr:
|
|
811
|
-
timedOut: isCommandTimeout(result.error)
|
|
857
|
+
stdout: stdout.text,
|
|
858
|
+
stderr: Buffer.isBuffer(result.stderr) ? result.stderr.toString("utf8") : "",
|
|
859
|
+
timedOut: isCommandTimeout(result.error),
|
|
860
|
+
...stdout.invalid ? { invalidOutput: true } : {}
|
|
812
861
|
};
|
|
813
862
|
} catch {
|
|
814
863
|
return { status: -1, stdout: "", stderr: "" };
|
|
815
864
|
}
|
|
816
865
|
}
|
|
866
|
+
function withForcedGitPrefix(runner) {
|
|
867
|
+
return (args2, cwd, maxOutputBytes, timeoutMs) => runner([...FORCED_GIT_PREFIX, ...args2], cwd, maxOutputBytes, timeoutMs);
|
|
868
|
+
}
|
|
817
869
|
function defaultRemoteCommandRunner(executable, args2, cwd, maxOutputBytes, timeoutMs) {
|
|
818
870
|
try {
|
|
819
871
|
const result = spawnSync(executable, [...args2], {
|
|
@@ -838,6 +890,7 @@ function mergeLimits(input) {
|
|
|
838
890
|
maxCommandOutputBytes: input?.maxCommandOutputBytes ?? DEFAULT_LIMITS.maxCommandOutputBytes,
|
|
839
891
|
maxCommandTimeoutMs: input?.maxCommandTimeoutMs ?? DEFAULT_LIMITS.maxCommandTimeoutMs,
|
|
840
892
|
maxFiles: input?.maxFiles ?? DEFAULT_LIMITS.maxFiles,
|
|
893
|
+
maxGitlinks: input?.maxGitlinks ?? DEFAULT_LIMITS.maxGitlinks,
|
|
841
894
|
maxRemoteCommandOutputBytes: input?.maxRemoteCommandOutputBytes ?? DEFAULT_LIMITS.maxRemoteCommandOutputBytes,
|
|
842
895
|
maxRemoteItems: input?.maxRemoteItems ?? DEFAULT_LIMITS.maxRemoteItems,
|
|
843
896
|
maxTotalFileBytes: input?.maxTotalFileBytes ?? DEFAULT_LIMITS.maxTotalFileBytes,
|
|
@@ -860,10 +913,10 @@ function parseStageEntries(output, maxPathBytes) {
|
|
|
860
913
|
const relativePath = record.slice(separator + 1);
|
|
861
914
|
if (outputBytes(relativePath) > maxPathBytes)
|
|
862
915
|
return;
|
|
863
|
-
const [mode] = header.split(" ");
|
|
864
|
-
if (!mode)
|
|
916
|
+
const [mode, id] = header.split(" ");
|
|
917
|
+
if (!mode || !id || !GIT_OBJECT_ID.test(id))
|
|
865
918
|
return;
|
|
866
|
-
entries.push({
|
|
919
|
+
entries.push({ mode, id: id.toLowerCase(), relativePath });
|
|
867
920
|
}
|
|
868
921
|
return entries.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
|
|
869
922
|
}
|
|
@@ -877,23 +930,37 @@ function safePath(root, relativePath) {
|
|
|
877
930
|
}
|
|
878
931
|
return absolutePath;
|
|
879
932
|
}
|
|
880
|
-
function
|
|
933
|
+
function commandResultError(result, limits) {
|
|
934
|
+
if (result.timedOut)
|
|
935
|
+
return "command-timeout";
|
|
936
|
+
if (result.invalidOutput)
|
|
937
|
+
return "file-read-failed";
|
|
938
|
+
if (outputBytes(result.stdout) > limits.maxCommandOutputBytes || outputBytes(result.stderr) > limits.maxCommandOutputBytes) {
|
|
939
|
+
return "command-output-limit";
|
|
940
|
+
}
|
|
941
|
+
return;
|
|
942
|
+
}
|
|
943
|
+
function runCommandAllowingExit(runner, args2, cwd, limits, acceptedExits) {
|
|
881
944
|
let result;
|
|
882
945
|
try {
|
|
883
946
|
result = runner(args2, cwd, limits.maxCommandOutputBytes, limits.maxCommandTimeoutMs);
|
|
884
947
|
} catch {
|
|
885
948
|
return { status: "error", reasonCode: "command-failed" };
|
|
886
949
|
}
|
|
887
|
-
|
|
888
|
-
|
|
889
|
-
|
|
890
|
-
if (
|
|
891
|
-
return { status: "error", reasonCode: "command-output-limit" };
|
|
892
|
-
}
|
|
893
|
-
if (result.status !== 0) {
|
|
950
|
+
const resultError = commandResultError(result, limits);
|
|
951
|
+
if (resultError)
|
|
952
|
+
return { status: "error", reasonCode: resultError };
|
|
953
|
+
if (!acceptedExits.includes(result.status)) {
|
|
894
954
|
return { status: "error", reasonCode: "command-failed" };
|
|
895
955
|
}
|
|
896
|
-
return {
|
|
956
|
+
return {
|
|
957
|
+
status: "ok",
|
|
958
|
+
output: { stdout: result.stdout },
|
|
959
|
+
exitCode: result.status
|
|
960
|
+
};
|
|
961
|
+
}
|
|
962
|
+
function runCommand(runner, args2, cwd, limits) {
|
|
963
|
+
return runCommandAllowingExit(runner, args2, cwd, limits, [0]);
|
|
897
964
|
}
|
|
898
965
|
function canonicalPath(filePath, realPath = fs6.realpathSync) {
|
|
899
966
|
try {
|
|
@@ -913,7 +980,7 @@ function requiredGitPath(runner, args2, cwd, limits, realPath = fs6.realpathSync
|
|
|
913
980
|
const value = canonicalPath(rawValue, realPath);
|
|
914
981
|
return value === undefined ? { status: "error", reasonCode: "target-unavailable" } : { status: "ok", value };
|
|
915
982
|
}
|
|
916
|
-
function
|
|
983
|
+
function captureRootPin(targetDirectory, runner, limits, realPath) {
|
|
917
984
|
const targetRoot = requiredGitPath(runner, ["rev-parse", "--show-toplevel"], targetDirectory, limits, realPath);
|
|
918
985
|
if (targetRoot.status === "error")
|
|
919
986
|
return targetRoot;
|
|
@@ -921,6 +988,19 @@ function captureParentIdentity(targetDirectory, runner, limits, realPath = fs6.r
|
|
|
921
988
|
if (gitDir.status === "error")
|
|
922
989
|
return gitDir;
|
|
923
990
|
const commonDir = requiredGitPath(runner, ["rev-parse", "--path-format=absolute", "--git-common-dir"], targetDirectory, limits, realPath);
|
|
991
|
+
if (commonDir.status === "error")
|
|
992
|
+
return commonDir;
|
|
993
|
+
return {
|
|
994
|
+
status: "ok",
|
|
995
|
+
pin: {
|
|
996
|
+
targetRoot: targetRoot.value,
|
|
997
|
+
gitDir: gitDir.value,
|
|
998
|
+
commonDir: commonDir.value
|
|
999
|
+
}
|
|
1000
|
+
};
|
|
1001
|
+
}
|
|
1002
|
+
function captureParentIdentity(targetDirectory, pin, runner, limits, realPath = fs6.realpathSync) {
|
|
1003
|
+
const commonDir = requiredGitPath(runner, ["rev-parse", "--path-format=absolute", "--git-common-dir"], targetDirectory, limits, realPath);
|
|
924
1004
|
if (commonDir.status === "error")
|
|
925
1005
|
return commonDir;
|
|
926
1006
|
const worktreeList = runCommand(runner, ["worktree", "list", "--porcelain", "-z"], targetDirectory, limits);
|
|
@@ -934,8 +1014,8 @@ function captureParentIdentity(targetDirectory, runner, limits, realPath = fs6.r
|
|
|
934
1014
|
return roots.length > 0 ? {
|
|
935
1015
|
status: "ok",
|
|
936
1016
|
identity: {
|
|
937
|
-
targetRoot: targetRoot
|
|
938
|
-
gitDir: gitDir
|
|
1017
|
+
targetRoot: pin.targetRoot,
|
|
1018
|
+
gitDir: pin.gitDir,
|
|
939
1019
|
commonDir: commonDir.value,
|
|
940
1020
|
registeredWorktreeRoots: roots
|
|
941
1021
|
}
|
|
@@ -995,7 +1075,7 @@ function validateDotGitLinkage(targetRoot, gitDir, commonDir, realPath) {
|
|
|
995
1075
|
return backlinkStat.isFile() && !backlinkStat.isSymbolicLink() && readGitdirBacklink(backlinkPath, realPath) === canonicalPath(dotGit, realPath);
|
|
996
1076
|
}
|
|
997
1077
|
function validateRegisteredWorktree(candidateDirectory, parentIdentity, options = {}) {
|
|
998
|
-
const runner = options.commandRunner ?? defaultCommandRunner;
|
|
1078
|
+
const runner = options.commandRunner ?? withForcedGitPrefix(defaultCommandRunner);
|
|
999
1079
|
const limits = mergeLimits(options.limits);
|
|
1000
1080
|
const realPath = options.realPath ?? fs6.realpathSync;
|
|
1001
1081
|
const candidateRoot = canonicalPath(candidateDirectory, realPath);
|
|
@@ -1030,175 +1110,688 @@ function validateRegisteredWorktree(candidateDirectory, parentIdentity, options
|
|
|
1030
1110
|
commonDir: commonDir.value
|
|
1031
1111
|
};
|
|
1032
1112
|
}
|
|
1033
|
-
function readRevision(runner, context, limits) {
|
|
1113
|
+
function readRevision(runner, context, head, insideWorkTree, limits) {
|
|
1034
1114
|
const branch = runCommand(runner, ["symbolic-ref", "--short", "HEAD"], context.commandDirectory, limits);
|
|
1035
1115
|
if (branch.status === "error" && branch.reasonCode !== "command-failed") {
|
|
1036
1116
|
return branch;
|
|
1037
1117
|
}
|
|
1038
1118
|
const branchValue = branch.status === "ok" ? branch.output.stdout.trim() : "detached";
|
|
1039
|
-
let head;
|
|
1040
|
-
try {
|
|
1041
|
-
head = runner(["rev-parse", "--verify", "HEAD"], context.commandDirectory, limits.maxCommandOutputBytes, limits.maxCommandTimeoutMs);
|
|
1042
|
-
} catch {
|
|
1043
|
-
return { status: "error", reasonCode: "command-failed" };
|
|
1044
|
-
}
|
|
1045
|
-
if (head.timedOut) {
|
|
1046
|
-
return { status: "error", reasonCode: "command-timeout" };
|
|
1047
|
-
}
|
|
1048
|
-
if (outputBytes(head.stdout) > limits.maxCommandOutputBytes || outputBytes(head.stderr) > limits.maxCommandOutputBytes) {
|
|
1049
|
-
return { status: "error", reasonCode: "command-output-limit" };
|
|
1050
|
-
}
|
|
1051
|
-
const headValue = head.status === 0 ? head.stdout.trim() : "unborn";
|
|
1052
|
-
const inside = runCommand(runner, ["rev-parse", "--is-inside-work-tree"], context.commandDirectory, limits);
|
|
1053
|
-
if (inside.status === "error")
|
|
1054
|
-
return inside;
|
|
1055
1119
|
return {
|
|
1056
1120
|
status: "ok",
|
|
1057
1121
|
digest: digest("repository-revision", [
|
|
1058
|
-
|
|
1122
|
+
head ?? "unborn",
|
|
1059
1123
|
branchValue,
|
|
1060
|
-
|
|
1124
|
+
String(insideWorkTree)
|
|
1061
1125
|
])
|
|
1062
1126
|
};
|
|
1063
1127
|
}
|
|
1128
|
+
function readRepositoryAnchor(runner, cwd, limits, realPath) {
|
|
1129
|
+
const result = runCommandAllowingExit(runner, [
|
|
1130
|
+
"rev-parse",
|
|
1131
|
+
"--show-toplevel",
|
|
1132
|
+
"--absolute-git-dir",
|
|
1133
|
+
"--git-path",
|
|
1134
|
+
"info/exclude",
|
|
1135
|
+
"--is-inside-work-tree",
|
|
1136
|
+
"--path-format=absolute",
|
|
1137
|
+
"--git-common-dir",
|
|
1138
|
+
"--verify",
|
|
1139
|
+
"-q",
|
|
1140
|
+
"HEAD"
|
|
1141
|
+
], cwd, limits, [0, 1]);
|
|
1142
|
+
if (result.status === "error")
|
|
1143
|
+
return result;
|
|
1144
|
+
const lines = result.output.stdout.split(`
|
|
1145
|
+
`);
|
|
1146
|
+
if (lines.at(-1) === "")
|
|
1147
|
+
lines.pop();
|
|
1148
|
+
const unborn = result.exitCode === 1 && lines.length === 5;
|
|
1149
|
+
if (result.exitCode !== 0 && !unborn) {
|
|
1150
|
+
return { status: "error", reasonCode: "command-failed" };
|
|
1151
|
+
}
|
|
1152
|
+
const [
|
|
1153
|
+
toplevelLine,
|
|
1154
|
+
gitDirLine,
|
|
1155
|
+
excludeLine,
|
|
1156
|
+
insideLine,
|
|
1157
|
+
commonDirLine,
|
|
1158
|
+
headLine
|
|
1159
|
+
] = lines;
|
|
1160
|
+
const malformed = lines.length !== (unborn ? 5 : 6) || commonDirLine === undefined || insideLine !== "true" && insideLine !== "false" || toplevelLine === undefined || gitDirLine === undefined || excludeLine === undefined || excludeLine.length === 0 || outputBytes(toplevelLine) > limits.maxPathBytes || headLine !== undefined && !GIT_OBJECT_ID.test(headLine);
|
|
1161
|
+
if (malformed)
|
|
1162
|
+
return { status: "error", reasonCode: "target-unavailable" };
|
|
1163
|
+
const toplevel = absoluteCanonicalPath(toplevelLine, realPath);
|
|
1164
|
+
const gitDir = absoluteCanonicalPath(gitDirLine, realPath);
|
|
1165
|
+
const commonDir = absoluteCanonicalPath(commonDirLine, realPath);
|
|
1166
|
+
if (toplevel === undefined || gitDir === undefined || commonDir === undefined) {
|
|
1167
|
+
return { status: "error", reasonCode: "target-unavailable" };
|
|
1168
|
+
}
|
|
1169
|
+
return {
|
|
1170
|
+
status: "ok",
|
|
1171
|
+
toplevel,
|
|
1172
|
+
gitDir,
|
|
1173
|
+
commonDir,
|
|
1174
|
+
head: headLine?.toLowerCase(),
|
|
1175
|
+
infoExcludePath: path5.resolve(cwd, excludeLine),
|
|
1176
|
+
insideWorkTree: insideLine === "true"
|
|
1177
|
+
};
|
|
1178
|
+
}
|
|
1179
|
+
function absoluteCanonicalPath(value, realPath) {
|
|
1180
|
+
return path5.isAbsolute(value) ? canonicalPath(value, realPath) : undefined;
|
|
1181
|
+
}
|
|
1064
1182
|
function isEnoent(error) {
|
|
1065
1183
|
return error !== null && typeof error === "object" && "code" in error && error.code === "ENOENT";
|
|
1066
1184
|
}
|
|
1067
|
-
function
|
|
1068
|
-
|
|
1069
|
-
|
|
1070
|
-
|
|
1071
|
-
|
|
1072
|
-
|
|
1185
|
+
function observed(absolutePath, record, stat, displacedByDirectory = false) {
|
|
1186
|
+
return {
|
|
1187
|
+
status: "ok",
|
|
1188
|
+
observation: {
|
|
1189
|
+
absolutePath,
|
|
1190
|
+
record,
|
|
1191
|
+
stat,
|
|
1192
|
+
...displacedByDirectory ? { displacedByDirectory: true } : {}
|
|
1193
|
+
}
|
|
1194
|
+
};
|
|
1195
|
+
}
|
|
1196
|
+
function hashField(hash, field) {
|
|
1197
|
+
const bytes = typeof field === "string" ? Buffer.from(field) : field;
|
|
1198
|
+
hash.update(`${bytes.byteLength}:`);
|
|
1199
|
+
hash.update(bytes);
|
|
1200
|
+
}
|
|
1201
|
+
function gitBlobId(content, format) {
|
|
1202
|
+
return createHash(format).update(`blob ${content.byteLength}\x00`).update(content).digest("hex");
|
|
1203
|
+
}
|
|
1204
|
+
function missingObservation(absolutePath, relativePath, displacedByDirectory = false) {
|
|
1205
|
+
return observed(absolutePath, { path: relativePath, kind: "missing", mode: "", id: undefined }, undefined, displacedByDirectory);
|
|
1206
|
+
}
|
|
1207
|
+
function vanishedPath(tracked, absolutePath, relativePath) {
|
|
1208
|
+
return tracked ? missingObservation(absolutePath, relativePath) : { status: "error", reasonCode: "worktree-unstable" };
|
|
1209
|
+
}
|
|
1210
|
+
function sameStat(left, right) {
|
|
1211
|
+
return left.isFile === right.isFile && left.isSymbolicLink === right.isSymbolicLink && left.mode === right.mode && left.size === right.size && left.dev === right.dev && left.ino === right.ino && left.mtimeNs === right.mtimeNs && left.ctimeNs === right.ctimeNs;
|
|
1212
|
+
}
|
|
1213
|
+
function hasErrorCode(error, ...codes) {
|
|
1214
|
+
return error !== null && typeof error === "object" && "code" in error && typeof error.code === "string" && codes.includes(error.code);
|
|
1215
|
+
}
|
|
1216
|
+
function openWithoutFollowing(absolutePath) {
|
|
1217
|
+
const flags2 = fs6.constants.O_RDONLY | (fs6.constants.O_NOFOLLOW ?? 0) | (fs6.constants.O_NONBLOCK ?? 0);
|
|
1218
|
+
try {
|
|
1219
|
+
return { status: "ok", fd: fs6.openSync(absolutePath, flags2) };
|
|
1220
|
+
} catch (error) {
|
|
1221
|
+
if (isEnoent(error))
|
|
1222
|
+
return { status: "missing" };
|
|
1223
|
+
if (hasErrorCode(error, "ELOOP", "EMLINK")) {
|
|
1224
|
+
return { status: "error", reasonCode: "worktree-unstable" };
|
|
1225
|
+
}
|
|
1073
1226
|
return { status: "error", reasonCode: "file-read-failed" };
|
|
1074
1227
|
}
|
|
1075
|
-
hash.update("gitlink\x00");
|
|
1076
|
-
hash.update(relativePath);
|
|
1077
|
-
hash.update("\x00");
|
|
1078
|
-
hash.update(revision.toLowerCase());
|
|
1079
|
-
hash.update("\x00");
|
|
1080
|
-
return { status: "ok", totalBytes };
|
|
1081
1228
|
}
|
|
1082
|
-
function
|
|
1083
|
-
|
|
1229
|
+
function readOpenedRegularFile(fd, expected, maxBytes) {
|
|
1230
|
+
const opened = fs6.fstatSync(fd, { bigint: true });
|
|
1231
|
+
const identityKnown = expected.dev !== undefined && expected.ino !== undefined;
|
|
1232
|
+
if (!opened.isFile() || identityKnown && (opened.dev !== BigInt(expected.dev ?? 0) || opened.ino !== BigInt(expected.ino ?? 0))) {
|
|
1233
|
+
return { status: "error", reasonCode: "worktree-unstable" };
|
|
1234
|
+
}
|
|
1235
|
+
let buffer = Buffer.allocUnsafe(Math.min(Math.max(expected.size, 0), maxBytes) + 1);
|
|
1236
|
+
let total = 0;
|
|
1237
|
+
for (;; ) {
|
|
1238
|
+
if (total === buffer.length) {
|
|
1239
|
+
const grown = Buffer.allocUnsafe(Math.min(buffer.length * 2, maxBytes + 1));
|
|
1240
|
+
buffer.copy(grown, 0, 0, total);
|
|
1241
|
+
buffer = grown;
|
|
1242
|
+
}
|
|
1243
|
+
const count = fs6.readSync(fd, buffer, total, buffer.length - total, null);
|
|
1244
|
+
if (count === 0)
|
|
1245
|
+
break;
|
|
1246
|
+
total += count;
|
|
1247
|
+
if (total > maxBytes) {
|
|
1248
|
+
return { status: "error", reasonCode: "file-output-limit" };
|
|
1249
|
+
}
|
|
1250
|
+
}
|
|
1251
|
+
return { status: "ok", content: buffer.subarray(0, total) };
|
|
1252
|
+
}
|
|
1253
|
+
function readRegularFileHardened(absolutePath, expected, maxBytes) {
|
|
1254
|
+
const opened = openWithoutFollowing(absolutePath);
|
|
1255
|
+
if (opened.status !== "ok")
|
|
1256
|
+
return opened;
|
|
1257
|
+
try {
|
|
1258
|
+
return readOpenedRegularFile(opened.fd, expected, maxBytes);
|
|
1259
|
+
} catch {
|
|
1260
|
+
return { status: "error", reasonCode: "file-read-failed" };
|
|
1261
|
+
} finally {
|
|
1262
|
+
try {
|
|
1263
|
+
fs6.closeSync(opened.fd);
|
|
1264
|
+
} catch {}
|
|
1265
|
+
}
|
|
1266
|
+
}
|
|
1267
|
+
function adaptInjectedFileReader(fileReader) {
|
|
1268
|
+
return (absolutePath) => {
|
|
1269
|
+
try {
|
|
1270
|
+
return { status: "ok", content: fileReader(absolutePath) };
|
|
1271
|
+
} catch (error) {
|
|
1272
|
+
return isEnoent(error) ? { status: "missing" } : { status: "error", reasonCode: "file-read-failed" };
|
|
1273
|
+
}
|
|
1274
|
+
};
|
|
1275
|
+
}
|
|
1276
|
+
function directoryEmptiness(absolutePath) {
|
|
1277
|
+
let directory;
|
|
1084
1278
|
try {
|
|
1085
|
-
|
|
1279
|
+
directory = fs6.opendirSync(absolutePath);
|
|
1086
1280
|
} catch (error) {
|
|
1087
|
-
return
|
|
1281
|
+
return hasErrorCode(error, "ENOENT", "ENOTDIR") ? "empty" : "unreadable";
|
|
1088
1282
|
}
|
|
1089
|
-
|
|
1090
|
-
|
|
1091
|
-
|
|
1092
|
-
return
|
|
1283
|
+
try {
|
|
1284
|
+
return directory.readSync() === null ? "empty" : "non-empty";
|
|
1285
|
+
} catch {
|
|
1286
|
+
return "unreadable";
|
|
1287
|
+
} finally {
|
|
1288
|
+
try {
|
|
1289
|
+
directory.closeSync();
|
|
1290
|
+
} catch {}
|
|
1093
1291
|
}
|
|
1094
|
-
hash.update("symlink\x00");
|
|
1095
|
-
hash.update(relativePath);
|
|
1096
|
-
hash.update("\x00");
|
|
1097
|
-
hash.update(targetBytes);
|
|
1098
|
-
hash.update("\x00");
|
|
1099
|
-
return { status: "ok", totalBytes: nextTotalBytes };
|
|
1100
1292
|
}
|
|
1101
|
-
function
|
|
1102
|
-
|
|
1293
|
+
function readInitializedGitlink(readers, absolutePath, limits) {
|
|
1294
|
+
const result = runCommand(readers.runner, ["rev-parse", "--show-toplevel", "--verify", "-q", "HEAD"], absolutePath, limits);
|
|
1295
|
+
if (result.status === "error")
|
|
1296
|
+
return result;
|
|
1297
|
+
const lines = result.output.stdout.split(`
|
|
1298
|
+
`);
|
|
1299
|
+
if (lines.at(-1) === "")
|
|
1300
|
+
lines.pop();
|
|
1301
|
+
const [toplevel, id] = lines;
|
|
1302
|
+
if (lines.length !== 2 || toplevel === undefined || id === undefined || !GIT_OBJECT_ID.test(id) || !path5.isAbsolute(toplevel)) {
|
|
1103
1303
|
return { status: "error", reasonCode: "file-read-failed" };
|
|
1104
1304
|
}
|
|
1105
|
-
|
|
1106
|
-
|
|
1305
|
+
const submodule = canonicalPath(absolutePath, readers.realPath);
|
|
1306
|
+
const reported = canonicalPath(toplevel, readers.realPath);
|
|
1307
|
+
return submodule !== undefined && submodule === reported ? { status: "initialized", id: id.toLowerCase() } : { status: "error", reasonCode: "file-read-failed" };
|
|
1308
|
+
}
|
|
1309
|
+
function inspectGitlink(readers, absolutePath, limits) {
|
|
1310
|
+
let directory;
|
|
1311
|
+
try {
|
|
1312
|
+
directory = readers.statReader(absolutePath);
|
|
1313
|
+
} catch (error) {
|
|
1314
|
+
return hasErrorCode(error, "ENOENT", "ENOTDIR") ? { status: "absent" } : { status: "error", reasonCode: "file-read-failed" };
|
|
1315
|
+
}
|
|
1316
|
+
if (!directory.isDirectory) {
|
|
1317
|
+
return { status: "error", reasonCode: "file-read-failed" };
|
|
1107
1318
|
}
|
|
1108
|
-
let content;
|
|
1109
1319
|
try {
|
|
1110
|
-
|
|
1320
|
+
readers.statReader(path5.join(absolutePath, ".git"));
|
|
1111
1321
|
} catch (error) {
|
|
1112
|
-
|
|
1322
|
+
if (!isEnoent(error)) {
|
|
1323
|
+
return { status: "error", reasonCode: "file-read-failed" };
|
|
1324
|
+
}
|
|
1325
|
+
switch (directoryEmptiness(absolutePath)) {
|
|
1326
|
+
case "empty":
|
|
1327
|
+
return { status: "uninitialized" };
|
|
1328
|
+
case "non-empty":
|
|
1329
|
+
case "unreadable":
|
|
1330
|
+
return { status: "error", reasonCode: "file-read-failed" };
|
|
1331
|
+
}
|
|
1332
|
+
}
|
|
1333
|
+
return readInitializedGitlink(readers, absolutePath, limits);
|
|
1334
|
+
}
|
|
1335
|
+
function appendSubmoduleFact(hash, readers, absolutePath, relativePath, limits) {
|
|
1336
|
+
const inspected = inspectGitlink(readers, absolutePath, limits);
|
|
1337
|
+
if (inspected.status === "error")
|
|
1338
|
+
return inspected;
|
|
1339
|
+
if (inspected.status === "absent") {
|
|
1340
|
+
return missingObservation(absolutePath, relativePath);
|
|
1341
|
+
}
|
|
1342
|
+
const id = inspected.status === "initialized" ? inspected.id : undefined;
|
|
1343
|
+
hash.update("gitlink");
|
|
1344
|
+
hashField(hash, relativePath);
|
|
1345
|
+
hashField(hash, id ?? "uninitialized");
|
|
1346
|
+
return observed(absolutePath, { path: relativePath, kind: "gitlink", mode: "160000", id }, undefined);
|
|
1347
|
+
}
|
|
1348
|
+
function appendSymlinkFact(hash, readers, absolutePath, relativePath, stat, limits, budget, format, tracked) {
|
|
1349
|
+
let target;
|
|
1350
|
+
try {
|
|
1351
|
+
target = readers.symlinkReader(absolutePath);
|
|
1352
|
+
} catch (error) {
|
|
1353
|
+
return isEnoent(error) ? vanishedPath(tracked, absolutePath, relativePath) : { status: "error", reasonCode: "file-read-failed" };
|
|
1354
|
+
}
|
|
1355
|
+
const nextBytes = budget.bytes + target.byteLength;
|
|
1356
|
+
if (target.byteLength > limits.maxPathBytes || nextBytes > limits.maxTotalFileBytes) {
|
|
1357
|
+
return { status: "error", reasonCode: "file-output-limit" };
|
|
1358
|
+
}
|
|
1359
|
+
hash.update("symlink");
|
|
1360
|
+
hashField(hash, relativePath);
|
|
1361
|
+
hashField(hash, target);
|
|
1362
|
+
budget.bytes = nextBytes;
|
|
1363
|
+
return observed(absolutePath, {
|
|
1364
|
+
path: relativePath,
|
|
1365
|
+
kind: "symlink",
|
|
1366
|
+
mode: "120000",
|
|
1367
|
+
id: gitBlobId(target, format)
|
|
1368
|
+
}, stat);
|
|
1369
|
+
}
|
|
1370
|
+
function appendRegularFact(hash, readers, absolutePath, relativePath, stat, limits, budget, format, tracked) {
|
|
1371
|
+
if (!stat.isFile || !Number.isSafeInteger(stat.size) || stat.size < 0) {
|
|
1372
|
+
return { status: "error", reasonCode: "file-read-failed" };
|
|
1373
|
+
}
|
|
1374
|
+
const remaining = limits.maxTotalFileBytes - budget.bytes;
|
|
1375
|
+
if (stat.size > remaining) {
|
|
1376
|
+
return { status: "error", reasonCode: "file-output-limit" };
|
|
1113
1377
|
}
|
|
1114
|
-
|
|
1378
|
+
const read = readers.readRegular(absolutePath, stat, remaining);
|
|
1379
|
+
if (read.status === "missing")
|
|
1380
|
+
return vanishedPath(tracked, absolutePath, relativePath);
|
|
1381
|
+
if (read.status === "error")
|
|
1382
|
+
return read;
|
|
1383
|
+
const { content } = read;
|
|
1384
|
+
if (content.byteLength > remaining) {
|
|
1115
1385
|
return { status: "error", reasonCode: "file-output-limit" };
|
|
1116
1386
|
}
|
|
1117
|
-
hash.update("regular
|
|
1118
|
-
hash
|
|
1119
|
-
hash.
|
|
1120
|
-
hash
|
|
1121
|
-
|
|
1122
|
-
|
|
1123
|
-
|
|
1387
|
+
hash.update("regular");
|
|
1388
|
+
hashField(hash, relativePath);
|
|
1389
|
+
hashField(hash, (stat.mode & 73) !== 0 ? "executable" : "non-executable");
|
|
1390
|
+
hashField(hash, content);
|
|
1391
|
+
budget.bytes += content.byteLength;
|
|
1392
|
+
return observed(absolutePath, {
|
|
1393
|
+
path: relativePath,
|
|
1394
|
+
kind: "regular",
|
|
1395
|
+
mode: (stat.mode & 64) !== 0 ? "100755" : "100644",
|
|
1396
|
+
id: gitBlobId(content, format)
|
|
1397
|
+
}, stat);
|
|
1398
|
+
}
|
|
1399
|
+
function checkAncestorDirectories(worktreeRoot, relativePath, verified) {
|
|
1400
|
+
const parts2 = relativePath.split("/").slice(0, -1);
|
|
1401
|
+
let current = worktreeRoot;
|
|
1402
|
+
for (const part of parts2) {
|
|
1403
|
+
current = path5.join(current, part);
|
|
1404
|
+
if (verified.has(current))
|
|
1405
|
+
continue;
|
|
1406
|
+
let stat;
|
|
1407
|
+
try {
|
|
1408
|
+
stat = fs6.lstatSync(current);
|
|
1409
|
+
} catch (error) {
|
|
1410
|
+
if (hasErrorCode(error, "ENOENT", "ENOTDIR"))
|
|
1411
|
+
return { status: "ok" };
|
|
1412
|
+
return { status: "error", reasonCode: "file-read-failed" };
|
|
1413
|
+
}
|
|
1414
|
+
if (stat.isSymbolicLink()) {
|
|
1415
|
+
return { status: "error", reasonCode: "file-read-failed" };
|
|
1416
|
+
}
|
|
1417
|
+
if (!stat.isDirectory())
|
|
1418
|
+
return { status: "ok" };
|
|
1419
|
+
verified.add(current);
|
|
1420
|
+
}
|
|
1421
|
+
return { status: "ok" };
|
|
1124
1422
|
}
|
|
1125
|
-
function
|
|
1423
|
+
function verifyAncestorsUnchanged(verified) {
|
|
1424
|
+
for (const directory of verified) {
|
|
1425
|
+
try {
|
|
1426
|
+
const stat = fs6.lstatSync(directory);
|
|
1427
|
+
if (stat.isSymbolicLink() || !stat.isDirectory())
|
|
1428
|
+
return UNSTABLE;
|
|
1429
|
+
} catch (error) {
|
|
1430
|
+
if (!hasErrorCode(error, "ENOENT", "ENOTDIR")) {
|
|
1431
|
+
return { status: "error", reasonCode: "file-read-failed" };
|
|
1432
|
+
}
|
|
1433
|
+
return UNSTABLE;
|
|
1434
|
+
}
|
|
1435
|
+
}
|
|
1436
|
+
return { status: "ok" };
|
|
1437
|
+
}
|
|
1438
|
+
function appendPathFact(hash, readers, context, entry, limits, budget, format, verifiedDirectories) {
|
|
1126
1439
|
const { mode, relativePath } = entry;
|
|
1127
1440
|
const absolutePath = safePath(context.worktreeRoot, relativePath);
|
|
1128
1441
|
if (!absolutePath || outputBytes(relativePath) > limits.maxPathBytes) {
|
|
1129
1442
|
return { status: "error", reasonCode: "file-read-failed" };
|
|
1130
1443
|
}
|
|
1444
|
+
const ancestors = checkAncestorDirectories(context.worktreeRoot, relativePath, verifiedDirectories);
|
|
1445
|
+
if (ancestors.status === "error")
|
|
1446
|
+
return ancestors;
|
|
1447
|
+
const tracked = mode !== "";
|
|
1448
|
+
if (entry.displacedGitlink) {
|
|
1449
|
+
return missingObservation(absolutePath, relativePath, true);
|
|
1450
|
+
}
|
|
1451
|
+
if (mode === "160000") {
|
|
1452
|
+
return appendSubmoduleFact(hash, readers, absolutePath, relativePath, limits);
|
|
1453
|
+
}
|
|
1131
1454
|
let stat;
|
|
1132
1455
|
try {
|
|
1133
|
-
stat = statReader(absolutePath);
|
|
1456
|
+
stat = readers.statReader(absolutePath);
|
|
1134
1457
|
} catch (error) {
|
|
1135
|
-
return
|
|
1458
|
+
return hasErrorCode(error, "ENOENT", "ENOTDIR") ? vanishedPath(tracked, absolutePath, relativePath) : { status: "error", reasonCode: "file-read-failed" };
|
|
1136
1459
|
}
|
|
1137
|
-
if (
|
|
1138
|
-
return
|
|
1139
|
-
if (stat.isSymbolicLink) {
|
|
1140
|
-
return appendSymlinkFact(hash, symlinkReader, absolutePath, relativePath, limits, totalBytes);
|
|
1460
|
+
if (tracked && stat.isDirectory && !stat.isSymbolicLink) {
|
|
1461
|
+
return missingObservation(absolutePath, relativePath, true);
|
|
1141
1462
|
}
|
|
1142
|
-
return appendRegularFact(hash,
|
|
1463
|
+
return stat.isSymbolicLink ? appendSymlinkFact(hash, readers, absolutePath, relativePath, stat, limits, budget, format, tracked) : appendRegularFact(hash, readers, absolutePath, relativePath, stat, limits, budget, format, tracked);
|
|
1143
1464
|
}
|
|
1144
|
-
function
|
|
1145
|
-
const
|
|
1146
|
-
if (tracked.status === "error")
|
|
1147
|
-
return tracked;
|
|
1148
|
-
const staged = runCommand(runner, ["ls-files", "--stage", "--full-name", "-z", "--", ":/"], context.commandDirectory, limits);
|
|
1465
|
+
function listWorktreePaths(runner, context, limits) {
|
|
1466
|
+
const staged = runCommand(runner, STAGE_LIST_ARGS, context.commandDirectory, limits);
|
|
1149
1467
|
if (staged.status === "error")
|
|
1150
1468
|
return staged;
|
|
1151
1469
|
const untracked = runCommand(runner, UNTRACKED_FILES_ARGS, context.commandDirectory, limits);
|
|
1152
1470
|
if (untracked.status === "error")
|
|
1153
1471
|
return untracked;
|
|
1154
|
-
const
|
|
1472
|
+
const ignoredGitignores = runCommand(runner, IGNORED_GITIGNORE_ARGS, context.commandDirectory, limits);
|
|
1473
|
+
if (ignoredGitignores.status === "error")
|
|
1474
|
+
return ignoredGitignores;
|
|
1475
|
+
return {
|
|
1476
|
+
status: "ok",
|
|
1477
|
+
staged: staged.output.stdout,
|
|
1478
|
+
untracked: untracked.output.stdout,
|
|
1479
|
+
ignoredGitignores: ignoredGitignores.output.stdout
|
|
1480
|
+
};
|
|
1481
|
+
}
|
|
1482
|
+
var UNSTABLE = {
|
|
1483
|
+
status: "error",
|
|
1484
|
+
reasonCode: "worktree-unstable"
|
|
1485
|
+
};
|
|
1486
|
+
function verifyGitlinkUnchanged(readers, limits, { absolutePath, record }) {
|
|
1487
|
+
const fresh = inspectGitlink(readers, absolutePath, limits);
|
|
1488
|
+
if (fresh.status === "error") {
|
|
1489
|
+
return fresh.reasonCode === "file-read-failed" ? UNSTABLE : fresh;
|
|
1490
|
+
}
|
|
1491
|
+
if (fresh.status === "absent")
|
|
1492
|
+
return UNSTABLE;
|
|
1493
|
+
const id = fresh.status === "initialized" ? fresh.id : undefined;
|
|
1494
|
+
return id === record.id ? { status: "ok" } : UNSTABLE;
|
|
1495
|
+
}
|
|
1496
|
+
function verifyObservationUnchanged(readers, limits, observation) {
|
|
1497
|
+
const { absolutePath, record, stat } = observation;
|
|
1498
|
+
if (record.kind === "gitlink") {
|
|
1499
|
+
return verifyGitlinkUnchanged(readers, limits, observation);
|
|
1500
|
+
}
|
|
1501
|
+
let fresh;
|
|
1502
|
+
try {
|
|
1503
|
+
fresh = readers.statReader(absolutePath);
|
|
1504
|
+
} catch (error) {
|
|
1505
|
+
if (!hasErrorCode(error, "ENOENT", "ENOTDIR")) {
|
|
1506
|
+
return { status: "error", reasonCode: "file-read-failed" };
|
|
1507
|
+
}
|
|
1508
|
+
return record.kind === "missing" ? { status: "ok" } : UNSTABLE;
|
|
1509
|
+
}
|
|
1510
|
+
if (record.kind === "missing") {
|
|
1511
|
+
const stillDisplaced = observation.displacedByDirectory === true && fresh.isDirectory && !fresh.isSymbolicLink;
|
|
1512
|
+
return stillDisplaced ? { status: "ok" } : UNSTABLE;
|
|
1513
|
+
}
|
|
1514
|
+
if (stat === undefined)
|
|
1515
|
+
return UNSTABLE;
|
|
1516
|
+
return sameStat(stat, fresh) ? { status: "ok" } : UNSTABLE;
|
|
1517
|
+
}
|
|
1518
|
+
function verifyObservationsUnchanged(readers, limits, observations) {
|
|
1519
|
+
for (const observation of observations) {
|
|
1520
|
+
const result = verifyObservationUnchanged(readers, limits, observation);
|
|
1521
|
+
if (result.status === "error")
|
|
1522
|
+
return result;
|
|
1523
|
+
}
|
|
1524
|
+
return { status: "ok" };
|
|
1525
|
+
}
|
|
1526
|
+
function verifyListingsUnchanged(runner, context, limits, first) {
|
|
1527
|
+
const fresh = listWorktreePaths(runner, context, limits);
|
|
1528
|
+
if (fresh.status === "error")
|
|
1529
|
+
return fresh;
|
|
1530
|
+
return fresh.staged === first.staged && fresh.untracked === first.untracked && fresh.ignoredGitignores === first.ignoredGitignores ? { status: "ok" } : UNSTABLE;
|
|
1531
|
+
}
|
|
1532
|
+
function verifyIgnoreSourcesUnchanged(runner, context, limits, first) {
|
|
1533
|
+
const fresh = readIgnoreSources(runner, context, limits);
|
|
1534
|
+
if (fresh.status === "error")
|
|
1535
|
+
return fresh;
|
|
1536
|
+
return sameIgnoreSources(first.ignoreSources, fresh.facts) ? { status: "ok" } : UNSTABLE;
|
|
1537
|
+
}
|
|
1538
|
+
function verifyAnchorUnchanged(readers, context, limits, head) {
|
|
1539
|
+
const anchor = readRepositoryAnchor(readers.runner, context.commandDirectory, limits, readers.realPath);
|
|
1540
|
+
if (anchor.status === "error")
|
|
1541
|
+
return anchor;
|
|
1542
|
+
const { pin } = context;
|
|
1543
|
+
if (anchor.toplevel !== pin.targetRoot || anchor.gitDir !== pin.gitDir || anchor.commonDir !== pin.commonDir) {
|
|
1544
|
+
return { status: "error", reasonCode: "target-unavailable" };
|
|
1545
|
+
}
|
|
1546
|
+
return anchor.head === head ? { status: "ok" } : UNSTABLE;
|
|
1547
|
+
}
|
|
1548
|
+
function runFinalPass(readers, context, limits, head, first, observations, verifiedDirectories) {
|
|
1549
|
+
const sources = verifyIgnoreSourcesUnchanged(readers.runner, context, limits, first);
|
|
1550
|
+
if (sources.status === "error")
|
|
1551
|
+
return sources;
|
|
1552
|
+
const ancestors = verifyAncestorsUnchanged(verifiedDirectories);
|
|
1553
|
+
if (ancestors.status === "error")
|
|
1554
|
+
return ancestors;
|
|
1555
|
+
const unchanged = verifyObservationsUnchanged(readers, limits, observations);
|
|
1556
|
+
if (unchanged.status === "error")
|
|
1557
|
+
return unchanged;
|
|
1558
|
+
const listings = verifyListingsUnchanged(readers.runner, context, limits, first);
|
|
1559
|
+
if (listings.status === "error")
|
|
1560
|
+
return listings;
|
|
1561
|
+
return verifyAnchorUnchanged(readers, context, limits, head);
|
|
1562
|
+
}
|
|
1563
|
+
function readIgnoreSourceFile(label, filePath) {
|
|
1564
|
+
const absent = {
|
|
1565
|
+
status: "ok",
|
|
1566
|
+
fact: { label, content: undefined }
|
|
1567
|
+
};
|
|
1568
|
+
let resolved;
|
|
1569
|
+
let stat;
|
|
1570
|
+
try {
|
|
1571
|
+
resolved = fs6.realpathSync(filePath);
|
|
1572
|
+
stat = fs6.statSync(resolved, { bigint: true });
|
|
1573
|
+
} catch (error) {
|
|
1574
|
+
return hasErrorCode(error, "ENOENT", "ENOTDIR") ? absent : { status: "error", reasonCode: "file-read-failed" };
|
|
1575
|
+
}
|
|
1576
|
+
if (!stat.isFile() || stat.size > BigInt(MAX_IGNORE_SOURCE_BYTES)) {
|
|
1577
|
+
return { status: "error", reasonCode: "file-read-failed" };
|
|
1578
|
+
}
|
|
1579
|
+
const read = readRegularFileHardened(resolved, {
|
|
1580
|
+
isFile: true,
|
|
1581
|
+
isSymbolicLink: false,
|
|
1582
|
+
isDirectory: false,
|
|
1583
|
+
mode: Number(stat.mode),
|
|
1584
|
+
size: Number(stat.size),
|
|
1585
|
+
dev: stat.dev,
|
|
1586
|
+
ino: stat.ino
|
|
1587
|
+
}, MAX_IGNORE_SOURCE_BYTES);
|
|
1588
|
+
if (read.status === "missing") {
|
|
1589
|
+
return { status: "error", reasonCode: "worktree-unstable" };
|
|
1590
|
+
}
|
|
1591
|
+
if (read.status === "error") {
|
|
1592
|
+
return {
|
|
1593
|
+
status: "error",
|
|
1594
|
+
reasonCode: read.reasonCode === "file-output-limit" ? "file-read-failed" : read.reasonCode
|
|
1595
|
+
};
|
|
1596
|
+
}
|
|
1597
|
+
return { status: "ok", fact: { label, content: read.content } };
|
|
1598
|
+
}
|
|
1599
|
+
function defaultExcludesFilePath() {
|
|
1600
|
+
const xdg = process.env.XDG_CONFIG_HOME;
|
|
1601
|
+
if (xdg)
|
|
1602
|
+
return path5.join(xdg, "git", "ignore");
|
|
1603
|
+
return path5.join(process.env.HOME || os3.homedir(), ".config", "git", "ignore");
|
|
1604
|
+
}
|
|
1605
|
+
function resolveExcludesFilePath(runner, context, limits) {
|
|
1606
|
+
const result = runCommandAllowingExit(runner, ["config", "--type=path", "--get", "core.excludesFile"], context.commandDirectory, limits, [0, 1]);
|
|
1607
|
+
if (result.status === "error")
|
|
1608
|
+
return result;
|
|
1609
|
+
if (result.exitCode === 1) {
|
|
1610
|
+
return { status: "ok", filePath: defaultExcludesFilePath() };
|
|
1611
|
+
}
|
|
1612
|
+
const configured = result.output.stdout.replace(/\n$/, "");
|
|
1613
|
+
return {
|
|
1614
|
+
status: "ok",
|
|
1615
|
+
filePath: configured.length === 0 ? undefined : path5.resolve(context.worktreeRoot, configured)
|
|
1616
|
+
};
|
|
1617
|
+
}
|
|
1618
|
+
function readIgnoreSources(runner, context, limits) {
|
|
1619
|
+
const infoExclude = readIgnoreSourceFile("info-exclude", context.infoExcludePath);
|
|
1620
|
+
if (infoExclude.status === "error")
|
|
1621
|
+
return infoExclude;
|
|
1622
|
+
const configured = resolveExcludesFilePath(runner, context, limits);
|
|
1623
|
+
if (configured.status === "error")
|
|
1624
|
+
return configured;
|
|
1625
|
+
const global = configured.filePath === undefined ? {
|
|
1626
|
+
status: "ok",
|
|
1627
|
+
fact: { label: "core-excludes-file", content: undefined }
|
|
1628
|
+
} : readIgnoreSourceFile("core-excludes-file", configured.filePath);
|
|
1629
|
+
if (global.status === "error")
|
|
1630
|
+
return global;
|
|
1631
|
+
return { status: "ok", facts: [infoExclude.fact, global.fact] };
|
|
1632
|
+
}
|
|
1633
|
+
function hashIgnoreSource(hash, fact) {
|
|
1634
|
+
hash.update("ignore-source");
|
|
1635
|
+
hashField(hash, fact.label);
|
|
1636
|
+
hashField(hash, fact.content === undefined ? "absent" : "present");
|
|
1637
|
+
hashField(hash, fact.content ?? "");
|
|
1638
|
+
}
|
|
1639
|
+
function sameIgnoreSources(left, right) {
|
|
1640
|
+
return left.length === right.length && left.every((fact, index) => {
|
|
1641
|
+
const other = right[index];
|
|
1642
|
+
if (other === undefined || fact.label !== other.label)
|
|
1643
|
+
return false;
|
|
1644
|
+
if (fact.content === undefined || other.content === undefined) {
|
|
1645
|
+
return fact.content === other.content;
|
|
1646
|
+
}
|
|
1647
|
+
return Buffer.compare(fact.content, other.content) === 0;
|
|
1648
|
+
});
|
|
1649
|
+
}
|
|
1650
|
+
function readHeadTree(runner, context, head, limits) {
|
|
1651
|
+
const entries = new Map;
|
|
1652
|
+
if (head === undefined)
|
|
1653
|
+
return { status: "ok", entries, ids: [] };
|
|
1654
|
+
const listing = runCommand(runner, ["ls-tree", "-r", "-z", "--full-tree", head], context.commandDirectory, limits);
|
|
1655
|
+
if (listing.status === "error")
|
|
1656
|
+
return listing;
|
|
1657
|
+
for (const record of splitRecords(listing.output.stdout)) {
|
|
1658
|
+
const separator = record.indexOf("\t");
|
|
1659
|
+
const [mode, , id] = record.slice(0, separator).split(" ");
|
|
1660
|
+
const entryPath = record.slice(separator + 1);
|
|
1661
|
+
if (separator <= 0 || !mode || !id || !/^[0-7]{6}$/.test(mode) || !GIT_OBJECT_ID.test(id) || outputBytes(entryPath) > limits.maxPathBytes) {
|
|
1662
|
+
return { status: "error", reasonCode: "file-read-failed" };
|
|
1663
|
+
}
|
|
1664
|
+
entries.set(entryPath, { mode, id: id.toLowerCase() });
|
|
1665
|
+
}
|
|
1666
|
+
return {
|
|
1667
|
+
status: "ok",
|
|
1668
|
+
entries,
|
|
1669
|
+
ids: [...entries.values()].map((entry) => entry.id)
|
|
1670
|
+
};
|
|
1671
|
+
}
|
|
1672
|
+
function inferObjectFormat(ids) {
|
|
1673
|
+
const lengths = new Set(ids.map((id) => id.length));
|
|
1674
|
+
if (lengths.size === 0)
|
|
1675
|
+
return "sha1";
|
|
1676
|
+
if (lengths.size > 1)
|
|
1677
|
+
return;
|
|
1678
|
+
return lengths.has(64) ? "sha256" : "sha1";
|
|
1679
|
+
}
|
|
1680
|
+
function readWorktreeListings(runner, context, headTree, limits) {
|
|
1681
|
+
const first = listWorktreePaths(runner, context, limits);
|
|
1682
|
+
if (first.status === "error")
|
|
1683
|
+
return first;
|
|
1684
|
+
const stageEntries = parseStageEntries(first.staged, limits.maxPathBytes);
|
|
1155
1685
|
if (!stageEntries)
|
|
1156
1686
|
return { status: "error", reasonCode: "file-read-failed" };
|
|
1157
|
-
const
|
|
1158
|
-
const
|
|
1159
|
-
...
|
|
1160
|
-
|
|
1161
|
-
|
|
1162
|
-
|
|
1163
|
-
]
|
|
1687
|
+
const selfIgnored = splitRecords(first.ignoredGitignores).filter((entry) => !entry.endsWith("/"));
|
|
1688
|
+
const unique = new Set([
|
|
1689
|
+
...stageEntries.map((entry) => entry.relativePath),
|
|
1690
|
+
...headTree.keys(),
|
|
1691
|
+
...splitRecords(first.untracked),
|
|
1692
|
+
...selfIgnored
|
|
1693
|
+
]);
|
|
1694
|
+
const paths = [...unique].map((entry) => ({ entry, key: Buffer.from(entry) })).sort((left, right) => left.key.compare(right.key)).map(({ entry }) => entry);
|
|
1695
|
+
return { status: "ok", first, stageEntries, paths };
|
|
1696
|
+
}
|
|
1697
|
+
function hasPathBeneath(sortedPaths, directory) {
|
|
1698
|
+
const prefix = `${directory}/`;
|
|
1699
|
+
const key = Buffer.from(prefix);
|
|
1700
|
+
let low = 0;
|
|
1701
|
+
let high = sortedPaths.length;
|
|
1702
|
+
while (low < high) {
|
|
1703
|
+
const middle = low + high >>> 1;
|
|
1704
|
+
const candidate = sortedPaths[middle];
|
|
1705
|
+
if (candidate !== undefined && Buffer.from(candidate).compare(key) < 0) {
|
|
1706
|
+
low = middle + 1;
|
|
1707
|
+
} else {
|
|
1708
|
+
high = middle;
|
|
1709
|
+
}
|
|
1710
|
+
}
|
|
1711
|
+
return low < sortedPaths.length && (sortedPaths[low]?.startsWith(prefix) ?? false);
|
|
1712
|
+
}
|
|
1713
|
+
function findDisplacedGitlinks(sortedPaths, indexModes, headTree) {
|
|
1714
|
+
const candidates = sortedPaths.filter((entry) => !indexModes.has(entry) && headTree.get(entry)?.mode === "160000");
|
|
1715
|
+
return new Set(candidates.filter((entry) => hasPathBeneath(sortedPaths, entry)));
|
|
1716
|
+
}
|
|
1717
|
+
function readWorktreeSnapshot(readers, context, head, limits) {
|
|
1718
|
+
const { runner } = readers;
|
|
1719
|
+
const sources = readIgnoreSources(runner, context, limits);
|
|
1720
|
+
if (sources.status === "error")
|
|
1721
|
+
return sources;
|
|
1722
|
+
const tree = readHeadTree(runner, context, head, limits);
|
|
1723
|
+
if (tree.status === "error")
|
|
1724
|
+
return tree;
|
|
1725
|
+
const listings = readWorktreeListings(runner, context, tree.entries, limits);
|
|
1726
|
+
if (listings.status === "error")
|
|
1727
|
+
return listings;
|
|
1728
|
+
const format = inferObjectFormat([
|
|
1729
|
+
...tree.ids,
|
|
1730
|
+
...listings.stageEntries.map((entry) => entry.id)
|
|
1731
|
+
]);
|
|
1732
|
+
if (format === undefined) {
|
|
1733
|
+
return { status: "error", reasonCode: "file-read-failed" };
|
|
1734
|
+
}
|
|
1735
|
+
const { paths } = listings;
|
|
1164
1736
|
if (paths.length > limits.maxFiles) {
|
|
1165
1737
|
return { status: "error", reasonCode: "file-limit" };
|
|
1166
1738
|
}
|
|
1739
|
+
const modes = new Map(listings.stageEntries.map((entry) => [entry.relativePath, entry.mode]));
|
|
1740
|
+
const modeOf = (relativePath) => modes.get(relativePath) ?? tree.entries.get(relativePath)?.mode ?? "";
|
|
1741
|
+
const displacedGitlinks = findDisplacedGitlinks(paths, modes, tree.entries);
|
|
1742
|
+
if (paths.filter((entry) => modeOf(entry) === "160000" && !displacedGitlinks.has(entry)).length > limits.maxGitlinks) {
|
|
1743
|
+
return { status: "error", reasonCode: "file-limit" };
|
|
1744
|
+
}
|
|
1167
1745
|
const hash = createHash("sha256");
|
|
1168
|
-
hash.update(
|
|
1169
|
-
|
|
1746
|
+
hash.update(WORKTREE_DIGEST_DOMAIN);
|
|
1747
|
+
const budget = { bytes: 0 };
|
|
1748
|
+
const observations = [];
|
|
1749
|
+
const verifiedDirectories = new Set;
|
|
1170
1750
|
for (const relativePath of paths) {
|
|
1171
|
-
const result =
|
|
1751
|
+
const result = appendPathFact(hash, readers, context, {
|
|
1752
|
+
relativePath,
|
|
1753
|
+
mode: modeOf(relativePath),
|
|
1754
|
+
...displacedGitlinks.has(relativePath) ? { displacedGitlink: true } : {}
|
|
1755
|
+
}, limits, budget, format, verifiedDirectories);
|
|
1172
1756
|
if (result.status === "error")
|
|
1173
1757
|
return result;
|
|
1174
|
-
|
|
1758
|
+
observations.push(result.observation);
|
|
1175
1759
|
}
|
|
1176
|
-
|
|
1177
|
-
|
|
1178
|
-
|
|
1179
|
-
|
|
1180
|
-
|
|
1181
|
-
diff = runner(["diff", "--quiet", "HEAD", "--", ":/"], context.commandDirectory, limits.maxCommandOutputBytes, limits.maxCommandTimeoutMs);
|
|
1182
|
-
} catch {
|
|
1183
|
-
return { status: "error", reasonCode: "command-failed" };
|
|
1184
|
-
}
|
|
1185
|
-
if (diff.timedOut) {
|
|
1186
|
-
return { status: "error", reasonCode: "command-timeout" };
|
|
1187
|
-
}
|
|
1188
|
-
if (outputBytes(diff.stdout) > limits.maxCommandOutputBytes || outputBytes(diff.stderr) > limits.maxCommandOutputBytes) {
|
|
1189
|
-
return { status: "error", reasonCode: "command-output-limit" };
|
|
1190
|
-
}
|
|
1191
|
-
if (diff.status !== 0 && diff.status !== 1) {
|
|
1192
|
-
return { status: "error", reasonCode: "command-failed" };
|
|
1193
|
-
}
|
|
1194
|
-
const untracked = runCommand(runner, UNTRACKED_FILES_ARGS, context.commandDirectory, limits);
|
|
1195
|
-
if (untracked.status === "error")
|
|
1196
|
-
return untracked;
|
|
1760
|
+
for (const fact of sources.facts)
|
|
1761
|
+
hashIgnoreSource(hash, fact);
|
|
1762
|
+
const stable = runFinalPass(readers, context, limits, head, { ...listings.first, ignoreSources: sources.facts }, observations, verifiedDirectories);
|
|
1763
|
+
if (stable.status === "error")
|
|
1764
|
+
return stable;
|
|
1197
1765
|
return {
|
|
1198
1766
|
status: "ok",
|
|
1199
|
-
|
|
1767
|
+
digest: hash.digest("hex"),
|
|
1768
|
+
records: observations.map((observation) => observation.record),
|
|
1769
|
+
headTree: tree.entries
|
|
1200
1770
|
};
|
|
1201
1771
|
}
|
|
1772
|
+
function recordKindForTreeMode(mode) {
|
|
1773
|
+
if (mode === "120000")
|
|
1774
|
+
return "symlink";
|
|
1775
|
+
if (mode === "160000")
|
|
1776
|
+
return "gitlink";
|
|
1777
|
+
return "regular";
|
|
1778
|
+
}
|
|
1779
|
+
function recordMatchesTreeEntry(record, entry) {
|
|
1780
|
+
return record.id !== undefined && record.id === entry.id && record.mode === entry.mode && record.kind === recordKindForTreeMode(entry.mode);
|
|
1781
|
+
}
|
|
1782
|
+
function deriveCommitClosure(records, headTree, head) {
|
|
1783
|
+
if (head === undefined)
|
|
1784
|
+
return false;
|
|
1785
|
+
let matched = 0;
|
|
1786
|
+
for (const record of records) {
|
|
1787
|
+
const entry = headTree.get(record.path);
|
|
1788
|
+
if (entry === undefined || !recordMatchesTreeEntry(record, entry)) {
|
|
1789
|
+
return false;
|
|
1790
|
+
}
|
|
1791
|
+
matched += 1;
|
|
1792
|
+
}
|
|
1793
|
+
return matched === headTree.size;
|
|
1794
|
+
}
|
|
1202
1795
|
function runRemoteCommand(runner, executable, args2, root, limits) {
|
|
1203
1796
|
let result;
|
|
1204
1797
|
try {
|
|
@@ -1378,6 +1971,28 @@ function readCheckReadback(runner, root, limits, pullRequest) {
|
|
|
1378
1971
|
function readRemoteSnapshot(runner, operation, phase, commandDirectory, limits) {
|
|
1379
1972
|
return operation === "push" ? readPushRemoteSnapshot(runner, phase, commandDirectory, limits) : readRemotePullRequest(runner, operation, commandDirectory, limits);
|
|
1380
1973
|
}
|
|
1974
|
+
function resolveWorktreeReaders(runner, options) {
|
|
1975
|
+
return {
|
|
1976
|
+
runner,
|
|
1977
|
+
realPath: options.realPath ?? fs6.realpathSync,
|
|
1978
|
+
readRegular: options.fileReader ? adaptInjectedFileReader(options.fileReader) : readRegularFileHardened,
|
|
1979
|
+
symlinkReader: options.symlinkReader ?? ((filePath) => fs6.readlinkSync(filePath, { encoding: "buffer" })),
|
|
1980
|
+
statReader: options.statReader ?? ((filePath) => {
|
|
1981
|
+
const stat = fs6.lstatSync(filePath, { bigint: true });
|
|
1982
|
+
return {
|
|
1983
|
+
isFile: stat.isFile(),
|
|
1984
|
+
isSymbolicLink: stat.isSymbolicLink(),
|
|
1985
|
+
isDirectory: stat.isDirectory(),
|
|
1986
|
+
mode: Number(stat.mode),
|
|
1987
|
+
size: Number(stat.size),
|
|
1988
|
+
dev: stat.dev,
|
|
1989
|
+
ino: stat.ino,
|
|
1990
|
+
mtimeNs: stat.mtimeNs,
|
|
1991
|
+
ctimeNs: stat.ctimeNs
|
|
1992
|
+
};
|
|
1993
|
+
})
|
|
1994
|
+
};
|
|
1995
|
+
}
|
|
1381
1996
|
function createOpencodeOperationObserver(options) {
|
|
1382
1997
|
const limits = mergeLimits(options.limits);
|
|
1383
1998
|
let targetDirectory;
|
|
@@ -1386,23 +2001,13 @@ function createOpencodeOperationObserver(options) {
|
|
|
1386
2001
|
} catch {
|
|
1387
2002
|
targetDirectory = path5.resolve(options.targetDirectory);
|
|
1388
2003
|
}
|
|
1389
|
-
const runner = options.commandRunner ?? defaultCommandRunner;
|
|
2004
|
+
const runner = withForcedGitPrefix(options.commandRunner ?? defaultCommandRunner);
|
|
1390
2005
|
const remoteRunner = options.remoteCommandRunner ?? defaultRemoteCommandRunner;
|
|
1391
2006
|
const realPath = options.realPath ?? fs6.realpathSync;
|
|
1392
|
-
const
|
|
2007
|
+
const rootPinResult = captureRootPin(targetDirectory, runner, limits, realPath);
|
|
2008
|
+
const parentIdentityResult = rootPinResult.status === "error" ? rootPinResult : captureParentIdentity(targetDirectory, rootPinResult.pin, runner, limits, realPath);
|
|
1393
2009
|
const targetDigest = digest("target", [targetDirectory]);
|
|
1394
|
-
const
|
|
1395
|
-
const symlinkReader = options.symlinkReader ?? fs6.readlinkSync;
|
|
1396
|
-
const statReader = options.statReader ?? ((filePath) => {
|
|
1397
|
-
const stat = fs6.lstatSync(filePath);
|
|
1398
|
-
return {
|
|
1399
|
-
isFile: stat.isFile(),
|
|
1400
|
-
isSymbolicLink: stat.isSymbolicLink(),
|
|
1401
|
-
isDirectory: stat.isDirectory(),
|
|
1402
|
-
mode: stat.mode,
|
|
1403
|
-
size: stat.size
|
|
1404
|
-
};
|
|
1405
|
-
});
|
|
2010
|
+
const readers = resolveWorktreeReaders(runner, options);
|
|
1406
2011
|
return {
|
|
1407
2012
|
targetDigest,
|
|
1408
2013
|
validateRegisteredWorktree(candidateDirectory) {
|
|
@@ -1411,33 +2016,33 @@ function createOpencodeOperationObserver(options) {
|
|
|
1411
2016
|
return validateRegisteredWorktree(candidateDirectory, parentIdentityResult.identity, { commandRunner: runner, limits, realPath });
|
|
1412
2017
|
},
|
|
1413
2018
|
async snapshot() {
|
|
1414
|
-
const
|
|
1415
|
-
if (
|
|
1416
|
-
return unavailable(
|
|
1417
|
-
|
|
1418
|
-
|
|
2019
|
+
const anchor = readRepositoryAnchor(runner, targetDirectory, limits, realPath);
|
|
2020
|
+
if (anchor.status === "error")
|
|
2021
|
+
return unavailable(anchor);
|
|
2022
|
+
if (rootPinResult.status === "error")
|
|
2023
|
+
return unavailable(rootPinResult);
|
|
2024
|
+
if (anchor.toplevel !== rootPinResult.pin.targetRoot || anchor.gitDir !== rootPinResult.pin.gitDir || anchor.commonDir !== rootPinResult.pin.commonDir) {
|
|
1419
2025
|
return { status: "unavailable", reasonCode: "target-unavailable" };
|
|
1420
2026
|
}
|
|
1421
2027
|
const context = {
|
|
1422
2028
|
commandDirectory: targetDirectory,
|
|
1423
|
-
worktreeRoot:
|
|
2029
|
+
worktreeRoot: anchor.toplevel,
|
|
2030
|
+
infoExcludePath: anchor.infoExcludePath,
|
|
2031
|
+
pin: rootPinResult.pin
|
|
1424
2032
|
};
|
|
1425
|
-
const repository = readRevision(runner, context, limits);
|
|
2033
|
+
const repository = readRevision(runner, context, anchor.head, anchor.insideWorkTree, limits);
|
|
1426
2034
|
if (repository.status === "error")
|
|
1427
2035
|
return unavailable(repository);
|
|
1428
|
-
const worktree =
|
|
2036
|
+
const worktree = readWorktreeSnapshot(readers, context, anchor.head, limits);
|
|
1429
2037
|
if (worktree.status === "error")
|
|
1430
2038
|
return unavailable(worktree);
|
|
1431
|
-
const closure = readCommitClosure(runner, context, limits);
|
|
1432
|
-
if (closure.status === "error")
|
|
1433
|
-
return unavailable(closure);
|
|
1434
2039
|
return {
|
|
1435
2040
|
status: "available",
|
|
1436
2041
|
snapshot: {
|
|
1437
2042
|
targetDigest,
|
|
1438
2043
|
repositoryRevisionDigest: repository.digest,
|
|
1439
2044
|
worktreeRevisionDigest: worktree.digest,
|
|
1440
|
-
commitClosure:
|
|
2045
|
+
commitClosure: deriveCommitClosure(worktree.records, worktree.headTree, anchor.head)
|
|
1441
2046
|
}
|
|
1442
2047
|
};
|
|
1443
2048
|
},
|