@hachej/boring-agent 0.1.78 → 0.1.80

package/dist/chunk-CUF7ELFO.js

@@ -0,0 +1,266 @@
+import {
+  AgentDefinitionErrorCode,
+  AgentDeploymentErrorCode,
+  ErrorCode
+} from "./chunk-CCNXYCD5.js";
+
+// src/shared/agent-definition.ts
+import { z } from "zod";
+var SHA256_DIGEST_RE = /^sha256:[a-f0-9]{64}$/;
+function hasWellFormedUnicode(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code >= 55296 && code <= 56319) {
+      if (index + 1 >= value.length) return false;
+      const next = value.charCodeAt(index + 1);
+      if (next < 56320 || next > 57343) return false;
+      index += 1;
+    } else if (code >= 56320 && code <= 57343) {
+      return false;
+    }
+  }
+  return true;
+}
+function isOpaqueRef(value) {
+  return hasWellFormedUnicode(value) && value.trim() === value && !/[\0-\x1f\x7f]/.test(value);
+}
+function isSafeAssetPath(value) {
+  const segments = value.split("/");
+  return hasWellFormedUnicode(value) && value.normalize("NFC") === value && !/[\0-\x1f\x7f]/.test(value) && !value.includes("\\") && !value.startsWith("/") && !/^[A-Za-z]:[\\/]/.test(value) && !value.startsWith("./") && segments.every((segment) => segment !== "" && segment !== "." && segment !== "..");
+}
+var OpaqueRefSchema = z.string().min(1, "must be a non-empty reference").max(256, "must be at most 256 characters").refine(isOpaqueRef, "must be a non-empty reference");
+var ReferenceArraySchema = z.array(OpaqueRefSchema).superRefine((refs, ctx) => {
+  const seen = /* @__PURE__ */ new Set();
+  refs.forEach((ref, index) => {
+    if (seen.has(ref)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: [index],
+        message: "must not contain duplicate references"
+      });
+    }
+    seen.add(ref);
+  });
+});
+var SafeAssetPathSchema = z.string().min(1).refine(isSafeAssetPath, "must be a safe relative asset path");
+var Sha256DigestSchema = z.string().regex(SHA256_DIGEST_RE, "must be a lowercase sha256 digest").transform((value) => value);
+var AgentDefinitionSchema = z.object({
+  schemaVersion: z.literal(1),
+  definitionId: OpaqueRefSchema,
+  version: OpaqueRefSchema,
+  label: z.string().refine(hasWellFormedUnicode, "must contain well-formed Unicode").optional(),
+  instructionsRef: SafeAssetPathSchema,
+  capabilityRequirements: ReferenceArraySchema.optional(),
+  toolRefs: ReferenceArraySchema.optional(),
+  skillRefs: ReferenceArraySchema.optional(),
+  mcpServerRefs: ReferenceArraySchema.optional()
+}).strict();
+var AgentDefinitionReferenceSchema = z.object({
+  definitionId: OpaqueRefSchema,
+  version: OpaqueRefSchema,
+  digest: Sha256DigestSchema
+}).strict();
+var AgentDeploymentSchema = z.object({
+  deploymentId: OpaqueRefSchema,
+  version: OpaqueRefSchema,
+  agentId: OpaqueRefSchema,
+  definition: AgentDefinitionReferenceSchema
+}).strict();
+var AgentDefinitionDigestAssetSchema = z.object({
+  path: SafeAssetPathSchema,
+  digest: Sha256DigestSchema,
+  content: z.string().refine(hasWellFormedUnicode, "must contain well-formed Unicode")
+}).strict();
+function formatPath(path) {
+  if (path.length === 0) return "<root>";
+  return path.reduce(
+    (result, part) => typeof part === "number" ? `${result}[${part}]` : result.length === 0 ? String(part) : `${result}.${String(part)}`,
+    ""
+  );
+}
+function mapZodIssues(issues, invalidCode, unsupportedCode) {
+  return issues.flatMap((issue) => {
+    if (issue.code === z.ZodIssueCode.unrecognized_keys) {
+      const parent = formatPath(issue.path);
+      return [...issue.keys].sort().map((key) => ({
+        code: unsupportedCode,
+        field: parent === "<root>" ? key : `${parent}.${key}`,
+        message: `${key} is not supported by schema version 1`
+      }));
+    }
+    const field = formatPath(issue.path);
+    return [{
+      code: invalidCode,
+      field,
+      message: field === "<root>" ? issue.message : `${field} ${issue.message}`
+    }];
+  });
+}
+function validateAgentDefinition(raw) {
+  const result = AgentDefinitionSchema.safeParse(raw);
+  if (!result.success) {
+    return {
+      valid: false,
+      issues: mapZodIssues(
+        result.error.issues,
+        AgentDefinitionErrorCode.enum.AGENT_DEFINITION_INVALID,
+        AgentDefinitionErrorCode.enum.AGENT_DEFINITION_UNSUPPORTED_FIELD
+      )
+    };
+  }
+  return { valid: true, value: result.data };
+}
+function validateAgentDeployment(raw) {
+  const result = AgentDeploymentSchema.safeParse(raw);
+  if (!result.success) {
+    return {
+      valid: false,
+      issues: mapZodIssues(
+        result.error.issues,
+        AgentDeploymentErrorCode.enum.AGENT_DEPLOYMENT_INVALID,
+        AgentDeploymentErrorCode.enum.AGENT_DEPLOYMENT_UNSUPPORTED_FIELD
+      )
+    };
+  }
+  return { valid: true, value: result.data };
+}
+function canonicalStringify(value) {
+  if (value === null || typeof value !== "object") {
+    const encoded = JSON.stringify(value);
+    if (encoded === void 0) throw new TypeError("Cannot canonicalize undefined");
+    return encoded;
+  }
+  if (Array.isArray(value)) return `[${value.map(canonicalStringify).join(",")}]`;
+  const record = value;
+  return `{${Object.keys(record).filter((key) => record[key] !== void 0).sort().map((key) => `${JSON.stringify(key)}:${canonicalStringify(record[key])}`).join(",")}}`;
+}
+async function sha256(value) {
+  const hash = await globalThis.crypto.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(value)
+  );
+  const hex = Array.from(
+    new Uint8Array(hash),
+    (byte) => byte.toString(16).padStart(2, "0")
+  ).join("");
+  return `sha256:${hex}`;
+}
+async function createAgentAssetDigest(content) {
+  if (!hasWellFormedUnicode(content)) {
+    throw new AgentDefinitionValidationError({
+      code: AgentDefinitionErrorCode.enum.AGENT_DEFINITION_INVALID,
+      field: "content",
+      message: "content must contain well-formed Unicode"
+    });
+  }
+  return sha256(content);
+}
+var AgentDefinitionValidationError = class extends Error {
+  code = ErrorCode.enum.CONFIG_INVALID;
+  field;
+  validationCode;
+  constructor(issue) {
+    super(issue.message);
+    this.name = "AgentDefinitionValidationError";
+    this.field = issue.field;
+    this.validationCode = issue.code;
+  }
+};
+var AgentDeploymentValidationError = class extends Error {
+  code = ErrorCode.enum.CONFIG_INVALID;
+  field;
+  validationCode;
+  constructor(issue) {
+    super(issue.message);
+    this.name = "AgentDeploymentValidationError";
+    this.field = issue.field;
+    this.validationCode = issue.code;
+  }
+};
+async function validatedDefinitionAssets(definition, assets) {
+  if (!Array.isArray(assets)) {
+    throw new AgentDefinitionValidationError({
+      code: AgentDefinitionErrorCode.enum.AGENT_DEFINITION_INVALID,
+      field: "assets",
+      message: "assets must be an array"
+    });
+  }
+  const canonicalAssets = [];
+  for (const [index, input] of assets.entries()) {
+    const result = AgentDefinitionDigestAssetSchema.safeParse(input);
+    if (!result.success) {
+      const issue = mapZodIssues(
+        result.error.issues,
+        AgentDefinitionErrorCode.enum.AGENT_DEFINITION_INVALID,
+        AgentDefinitionErrorCode.enum.AGENT_DEFINITION_UNSUPPORTED_FIELD
+      )[0];
+      throw new AgentDefinitionValidationError({
+        ...issue,
+        field: `assets[${index}].${issue.field}`
+      });
+    }
+    if (await createAgentAssetDigest(result.data.content) !== result.data.digest) {
+      throw new AgentDefinitionValidationError({
+        code: AgentDefinitionErrorCode.enum.AGENT_DEFINITION_INVALID,
+        field: "assets.digest",
+        message: `asset digest does not match UTF-8 content: ${result.data.path}`
+      });
+    }
+    canonicalAssets.push(result.data);
+  }
+  canonicalAssets.sort(
+    (left, right) => left.path < right.path ? -1 : left.path > right.path ? 1 : 0
+  );
+  for (let index = 1; index < canonicalAssets.length; index += 1) {
+    if (canonicalAssets[index - 1].path === canonicalAssets[index].path) {
+      throw new AgentDefinitionValidationError({
+        code: AgentDefinitionErrorCode.enum.AGENT_DEFINITION_INVALID,
+        field: "assets.path",
+        message: `duplicate asset path: ${canonicalAssets[index].path}`
+      });
+    }
+  }
+  if (!canonicalAssets.some((asset) => asset.path === definition.instructionsRef)) {
+    throw new AgentDefinitionValidationError({
+      code: AgentDefinitionErrorCode.enum.AGENT_DEFINITION_INVALID,
+      field: "instructionsRef",
+      message: "instructionsRef must name an included verified asset"
+    });
+  }
+  return canonicalAssets;
+}
+async function createAgentDefinitionDigest(input) {
+  const validated = validateAgentDefinition(input.definition);
+  if (!validated.valid) throw new AgentDefinitionValidationError(validated.issues[0]);
+  const assets = await validatedDefinitionAssets(validated.value, input.assets);
+  return sha256(canonicalStringify({ definition: validated.value, assets }));
+}
+async function createAgentDeploymentDigest(deployment) {
+  const validated = validateAgentDeployment(deployment);
+  if (!validated.valid) throw new AgentDeploymentValidationError(validated.issues[0]);
+  return sha256(canonicalStringify(validated.value));
+}
+
+// src/shared/validateTool.ts
+function validateTool(tool) {
+  if (typeof tool !== "object" || tool === null) return null;
+  const t = tool;
+  if (typeof t.name !== "string" || t.name.length === 0) return null;
+  if (typeof t.description !== "string") return null;
+  if (typeof t.parameters !== "object" || t.parameters === null) return null;
+  if (typeof t.execute !== "function") return null;
+  return t;
+}
+
+export {
+  OpaqueRefSchema,
+  Sha256DigestSchema,
+  validateAgentDefinition,
+  validateAgentDeployment,
+  createAgentAssetDigest,
+  AgentDefinitionValidationError,
+  AgentDeploymentValidationError,
+  createAgentDefinitionDigest,
+  createAgentDeploymentDigest,
+  validateTool
+};

package/dist/{chunk-TS3QGFKK.js → chunk-N4ES6PVX.js}

@@ -2,12 +2,9 @@ import {
   noopTelemetry,
   safeCapture
 } from "./chunk-AQBXNPMD.js";
-import {
-  createLogger
-} from "./chunk-AJZHR626.js";
 import {
   ErrorCode
-} from "./chunk-6AEK34XU.js";
+} from "./chunk-CCNXYCD5.js";
 
 // src/server/harness/pi-coding-agent/createHarness.ts
 import { AsyncLocalStorage } from "async_hooks";
@@ -24,6 +21,88 @@ import {
   loadSkills
 } from "@mariozechner/pi-coding-agent";
 
+// src/server/logging.ts
+var SENSITIVE_KEYS = new Set([
+  "apiKey",
+  "api_key",
+  "token",
+  "secret",
+  "password",
+  "authorization",
+  "cookie",
+  "oidcToken",
+  "accessToken",
+  "refreshToken",
+  "ANTHROPIC_API_KEY",
+  "OPENAI_API_KEY",
+  "VERCEL_OIDC_TOKEN",
+  "VERCEL_TEAM_ID"
+].map((key) => key.toLowerCase()));
+function isSensitiveKey(key) {
+  return SENSITIVE_KEYS.has(key.toLowerCase());
+}
+function redactValue(key, value, seen) {
+  if (key && isSensitiveKey(key) && value != null) return "***";
+  if (value == null || typeof value !== "object") return value;
+  if (value instanceof Date) return value;
+  if (seen.has(value)) return "[Circular]";
+  seen.add(value);
+  if (Array.isArray(value)) {
+    const out2 = value.map((item) => redactValue(void 0, item, seen));
+    seen.delete(value);
+    return out2;
+  }
+  const out = {};
+  for (const [childKey, childValue] of Object.entries(value)) {
+    out[childKey] = redactValue(childKey, childValue, seen);
+  }
+  seen.delete(value);
+  return out;
+}
+function redact(fields) {
+  const out = {};
+  const seen = /* @__PURE__ */ new WeakSet();
+  for (const [k, v] of Object.entries(fields)) {
+    out[k] = redactValue(k, v, seen);
+  }
+  return out;
+}
+function isVerbose() {
+  return typeof process !== "undefined" && process.env?.BORING_AGENT_VERBOSE === "1";
+}
+function createLogger(prefix) {
+  function emit(level, msg, fields) {
+    const entry = {
+      level,
+      prefix,
+      msg,
+      ...fields ? redact(fields) : {},
+      t: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (level === "error") {
+      console.error(JSON.stringify(entry));
+    } else if (level === "warn") {
+      console.warn(JSON.stringify(entry));
+    } else {
+      console.log(JSON.stringify(entry));
+    }
+  }
+  return {
+    debug(msg, fields) {
+      if (isVerbose()) emit("debug", msg, fields);
+    },
+    info(msg, fields) {
+      emit("info", msg, fields);
+    },
+    warn(msg, fields) {
+      emit("warn", msg, fields);
+    },
+    error(msg, fields) {
+      emit("error", msg, fields);
+    }
+  };
+}
+
 // src/server/harness/pi-coding-agent/tool-adapter.ts
 var BORING_TOOL_ERROR_MARKER = "__boringToolError";
 function markToolResultErrorDetails(details) {
@@ -1506,7 +1585,7 @@ function createPiCodingAgentHarness(opts) {
     sessionNamespace: opts.sessionNamespace,
     sessionRoot: opts.sessionRoot,
     sessionDir: opts.sessionDir,
-    storageCwd: opts.sessionStorageCwd ?? opts.cwd
+    storageCwd: opts.cwd
   });
   const piSessions = /* @__PURE__ */ new Map();
   const runContextStorage = new AsyncLocalStorage();
@@ -1799,7 +1878,7 @@ export {
   getEnv,
   getEnvSnapshot,
   setEnvDefault,
-  PiSessionStore,
+  createLogger,
   registerConfiguredModelProviders,
   readConfiguredDefaultModel,
   PI_PACKAGE_RESOURCE_FILTERS,

package/dist/{chunk-ORURYKNY.js → chunk-UJQXCOHR.js}

@@ -1,6 +1,6 @@
 import {
   ErrorCode
-} from "./chunk-6AEK34XU.js";
+} from "./chunk-CCNXYCD5.js";
 
 // src/shared/tool-ui.ts
 function isRecord(value) {