openlinear 0.1.3

package/dist/index.js

@@ -0,0 +1,304 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ErrorCategory: () => ErrorCategory2,
+  ExecutionMetadataSyncSchema: () => ExecutionMetadataSyncSchema2,
+  ExecutionStatus: () => ExecutionStatus2,
+  FORBIDDEN_SYNC_FIELDS: () => FORBIDDEN_SYNC_FIELDS2,
+  FeatureFlagsSchema: () => FeatureFlagsSchema,
+  checkExecutionMetadataSync: () => checkExecutionMetadataSync,
+  getFeatureFlags: () => getFeatureFlags,
+  getMigrationPhase: () => getMigrationPhase,
+  isForbiddenField: () => isForbiddenField,
+  isLocalExecutionEnabled: () => isLocalExecutionEnabled,
+  isServerExecutionEnabled: () => isServerExecutionEnabled,
+  parseFeatureFlags: () => parseFeatureFlags,
+  safeValidateExecutionMetadataSync: () => safeValidateExecutionMetadataSync,
+  sanitizePayload: () => sanitizePayload,
+  validateExecutionMetadataMiddleware: () => validateExecutionMetadataMiddleware,
+  validateExecutionMetadataSync: () => validateExecutionMetadataSync,
+  validateFlagConfiguration: () => validateFlagConfiguration
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/config/feature-flags.ts
+var import_zod = require("zod");
+var FeatureFlagsSchema = import_zod.z.object({
+  LOCAL_EXECUTION_ENABLED: import_zod.z.enum(["true", "false"]).default("false").transform((v) => v === "true"),
+  SERVER_EXECUTION_ENABLED: import_zod.z.enum(["true", "false"]).default("true").transform((v) => v === "true"),
+  CANARY_PERCENTAGE: import_zod.z.string().default("0").transform((v) => parseInt(v, 10)).refine((v) => v >= 0 && v <= 100, {
+    message: "CANARY_PERCENTAGE must be between 0 and 100"
+  }),
+  FORCE_LOCAL_EXECUTION: import_zod.z.enum(["true", "false"]).default("false").transform((v) => v === "true"),
+  KILL_SWITCH_LOCAL_EXECUTION: import_zod.z.enum(["true", "false"]).default("false").transform((v) => v === "true")
+});
+function parseFeatureFlags(env = process.env) {
+  return FeatureFlagsSchema.parse(env);
+}
+function getFeatureFlags() {
+  return parseFeatureFlags();
+}
+function isLocalExecutionEnabled(userId, flags = getFeatureFlags()) {
+  if (flags.KILL_SWITCH_LOCAL_EXECUTION) {
+    return false;
+  }
+  if (flags.FORCE_LOCAL_EXECUTION) {
+    return true;
+  }
+  if (!flags.LOCAL_EXECUTION_ENABLED) {
+    return false;
+  }
+  if (flags.CANARY_PERCENTAGE >= 100) {
+    return true;
+  }
+  if (flags.CANARY_PERCENTAGE <= 0) {
+    return false;
+  }
+  const hash = hashString(userId);
+  const userPercentage = hash % 100 + 1;
+  return userPercentage <= flags.CANARY_PERCENTAGE;
+}
+function isServerExecutionEnabled(flags = getFeatureFlags()) {
+  return flags.SERVER_EXECUTION_ENABLED;
+}
+function validateFlagConfiguration(flags) {
+  const errors = [];
+  if (flags.FORCE_LOCAL_EXECUTION && flags.KILL_SWITCH_LOCAL_EXECUTION) {
+    errors.push("Cannot enable both FORCE_LOCAL_EXECUTION and KILL_SWITCH_LOCAL_EXECUTION");
+  }
+  if (!flags.LOCAL_EXECUTION_ENABLED && !flags.SERVER_EXECUTION_ENABLED) {
+    errors.push("At least one execution mode must be enabled");
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function hashString(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash);
+}
+function getMigrationPhase(flags = getFeatureFlags()) {
+  if (flags.KILL_SWITCH_LOCAL_EXECUTION) {
+    return "rollback";
+  }
+  if (!flags.SERVER_EXECUTION_ENABLED) {
+    return "cutover";
+  }
+  if (flags.LOCAL_EXECUTION_ENABLED && flags.CANARY_PERCENTAGE > 0) {
+    return "canary";
+  }
+  if (flags.LOCAL_EXECUTION_ENABLED && flags.CANARY_PERCENTAGE === 0) {
+    return "shadow";
+  }
+  return "unknown";
+}
+
+// src/validation/security.ts
+var import_zod2 = require("zod");
+var ErrorCategory = import_zod2.z.enum([
+  "AUTH",
+  "RATE_LIMIT",
+  "MERGE_CONFLICT",
+  "TIMEOUT",
+  "UNKNOWN"
+]);
+var ExecutionStatus = import_zod2.z.enum([
+  "pending",
+  "running",
+  "completed",
+  "failed",
+  "cancelled"
+]);
+var ExecutionMetadataSyncSchema = import_zod2.z.object({
+  taskId: import_zod2.z.string(),
+  runId: import_zod2.z.string(),
+  status: ExecutionStatus,
+  startedAt: import_zod2.z.string().datetime().optional(),
+  completedAt: import_zod2.z.string().datetime().optional(),
+  durationMs: import_zod2.z.number().int().min(0).optional(),
+  progress: import_zod2.z.number().int().min(0).max(100).optional(),
+  branch: import_zod2.z.string().optional(),
+  commitSha: import_zod2.z.string().optional(),
+  prUrl: import_zod2.z.string().url().optional(),
+  prNumber: import_zod2.z.number().int().positive().optional(),
+  outcome: import_zod2.z.string().max(500).optional(),
+  errorCategory: ErrorCategory.optional(),
+  filesChanged: import_zod2.z.number().int().min(0).optional(),
+  toolsExecuted: import_zod2.z.number().int().min(0).optional()
+}).strict();
+var FORBIDDEN_SYNC_FIELDS = [
+  "prompt",
+  "logs",
+  "toolLogs",
+  "executionLogs",
+  "repoPath",
+  "accessToken",
+  "apiKey",
+  "passwordHash",
+  "jwt",
+  "client",
+  "timeoutId",
+  "rawOutput",
+  "diff",
+  "fileContents",
+  "env",
+  "environment",
+  "processEnv"
+];
+function isForbiddenField(field) {
+  return FORBIDDEN_SYNC_FIELDS.includes(field);
+}
+function sanitizePayload(payload) {
+  const sanitized = {};
+  const removed = [];
+  for (const [key, value] of Object.entries(payload)) {
+    if (isForbiddenField(key)) {
+      removed.push(key);
+    } else {
+      sanitized[key] = value;
+    }
+  }
+  return { sanitized, removed };
+}
+
+// src/types/execution-metadata.ts
+var import_zod3 = require("zod");
+var ErrorCategory2 = import_zod3.z.enum([
+  "AUTH",
+  "RATE_LIMIT",
+  "MERGE_CONFLICT",
+  "TIMEOUT",
+  "UNKNOWN"
+]);
+var ExecutionStatus2 = import_zod3.z.enum([
+  "pending",
+  "running",
+  "completed",
+  "failed",
+  "cancelled"
+]);
+var ExecutionMetadataSyncSchema2 = import_zod3.z.object({
+  taskId: import_zod3.z.string(),
+  runId: import_zod3.z.string(),
+  status: ExecutionStatus2,
+  startedAt: import_zod3.z.string().datetime().optional(),
+  completedAt: import_zod3.z.string().datetime().optional(),
+  durationMs: import_zod3.z.number().int().min(0).optional(),
+  progress: import_zod3.z.number().int().min(0).max(100).optional(),
+  branch: import_zod3.z.string().optional(),
+  commitSha: import_zod3.z.string().optional(),
+  prUrl: import_zod3.z.string().url().optional(),
+  prNumber: import_zod3.z.number().int().positive().optional(),
+  outcome: import_zod3.z.string().max(500).optional(),
+  errorCategory: ErrorCategory2.optional(),
+  filesChanged: import_zod3.z.number().int().min(0).optional(),
+  toolsExecuted: import_zod3.z.number().int().min(0).optional()
+}).strict();
+function validateExecutionMetadataSync(payload) {
+  return ExecutionMetadataSyncSchema2.parse(payload);
+}
+function safeValidateExecutionMetadataSync(payload) {
+  const result = ExecutionMetadataSyncSchema2.safeParse(payload);
+  if (result.success) {
+    return { success: true, data: result.data };
+  } else {
+    return { success: false, error: result.error };
+  }
+}
+function checkExecutionMetadataSync(payload) {
+  const result = ExecutionMetadataSyncSchema2.safeParse(payload);
+  if (result.success) {
+    return { valid: true };
+  } else {
+    return {
+      valid: false,
+      issues: result.error.errors.map(
+        (e) => `${e.path.join(".")}: ${e.message}`
+      )
+    };
+  }
+}
+function validateExecutionMetadataMiddleware() {
+  return (req, res, next) => {
+    const result = safeValidateExecutionMetadataSync(req.body);
+    if (!result.success) {
+      const hasUnknownKeys = result.error.errors.some(
+        (e) => e.message.includes("Unrecognized key") || e.code === "unrecognized_keys"
+      );
+      return res.status(400).json({
+        error: "Invalid sync payload",
+        code: hasUnknownKeys ? "FORBIDDEN_FIELDS" : "VALIDATION_ERROR",
+        details: result.error.errors.map((e) => ({
+          field: e.path.join("."),
+          message: e.message
+        }))
+      });
+    }
+    req.validatedMetadata = result.data;
+    next();
+  };
+}
+var FORBIDDEN_SYNC_FIELDS2 = [
+  "prompt",
+  "logs",
+  "toolLogs",
+  "executionLogs",
+  "repoPath",
+  "accessToken",
+  "apiKey",
+  "passwordHash",
+  "jwt",
+  "client",
+  "timeoutId",
+  "rawOutput",
+  "diff",
+  "fileContents",
+  "env",
+  "environment",
+  "processEnv"
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ErrorCategory,
+  ExecutionMetadataSyncSchema,
+  ExecutionStatus,
+  FORBIDDEN_SYNC_FIELDS,
+  FeatureFlagsSchema,
+  checkExecutionMetadataSync,
+  getFeatureFlags,
+  getMigrationPhase,
+  isForbiddenField,
+  isLocalExecutionEnabled,
+  isServerExecutionEnabled,
+  parseFeatureFlags,
+  safeValidateExecutionMetadataSync,
+  sanitizePayload,
+  validateExecutionMetadataMiddleware,
+  validateExecutionMetadataSync,
+  validateFlagConfiguration
+});

package/dist/index.mjs

@@ -0,0 +1,42 @@
+import {
+  FeatureFlagsSchema,
+  getFeatureFlags,
+  getMigrationPhase,
+  isLocalExecutionEnabled,
+  isServerExecutionEnabled,
+  parseFeatureFlags,
+  validateFlagConfiguration
+} from "./chunk-5E4TN2YB.mjs";
+import {
+  ErrorCategory,
+  ExecutionMetadataSyncSchema,
+  ExecutionStatus,
+  FORBIDDEN_SYNC_FIELDS,
+  checkExecutionMetadataSync,
+  safeValidateExecutionMetadataSync,
+  validateExecutionMetadataMiddleware,
+  validateExecutionMetadataSync
+} from "./chunk-HARBMOVK.mjs";
+import {
+  isForbiddenField,
+  sanitizePayload
+} from "./chunk-P3FFNK6N.mjs";
+export {
+  ErrorCategory,
+  ExecutionMetadataSyncSchema,
+  ExecutionStatus,
+  FORBIDDEN_SYNC_FIELDS,
+  FeatureFlagsSchema,
+  checkExecutionMetadataSync,
+  getFeatureFlags,
+  getMigrationPhase,
+  isForbiddenField,
+  isLocalExecutionEnabled,
+  isServerExecutionEnabled,
+  parseFeatureFlags,
+  safeValidateExecutionMetadataSync,
+  sanitizePayload,
+  validateExecutionMetadataMiddleware,
+  validateExecutionMetadataSync,
+  validateFlagConfiguration
+};

package/dist/types/index.d.mts

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+
+declare const ErrorCategory: z.ZodEnum<["AUTH", "RATE_LIMIT", "MERGE_CONFLICT", "TIMEOUT", "UNKNOWN"]>;
+declare const ExecutionStatus: z.ZodEnum<["pending", "running", "completed", "failed", "cancelled"]>;
+declare const ExecutionMetadataSyncSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    runId: z.ZodString;
+    status: z.ZodEnum<["pending", "running", "completed", "failed", "cancelled"]>;
+    startedAt: z.ZodOptional<z.ZodString>;
+    completedAt: z.ZodOptional<z.ZodString>;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    progress: z.ZodOptional<z.ZodNumber>;
+    branch: z.ZodOptional<z.ZodString>;
+    commitSha: z.ZodOptional<z.ZodString>;
+    prUrl: z.ZodOptional<z.ZodString>;
+    prNumber: z.ZodOptional<z.ZodNumber>;
+    outcome: z.ZodOptional<z.ZodString>;
+    errorCategory: z.ZodOptional<z.ZodEnum<["AUTH", "RATE_LIMIT", "MERGE_CONFLICT", "TIMEOUT", "UNKNOWN"]>>;
+    filesChanged: z.ZodOptional<z.ZodNumber>;
+    toolsExecuted: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    status: "pending" | "running" | "completed" | "failed" | "cancelled";
+    taskId: string;
+    runId: string;
+    startedAt?: string | undefined;
+    completedAt?: string | undefined;
+    durationMs?: number | undefined;
+    progress?: number | undefined;
+    branch?: string | undefined;
+    commitSha?: string | undefined;
+    prUrl?: string | undefined;
+    prNumber?: number | undefined;
+    outcome?: string | undefined;
+    errorCategory?: "AUTH" | "RATE_LIMIT" | "MERGE_CONFLICT" | "TIMEOUT" | "UNKNOWN" | undefined;
+    filesChanged?: number | undefined;
+    toolsExecuted?: number | undefined;
+}, {
+    status: "pending" | "running" | "completed" | "failed" | "cancelled";
+    taskId: string;
+    runId: string;
+    startedAt?: string | undefined;
+    completedAt?: string | undefined;
+    durationMs?: number | undefined;
+    progress?: number | undefined;
+    branch?: string | undefined;
+    commitSha?: string | undefined;
+    prUrl?: string | undefined;
+    prNumber?: number | undefined;
+    outcome?: string | undefined;
+    errorCategory?: "AUTH" | "RATE_LIMIT" | "MERGE_CONFLICT" | "TIMEOUT" | "UNKNOWN" | undefined;
+    filesChanged?: number | undefined;
+    toolsExecuted?: number | undefined;
+}>;
+type ExecutionMetadataSync = z.infer<typeof ExecutionMetadataSyncSchema>;
+declare function validateExecutionMetadataSync(payload: unknown): ExecutionMetadataSync;
+declare function safeValidateExecutionMetadataSync(payload: unknown): {
+    success: true;
+    data: ExecutionMetadataSync;
+} | {
+    success: false;
+    error: z.ZodError;
+};
+declare function checkExecutionMetadataSync(payload: unknown): {
+    valid: boolean;
+    issues?: string[];
+};
+declare function validateExecutionMetadataMiddleware(): (req: any, res: any, next: any) => any;
+declare const FORBIDDEN_SYNC_FIELDS: readonly ["prompt", "logs", "toolLogs", "executionLogs", "repoPath", "accessToken", "apiKey", "passwordHash", "jwt", "client", "timeoutId", "rawOutput", "diff", "fileContents", "env", "environment", "processEnv"];
+
+export { ErrorCategory, type ExecutionMetadataSync, ExecutionMetadataSyncSchema, ExecutionStatus, FORBIDDEN_SYNC_FIELDS, checkExecutionMetadataSync, safeValidateExecutionMetadataSync, validateExecutionMetadataMiddleware, validateExecutionMetadataSync };

package/dist/types/index.d.ts

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+
+declare const ErrorCategory: z.ZodEnum<["AUTH", "RATE_LIMIT", "MERGE_CONFLICT", "TIMEOUT", "UNKNOWN"]>;
+declare const ExecutionStatus: z.ZodEnum<["pending", "running", "completed", "failed", "cancelled"]>;
+declare const ExecutionMetadataSyncSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    runId: z.ZodString;
+    status: z.ZodEnum<["pending", "running", "completed", "failed", "cancelled"]>;
+    startedAt: z.ZodOptional<z.ZodString>;
+    completedAt: z.ZodOptional<z.ZodString>;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    progress: z.ZodOptional<z.ZodNumber>;
+    branch: z.ZodOptional<z.ZodString>;
+    commitSha: z.ZodOptional<z.ZodString>;
+    prUrl: z.ZodOptional<z.ZodString>;
+    prNumber: z.ZodOptional<z.ZodNumber>;
+    outcome: z.ZodOptional<z.ZodString>;
+    errorCategory: z.ZodOptional<z.ZodEnum<["AUTH", "RATE_LIMIT", "MERGE_CONFLICT", "TIMEOUT", "UNKNOWN"]>>;
+    filesChanged: z.ZodOptional<z.ZodNumber>;
+    toolsExecuted: z.ZodOptional<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    status: "pending" | "running" | "completed" | "failed" | "cancelled";
+    taskId: string;
+    runId: string;
+    startedAt?: string | undefined;
+    completedAt?: string | undefined;
+    durationMs?: number | undefined;
+    progress?: number | undefined;
+    branch?: string | undefined;
+    commitSha?: string | undefined;
+    prUrl?: string | undefined;
+    prNumber?: number | undefined;
+    outcome?: string | undefined;
+    errorCategory?: "AUTH" | "RATE_LIMIT" | "MERGE_CONFLICT" | "TIMEOUT" | "UNKNOWN" | undefined;
+    filesChanged?: number | undefined;
+    toolsExecuted?: number | undefined;
+}, {
+    status: "pending" | "running" | "completed" | "failed" | "cancelled";
+    taskId: string;
+    runId: string;
+    startedAt?: string | undefined;
+    completedAt?: string | undefined;
+    durationMs?: number | undefined;
+    progress?: number | undefined;
+    branch?: string | undefined;
+    commitSha?: string | undefined;
+    prUrl?: string | undefined;
+    prNumber?: number | undefined;
+    outcome?: string | undefined;
+    errorCategory?: "AUTH" | "RATE_LIMIT" | "MERGE_CONFLICT" | "TIMEOUT" | "UNKNOWN" | undefined;
+    filesChanged?: number | undefined;
+    toolsExecuted?: number | undefined;
+}>;
+type ExecutionMetadataSync = z.infer<typeof ExecutionMetadataSyncSchema>;
+declare function validateExecutionMetadataSync(payload: unknown): ExecutionMetadataSync;
+declare function safeValidateExecutionMetadataSync(payload: unknown): {
+    success: true;
+    data: ExecutionMetadataSync;
+} | {
+    success: false;
+    error: z.ZodError;
+};
+declare function checkExecutionMetadataSync(payload: unknown): {
+    valid: boolean;
+    issues?: string[];
+};
+declare function validateExecutionMetadataMiddleware(): (req: any, res: any, next: any) => any;
+declare const FORBIDDEN_SYNC_FIELDS: readonly ["prompt", "logs", "toolLogs", "executionLogs", "repoPath", "accessToken", "apiKey", "passwordHash", "jwt", "client", "timeoutId", "rawOutput", "diff", "fileContents", "env", "environment", "processEnv"];
+
+export { ErrorCategory, type ExecutionMetadataSync, ExecutionMetadataSyncSchema, ExecutionStatus, FORBIDDEN_SYNC_FIELDS, checkExecutionMetadataSync, safeValidateExecutionMetadataSync, validateExecutionMetadataMiddleware, validateExecutionMetadataSync };

package/dist/types/index.js

@@ -0,0 +1,140 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/types/index.ts
+var types_exports = {};
+__export(types_exports, {
+  ErrorCategory: () => ErrorCategory,
+  ExecutionMetadataSyncSchema: () => ExecutionMetadataSyncSchema,
+  ExecutionStatus: () => ExecutionStatus,
+  FORBIDDEN_SYNC_FIELDS: () => FORBIDDEN_SYNC_FIELDS,
+  checkExecutionMetadataSync: () => checkExecutionMetadataSync,
+  safeValidateExecutionMetadataSync: () => safeValidateExecutionMetadataSync,
+  validateExecutionMetadataMiddleware: () => validateExecutionMetadataMiddleware,
+  validateExecutionMetadataSync: () => validateExecutionMetadataSync
+});
+module.exports = __toCommonJS(types_exports);
+
+// src/types/execution-metadata.ts
+var import_zod = require("zod");
+var ErrorCategory = import_zod.z.enum([
+  "AUTH",
+  "RATE_LIMIT",
+  "MERGE_CONFLICT",
+  "TIMEOUT",
+  "UNKNOWN"
+]);
+var ExecutionStatus = import_zod.z.enum([
+  "pending",
+  "running",
+  "completed",
+  "failed",
+  "cancelled"
+]);
+var ExecutionMetadataSyncSchema = import_zod.z.object({
+  taskId: import_zod.z.string(),
+  runId: import_zod.z.string(),
+  status: ExecutionStatus,
+  startedAt: import_zod.z.string().datetime().optional(),
+  completedAt: import_zod.z.string().datetime().optional(),
+  durationMs: import_zod.z.number().int().min(0).optional(),
+  progress: import_zod.z.number().int().min(0).max(100).optional(),
+  branch: import_zod.z.string().optional(),
+  commitSha: import_zod.z.string().optional(),
+  prUrl: import_zod.z.string().url().optional(),
+  prNumber: import_zod.z.number().int().positive().optional(),
+  outcome: import_zod.z.string().max(500).optional(),
+  errorCategory: ErrorCategory.optional(),
+  filesChanged: import_zod.z.number().int().min(0).optional(),
+  toolsExecuted: import_zod.z.number().int().min(0).optional()
+}).strict();
+function validateExecutionMetadataSync(payload) {
+  return ExecutionMetadataSyncSchema.parse(payload);
+}
+function safeValidateExecutionMetadataSync(payload) {
+  const result = ExecutionMetadataSyncSchema.safeParse(payload);
+  if (result.success) {
+    return { success: true, data: result.data };
+  } else {
+    return { success: false, error: result.error };
+  }
+}
+function checkExecutionMetadataSync(payload) {
+  const result = ExecutionMetadataSyncSchema.safeParse(payload);
+  if (result.success) {
+    return { valid: true };
+  } else {
+    return {
+      valid: false,
+      issues: result.error.errors.map(
+        (e) => `${e.path.join(".")}: ${e.message}`
+      )
+    };
+  }
+}
+function validateExecutionMetadataMiddleware() {
+  return (req, res, next) => {
+    const result = safeValidateExecutionMetadataSync(req.body);
+    if (!result.success) {
+      const hasUnknownKeys = result.error.errors.some(
+        (e) => e.message.includes("Unrecognized key") || e.code === "unrecognized_keys"
+      );
+      return res.status(400).json({
+        error: "Invalid sync payload",
+        code: hasUnknownKeys ? "FORBIDDEN_FIELDS" : "VALIDATION_ERROR",
+        details: result.error.errors.map((e) => ({
+          field: e.path.join("."),
+          message: e.message
+        }))
+      });
+    }
+    req.validatedMetadata = result.data;
+    next();
+  };
+}
+var FORBIDDEN_SYNC_FIELDS = [
+  "prompt",
+  "logs",
+  "toolLogs",
+  "executionLogs",
+  "repoPath",
+  "accessToken",
+  "apiKey",
+  "passwordHash",
+  "jwt",
+  "client",
+  "timeoutId",
+  "rawOutput",
+  "diff",
+  "fileContents",
+  "env",
+  "environment",
+  "processEnv"
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ErrorCategory,
+  ExecutionMetadataSyncSchema,
+  ExecutionStatus,
+  FORBIDDEN_SYNC_FIELDS,
+  checkExecutionMetadataSync,
+  safeValidateExecutionMetadataSync,
+  validateExecutionMetadataMiddleware,
+  validateExecutionMetadataSync
+});

package/dist/types/index.mjs

@@ -0,0 +1,20 @@
+import {
+  ErrorCategory,
+  ExecutionMetadataSyncSchema,
+  ExecutionStatus,
+  FORBIDDEN_SYNC_FIELDS,
+  checkExecutionMetadataSync,
+  safeValidateExecutionMetadataSync,
+  validateExecutionMetadataMiddleware,
+  validateExecutionMetadataSync
+} from "../chunk-HARBMOVK.mjs";
+export {
+  ErrorCategory,
+  ExecutionMetadataSyncSchema,
+  ExecutionStatus,
+  FORBIDDEN_SYNC_FIELDS,
+  checkExecutionMetadataSync,
+  safeValidateExecutionMetadataSync,
+  validateExecutionMetadataMiddleware,
+  validateExecutionMetadataSync
+};