@hachej/boring-agent 0.1.89 → 0.1.91

package/dist/chunk-XPQEF32D.js

@@ -1,385 +0,0 @@
-import {
-  AgentDefinitionErrorCode,
-  AgentDeploymentErrorCode,
-  ErrorCode
-} from "./chunk-GOM3VJOJ.js";
-
-// src/shared/agent-definition.ts
-import { z as z2 } from "zod";
-
-// src/shared/digest.ts
-function toHex(bytes) {
-  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-async function digestBytes(bytes) {
-  const hash = await globalThis.crypto.subtle.digest("SHA-256", new Uint8Array(bytes));
-  return `sha256:${toHex(new Uint8Array(hash))}`;
-}
-async function sha256(value) {
-  return digestBytes(new TextEncoder().encode(value));
-}
-async function sha256Bytes(bytes) {
-  return digestBytes(bytes);
-}
-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(",")}}`;
-}
-
-// src/shared/schema-issue.ts
-import { z } from "zod";
-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}`
-    }];
-  });
-}
-var SchemaValidationError = class extends Error {
-  code = ErrorCode.enum.CONFIG_INVALID;
-  field;
-  validationCode;
-  constructor(issue) {
-    super(issue.message);
-    this.field = issue.field;
-    this.validationCode = issue.code;
-  }
-};
-
-// src/shared/agent-definition.ts
-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 = z2.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 = z2.array(OpaqueRefSchema).superRefine((refs, ctx) => {
-  const seen = /* @__PURE__ */ new Set();
-  refs.forEach((ref, index) => {
-    if (seen.has(ref)) {
-      ctx.addIssue({
-        code: z2.ZodIssueCode.custom,
-        path: [index],
-        message: "must not contain duplicate references"
-      });
-    }
-    seen.add(ref);
-  });
-});
-var SafeAssetPathSchema = z2.string().min(1).refine(isSafeAssetPath, "must be a safe relative asset path");
-var Sha256DigestSchema = z2.string().regex(SHA256_DIGEST_RE, "must be a lowercase sha256 digest").transform((value) => value);
-var AgentDefinitionSchema = z2.object({
-  schemaVersion: z2.literal(1),
-  definitionId: OpaqueRefSchema,
-  version: OpaqueRefSchema,
-  label: z2.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 = z2.object({
-  definitionId: OpaqueRefSchema,
-  version: OpaqueRefSchema,
-  digest: Sha256DigestSchema
-}).strict();
-var AgentDeploymentSchema = z2.object({
-  deploymentId: OpaqueRefSchema,
-  version: OpaqueRefSchema,
-  agentId: OpaqueRefSchema,
-  definition: AgentDefinitionReferenceSchema
-}).strict();
-var AgentDefinitionDigestAssetSchema = z2.object({
-  path: SafeAssetPathSchema,
-  digest: Sha256DigestSchema,
-  content: z2.string().refine(hasWellFormedUnicode, "must contain well-formed Unicode")
-}).strict();
-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 };
-}
-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 SchemaValidationError {
-  constructor(issue) {
-    super(issue);
-    this.name = "AgentDefinitionValidationError";
-  }
-};
-var AgentDeploymentValidationError = class extends SchemaValidationError {
-  constructor(issue) {
-    super(issue);
-    this.name = "AgentDeploymentValidationError";
-  }
-};
-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;
-}
-
-// src/shared/share-entry.ts
-import { z as z3 } from "zod";
-var nonEmptyString = z3.string().min(1);
-function isOpaqueLocatorId(value) {
-  return value.trim() === value && !/[\0-\x1f\x7f]/.test(value) && !value.includes("/") && !value.includes("\\") && !value.includes(":") && value !== "." && value !== "..";
-}
-var OpaqueShareLocatorIdSchema = z3.string().min(1, "must be a non-empty opaque id").max(256, "must be at most 256 characters").refine(isOpaqueLocatorId, "must be an opaque platform-owned id (no path separators, no scheme, no traversal)");
-function mintShareEntryId() {
-  return globalThis.crypto.randomUUID();
-}
-var ShareEntryProvenanceSchema = z3.object({
-  producerPrincipalRef: nonEmptyString,
-  createdAt: nonEmptyString
-}).strict();
-var ShareEntryV1Schema = z3.object({
-  schemaVersion: z3.literal(1),
-  id: OpaqueShareLocatorIdSchema,
-  workspaceId: OpaqueShareLocatorIdSchema,
-  path: nonEmptyString,
-  provenance: ShareEntryProvenanceSchema
-}).strict();
-var ShareEntryErrorCode = z3.enum(["AR1_SHARE_NOT_FOUND", "AR1_SHARE_TOMBSTONED"]);
-var ShareEntryValidationCode = z3.enum(["SHARE_ENTRY_INPUT_INVALID"]);
-var ShareEntryValidationError = class extends Error {
-  code = ErrorCode.enum.CONFIG_INVALID;
-  field;
-  constructor(issue) {
-    super(issue.message);
-    this.name = "ShareEntryValidationError";
-    this.field = issue.field;
-  }
-};
-function assertValidCreateInput(raw) {
-  const result = CreateShareEntryInputSchema.safeParse(raw);
-  if (result.success) return;
-  const issue = result.error.issues[0];
-  const field = formatPath(issue.path);
-  throw new ShareEntryValidationError({
-    code: ShareEntryValidationCode.enum.SHARE_ENTRY_INPUT_INVALID,
-    field,
-    message: field === "<root>" ? issue.message : `${field} ${issue.message}`
-  });
-}
-var CreateShareEntryInputSchema = z3.object({
-  workspaceId: OpaqueShareLocatorIdSchema,
-  path: nonEmptyString,
-  provenance: z3.object({
-    producerPrincipalRef: nonEmptyString,
-    createdAt: nonEmptyString.optional()
-  }).strict()
-}).strict();
-var InMemoryShareEntryStore = class {
-  entries = /* @__PURE__ */ new Map();
-  async create(input) {
-    assertValidCreateInput(input);
-    const entry = {
-      schemaVersion: 1,
-      id: mintShareEntryId(),
-      workspaceId: input.workspaceId,
-      path: input.path,
-      provenance: {
-        producerPrincipalRef: input.provenance.producerPrincipalRef,
-        createdAt: input.provenance.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
-      }
-    };
-    this.entries.set(entry.id, entry);
-    return entry;
-  }
-  async get(id) {
-    return this.entries.get(id) ?? null;
-  }
-  async delete(id) {
-    this.entries.delete(id);
-  }
-  async list(workspaceId) {
-    return Array.from(this.entries.values()).filter((entry) => entry.workspaceId === workspaceId);
-  }
-};
-async function resolveShareEntry(store, id, workspace) {
-  const entry = await store.get(id);
-  if (!entry) {
-    return { status: "not_found", code: ShareEntryErrorCode.enum.AR1_SHARE_NOT_FOUND };
-  }
-  try {
-    await workspace.stat(entry.path);
-  } catch {
-    return {
-      status: "tombstoned",
-      code: ShareEntryErrorCode.enum.AR1_SHARE_TOMBSTONED,
-      tombstone: {
-        id: entry.id,
-        workspaceId: entry.workspaceId,
-        provenance: entry.provenance
-      }
-    };
-  }
-  return { status: "ok", entry };
-}
-
-export {
-  sha256Bytes,
-  canonicalStringify,
-  formatPath,
-  SchemaValidationError,
-  OpaqueRefSchema,
-  Sha256DigestSchema,
-  validateAgentDefinition,
-  validateAgentDeployment,
-  createAgentAssetDigest,
-  AgentDefinitionValidationError,
-  AgentDeploymentValidationError,
-  createAgentDefinitionDigest,
-  createAgentDeploymentDigest,
-  validateTool,
-  OpaqueShareLocatorIdSchema,
-  ShareEntryProvenanceSchema,
-  ShareEntryV1Schema,
-  ShareEntryErrorCode,
-  ShareEntryValidationError,
-  InMemoryShareEntryStore,
-  resolveShareEntry
-};