@zq-silk/yui 2.23.0 → 2.25.0

package/dist/config/configCatalog.js

@@ -20,6 +20,9 @@ export const CONFIG_DEFINITIONS = Object.freeze([
     { key: "resources-quarantine-ttl-hours", domain: "resources", property: "resourcesQuarantineTtlHours", label: "Resource quarantine TTL", summary: "Default observation window before purge, 1-720 hours (default: 24).", takesEffect: "The next resource GC command without an explicit TTL override." },
     { key: "tmux-bin", domain: "tools", property: "tmuxBin", label: "Tmux bin", summary: "Command or path to the tmux binary (default: tmux).", takesEffect: "The next CLI-owned tmux invocation; restart the Controller for Controller-owned launches." },
     { key: "tmux-history-limit", domain: "tools", property: "tmuxHistoryLimit", label: "Tmux history limit", summary: "History lines retained for newly created tmux sessions, 1000-1000000 (default: 100000).", takesEffect: "New tmux sessions; existing sessions report drift until recreated." },
+    { key: "git-local-timeout-seconds", domain: "tools", property: "gitLocalTimeoutSeconds", label: "Git local total timeout", summary: "Total elapsed-time limit for each local Git command, 1-86400 seconds (default: 30). Independent of remote transport budgets.", takesEffect: "The next local Git command, including Controller-owned commands; in-flight commands keep their budgets." },
+    { key: "git-remote-inactivity-timeout-seconds", domain: "tools", property: "gitRemoteInactivityTimeoutSeconds", label: "Git remote inactivity timeout", summary: "Maximum silence on stdout/stderr for clone, remote fetch and ls-remote, 1-86400 seconds (default: 120). Local Git uses its separate configurable total budget.", takesEffect: "The next remote Git command, including Controller-owned commands; in-flight commands keep their budgets." },
+    { key: "git-remote-timeout-seconds", domain: "tools", property: "gitRemoteTimeoutSeconds", label: "Git remote total timeout", summary: "Total elapsed-time limit for each clone, remote fetch or ls-remote, 1-86400 seconds (default: 1800), even while progress continues.", takesEffect: "The next remote Git command, including Controller-owned commands; in-flight commands keep their budgets." },
     { key: "telemetry-enabled", domain: "tools", property: "telemetryEnabled", label: "Diagnostic telemetry", summary: "Enable the optional SQLite diagnostic telemetry projection (default: false); requires a SQLite Home.", takesEffect: "Standalone telemetry commands immediately; scheduler writes after Controller restart." },
     { key: "telemetry-terminal-keep", domain: "tools", property: "telemetryTerminalKeep", label: "Telemetry terminal keep", summary: "Positive-integer rows retained per terminal AgentRun (default: 200).", takesEffect: "Explicit retention immediately; automatic retention after the Controller restarts." },
     { key: "telemetry-run-cap", domain: "tools", property: "telemetryRunCap", label: "Telemetry AgentRun cap", summary: `Positive-integer maximum rows retained per AgentRun, at most ${MAX_RUN_CAP} (default: 50000).`, takesEffect: "Explicit retention immediately; automatic write-time capping after the Controller restarts." }

package/dist/config/gitConfig.js

@@ -0,0 +1,20 @@
+export const DEFAULT_GIT_LOCAL_TIMEOUT_SECONDS = 30;
+export const DEFAULT_GIT_REMOTE_INACTIVITY_TIMEOUT_SECONDS = 120;
+export const DEFAULT_GIT_REMOTE_TIMEOUT_SECONDS = 1_800;
+export function resolveGitLocalTimeoutSeconds(value) {
+    return timeoutSeconds(value, DEFAULT_GIT_LOCAL_TIMEOUT_SECONDS, "gitLocalTimeoutSeconds");
+}
+export function resolveGitRemoteInactivityTimeoutSeconds(value) {
+    return timeoutSeconds(value, DEFAULT_GIT_REMOTE_INACTIVITY_TIMEOUT_SECONDS, "gitRemoteInactivityTimeoutSeconds");
+}
+export function resolveGitRemoteTimeoutSeconds(value) {
+    return timeoutSeconds(value, DEFAULT_GIT_REMOTE_TIMEOUT_SECONDS, "gitRemoteTimeoutSeconds");
+}
+function timeoutSeconds(value, fallback, label) {
+    if (value === undefined)
+        return fallback;
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1 || value > 86_400) {
+        throw new TypeError(`${label} must be an integer from 1 to 86400.`);
+    }
+    return value;
+}

package/dist/config/yuiConfig.js

@@ -91,6 +91,7 @@ export const MAX_CONTROLLER_TASK_CONCURRENCY = 32;
 export const DEFAULT_AGENT_LAUNCH_INACTIVITY_TIMEOUT_SECONDS = 300;
 export const DEFAULT_DELIVERY_TIMEOUT_SECONDS = 120;
 export const DEFAULT_TMUX_HISTORY_LIMIT = 100_000;
+export { DEFAULT_GIT_LOCAL_TIMEOUT_SECONDS, DEFAULT_GIT_REMOTE_INACTIVITY_TIMEOUT_SECONDS, DEFAULT_GIT_REMOTE_TIMEOUT_SECONDS, resolveGitLocalTimeoutSeconds, resolveGitRemoteInactivityTimeoutSeconds, resolveGitRemoteTimeoutSeconds } from "./gitConfig.js";
 export function resolveRuntimeHealth(configured) {
     if (configured === undefined || configured === null)
         return DEFAULT_RUNTIME_HEALTH_POLICY;

package/dist/controlPlaneCli.js

@@ -1111,7 +1111,7 @@ export async function main() {
                 if (action === "list") {
                     if (resolved.length !== 4)
                         throw usageError(usage);
-                    data = await listArtifactsCapability(home, taskId);
+                    data = await listArtifactsCapability(home, taskId, () => store.getConfig());
                 }
                 else if (action === "read") {
                     const relativePath = resolved[4];
@@ -1120,7 +1120,7 @@ export async function main() {
                         throw usageError(usage);
                     data = await readArtifactCapability(home, taskId, {
                         relativePath, ...(commit === undefined ? {} : { commit })
-                    });
+                    }, () => store.getConfig());
                 }
                 else {
                     // save: a delivery-authoritative action; a managed Task caller must be the current Leader.
@@ -1156,7 +1156,7 @@ export async function main() {
                         relativePath, content, ...(encoding === undefined ? {} : { encoding }),
                         ...(message === undefined ? {} : { message }),
                         ...(expectedHead === undefined ? {} : { expectedHead })
-                    });
+                    }, () => store.getConfig());
                 }
                 emit(JSON.stringify(data, null, 2), false, data);
                 return;
@@ -2515,7 +2515,7 @@ async function deltaRecheckPreflightForTaskCommand(args, store, actualTaskReview
         repositoryPaths,
         previousRound: previous,
         candidate: actualTaskReviewCandidate,
-        git: new NodeGitWorkspace()
+        git: new NodeGitWorkspace(() => store.getConfig())
     });
     if (assessment.kind === "ineligible") {
         throw usageError(`Delta-recheck is technically unavailable: ${assessment.reason}`);

package/dist/controller/jobArtifactControl.js

@@ -19,7 +19,7 @@ export async function controlJobArtifact(store, home, value, now) {
         op: "run-get", scope: input.scope, caller: input.caller, id: input.id, runId: input.runId
     }, now);
     const run = current(); // Both definition and historical Assignment authorization.
-    const repo = openJobArtifactRepository(home, jobArtifactOwner(run), runReference(run));
+    const repo = openJobArtifactRepository(home, jobArtifactOwner(run), runReference(run), () => store.getConfig());
     if (input.op === "artifact-list") {
         const head = await repo.head();
         const files = head === null ? [] : await repo.list(head);
@@ -45,7 +45,7 @@ export async function controlJobArtifact(store, home, value, now) {
         if (!(run.artifacts ?? []).some(item => isDeepStrictEqual(item, ref))) {
             throw new Error("Artifact reference is not registered for this exact Run.");
         }
-        const content = await readJobArtifactReference(home, ref);
+        const content = await readJobArtifactReference(home, ref, () => store.getConfig());
         current(); // A replaced Session during I/O must not receive the material.
         return boundedJobArtifactPayload({ reference: ref, ...(input.op === "artifact-preview"
                 ? previewArtifactContent(content, input.offset) : presentArtifactContent(content)) }, "Artifact response", MAX_JOB_ARTIFACT_RESPONSE_BYTES);
@@ -79,7 +79,7 @@ export async function controlJobArtifact(store, home, value, now) {
             }
             assertCallerAuthorized(store, input.caller, ref.owner.taskId);
         }
-        await readJobArtifactReference(home, ref);
+        await readJobArtifactReference(home, ref, () => store.getConfig());
     }
     try {
         return store.transaction(tx => {

package/dist/controller/jobDefinitionControl.js

@@ -303,7 +303,7 @@ export function authorizeGlobalJobStart(store, run) {
             const definition = store.getJobDefinition({ kind: "global" }, run.definitionId);
             if (definition?.builtin)
                 requireProjectSyncTarget(store, definition);
-            const project = requireRefreshProject({ listProjects: () => projects, rootDirectory: () => home }, run.projectId, true);
+            const project = requireRefreshProject({ listProjects: () => projects }, run.projectId, true);
             if (projectRefreshTargetDigest(project) !== projectRefreshDigest({
                 kind: "builtin", action: run.action, projectId: run.projectId, input: run.actionInput
             }))

package/dist/integration/gitIntegrationService.js

@@ -64,7 +64,7 @@ export class GitIntegrationService {
     environment;
     runtimeIsolation;
     #resourceRegistrarValue;
-    constructor(home, store, git = new NodeGitWorkspace(), now = () => new Date(), environment = process.env, runtimeIsolation = defaultIntegrationRuntimeIsolation(home, store.getHomeIdentity().homeId), jobPort) {
+    constructor(home, store, git = new NodeGitWorkspace(() => store.getConfig()), now = () => new Date(), environment = process.env, runtimeIsolation = defaultIntegrationRuntimeIsolation(home, store.getHomeIdentity().homeId), jobPort) {
         this.store = store;
         this.git = git;
         this.now = now;

package/dist/kernel/builtinCapabilities.js

@@ -324,14 +324,14 @@ export function createBuiltinCapabilities(host, store, jobs, signal = () => unde
                     ...(params.encoding === undefined ? {} : { encoding: params.encoding }),
                     ...(params.message === undefined ? {} : { message: params.message }),
                     ...(params.expectedHead === undefined ? {} : { expectedHead: params.expectedHead })
-                });
+                }, () => store.getConfig());
             if (name === "artifact.read")
                 return readArtifactCapability(store.rootDirectory(), taskId, {
                     relativePath: params.relativePath,
                     ...(params.commit === undefined ? {} : { commit: params.commit })
-                });
+                }, () => store.getConfig());
             if (name === "artifact.list")
-                return listArtifactsCapability(store.rootDirectory(), taskId);
+                return listArtifactsCapability(store.rootDirectory(), taskId, () => store.getConfig());
             if (name === "environment.prepare")
                 return resources.prepare(taskId, params.plan);
             if (name === "environment.adopt")

package/dist/repository/gitCommand.js

@@ -0,0 +1,153 @@
+import { spawn } from "node:child_process";
+import { performance } from "node:perf_hooks";
+import { DEFAULT_GIT_LOCAL_TIMEOUT_SECONDS } from "../config/gitConfig.js";
+export const LOCAL_GIT_TIMEOUT_MS = DEFAULT_GIT_LOCAL_TIMEOUT_SECONDS * 1_000;
+/** Retain process facts independently of Git's last progress/error output. */
+export class GitCommandError extends Error {
+    timeoutKind;
+    budget;
+    elapsedMs;
+    code;
+    exitCode;
+    signal;
+    stdout;
+    stderr;
+    stderrTruncated;
+    constructor(cause, timeoutKind, budget, elapsedMs, output) {
+        const failure = cause;
+        const code = failure?.code ?? output.exitCode;
+        const exitCode = output.exitCode;
+        const stderr = output.stderr.toString("utf8").trim();
+        const reasons = [
+            ...(timeoutKind === undefined ? [] : [
+                `${timeoutKind === "inactivity" ? "no-progress timeout" : "total timeout"} after `
+                    + `${timeoutKind === "inactivity" ? budget.inactivityMs : budget.totalMs} ms`
+            ]),
+            ...(exitCode === null ? [] : [`exit code ${exitCode}`]),
+            ...(output.signal === null ? [] : [`signal ${output.signal}`]),
+            ...(typeof code === "string" ? [`${code}: ${failure?.message ?? "process error"}`] : [])
+        ];
+        if (reasons.length === 0)
+            reasons.push(failure?.message ?? "unknown process failure");
+        super(`Git command failed (${reasons.join("; ")}; elapsed ${elapsedMs} ms)`
+            + (stderr.length === 0 ? "." : `: ${output.stderrTruncated ? "[stderr tail; earlier output omitted] " : ""}${stderr}`), { cause });
+        this.timeoutKind = timeoutKind;
+        this.budget = budget;
+        this.elapsedMs = elapsedMs;
+        this.name = "GitCommandError";
+        this.code = code;
+        this.exitCode = exitCode;
+        this.signal = output.signal;
+        this.stdout = output.stdout;
+        this.stderr = stderr;
+        this.stderrTruncated = output.stderrTruncated;
+    }
+}
+/**
+ * One buffered invocation, never retried. Output refreshes only the inactivity
+ * clock; the total deadline never moves. At the hard deadline, kill the owned
+ * process group (including transport helpers) before reporting completion.
+ */
+export async function executeGitCommand(program, args, options = {}) {
+    const budget = options.budget ?? { totalMs: LOCAL_GIT_TIMEOUT_MS };
+    for (const value of [budget.totalMs, ...(budget.inactivityMs === undefined ? [] : [budget.inactivityMs])]) {
+        if (!Number.isSafeInteger(value) || value < 1 || value > 2_147_483_647) {
+            throw new TypeError("Git timeout budgets must be positive integer milliseconds within the timer range.");
+        }
+    }
+    const started = performance.now();
+    const child = spawn(program, args, {
+        ...(options.environment === undefined ? {} : { env: options.environment }),
+        detached: process.platform !== "win32",
+        windowsHide: true
+    });
+    const maxBuffer = options.maxBuffer ?? 1024 * 1024;
+    const chunks = { stdout: [], stderr: [] };
+    const sizes = { stdout: 0, stderr: 0 };
+    let stderrTruncated = false;
+    let failure;
+    let timeoutKind;
+    let terminationError;
+    const terminate = () => {
+        try {
+            if (child.pid !== undefined && process.platform !== "win32") {
+                try {
+                    process.kill(-child.pid, "SIGKILL");
+                }
+                catch (error) {
+                    if (error.code !== "ESRCH")
+                        throw error;
+                }
+            }
+            else {
+                child.kill("SIGKILL");
+            }
+        }
+        catch (error) {
+            terminationError = error;
+            child.kill("SIGKILL");
+        }
+    };
+    const expire = (kind) => {
+        if (timeoutKind !== undefined || failure !== undefined)
+            return;
+        timeoutKind = kind;
+        terminate();
+    };
+    child.once("error", error => { failure ??= error; });
+    const completion = new Promise(settle => {
+        child.once("close", (exitCode, signal) => settle({
+            // A negative close code is an OS spawn error, not a process exit.
+            exitCode: exitCode !== null && exitCode >= 0 ? exitCode : null, signal
+        }));
+    });
+    const totalTimer = setTimeout(() => expire("total"), budget.totalMs);
+    const inactivityTimer = budget.inactivityMs === undefined
+        ? undefined : setTimeout(() => expire("inactivity"), budget.inactivityMs);
+    const collect = (stream, chunk) => {
+        if (chunk.length === 0)
+            return;
+        if (timeoutKind === undefined && failure === undefined)
+            inactivityTimer?.refresh();
+        if (stream === "stderr" && options.stderrTail) {
+            const limit = Math.min(maxBuffer, 64 * 1024);
+            stderrTruncated ||= sizes.stderr + chunk.length > limit;
+            const tail = Buffer.concat([...chunks.stderr, chunk]);
+            chunks.stderr = [tail.subarray(Math.max(0, tail.length - limit))];
+            sizes.stderr = Math.min(limit, tail.length);
+            return;
+        }
+        const remaining = maxBuffer - sizes[stream];
+        if (remaining > 0) {
+            chunks[stream].push(chunk.subarray(0, remaining));
+            sizes[stream] += Math.min(chunk.length, remaining);
+        }
+        if (chunk.length > remaining && failure === undefined) {
+            failure = Object.assign(new Error(`${stream} maxBuffer length exceeded (${maxBuffer} bytes).`), { code: "ERR_CHILD_PROCESS_STDIO_MAXBUFFER" });
+            terminate();
+        }
+    };
+    child.stdout.on("data", chunk => collect("stdout", chunk));
+    child.stderr.on("data", chunk => collect("stderr", chunk));
+    child.stdin.on("error", error => {
+        failure ??= error;
+        terminate();
+    });
+    try {
+        child.stdin.end(options.input);
+        const status = await completion;
+        const result = { stdout: Buffer.concat(chunks.stdout), stderr: Buffer.concat(chunks.stderr), stderrTruncated };
+        if (failure !== undefined || timeoutKind !== undefined || status.exitCode !== 0 || status.signal !== null) {
+            const error = new GitCommandError(failure, timeoutKind, budget, Math.round(performance.now() - started), { ...result, ...status });
+            if (terminationError !== undefined) {
+                throw new AggregateError([error, terminationError], `${error.message} Process-group termination failed; helper effects are unconfirmed.`, { cause: error });
+            }
+            throw error;
+        }
+        return result;
+    }
+    finally {
+        clearTimeout(totalTimer);
+        clearTimeout(inactivityTimer);
+    }
+}

package/dist/repository/gitCompatibility.js

@@ -1,6 +1,7 @@
 import { execFileSync } from "node:child_process";
 import { realpathSync, statSync } from "node:fs";
 import { resolveExecutable } from "../external/pinnedCommandRunner.js";
+import { DEFAULT_GIT_LOCAL_TIMEOUT_SECONDS } from "../config/gitConfig.js";
 // The fetch isolation boundary needs --no-write-fetch-head. Older Git cannot
 // implement it by saving/restoring FETCH_HEAD without racing another writer.
 export const MINIMUM_GIT_VERSION = "2.29.0";
@@ -17,7 +18,7 @@ export function gitVersionSupport(output) {
 }
 let cached;
 /** Pin the executable checked, reusing only an unchanged on-disk identity. */
-export function supportedGit() {
+export function supportedGit(timeoutMs = DEFAULT_GIT_LOCAL_TIMEOUT_SECONDS * 1_000) {
     const selected = resolveExecutable("git", process.env.PATH);
     if (selected === undefined)
         throw new Error("Git executable not found in PATH; install a supported Git before retrying. No Git operation was started.");
@@ -27,7 +28,7 @@ export function supportedGit() {
     if (cached?.identity === identity)
         return cached;
     const output = execFileSync(path, ["--version"], {
-        encoding: "utf8", timeout: 5_000, stdio: ["ignore", "pipe", "pipe"]
+        encoding: "utf8", timeout: timeoutMs, stdio: ["ignore", "pipe", "pipe"]
     });
     const support = gitVersionSupport(output);
     if (!support.supported) {