flavor-code 1.4.1 → 1.4.3-beta.2

package/dist/chunk-IQEEFDEE.js

@@ -0,0 +1,389 @@
+#!/usr/bin/env node
+import { createRequire as createFlavorRequire } from "node:module"; const require = createFlavorRequire(import.meta.url);
+import {
+  external_exports
+} from "./chunk-EWD7FWTH.js";
+
+// src/pals/protocol.ts
+var PROTOCOL_VERSION = 1;
+var MAX_ALIAS_LENGTH = 64;
+var MAX_MESSAGE_BYTES = 32 * 1024;
+var MAX_CONTROL_FRAME_BYTES = 64 * 1024;
+var MAX_PARTICIPANTS = 16;
+var MAX_ACTIVE_PALS = 16;
+var MAX_PLAN_TASKS = 32;
+var MAX_PROJECT_PATH_BYTES = 1024;
+var MAX_PLAN_ENCODED_BYTES = 24 * 1024;
+var MAX_SNAPSHOT_ENCODED_BYTES = 56 * 1024;
+var MAX_COMPLETION_DETAIL_BYTES = 4 * 1024;
+var MAX_COMPLETION_ASSERTIONS_BYTES = 12 * 1024;
+var MIN_UUID_PREFIX_LENGTH = 8;
+function normalizePalIdentity(value) {
+  return value.trim().toLocaleLowerCase("en-US");
+}
+var VersionSchema = external_exports.literal(PROTOCOL_VERSION);
+var UuidSchema = external_exports.uuid();
+var PrintableIdentitySchema = external_exports.string().trim().min(1).max(MAX_ALIAS_LENGTH).refine(
+  (value) => !/[\p{Cc}\uD800-\uDFFF]/u.test(value),
+  "Identity must contain only printable non-control Unicode"
+);
+var PalAliasSchema = PrintableIdentitySchema;
+var PalTargetSchema = PrintableIdentitySchema;
+var BoundedTextSchema = external_exports.string().refine(
+  (value) => Buffer.byteLength(value, "utf8") <= MAX_MESSAGE_BYTES,
+  `Text must not exceed ${MAX_MESSAGE_BYTES} UTF-8 bytes`
+);
+var NonEmptyBoundedTextSchema = BoundedTextSchema.refine((value) => value.length > 0, "Text must not be empty");
+var CompletionDetailSchema = external_exports.string().trim().min(1).refine(
+  (value) => Buffer.byteLength(value, "utf8") <= MAX_COMPLETION_DETAIL_BYTES,
+  `Completion evidence must not exceed ${MAX_COMPLETION_DETAIL_BYTES} UTF-8 bytes`
+);
+var PalPresenceSchema = external_exports.object({
+  version: VersionSchema,
+  id: UuidSchema,
+  alias: PalAliasSchema,
+  projectPath: external_exports.string().min(1).refine(
+    (value) => Buffer.byteLength(value, "utf8") <= MAX_PROJECT_PATH_BYTES,
+    `Project path must not exceed ${MAX_PROJECT_PATH_BYTES} UTF-8 bytes`
+  ),
+  connectedAt: external_exports.iso.datetime(),
+  lastSeenAt: external_exports.iso.datetime()
+}).strict();
+var PalPresenceListSchema = external_exports.array(PalPresenceSchema).max(MAX_ACTIVE_PALS);
+var PalTaskMessageSchema = external_exports.object({
+  version: VersionSchema,
+  type: external_exports.literal("task"),
+  messageId: UuidSchema,
+  target: PalTargetSchema,
+  goal: NonEmptyBoundedTextSchema
+}).strict();
+var PalTaskEventSchema = external_exports.object({
+  version: VersionSchema,
+  type: external_exports.literal("task-event"),
+  messageId: UuidSchema,
+  taskId: UuidSchema,
+  senderId: UuidSchema,
+  recipientId: UuidSchema,
+  status: external_exports.enum(["accepted", "started", "progress", "completed", "failed", "cancelled"]),
+  detail: BoundedTextSchema.optional()
+}).strict();
+var DeliveryReceiptSchema = external_exports.object({
+  version: VersionSchema,
+  type: external_exports.literal("delivery-receipt"),
+  messageId: UuidSchema,
+  status: external_exports.enum(["delivered", "duplicate", "rejected"]),
+  recipientIds: external_exports.array(UuidSchema).max(MAX_PARTICIPANTS),
+  error: BoundedTextSchema.optional()
+}).strict();
+var CoWorkParticipantSchema = external_exports.object({
+  palId: UuidSchema,
+  required: external_exports.boolean()
+}).strict();
+var CoWorkProposalParticipantsSchema = external_exports.array(CoWorkParticipantSchema).min(2).max(MAX_PARTICIPANTS).superRefine((participants, context) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, participant] of participants.entries()) {
+    const id = participant.palId.toLowerCase();
+    if (seen.has(id)) {
+      context.addIssue({ code: "custom", path: [index, "palId"], message: "Duplicate participant" });
+    }
+    seen.add(id);
+  }
+});
+var CoWorkPlanTaskSchema = external_exports.object({
+  id: external_exports.string().min(1).max(128),
+  assigneeId: UuidSchema,
+  description: NonEmptyBoundedTextSchema,
+  dependsOn: external_exports.array(external_exports.string().min(1).max(128)).max(MAX_PLAN_TASKS)
+}).strict();
+var CoWorkPlanSchema = external_exports.object({
+  version: VersionSchema,
+  coWorkId: UuidSchema,
+  epoch: external_exports.number().int().positive(),
+  goal: NonEmptyBoundedTextSchema,
+  participants: external_exports.array(CoWorkParticipantSchema).min(1).max(MAX_PARTICIPANTS),
+  tasks: external_exports.array(CoWorkPlanTaskSchema).min(1).max(MAX_PLAN_TASKS)
+}).strict().superRefine((plan, context) => {
+  if (Buffer.byteLength(JSON.stringify(plan), "utf8") > MAX_PLAN_ENCODED_BYTES) {
+    context.addIssue({ code: "custom", message: `Encoded plan must not exceed ${MAX_PLAN_ENCODED_BYTES} UTF-8 bytes` });
+  }
+  const participantIds = /* @__PURE__ */ new Set();
+  for (const [index, participant] of plan.participants.entries()) {
+    if (participantIds.has(participant.palId)) {
+      context.addIssue({ code: "custom", path: ["participants", index, "palId"], message: "Duplicate participant" });
+    }
+    participantIds.add(participant.palId);
+  }
+  const taskIds = /* @__PURE__ */ new Set();
+  for (const [index, task] of plan.tasks.entries()) {
+    if (taskIds.has(task.id)) {
+      context.addIssue({ code: "custom", path: ["tasks", index, "id"], message: "Duplicate task id" });
+    }
+    taskIds.add(task.id);
+    if (!participantIds.has(task.assigneeId)) {
+      context.addIssue({ code: "custom", path: ["tasks", index, "assigneeId"], message: "Assignee is not a participant" });
+    }
+  }
+  for (const [index, task] of plan.tasks.entries()) {
+    for (const dependency of task.dependsOn) {
+      if (!taskIds.has(dependency) || dependency === task.id) {
+        context.addIssue({ code: "custom", path: ["tasks", index, "dependsOn"], message: "Invalid task dependency" });
+      }
+    }
+  }
+  const dependencies = new Map(plan.tasks.map((task) => [task.id, task.dependsOn]));
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const visit = (taskId) => {
+    if (visiting.has(taskId)) return true;
+    if (visited.has(taskId)) return false;
+    visiting.add(taskId);
+    for (const dependency of dependencies.get(taskId) ?? []) {
+      if (dependencies.has(dependency) && visit(dependency)) return true;
+    }
+    visiting.delete(taskId);
+    visited.add(taskId);
+    return false;
+  };
+  for (const [index, task] of plan.tasks.entries()) {
+    if (visit(task.id)) {
+      context.addIssue({ code: "custom", path: ["tasks", index, "dependsOn"], message: "Task dependencies must be acyclic" });
+      break;
+    }
+  }
+});
+var CoWorkPhaseSchema = external_exports.enum([
+  "proposed",
+  "planning",
+  "prepared",
+  "running",
+  "verifying",
+  "completed",
+  "failed",
+  "cancelled"
+]);
+var IntegrationResultSchema = external_exports.object({
+  passed: external_exports.boolean(),
+  evidence: CompletionDetailSchema
+}).strict();
+var CoWorkCompletionAssertionSchema = external_exports.object({
+  participantId: UuidSchema,
+  passed: external_exports.boolean(),
+  detail: CompletionDetailSchema.optional()
+}).strict();
+var CoWorkSnapshotSchema = external_exports.object({
+  version: VersionSchema,
+  coWorkId: UuidSchema,
+  epoch: external_exports.number().int().positive(),
+  phase: CoWorkPhaseSchema,
+  goal: NonEmptyBoundedTextSchema,
+  participants: external_exports.array(CoWorkParticipantSchema).min(1).max(MAX_PARTICIPANTS),
+  integrationOwnerId: UuidSchema,
+  acceptedParticipantIds: external_exports.array(UuidSchema).max(MAX_PARTICIPANTS),
+  planHash: external_exports.string().regex(/^[a-f0-9]{64}$/).nullable(),
+  plan: CoWorkPlanSchema.nullable(),
+  planAcceptedParticipantIds: external_exports.array(UuidSchema).max(MAX_PARTICIPANTS),
+  readyParticipantIds: external_exports.array(UuidSchema).max(MAX_PARTICIPANTS),
+  completedParticipantIds: external_exports.array(UuidSchema).max(MAX_PARTICIPANTS),
+  completionAssertions: external_exports.array(CoWorkCompletionAssertionSchema).max(MAX_PARTICIPANTS),
+  integration: IntegrationResultSchema.nullable()
+}).strict().superRefine((snapshot, context) => {
+  if (Buffer.byteLength(JSON.stringify(snapshot), "utf8") > MAX_SNAPSHOT_ENCODED_BYTES) {
+    context.addIssue({ code: "custom", message: `Encoded snapshot must not exceed ${MAX_SNAPSHOT_ENCODED_BYTES} UTF-8 bytes` });
+  }
+  const participantIds = new Set(snapshot.participants.map(({ palId }) => palId));
+  const requiredParticipantIds = new Set(snapshot.participants.filter(({ required }) => required).map(({ palId }) => palId));
+  if (!requiredParticipantIds.has(snapshot.integrationOwnerId)) {
+    context.addIssue({ code: "custom", path: ["integrationOwnerId"], message: "Integration owner must be a required participant" });
+  }
+  const assertionIds = /* @__PURE__ */ new Set();
+  let assertionBytes = 0;
+  for (const [index, assertion] of snapshot.completionAssertions.entries()) {
+    if (!participantIds.has(assertion.participantId)) {
+      context.addIssue({ code: "custom", path: ["completionAssertions", index, "participantId"], message: "Assertion owner must be a participant" });
+    }
+    if (assertionIds.has(assertion.participantId)) {
+      context.addIssue({ code: "custom", path: ["completionAssertions", index, "participantId"], message: "Duplicate completion assertion" });
+    }
+    assertionIds.add(assertion.participantId);
+    assertionBytes += Buffer.byteLength(assertion.detail ?? "", "utf8");
+  }
+  if (assertionBytes > MAX_COMPLETION_ASSERTIONS_BYTES) {
+    context.addIssue({ code: "custom", path: ["completionAssertions"], message: `Completion assertions must not exceed ${MAX_COMPLETION_ASSERTIONS_BYTES} UTF-8 bytes in aggregate` });
+  }
+});
+var RequestBase = {
+  version: VersionSchema,
+  requestId: UuidSchema
+};
+var RegisterRequestSchema = external_exports.object({
+  ...RequestBase,
+  type: external_exports.literal("register"),
+  authToken: external_exports.string().regex(/^[a-f0-9]{64}$/).optional(),
+  presence: PalPresenceSchema
+}).strict();
+var HeartbeatRequestSchema = external_exports.object({ ...RequestBase, type: external_exports.literal("heartbeat") }).strict();
+var ListRequestSchema = external_exports.object({ ...RequestBase, type: external_exports.literal("list") }).strict();
+var DisconnectRequestSchema = external_exports.object({ ...RequestBase, type: external_exports.literal("disconnect") }).strict();
+var ChatRequestSchema = external_exports.object({
+  ...RequestBase,
+  type: external_exports.literal("chat"),
+  messageId: UuidSchema,
+  target: PalTargetSchema,
+  message: NonEmptyBoundedTextSchema
+}).strict();
+var TaskRequestSchema = external_exports.object({
+  ...RequestBase,
+  type: external_exports.literal("task"),
+  messageId: UuidSchema,
+  target: PalTargetSchema,
+  goal: NonEmptyBoundedTextSchema
+}).strict();
+var CoWorkProposeRequestSchema = external_exports.object({
+  ...RequestBase,
+  type: external_exports.literal("cowork-propose"),
+  coWorkId: UuidSchema,
+  goal: NonEmptyBoundedTextSchema,
+  participants: CoWorkProposalParticipantsSchema
+}).strict();
+var CoWorkAcceptanceRequestSchema = external_exports.object({
+  ...RequestBase,
+  type: external_exports.literal("cowork-accept"),
+  coWorkId: UuidSchema,
+  epoch: external_exports.number().int().positive()
+}).strict();
+var CoWorkPlanRequestSchema = external_exports.object({ ...RequestBase, type: external_exports.literal("cowork-plan"), plan: CoWorkPlanSchema }).strict();
+var CoWorkPlanAcceptanceRequestSchema = external_exports.object({
+  ...RequestBase,
+  type: external_exports.literal("cowork-plan-accept"),
+  coWorkId: UuidSchema,
+  epoch: external_exports.number().int().positive(),
+  planHash: external_exports.string().regex(/^[a-f0-9]{64}$/)
+}).strict();
+var CoWorkReadyRequestSchema = external_exports.object({
+  ...RequestBase,
+  type: external_exports.literal("cowork-ready"),
+  coWorkId: UuidSchema,
+  epoch: external_exports.number().int().positive(),
+  planHash: external_exports.string().regex(/^[a-f0-9]{64}$/)
+}).strict();
+var CoWorkCompleteRequestSchema = external_exports.object({
+  ...RequestBase,
+  type: external_exports.literal("cowork-complete"),
+  coWorkId: UuidSchema,
+  epoch: external_exports.number().int().positive(),
+  planHash: external_exports.string().regex(/^[a-f0-9]{64}$/),
+  passed: external_exports.boolean(),
+  detail: CompletionDetailSchema.optional()
+}).strict();
+var CoWorkIntegrationRequestSchema = external_exports.object({
+  ...RequestBase,
+  type: external_exports.literal("cowork-integration"),
+  coWorkId: UuidSchema,
+  epoch: external_exports.number().int().positive(),
+  planHash: external_exports.string().regex(/^[a-f0-9]{64}$/),
+  passed: external_exports.boolean(),
+  evidence: CompletionDetailSchema
+}).strict();
+var CoWorkGetRequestSchema = external_exports.object({
+  ...RequestBase,
+  type: external_exports.literal("cowork-get"),
+  coWorkId: UuidSchema
+}).strict();
+var CoWorkCancelRequestSchema = external_exports.object({
+  ...RequestBase,
+  type: external_exports.literal("cowork-cancel"),
+  coWorkId: UuidSchema,
+  reason: NonEmptyBoundedTextSchema
+}).strict();
+var BrokerRequestSchema = external_exports.discriminatedUnion("type", [
+  RegisterRequestSchema,
+  HeartbeatRequestSchema,
+  ListRequestSchema,
+  DisconnectRequestSchema,
+  ChatRequestSchema,
+  TaskRequestSchema,
+  CoWorkProposeRequestSchema,
+  CoWorkAcceptanceRequestSchema,
+  CoWorkPlanRequestSchema,
+  CoWorkPlanAcceptanceRequestSchema,
+  CoWorkReadyRequestSchema,
+  CoWorkCompleteRequestSchema,
+  CoWorkIntegrationRequestSchema,
+  CoWorkGetRequestSchema,
+  CoWorkCancelRequestSchema
+]);
+var BrokerOkResponseSchema = external_exports.object({
+  version: VersionSchema,
+  type: external_exports.literal("ok"),
+  requestId: UuidSchema,
+  data: external_exports.unknown()
+}).strict();
+var BrokerErrorResponseSchema = external_exports.object({
+  version: VersionSchema,
+  type: external_exports.literal("error"),
+  requestId: UuidSchema,
+  code: external_exports.enum(["invalid-request", "authentication-failed", "not-found", "ambiguous-target", "alias-conflict", "invalid-transition", "stale-epoch", "duplicate"]),
+  message: BoundedTextSchema
+}).strict();
+var ChatEventSchema = external_exports.object({
+  version: VersionSchema,
+  type: external_exports.literal("chat-event"),
+  messageId: UuidSchema,
+  senderId: UuidSchema,
+  recipientId: UuidSchema,
+  message: NonEmptyBoundedTextSchema
+}).strict();
+var CoWorkEventSchema = external_exports.object({
+  version: VersionSchema,
+  type: external_exports.literal("cowork-event"),
+  action: external_exports.enum(["PROPOSE", "PLAN", "START", "END", "FAIL", "CANCEL"]),
+  actorId: UuidSchema,
+  coWorkId: UuidSchema,
+  epoch: external_exports.number().int().positive(),
+  planHash: external_exports.string().regex(/^[a-f0-9]{64}$/).nullable(),
+  snapshot: CoWorkSnapshotSchema
+}).strict();
+var BrokerEventSchema = external_exports.union([ChatEventSchema, PalTaskEventSchema, DeliveryReceiptSchema, CoWorkEventSchema]);
+var BrokerEventResponseSchema = external_exports.object({
+  version: VersionSchema,
+  type: external_exports.literal("event"),
+  event: BrokerEventSchema
+}).strict();
+var BrokerResponseSchema = external_exports.discriminatedUnion("type", [
+  BrokerOkResponseSchema,
+  BrokerErrorResponseSchema,
+  BrokerEventResponseSchema
+]);
+var ControlFrameSchema = external_exports.string().refine(
+  (frame) => Buffer.byteLength(frame, "utf8") <= MAX_CONTROL_FRAME_BYTES,
+  `Control frame must not exceed ${MAX_CONTROL_FRAME_BYTES} UTF-8 bytes`
+);
+function encodeControlFrame(value) {
+  const encoded = JSON.stringify(value);
+  if (encoded === void 0) throw new Error("Control frame cannot encode undefined");
+  const parsed = ControlFrameSchema.safeParse(encoded);
+  if (!parsed.success) throw new Error(`Control frame is too large (maximum ${MAX_CONTROL_FRAME_BYTES} UTF-8 bytes)`);
+  return `${parsed.data}
+`;
+}
+
+export {
+  MAX_ALIAS_LENGTH,
+  MAX_MESSAGE_BYTES,
+  MAX_CONTROL_FRAME_BYTES,
+  MAX_ACTIVE_PALS,
+  MAX_COMPLETION_DETAIL_BYTES,
+  MIN_UUID_PREFIX_LENGTH,
+  normalizePalIdentity,
+  PalAliasSchema,
+  PalTargetSchema,
+  PalPresenceSchema,
+  PalPresenceListSchema,
+  DeliveryReceiptSchema,
+  CoWorkProposalParticipantsSchema,
+  CoWorkPlanSchema,
+  CoWorkSnapshotSchema,
+  BrokerRequestSchema,
+  BrokerResponseSchema,
+  encodeControlFrame
+};

package/dist/chunk-IU3UBETC.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { createRequire as createFlavorRequire } from "node:module"; const require = createFlavorRequire(import.meta.url);
+
+// src/utils/execFileNoThrow.ts
+import { execFile } from "child_process";
+function execFileNoThrow(file, args, options = {}) {
+  return new Promise((resolve) => {
+    const child = execFile(file, args, {
+      timeout: options.timeout,
+      maxBuffer: options.maxBuffer,
+      cwd: options.useCwd === false ? void 0 : process.cwd(),
+      env: options.env,
+      encoding: "utf8",
+      windowsHide: true,
+      ...options.signal === void 0 ? {} : { signal: options.signal }
+    }, (error, stdout, stderr) => {
+      resolve({
+        stdout,
+        stderr,
+        code: typeof error?.code === "number" ? error.code : error ? 1 : 0,
+        ...error === null ? {} : { error: error.message }
+      });
+    });
+    if (options.input !== void 0) child.stdin?.end(options.input);
+  });
+}
+
+export {
+  execFileNoThrow
+};