@zhivex-ai/harness 1.2.0 → 1.3.0-rc.7

package/dist/index-4jw3tvy8.js

@@ -0,0 +1,301 @@
+// src/cli/terminal/session-grants.ts
+function checkApprovalGrant(approval, workspace) {
+  if (approval.kind !== "local-tool" || approval.name !== "run_check")
+    return;
+  try {
+    const args = JSON.parse(approval.arguments);
+    if (!args || typeof args !== "object" || Array.isArray(args))
+      return;
+    const value = args;
+    if (Object.keys(value).sort().join(",") !== "check,expectedScript" || typeof value.check !== "string" || typeof value.expectedScript !== "string" || !value.expectedScript.trim())
+      return;
+    return JSON.stringify([workspace, approval.provider, approval.childAgentId ?? "", approval.name, value.check, value.expectedScript]);
+  } catch {
+    return;
+  }
+}
+
+// src/cli/terminal/terminal-ui.ts
+var DEFAULT_APPROVAL_SUMMARY_CHARACTERS = 1200;
+var EXACT_REVIEW_TOOLS = new Set([
+  "apply_patch",
+  "apply_reviewed_edits",
+  "apply_reviewed_replacement",
+  "verify_and_apply_reviewed_edits",
+  "move_file",
+  "quarantine_file",
+  "restore_file",
+  "run_check",
+  "run_environment_command",
+  "run_environment_batch",
+  "run_environment_shell",
+  "apply_environment_patch",
+  "verify_and_apply_environment_patch"
+]);
+var TERMINAL_CONTROL_CHARACTERS = /[\u0000-\u0008\u000b\u000c\u000d\u000e-\u001f\u007f-\u009f\u202a-\u202e\u2066-\u2069]/gu;
+var escapeCodePoint = (character) => {
+  const codePoint = character.codePointAt(0) ?? 0;
+  return codePoint <= 65535 ? `\\u${codePoint.toString(16).padStart(4, "0")}` : `\\u{${codePoint.toString(16)}}`;
+};
+var sanitizeTerminalText = (value) => value.replace(TERMINAL_CONTROL_CHARACTERS, escapeCodePoint);
+var readableApprovalArguments = (argumentsText) => {
+  try {
+    return sanitizeTerminalText(JSON.stringify(JSON.parse(argumentsText), null, 2));
+  } catch {
+    return sanitizeTerminalText(argumentsText);
+  }
+};
+var boundedText = (value, maximumCharacters) => {
+  if (value.length <= maximumCharacters) {
+    return { text: value, omitted: 0 };
+  }
+  return {
+    text: `${value.slice(0, maximumCharacters)}…`,
+    omitted: value.length - maximumCharacters
+  };
+};
+var formatApproval = (approval, options = {}) => {
+  const detail = options.detail ?? "summary";
+  const maximumCharacters = options.maxSummaryCharacters ?? DEFAULT_APPROVAL_SUMMARY_CHARACTERS;
+  if (!Number.isSafeInteger(maximumCharacters) || maximumCharacters < 1) {
+    throw new Error("Approval summary length must be a positive safe integer.");
+  }
+  const completePayload = readableApprovalArguments(approval.arguments);
+  const shouldShowComplete = detail === "full" || EXACT_REVIEW_TOOLS.has(approval.name);
+  const payload = shouldShowComplete ? { text: completePayload, omitted: 0 } : boundedText(completePayload, maximumCharacters);
+  const identity = [
+    detail === "full" && approval.id ? `approval ${sanitizeTerminalText(approval.id)}` : undefined,
+    detail === "full" && approval.inputDigest ? `input ${sanitizeTerminalText(approval.inputDigest)}` : undefined,
+    approval.serverLabel ? `server ${sanitizeTerminalText(approval.serverLabel)}` : undefined,
+    approval.childAgentId ? `child ${sanitizeTerminalText(approval.childAgentId)}` : undefined
+  ].filter((value) => value !== undefined);
+  const header = `[${sanitizeTerminalText(approval.kind ?? "provider")}] ` + `${sanitizeTerminalText(approval.name)}` + (identity.length > 0 ? ` · ${identity.join(" · ")}` : "");
+  const omissionNotice = payload.omitted > 0 ? `
+[${payload.omitted} characters omitted; press v to view the complete payload]` : "";
+  const scope = [];
+  if (EXACT_REVIEW_TOOLS.has(approval.name)) {
+    try {
+      const args = JSON.parse(approval.arguments);
+      if (Array.isArray(args.changes))
+        for (const change of args.changes) {
+          if (typeof change?.path === "string")
+            scope.push(`${change.expectedDigest === null ? "ADD" : "MODIFY"} ${change.path}`);
+        }
+      if (approval.name === "quarantine_file" && typeof args.path === "string")
+        scope.push(`REMOVE (recoverable quarantine) ${args.path}`);
+      if (approval.name === "move_file")
+        scope.push(`MOVE ${args.source} -> ${args.destination}`);
+      if (approval.name.includes("verify_and_apply"))
+        scope.push("Verification: pending; approval authorizes the checks and conditional application, not a successful result.");
+    } catch {}
+  }
+  if (detail === "summary" && approval.kind === "local-tool" && approval.name === "run_check") {
+    try {
+      const args = JSON.parse(approval.arguments);
+      if (typeof args.check === "string" && typeof args.expectedScript === "string" && Object.keys(args).every((key) => ["check", "expectedScript"].includes(key))) {
+        return `Run check: ${sanitizeTerminalText(args.check)}${identity.length ? ` · ${identity.join(" · ")}` : ""}
+
+  ${sanitizeTerminalText(args.expectedScript)}
+`;
+      }
+    } catch {}
+  }
+  return `${header}
+${scope.map(sanitizeTerminalText).map((line) => `${line}
+`).join("")}${payload.text}${omissionNotice}`;
+};
+var promptEnded = (error) => {
+  if (!error || typeof error !== "object")
+    return false;
+  const candidate = error;
+  return candidate.name === "AbortError" || candidate.code === "ABORT_ERR" || candidate.code === "ERR_USE_AFTER_CLOSE";
+};
+var normalizedDecision = (answer) => answer.trim().toLowerCase();
+var resolveTerminalApprovals = async (approvals, options) => {
+  if (options.requireCompleteReview && approvals.reduce((bytes, approval) => bytes + Buffer.byteLength(approval.arguments), 0) > 256 * 1024) {
+    options.write(`Explicit review exceeds the complete payload limit; approvals remain pending.
+`);
+    return;
+  }
+  const responses = [];
+  const staged = new Set(options.sessionGrants);
+  for (let index = 0;index < approvals.length; index += 1) {
+    const approval = approvals[index];
+    const grant = !options.requireCompleteReview && options.sessionGrants && options.workspace ? checkApprovalGrant(approval, options.workspace) : undefined;
+    if (grant && staged.has(grant)) {
+      responses.push({ provider: approval.provider, approvalRequestId: approval.id, approve: true, reason: "Exact check approved for this CLI session." });
+      options.onDecisionOrigin?.("automatic");
+      continue;
+    }
+    options.write(`
+Approval required ${index + 1}/${approvals.length}:
+` + `${formatApproval(approval, {
+      detail: options.requireCompleteReview ? "full" : "summary",
+      ...options.maxSummaryCharacters !== undefined ? { maxSummaryCharacters: options.maxSummaryCharacters } : {}
+    })}
+`);
+    if (options.workspace)
+      options.write(`Workspace: ${sanitizeTerminalText(options.workspace)}
+`);
+    for (;; ) {
+      let answer;
+      try {
+        const received = options.select ? await options.select("Permission required", [
+          { value: "n", label: "Reject" },
+          { value: "y", label: "Allow once", detail: "Only the action shown above" },
+          ...grant ? [{ value: "s", label: "Allow this exact check for this session", detail: "Changing the script requires approval again" }] : [],
+          { value: "v", label: "View technical details" },
+          { value: "q", label: "Leave pending" }
+        ]) : await options.ask(`Approve? [y]es/${grant ? "[s]ession/" : ""}[n]o/[v]iew/[q]uit (default: no) `);
+        if (typeof received !== "string")
+          return;
+        answer = normalizedDecision(received);
+      } catch (error) {
+        if (promptEnded(error))
+          return;
+        throw error;
+      }
+      if (answer === "v" || answer === "view") {
+        options.write(`
+Complete approval payload:
+${formatApproval(approval, { detail: "full" })}
+`);
+        continue;
+      }
+      if (answer === "q" || answer === "quit") {
+        return;
+      }
+      if (answer === "y" || answer === "yes" || answer === "s" && grant) {
+        if (answer === "s" && grant)
+          staged.add(grant);
+        responses.push({
+          provider: approval.provider,
+          approvalRequestId: approval.id,
+          approve: true,
+          reason: options.approvedReason ?? "Approved interactively."
+        });
+        options.onDecisionOrigin?.("interactive");
+        break;
+      }
+      if (answer === "" || answer === "n" || answer === "no") {
+        responses.push({
+          provider: approval.provider,
+          approvalRequestId: approval.id,
+          approve: false,
+          reason: options.deniedReason ?? "Denied by the operator."
+        });
+        options.onDecisionOrigin?.("interactive");
+        break;
+      }
+      options.write(`Choose y, n, v, or q.
+`);
+    }
+  }
+  for (const key of staged)
+    options.sessionGrants?.add(key);
+  return responses;
+};
+var terminalSupportsColor = (isTTY, env = process.env) => isTTY && !Object.prototype.hasOwnProperty.call(env, "NO_COLOR") && env.TERM !== "dumb" && env.FORCE_COLOR !== "0";
+var verificationReceipt = (name, output) => {
+  if (!output || typeof output !== "object")
+    return;
+  const value = output;
+  const receipt = name === "run_check" || name === "run_environment_command" ? value : name.startsWith("verify_and_apply_") && value.verification && typeof value.verification === "object" ? value.verification : undefined;
+  if (!receipt || !Number.isSafeInteger(receipt.exitCode))
+    return;
+  const command = receipt.command;
+  const prefix = Array.isArray(command) ? JSON.stringify(command.slice(0, -1)) : "";
+  const supported = [
+    '["bun","--no-env-file","run"]',
+    '["npm","--ignore-scripts","run"]',
+    '["pnpm","--ignore-scripts","run"]',
+    '["yarn","run"]'
+  ];
+  const last = Array.isArray(command) ? command.at(-1) : undefined;
+  const check = name === "run_check" && supported.includes(prefix) && typeof last === "string" && /^[A-Za-z0-9:_-]{1,100}$/.test(last) ? last : undefined;
+  return { exitCode: receipt.exitCode, timedOut: receipt.timedOut === true, check };
+};
+var paint = (text, code, color) => color ? `\x1B[${code}m${text}\x1B[0m` : text;
+var terminalRunFailure = (error) => {
+  const message = error instanceof Error ? error.message : error && typeof error === "object" && ("message" in error) && typeof error.message === "string" ? error.message : "";
+  const provider = /^(Meta|Qwen|OpenAI|Gemini) request failed with status ([45]\d{2})(?: \((previous response unavailable|context length exceeded|tools rejected|input rejected|output token limit rejected|previous response rejected|reason unavailable)\))?\.$/.exec(message);
+  if (provider)
+    return `${provider[1]} request failed · HTTP ${provider[2]}${provider[3] ? ` · ${provider[3]}` : ""}`;
+  const budget = /^Agent budget exceeded including child runs: (maxInputTokens|maxOutputTokens|maxTotalTokens|maxToolCalls|maxToolErrors|maxSteps) limit (\d+), actual (\d+)\.$/.exec(message);
+  if (budget)
+    return `budget exceeded · ${budget[1]} · ${budget[3]} / ${budget[2]}`;
+  const denied = /^Tool "(read_file|read_files|list_files|search_files|search_many)" failed: The path is protected by the harness policy: (node_modules|\.git|\.zhivex-harness|dist|coverage|\.next|\.turbo)$/.exec(message);
+  if (denied)
+    return `read denied · protected path ${denied[2]}`;
+  if (message === "Agent compaction result still exceeds maxEstimatedInputTokens." || message === "Agent compaction cannot satisfy its limits without removing protected messages.") {
+    return "context could not fit after compaction · retained messages exceed the input limit";
+  }
+  const streamOverflow = /^Stream replay buffer exceeded its limit of (\d+) events\.$/.exec(message);
+  if (streamOverflow)
+    return `event replay limit reached · ${streamOverflow[1]} events`;
+  const stateOverflow = /^Agent run state is (\d+) bytes and exceeds maxStateBytes=(\d+)\. Offload large tool outputs to artifacts or raise the explicit limit\.$/.exec(message);
+  if (stateOverflow)
+    return `durable state limit reached · ${stateOverflow[1]} / ${stateOverflow[2]} bytes · inspect /status before /continue`;
+  if (/^Tool is not registered \(sha256:[a-f0-9]{64}\)\.$/.test(message)) {
+    return "requested tool is not registered · use an available tool with its exact name";
+  }
+  const cap = /^(maxInputTokens|maxOutputTokens|maxTotalTokens) budget (exceeded|exhausted)$/.exec(message);
+  if (cap)
+    return `budget ${cap[2]} · ${cap[1]}`;
+  if (message === "Agent exhausted maxSteps before reaching a terminal response.") {
+    return "step limit reached before a final response";
+  }
+  return "run failed · cause unavailable (inspect run diagnostics)";
+};
+var formatTerminalEvent = (event, options = {}) => {
+  const color = options.color ?? false;
+  switch (event.type) {
+    case "text-delta":
+      return;
+    case "tool-call":
+      return `${paint("↳", 36, color)} tool · ${sanitizeTerminalText(event.toolCall.name)}`;
+    case "tool-result": {
+      const receipt = verificationReceipt(event.toolResult.toolName, event.toolResult.output);
+      if (receipt) {
+        const failed = event.toolResult.isError || receipt.timedOut || receipt.exitCode !== 0;
+        return `${paint(failed ? "✗" : "✓", failed ? 31 : 32, color)} check · ${receipt.check ?? sanitizeTerminalText(event.toolResult.toolName)} · exit ${receipt.exitCode}${receipt.timedOut ? " · timed out" : ""}`;
+      }
+      return event.toolResult.isError ? `${paint("✗", 31, color)} tool · ${sanitizeTerminalText(event.toolResult.toolName)} · error` : `${paint("✓", 32, color)} tool · ${sanitizeTerminalText(event.toolResult.toolName)}`;
+    }
+    case "tool-approval-request":
+    case "agent-approval-request":
+      return `${paint("!", 33, color)} approval · ` + `${sanitizeTerminalText(event.approval.kind ?? "provider")} · ` + sanitizeTerminalText(event.approval.name);
+    case "agent-approval-resolved":
+      return event.approval.approve ? `${paint("✓", 32, color)} approval · approved` : `${paint("✗", 31, color)} approval · denied`;
+    case "provider-data":
+      return `${paint("·", 90, color)} provider · ${sanitizeTerminalText(event.provider)}`;
+    case "image-generation":
+      return `${paint("·", 36, color)} image · ${sanitizeTerminalText(event.provider)}` + (event.partial ? " · partial" : " · complete");
+    case "finish":
+      return `${paint("·", 90, color)} model stream` + (event.finishReason ? ` · ${sanitizeTerminalText(event.finishReason)}` : " · finished");
+    case "error":
+      return `${paint("✗", 31, color)} ${terminalRunFailure(event.error)}`;
+    case "agent-run-start":
+      return `${paint("●", 36, color)} run · step ${event.currentStep}/${event.maxSteps}`;
+    case "agent-step-start":
+      return `${paint("●", 36, color)} step ${event.stepIndex + 1}`;
+    case "agent-step-finish":
+      return `${paint(event.step.status === "failed" ? "✗" : "✓", event.step.status === "failed" ? 31 : 32, color)} ` + `step ${event.step.index + 1} · ${sanitizeTerminalText(event.step.status)} · ` + `${event.step.toolResults.length} tool${event.step.toolResults.length === 1 ? "" : "s"}`;
+    case "agent-compaction":
+      return `${paint("↺", 36, color)} context · ${event.compaction.messageCountBefore} → ` + `${event.compaction.messageCountAfter} messages`;
+    case "agent-run-finish":
+      if (event.status === "failed") {
+        const cause = terminalRunFailure(event.state.error);
+        return `${paint("✗", 31, color)} ${cause}` + (cause === "step limit reached before a final response" ? ` (${event.state.currentStep}/${event.state.maxSteps}). Session retained; use /limits to adjust the next turn, then ask to continue.` : "");
+      }
+      return `${paint(event.status === "completed" ? "✓" : "●", event.status === "completed" ? 32 : 33, color)} ` + `run · ${sanitizeTerminalText(event.status)} · ` + `${sanitizeTerminalText(event.state.provider)}/${sanitizeTerminalText(event.state.modelId)}`;
+  }
+};
+var formatTerminalHeader = (input, options = {}) => {
+  const color = options.color ?? false;
+  const title = input.sessionTitle ? ` · ${sanitizeTerminalText(input.sessionTitle)}` : "";
+  return `${paint(`Zhivex Harness ${sanitizeTerminalText(input.version)}`, 36, color)} · ` + `${sanitizeTerminalText(input.provider)}/${sanitizeTerminalText(input.model)}
+` + `session ${sanitizeTerminalText(input.sessionId)}${title}`;
+};
+
+export { DEFAULT_APPROVAL_SUMMARY_CHARACTERS, sanitizeTerminalText, formatApproval, resolveTerminalApprovals, terminalSupportsColor, formatTerminalEvent, formatTerminalHeader };

package/dist/index-8705zxpr.js

@@ -0,0 +1,145 @@
+// src/providers/vertex-auth.ts
+import { GoogleAuth } from "google-auth-library";
+import { createVertex } from "@zhivex-ai/vertex";
+import { wrapLanguageModel } from "@zhivex-ai/core";
+
+// src/runtime/provider-diagnostics.ts
+import { z } from "zod";
+var providerDiagnosticSchema = z.strictObject({
+  reason: z.enum(["previous_response_unavailable", "context_length_exceeded", "authentication", "payment_required", "permission", "rate_limit", "model_unavailable", "invalid_request", "server_error", "unknown"]),
+  parameter: z.enum(["previous_response_id", "input", "messages", "tools", "model", "max_output_tokens", "max_tokens", "temperature", "other", "none"]),
+  bodyState: z.enum(["parsed", "malformed", "too_large", "unavailable", "read_timeout"])
+});
+function providerDiagnostic(body, status) {
+  let reason = status === 401 ? "authentication" : status === 402 ? "payment_required" : status === 403 ? "permission" : status === 429 ? "rate_limit" : status && status >= 500 ? "server_error" : "unknown";
+  let parameter = "none";
+  if (typeof body !== "string")
+    return { reason, parameter, bodyState: "unavailable" };
+  if (Buffer.byteLength(body) > 8192)
+    return { reason, parameter, bodyState: "too_large" };
+  try {
+    const parsed = JSON.parse(body);
+    const detail = parsed?.error ?? parsed;
+    const code = [detail?.code, detail?.status, detail?.type].find((value) => typeof value === "string") ?? "";
+    const message = typeof detail?.message === "string" ? detail.message : "";
+    const param = providerDiagnosticSchema.shape.parameter.safeParse(detail?.param);
+    parameter = param.success ? param.data : detail?.param == null ? "none" : "other";
+    if (/response/i.test(message) && /not found|expired/i.test(message) && (parameter === "previous_response_id" || parameter === "none"))
+      reason = "previous_response_unavailable";
+    else if (["context_length_exceeded", "context_window_exceeded"].includes(code))
+      reason = "context_length_exceeded";
+    else if (["invalid_api_key", "authentication_error", "UNAUTHENTICATED"].includes(code))
+      reason = "authentication";
+    else if (["permission_denied", "permission_error", "PERMISSION_DENIED"].includes(code))
+      reason = "permission";
+    else if (["rate_limit_exceeded", "rate_limit_error", "RESOURCE_EXHAUSTED"].includes(code))
+      reason = "rate_limit";
+    else if (["model_not_found", "model_not_available", "NOT_FOUND"].includes(code))
+      reason = "model_unavailable";
+    else if (["invalid_request_error", "INVALID_ARGUMENT"].includes(code) || status === 400 || status === 422)
+      reason = "invalid_request";
+    return { reason, parameter, bodyState: "parsed" };
+  } catch {
+    return { reason, parameter, bodyState: "malformed" };
+  }
+}
+
+// src/providers/vertex-auth.ts
+var CLOUD_PLATFORM_SCOPE = "https://www.googleapis.com/auth/cloud-platform";
+function vertexRoute(env) {
+  const projectId = (env.GOOGLE_CLOUD_PROJECT ?? "").trim();
+  const location = (env.VERTEX_LOCATION ?? "").trim();
+  if (!/^(?:[a-z][a-z0-9-]{4,61}[a-z0-9]|[0-9]{6,20})$/.test(projectId)) {
+    throw new Error("Vertex requires a valid GOOGLE_CLOUD_PROJECT.");
+  }
+  if (!/^(?:global|us|eu|[a-z]+-[a-z]+[0-9]+)$/.test(location)) {
+    throw new Error("Vertex requires an explicit valid VERTEX_LOCATION.");
+  }
+  return Object.freeze({ projectId, location });
+}
+function vertexConfigured(env) {
+  try {
+    vertexRoute(env);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var VERTEX_ENVIRONMENT = ["GOOGLE_CLOUD_PROJECT", "VERTEX_LOCATION", "GOOGLE_APPLICATION_CREDENTIALS"];
+function vertexEnvironment(env) {
+  return Object.fromEntries(VERTEX_ENVIRONMENT.flatMap((name) => env[name] ? [[name, env[name]]] : []));
+}
+function vertexTokenSource(env, route, createAuth = (options) => new GoogleAuth(options)) {
+  const keyFilename = env.GOOGLE_APPLICATION_CREDENTIALS?.trim();
+  const auth = createAuth({
+    projectId: route.projectId,
+    scopes: [CLOUD_PLATFORM_SCOPE],
+    ...keyFilename ? { keyFilename } : {}
+  });
+  return async () => {
+    try {
+      const token = await auth.getAccessToken();
+      if (!token)
+        throw new Error("Empty ADC token");
+      return token;
+    } catch {
+      throw new VertexAuthenticationError;
+    }
+  };
+}
+
+class VertexAuthenticationError extends Error {
+  status = 401;
+  retryable = false;
+  constructor() {
+    super("Vertex ADC credentials are unavailable or could not be refreshed. Configure Application Default Credentials and retry.");
+    this.name = "VertexAuthenticationError";
+  }
+}
+function createVertexModel(model, env, createAuth) {
+  const route = vertexRoute(env);
+  const adapter = createVertex({
+    ...route,
+    getAccessToken: vertexTokenSource(env, route, createAuth)
+  })(model);
+  return wrapLanguageModel(adapter, [{
+    name: "harness-vertex-sanitized-errors",
+    async wrapGenerate(_context, next) {
+      try {
+        return await next();
+      } catch (error) {
+        throw safeVertexError(error);
+      }
+    },
+    async wrapStream(_context, next) {
+      let stream;
+      try {
+        stream = await next();
+      } catch (error) {
+        throw safeVertexError(error);
+      }
+      return async function* () {
+        try {
+          yield* stream;
+        } catch (error) {
+          throw safeVertexError(error);
+        }
+      }();
+    }
+  }]);
+}
+function safeVertexError(error) {
+  if (error instanceof VertexAuthenticationError)
+    return error;
+  const record = error && typeof error === "object" ? error : {};
+  if (record.name === "AbortError")
+    return new DOMException("Vertex request cancelled.", "AbortError");
+  const status = typeof record.status === "number" && Number.isInteger(record.status) && record.status >= 100 && record.status <= 599 ? record.status : undefined;
+  return Object.assign(new Error("Vertex request failed. Check the sanitized provider diagnosis."), {
+    ...status ? { status } : {},
+    provider: providerDiagnostic(record.responseBody ?? record.body, status),
+    retryable: record.retryable === true
+  });
+}
+
+export { providerDiagnosticSchema, providerDiagnostic, vertexRoute, vertexConfigured, VERTEX_ENVIRONMENT, vertexEnvironment, vertexTokenSource, createVertexModel };