@go-labs-sg/event-tech 1.3.0 → 1.4.0

package/README.md

@@ -85,8 +85,10 @@ Use `EVENT_TECH_API_URL` or `--api-url` to target another HTTPS deployment. Plai
 et --help
 et organization list
 et organization get --organization-id <id>
+et organization create --name "Example Org" --owner-email owner@example.test --allowed-event-types LUCKY_DRAW
 et event list --organization-id <id>
 et event get --event-id <id>
+et event create --organization-id <id> --name "Example Dinner" --type LUCKY_DRAW --location "Ballroom" --start 2026-11-20T18:00:00+08:00
 et event appearance get --event-id <id>
 et event appearance get --event-id <id> --public
 et event appearance update --event-id <id> --appearance-version <n> --appearance '<json>'
@@ -95,6 +97,10 @@ et event appearance upload --event-id <id> --file ./background.mp4 --media-type
 et event photo-wall display-items --event-id <id> --limit 30
 et lucky-draw participants replace --event-id <id> --participants '[{"luckyDrawId":"illustrative-001","name":"Example Person","email":"example@example.test"}]' --allow-state-change --target <id>
 et lucky-draw participants list --event-id <id> --page 1 --per-page 100
+et lucky-draw config get --event-id <id>
+et lucky-draw config update --event-id <id> --config '{"luckyDrawType":"SLOT"}'
+et lucky-draw background upload --event-id <id> --file ./board.png --content-type image/png
+et lucky-draw prizes list --event-id <id>
 ```
 
 Commands emit deterministic JSON envelopes. Authentication credentials are never included in successful output, and bearer credentials are redacted from errors.
@@ -231,6 +237,102 @@ bun run packages/event-tech/cli/src/index.ts help
 
 Building is not publication or permission to mutate live data. Use focused temporary business-behavior tests and the final pre-push gate from the shared workflow. Use this package's actual scripts; do not assume it has a command-artifact generator.
 
+## Lucky draw setup from scratch
+
+An admin can set up a lucky draw without the browser. Each command uses the
+same tRPC procedure and permission as the web flow: `organization create` is
+global-admin only, `event create` needs organization owner/admin (or global
+admin), and config, background and prize writes need `event.setup`.
+
+```sh
+# 1. Organization (skip if it exists; check with `et organization get`).
+et organization create --name "Example Org" \
+  --owner-email owner@example.test --allowed-event-types LUCKY_DRAW
+
+# 2. LUCKY_DRAW event. The board row and default config are created with it.
+et event create --organization-id <org-id> --name "Example Dinner" \
+  --type LUCKY_DRAW --location "Ballroom" \
+  --start 2026-11-20T18:00:00+08:00 --end 2026-11-20T23:00:00+08:00
+
+# 3. 1920x1080 background (jpeg/png/webp/gif).
+et lucky-draw background upload --event-id <event-id> \
+  --file ./board-1920x1080.png --content-type image/png
+
+# 4. Slot mode plus theme. Preview first with --dry-run.
+et lucky-draw config update --event-id <event-id> --config-file ./theme.json --dry-run
+et lucky-draw config update --event-id <event-id> --config-file ./theme.json
+
+# 5. Prizes, then the participant roster.
+et lucky-draw prizes create --event-id <event-id> --prizes-file ./prizes.json
+et lucky-draw participants replace --event-id <event-id> \
+  --participants-file ./participants.json --allow-state-change --target <event-id>
+
+# 6. Read everything back.
+et lucky-draw config get --event-id <event-id>
+et lucky-draw prizes list --event-id <event-id>
+```
+
+`organization create` also emails an owner invitation to `--owner-email`;
+`data.deliveryStatus` reports `sent` or `failed`. The name must be unique among
+active organizations (case-insensitive), otherwise the API returns `CONFLICT`.
+
+`event create` requires `--location` and `--start` because the API does. Dates
+are ISO 8601 date-times; include an offset so the time is unambiguous.
+
+### Config merge patch
+
+`config update` reads the current config, applies only the keys you pass, and
+saves the full result. Example `theme.json`:
+
+```json
+{
+  "luckyDrawType": "SLOT",
+  "backgroundPreset": "#050d24",
+  "title": "Lucky Draw",
+  "titleColor": "#ffffff",
+  "titleFont": "font-serif",
+  "slotBorderColor": "#67ddf2",
+  "slotTextColor": "#ffffff",
+  "slotPositionX": 600,
+  "slotPositionY": 420
+}
+```
+
+Keys are validated with the API's `luckyDrawConfigSchema` before any request:
+unknown keys, wrong types and invalid enum values (`luckyDrawType`:
+`WHEEL|SLOT`; `segmentText`: `NAME|LUCKY_DRAW_ID|BOTH`) fail with a `USAGE`
+error that names the field. Arrays such as `includeDomains` are replaced, not
+appended. Fields missing from an older stored config fall back to the web
+form's defaults. `--dry-run` prints `changedFields` and the merged config
+without saving. It must be passed bare: `--dry-run=true` (or any
+`--flag=value` form of a bare flag) is a `USAGE` error, never a write. Run `et --help` for the full key list; positions are pixels on
+the 1920x1080 board.
+
+### Background
+
+`background upload` uploads through the same presigned
+`lucky-draw/backgrounds` flow as the preview page, then stores the key in
+`customBackgroundImage`. It prints the `config get` readback, where
+`customBackgroundImage` is a signed `/api/images/...` URL relative to the
+Event Tech app. `background clear --allow-state-change --target <event-id>`
+unsets it.
+
+### Prizes
+
+`prizes create` appends after the last prize. Pass one prize with `--name`
+(and optional `--description`) or many with `--prizes`/`--prizes-file`
+(`[{"name":"Grand Prize","description":"Optional"}]`, up to 500).
+
+`prizes update --prize-id <id> --name <text> [--description <text>]` renames a
+prize. `prizes reorder --prize-ids <id,...>` must list every active prize ID
+exactly once, in the new order.
+
+`prizes delete --prize-ids <id,...> --allow-state-change --target <event-id>`
+permanently deletes the prizes (the API hard-deletes them) and renumbers the
+rest. A prize already assigned to a winner cannot be deleted (`CONFLICT`).
+Before update, delete and reorder, the CLI checks that every prize ID belongs
+to `--event-id`.
+
 ## Lucky draw participant source import
 
 The participant import is an API-first rollout: use a deployment that includes

package/dist/index.js

@@ -1814,6 +1814,41 @@ var $ZodCheckEndsWith = /* @__PURE__ */ $constructor("$ZodCheckEndsWith", (inst,
     });
   };
 });
+function handleCheckPropertyResult(result, payload, property) {
+  if (result.issues.length) {
+    payload.issues.push(...prefixIssues(property, result.issues));
+  }
+}
+var $ZodCheckProperties = /* @__PURE__ */ $constructor("$ZodCheckProperties", (inst, def) => {
+  $ZodCheck.init(inst, def);
+  hide(inst, Symbol.iterator, function* () {
+    yield inst;
+  });
+  let entries;
+  inst._zod.check = (payload) => {
+    if (payload.value == null) {
+      payload.issues.push({ expected: "object", code: "invalid_type", input: payload.value, inst });
+      return;
+    }
+    entries ?? (entries = Reflect.ownKeys(def.shape).map((key) => [key, def.shape[key]]));
+    const input = payload.value;
+    let proms;
+    for (const [key, schema] of entries) {
+      const result = schema._zod.run({ value: input[key], issues: [] }, {});
+      if (result instanceof Promise) {
+        proms ?? (proms = []);
+        proms.push(result.then((result) => handleCheckPropertyResult(result, payload, key)));
+      } else {
+        handleCheckPropertyResult(result, payload, key);
+      }
+    }
+    if (proms)
+      return Promise.all(proms).then(() => {
+        return;
+      });
+    return;
+  };
+});
 var $ZodCheckOverwrite = /* @__PURE__ */ $constructor("$ZodCheckOverwrite", (inst, def) => {
   $ZodCheck.init(inst, def);
   inst._zod.check = (payload) => {
@@ -4111,6 +4146,13 @@ function _endsWith(suffix, params) {
     suffix
   });
 }
+function _properties(shape, params) {
+  return new $ZodCheckProperties({
+    check: "properties",
+    shape,
+    ...normalizeParams(params)
+  });
+}
 function _overwrite(tx) {
   return new $ZodCheckOverwrite({
     check: "overwrite",
@@ -6060,6 +6102,35 @@ function refine(fn, _params = {}) {
 function superRefine(fn, params) {
   return _superRefine(fn, params);
 }
+var ZodInstanceOf = /* @__PURE__ */ $constructor("ZodInstanceOf", (inst, def) => {
+  ZodCustom.init(inst, def);
+}, {
+  properties(shape, params) {
+    return this.check(_properties(shape, params));
+  }
+});
+function _instanceof(cls, params = {}) {
+  const inst = new ZodInstanceOf({
+    type: "custom",
+    check: "custom",
+    fn: (data) => data instanceof cls,
+    abort: true,
+    ...normalizeParams(params)
+  });
+  inst._zod.bag.Class = cls;
+  inst._zod.check = (payload) => {
+    if (!(payload.value instanceof cls)) {
+      payload.issues.push({
+        code: "invalid_type",
+        expected: cls.name,
+        input: payload.value,
+        inst,
+        path: [...inst._zod.def.path ?? []]
+      });
+    }
+  };
+  return inst;
+}
 // ../../cli-auth/src/protocol/schemas.ts
 var dateTimeString = string2().refine((value) => Number.isFinite(Date.parse(value)), "Invalid datetime");
 var base64Url2 = string2().min(43).max(128).regex(/^[A-Za-z0-9_-]+$/);
@@ -6754,8 +6825,30 @@ var logoutCliSession = async ({
 };
 // src/cli.ts
 import { readFileSync } from "fs";
-import { readFile as readFile2 } from "fs/promises";
-import { basename, resolve } from "path";
+import { readFile as readFile4 } from "fs/promises";
+import { basename as basename2, resolve } from "path";
+
+// ../db/src/generated/prisma/enums.ts
+var EventType = {
+  POST_IT_NOTE: "POST_IT_NOTE",
+  PHOTO_WALL: "PHOTO_WALL",
+  STORY_COLLECTION: "STORY_COLLECTION",
+  LUCKY_DRAW: "LUCKY_DRAW",
+  SCAVENGER_HUNT: "SCAVENGER_HUNT",
+  HUMAN_BINGO: "HUMAN_BINGO",
+  SIGNATURE_WALL: "SIGNATURE_WALL",
+  GARDENS_BY_THE_BAY: "GARDENS_BY_THE_BAY",
+  RATING_SYSTEM: "RATING_SYSTEM",
+  EVENT_PASSPORT: "EVENT_PASSPORT"
+};
+
+// ../validators/src/event-type.schema.ts
+var DEPRECATED_EVENT_TYPES = [
+  EventType.SCAVENGER_HUNT,
+  EventType.GARDENS_BY_THE_BAY
+];
+var activeEventTypeSchema = _enum(EventType).exclude(DEPRECATED_EVENT_TYPES);
+var ACTIVE_EVENT_TYPES = activeEventTypeSchema.options;
 
 // src/api-client.ts
 import {
@@ -6841,6 +6934,193 @@ var api2 = new Proxy({}, {
   get: (_target, property, receiver) => Reflect.get(property === "public" ? testingClient ?? activePublicClient : testingClient ?? activeClient, property, receiver)
 });
 
+// src/arguments.ts
+import { readFile as readFile2 } from "fs/promises";
+
+// src/runtime/index.ts
+var processRuntime = {
+  stdout: process.stdout,
+  stderr: process.stderr
+};
+
+class CliUsageError extends Error {
+  code = "USAGE";
+  constructor(message) {
+    super(message);
+    this.name = "CliUsageError";
+  }
+}
+var canonicalize = (value) => {
+  if (Array.isArray(value))
+    return value.map(canonicalize);
+  if (value instanceof Date)
+    return value.toJSON();
+  if (typeof value === "object" && value !== null) {
+    return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, nested]) => [key, canonicalize(nested)]));
+  }
+  return value;
+};
+var serialize = (value) => `${JSON.stringify(canonicalize(value), null, 2)}
+`;
+var writeSuccess = (runtime, data) => {
+  runtime.stdout.write(serialize({ ok: true, data }));
+};
+var sanitizeErrorMessage = (message) => message.replace(/\bBearer\s+\S+/giu, "Bearer [REDACTED]");
+var errorCode = (error) => {
+  if (error instanceof CliUsageError)
+    return error.code;
+  if (error instanceof CliConfigurationError)
+    return error.code;
+  if (typeof error === "object" && error !== null && "data" in error) {
+    const data = error.data;
+    if (typeof data === "object" && data !== null && "code" in data && typeof data.code === "string") {
+      return data.code;
+    }
+  }
+  return "INTERNAL_ERROR";
+};
+var writeError = (runtime, error) => {
+  const storageError = getCliStorageError(error);
+  if (storageError) {
+    runtime.stderr.write(serialize({ ok: false, error: storageError }));
+    return;
+  }
+  const message = error instanceof Error ? sanitizeErrorMessage(error.message) : "Unknown error.";
+  runtime.stderr.write(serialize({ ok: false, error: { code: errorCode(error), message } }));
+};
+
+// src/arguments.ts
+var booleanFlags = new Set([
+  "allow-delete",
+  "allow-state-change",
+  "dry-run",
+  "help",
+  "no-browser",
+  "public",
+  "version"
+]);
+var parseArguments = (args) => {
+  const positionals = [];
+  const flags = new Map;
+  for (let index = 0;index < args.length; index += 1) {
+    const token = args[index];
+    if (!token)
+      continue;
+    if (!token.startsWith("--")) {
+      positionals.push(token);
+      continue;
+    }
+    const [rawName, inlineValue] = token.slice(2).split("=", 2);
+    if (!rawName)
+      throw new CliUsageError("Flag names cannot be empty.");
+    if (booleanFlags.has(rawName)) {
+      if (inlineValue !== undefined) {
+        throw new CliUsageError(`--${rawName} is a bare flag and does not take a value.`);
+      }
+      flags.set(rawName, true);
+      continue;
+    }
+    if (inlineValue !== undefined) {
+      flags.set(rawName, inlineValue);
+      continue;
+    }
+    const nextValue = args[index + 1];
+    if (nextValue && !nextValue.startsWith("--")) {
+      flags.set(rawName, nextValue);
+      index += 1;
+    } else {
+      flags.set(rawName, true);
+    }
+  }
+  return { positionals, flags };
+};
+var getOptionalFlag = (parsed, name) => {
+  const value = parsed.flags.get(name);
+  if (value === undefined)
+    return;
+  if (value === true)
+    throw new CliUsageError(`--${name} requires a value.`);
+  return value;
+};
+var getRequiredFlag = (parsed, name) => {
+  const value = getOptionalFlag(parsed, name);
+  if (!value)
+    throw new CliUsageError(`--${name} is required.`);
+  return value;
+};
+var assertOnlyFlags = (parsed, allowedFlags) => {
+  const allowed = new Set(["api-url", ...allowedFlags]);
+  const unknown = [...parsed.flags.keys()].filter((name) => !allowed.has(name));
+  if (unknown.length > 0) {
+    throw new CliUsageError(`Unknown option${unknown.length === 1 ? "" : "s"}: ${unknown.map((name) => `--${name}`).join(", ")}.`);
+  }
+};
+var assertPositionalCount = (parsed, expectedCount) => {
+  if (parsed.positionals.length === expectedCount)
+    return;
+  throw new CliUsageError("Unexpected positional arguments.");
+};
+var assertStateChangeTarget = (parsed, eventId) => {
+  if (parsed.flags.get("allow-state-change") !== true) {
+    throw new CliUsageError("--allow-state-change is required as an explicit acknowledgement.");
+  }
+  if (getRequiredFlag(parsed, "target") !== eventId) {
+    throw new CliUsageError("--target must exactly match --event-id.");
+  }
+};
+var readInlineOrFile = async (parsed, inlineFlag, fileFlag) => {
+  const inlineValue = getOptionalFlag(parsed, inlineFlag);
+  const filePath = getOptionalFlag(parsed, fileFlag);
+  if (inlineValue === undefined === (filePath === undefined)) {
+    throw new CliUsageError(`Provide exactly one of --${inlineFlag} or --${fileFlag}.`);
+  }
+  if (inlineValue !== undefined)
+    return inlineValue;
+  try {
+    return await readFile2(filePath, "utf8");
+  } catch {
+    throw new CliUsageError(`--${fileFlag} could not be read.`);
+  }
+};
+var parseJsonValue = (value, name) => {
+  try {
+    return JSON.parse(value);
+  } catch {
+    throw new CliUsageError(`--${name} must be valid JSON.`);
+  }
+};
+var parsePositiveInteger = (value, name) => {
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed <= 0) {
+    throw new CliUsageError(`--${name} must be a positive integer.`);
+  }
+  return parsed;
+};
+var parseNonnegativeInteger = (value, name) => {
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed < 0) {
+    throw new CliUsageError(`--${name} must be a non-negative integer.`);
+  }
+  return parsed;
+};
+var parseBoundedInteger = (value, name, minimum, maximum) => {
+  const parsed = parsePositiveInteger(value, name);
+  if (parsed > maximum || parsed < minimum) {
+    throw new CliUsageError(`--${name} must be an integer from ${minimum} to ${maximum}.`);
+  }
+  return parsed;
+};
+var parseIdList = (value, name) => {
+  const ids = value.split(",").map((id) => id.trim());
+  if (ids.some((id) => id.length === 0)) {
+    throw new CliUsageError(`--${name} must not contain blank entries.`);
+  }
+  if (new Set(ids).size !== ids.length) {
+    throw new CliUsageError(`--${name} must not contain duplicates.`);
+  }
+  return ids;
+};
+
 // src/commands/index.ts
 var usage = `Event Tech CLI
 
@@ -6853,13 +7133,24 @@ Usage:
   et auth whoami
   et organization list
   et organization get --organization-id <id>
+  et organization create --name <text> --owner-email <email> [--allowed-event-types <TYPE,...>]
   et event list --organization-id <id> [--page <n>] [--per-page <n>] [--name <text>] [--status <status>] [--archive-status <status>]
   et event get --event-id <id>
+  et event create --organization-id <id> --name <text> --type <type> --location <text> --start <iso> [--end <iso>]
   et event appearance get --event-id <id> [--public]
   et event appearance update --event-id <id> --appearance-version <n> --appearance <json>
   et event appearance reset --event-id <id> --appearance-version <n>
   et event appearance upload --event-id <id> --file <path> --media-type <image|video> --content-type <mime>
   et event photo-wall display-items --event-id <id> [--limit <n>] [--cursor <json>] [--retained-ids <json>]
+  et lucky-draw config get --event-id <id>
+  et lucky-draw config update --event-id <id> (--config <json> | --config-file <path>) [--dry-run]
+  et lucky-draw background upload --event-id <id> --file <path> --content-type <image-mime>
+  et lucky-draw background clear --event-id <id> --allow-state-change --target <same-event-id>
+  et lucky-draw prizes list --event-id <id>
+  et lucky-draw prizes create --event-id <id> (--name <text> [--description <text>] | --prizes <json-array> | --prizes-file <path>)
+  et lucky-draw prizes update --event-id <id> --prize-id <id> --name <text> [--description <text>]
+  et lucky-draw prizes delete --event-id <id> --prize-ids <id,...> --allow-state-change --target <same-event-id>
+  et lucky-draw prizes reorder --event-id <id> --prize-ids <id,...>
   et lucky-draw pre-draw --event-id <id> --prize-count <n>
   et lucky-draw participants replace --event-id <id> (--participants <json-array> | --participants-file <path>) --allow-state-change --target <same-event-id>
   et lucky-draw participants list --event-id <id> [--page <n>] [--per-page <n>]
@@ -6903,7 +7194,30 @@ Event Passport:
   Points are scores only; existing stamp-based Lucky Draw and prize thresholds still apply.
   Guest enrollment and account-linking require the browser; CLI uses existing device-approved auth.
 
+Organization and event setup:
+  organization create is global-admin only. It provisions the org and emails an owner invitation
+  to --owner-email; deliveryStatus reports whether that email was sent. Names must be unique.
+  event create needs org owner/admin (or global admin). --type is an active event type such as
+  LUCKY_DRAW; a LUCKY_DRAW event gets its board with default config automatically.
+  --start/--end are ISO 8601 date-times with an offset, for example 2026-11-20T18:00:00+08:00.
+
 Lucky draw:
+  config, background and prize writes need event.setup, the same as the web board settings.
+  config update is a merge patch: only the given keys change. Unknown keys and wrong value types
+  are rejected before any request. Arrays (includeDomains etc.) are replaced, not appended.
+  --dry-run prints the merged config without saving it.
+  Keys: title, titleColor, isTitleVisible, titleFontSize, titleFont, prizeColor, prizeFontSize,
+  isPrizeVisible, prizeFont, luckyDrawType (WHEEL|SLOT), slotBackgroundColor, slotBorderColor,
+  slotTextColor, slotFontSize, slotTextFont, backgroundPreset, customBackgroundImage,
+  numberOfSegments, segmentPreset, segmentText (NAME|LUCKY_DRAW_ID|BOTH), wheelSegmentFont,
+  wheelSegmentFontSize, wheelSegmentColorsPreset, includeDomains, excludeDomains, includeEmails,
+  excludeEmails, titlePositionX/Y, slotPositionX/Y, prizePositionX/Y, prizeDivWidth, prizeDivHeight.
+  Positions are pixels on the 1920x1080 board.
+  background upload stores the image (jpeg/png/webp/gif) and sets customBackgroundImage;
+  the readback contains a signed /api/images URL. background clear unsets it.
+  prizes create appends after the last prize; --prizes takes [{"name","description"?}].
+  prizes delete permanently removes unassigned prizes and renumbers the rest.
+  prizes reorder takes every active prize ID once, in the new order.
   pre-draw immediately saves winners for the next unassigned prizes in order.
   Uses the live draw random selection and participant filters in the backend.
   participants replace replaces the imported source roster; it is not an append.
@@ -6911,6 +7225,8 @@ Lucky draw:
   participants list defaults to page 1 with 100 results per page; inspect every page.
 
 Global options:
+  Bare flags (--dry-run, --allow-state-change, --public, --no-browser) take no value;
+  --flag=value spellings are rejected before any request.
   --api-url <url>           Override EVENT_TECH_API_URL.
   --help                    Print this help as JSON.
   --version                 Print the CLI version as JSON.
@@ -6920,56 +7236,351 @@ Authentication:
   Credentials are stored exclusively through Bun.secrets.
   EVENT_TECH_API_URL defaults to ${DEFAULT_EVENT_TECH_API_BASE_URL}.`;
 
-// src/runtime/index.ts
-var processRuntime = {
-  stdout: process.stdout,
-  stderr: process.stderr
+// src/commands/lucky-draw-setup.ts
+import { readFile as readFile3 } from "fs/promises";
+import { basename } from "path";
+
+// ../db/src/lucky-draw-config-json.ts
+var LuckyDrawSegmentText = {
+  NAME: "NAME",
+  LUCKY_DRAW_ID: "LUCKY_DRAW_ID",
+  BOTH: "BOTH"
+};
+var LuckyDrawType = {
+  WHEEL: "WHEEL",
+  SLOT: "SLOT"
 };
 
-class CliUsageError extends Error {
-  code = "USAGE";
-  constructor(message) {
-    super(message);
-    this.name = "CliUsageError";
+// ../validators/src/lucky-draw/lucky-draw-config.schema.ts
+var luckyDrawConfigSchema = object({
+  title: string2(),
+  titleColor: string2(),
+  isTitleVisible: boolean2(),
+  titleFontSize: number2(),
+  prizeColor: string2(),
+  prizeFontSize: number2(),
+  isPrizeVisible: boolean2(),
+  slotBackgroundColor: string2(),
+  slotBorderColor: string2(),
+  slotTextColor: string2(),
+  slotFontSize: number2(),
+  wheelSegmentColorsPreset: string2(),
+  backgroundPreset: string2(),
+  numberOfSegments: number2(),
+  includeDomains: array(string2()),
+  excludeDomains: array(string2()),
+  includeEmails: array(string2()),
+  excludeEmails: array(string2()),
+  segmentPreset: string2(),
+  segmentText: _enum([
+    LuckyDrawSegmentText.NAME,
+    LuckyDrawSegmentText.LUCKY_DRAW_ID,
+    LuckyDrawSegmentText.BOTH
+  ]),
+  luckyDrawType: _enum([LuckyDrawType.WHEEL, LuckyDrawType.SLOT]),
+  titleFont: string2(),
+  prizeFont: string2(),
+  wheelSegmentFont: string2(),
+  wheelSegmentFontSize: number2(),
+  slotTextFont: string2(),
+  customBackgroundImage: string2().optional().nullable(),
+  titlePositionX: number2(),
+  titlePositionY: number2(),
+  slotPositionX: number2(),
+  slotPositionY: number2(),
+  prizePositionX: number2(),
+  prizePositionY: number2(),
+  prizeDivWidth: number2(),
+  prizeDivHeight: number2()
+});
+
+// ../validators/src/lucky-draw/lucky-draw-config-input.schema.ts
+var luckyDrawConfigInputProcedureSchema = object({
+  eventId: string2(),
+  config: luckyDrawConfigSchema
+});
+var luckyDrawConfigInputSchema = object({
+  ...luckyDrawConfigSchema.omit({ customBackgroundImage: true }).shape,
+  customBackgroundImage: union([_instanceof(File), string2()]).optional().nullable()
+});
+var DEFAULT_LUCKY_DRAW_CONFIG_INPUT_VALUES = {
+  title: "Lucky Draw Title",
+  titleColor: "#111111",
+  isTitleVisible: true,
+  titleFontSize: 40,
+  prizeColor: "#111111",
+  prizeFontSize: 30,
+  isPrizeVisible: true,
+  slotBackgroundColor: "#ffffff",
+  slotBorderColor: "#ffffff",
+  slotTextColor: "#111111",
+  slotFontSize: 5,
+  backgroundPreset: "#ede9fe",
+  numberOfSegments: 12,
+  includeDomains: [],
+  excludeDomains: [],
+  includeEmails: [],
+  excludeEmails: [],
+  segmentPreset: "Vibrant",
+  segmentText: LuckyDrawSegmentText.NAME,
+  luckyDrawType: LuckyDrawType.WHEEL,
+  titleFont: "font-sans",
+  prizeFont: "font-sans",
+  wheelSegmentFont: "font-sans",
+  wheelSegmentFontSize: 12,
+  slotTextFont: "font-sans",
+  customBackgroundImage: null,
+  titlePositionX: 750,
+  titlePositionY: 100,
+  slotPositionX: 600,
+  slotPositionY: 300,
+  prizePositionX: 800,
+  prizePositionY: 200,
+  prizeDivWidth: 500,
+  prizeDivHeight: 100,
+  wheelSegmentColorsPreset: "Vibrant"
+};
+
+// ../validators/src/lucky-draw/lucky-draw-prize-input.schema.ts
+var luckyDrawPrizeInputSchema = object({
+  name: string2().min(1),
+  description: string2().optional()
+});
+var multipleLuckyDrawPrizeInputSchema = object({
+  eventId: string2().min(1, "EventID is required"),
+  prizes: array(luckyDrawPrizeInputSchema)
+});
+
+// src/commands/lucky-draw-setup.ts
+var LUCKY_DRAW_BACKGROUND_FOLDER = "lucky-draw/backgrounds";
+var luckyDrawConfigPatchSchema = luckyDrawConfigSchema.partial().strict();
+var formatIssues = (label, issues) => `${label} is invalid: ${issues.map((issue) => {
+  const path = issue.path.map(String).join(".");
+  return path ? `${path}: ${issue.message}` : issue.message;
+}).join("; ")}.`;
+var parseLuckyDrawConfigPatch = (raw) => {
+  const value = parseJsonValue(raw, "config");
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new CliUsageError("--config must be a JSON object.");
+  }
+  const result = luckyDrawConfigPatchSchema.safeParse(value);
+  if (!result.success) {
+    throw new CliUsageError(formatIssues("--config", result.error.issues));
+  }
+  if (Object.keys(result.data).length === 0) {
+    throw new CliUsageError("--config must change at least one field.");
+  }
+  return result.data;
+};
+var mergeLuckyDrawConfig = (current, patch) => {
+  const merged = {
+    ...DEFAULT_LUCKY_DRAW_CONFIG_INPUT_VALUES,
+    ...current ?? {},
+    ...patch
+  };
+  const result = luckyDrawConfigSchema.safeParse(merged);
+  if (!result.success) {
+    throw new CliUsageError(formatIssues("Merged lucky draw config", result.error.issues));
   }
-}
-var canonicalize = (value) => {
-  if (Array.isArray(value))
-    return value.map(canonicalize);
-  if (value instanceof Date)
-    return value.toJSON();
-  if (typeof value === "object" && value !== null) {
-    return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, nested]) => [key, canonicalize(nested)]));
+  return result.data;
+};
+var parsePrizeList = (raw) => {
+  const value = parseJsonValue(raw, "prizes");
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new CliUsageError("--prizes must be a non-empty JSON array.");
   }
-  return value;
+  if (value.length > 500) {
+    throw new CliUsageError("--prizes must contain at most 500 prizes.");
+  }
+  return value.map((item, index) => {
+    const result = luckyDrawPrizeInputSchema.strict().safeParse(item);
+    if (!result.success) {
+      throw new CliUsageError(formatIssues(`--prizes[${index}]`, result.error.issues));
+    }
+    return result.data;
+  });
 };
-var serialize = (value) => `${JSON.stringify(canonicalize(value), null, 2)}
-`;
-var writeSuccess = (runtime, data) => {
-  runtime.stdout.write(serialize({ ok: true, data }));
+var loadCurrentConfig = async (eventId) => (await api2.event.luckyDraw.getLuckyDrawByEventId.query({ eventId })).config;
+var loadPrizes = async (eventId) => (await api2.event.luckyDraw.getLuckyDrawPrizesByEventId.query({ eventId })).prizes;
+var assertPrizesBelongToEvent = (prizes, prizeIds, eventId) => {
+  const known = new Set(prizes.map((prize) => prize.id));
+  const missing = prizeIds.filter((id) => !known.has(id));
+  if (missing.length > 0) {
+    throw new CliUsageError(`Prize ID(s) not found on event ${eventId}: ${missing.join(", ")}.`);
+  }
 };
-var sanitizeErrorMessage = (message) => message.replace(/\bBearer\s+\S+/giu, "Bearer [REDACTED]");
-var errorCode = (error) => {
-  if (error instanceof CliUsageError)
-    return error.code;
-  if (error instanceof CliConfigurationError)
-    return error.code;
-  if (typeof error === "object" && error !== null && "data" in error) {
-    const data = error.data;
-    if (typeof data === "object" && data !== null && "code" in data && typeof data.code === "string") {
-      return data.code;
+var saveConfig = (eventId, config) => api2.event.luckyDraw.updateLuckyDrawConfigJson.mutate({ eventId, config });
+var runLuckyDrawSetupCommand = async (input) => {
+  const { parsed, runtime, authenticate } = input;
+  const [, action, subAction] = parsed.positionals;
+  if (action === "config" && subAction === "get") {
+    assertPositionalCount(parsed, 3);
+    assertOnlyFlags(parsed, ["event-id"]);
+    const eventId = getRequiredFlag(parsed, "event-id");
+    await authenticate();
+    writeSuccess(runtime, await api2.event.luckyDraw.getLuckyDrawByEventId.query({ eventId }));
+    return true;
+  }
+  if (action === "config" && subAction === "update") {
+    assertPositionalCount(parsed, 3);
+    assertOnlyFlags(parsed, ["event-id", "config", "config-file", "dry-run"]);
+    const eventId = getRequiredFlag(parsed, "event-id");
+    const patch = parseLuckyDrawConfigPatch(await readInlineOrFile(parsed, "config", "config-file"));
+    await authenticate();
+    const config = mergeLuckyDrawConfig(await loadCurrentConfig(eventId), patch);
+    if (parsed.flags.get("dry-run") === true) {
+      writeSuccess(runtime, {
+        dryRun: true,
+        changedFields: Object.keys(patch).sort(),
+        config
+      });
+      return true;
     }
+    writeSuccess(runtime, await saveConfig(eventId, config));
+    return true;
   }
-  return "INTERNAL_ERROR";
-};
-var writeError = (runtime, error) => {
-  const storageError = getCliStorageError(error);
-  if (storageError) {
-    runtime.stderr.write(serialize({ ok: false, error: storageError }));
-    return;
+  if (action === "background" && subAction === "upload") {
+    assertPositionalCount(parsed, 3);
+    assertOnlyFlags(parsed, ["event-id", "file", "content-type"]);
+    const eventId = getRequiredFlag(parsed, "event-id");
+    const filePath = getRequiredFlag(parsed, "file");
+    const contentType = getRequiredFlag(parsed, "content-type");
+    if (!contentType.startsWith("image/")) {
+      throw new CliUsageError("--content-type must be an image MIME type.");
+    }
+    let file;
+    try {
+      file = await readFile3(filePath);
+    } catch {
+      throw new CliUsageError("--file could not be read.");
+    }
+    await authenticate();
+    const signed = await api2.attachment.getPresignedUrlToUpload.mutate({
+      folder: LUCKY_DRAW_BACKGROUND_FOLDER,
+      fileName: basename(filePath),
+      contentType,
+      size: file.byteLength,
+      eventId
+    });
+    const uploadResponse = await fetch(signed.uploadUrl, {
+      method: "PUT",
+      headers: { "content-type": contentType },
+      body: file
+    });
+    if (!uploadResponse.ok) {
+      throw new Error(`Lucky draw background upload failed with HTTP ${uploadResponse.status}.`);
+    }
+    const config = mergeLuckyDrawConfig(await loadCurrentConfig(eventId), {
+      customBackgroundImage: signed.key
+    });
+    await saveConfig(eventId, config);
+    writeSuccess(runtime, await api2.event.luckyDraw.getLuckyDrawByEventId.query({ eventId }));
+    return true;
   }
-  const message = error instanceof Error ? sanitizeErrorMessage(error.message) : "Unknown error.";
-  runtime.stderr.write(serialize({ ok: false, error: { code: errorCode(error), message } }));
+  if (action === "background" && subAction === "clear") {
+    assertPositionalCount(parsed, 3);
+    assertOnlyFlags(parsed, ["event-id", "allow-state-change", "target"]);
+    const eventId = getRequiredFlag(parsed, "event-id");
+    assertStateChangeTarget(parsed, eventId);
+    await authenticate();
+    const config = mergeLuckyDrawConfig(await loadCurrentConfig(eventId), {
+      customBackgroundImage: null
+    });
+    writeSuccess(runtime, await saveConfig(eventId, config));
+    return true;
+  }
+  if (action === "prizes" && subAction === "list") {
+    assertPositionalCount(parsed, 3);
+    assertOnlyFlags(parsed, ["event-id"]);
+    const eventId = getRequiredFlag(parsed, "event-id");
+    await authenticate();
+    writeSuccess(runtime, await api2.event.luckyDraw.getLuckyDrawPrizesByEventId.query({ eventId }));
+    return true;
+  }
+  if (action === "prizes" && subAction === "create") {
+    assertPositionalCount(parsed, 3);
+    assertOnlyFlags(parsed, [
+      "event-id",
+      "name",
+      "description",
+      "prizes",
+      "prizes-file"
+    ]);
+    const eventId = getRequiredFlag(parsed, "event-id");
+    const name = getOptionalFlag(parsed, "name");
+    const description = getOptionalFlag(parsed, "description");
+    const hasList = parsed.flags.has("prizes") || parsed.flags.has("prizes-file");
+    if (hasList === (name !== undefined)) {
+      throw new CliUsageError("Provide either --name [--description] or one of --prizes / --prizes-file.");
+    }
+    if (hasList && description !== undefined) {
+      throw new CliUsageError("--description is only valid with --name; include descriptions in the --prizes JSON.");
+    }
+    const prizes = hasList ? parsePrizeList(await readInlineOrFile(parsed, "prizes", "prizes-file")) : parsePrizeList(JSON.stringify([
+      { name, ...description === undefined ? {} : { description } }
+    ]));
+    await authenticate();
+    writeSuccess(runtime, await api2.event.luckyDraw.createLuckyDrawPrize.mutate({
+      eventId,
+      prizes
+    }));
+    return true;
+  }
+  if (action === "prizes" && subAction === "update") {
+    assertPositionalCount(parsed, 3);
+    assertOnlyFlags(parsed, ["event-id", "prize-id", "name", "description"]);
+    const eventId = getRequiredFlag(parsed, "event-id");
+    const prizeId = getRequiredFlag(parsed, "prize-id");
+    const name = getRequiredFlag(parsed, "name");
+    const description = getOptionalFlag(parsed, "description");
+    await authenticate();
+    assertPrizesBelongToEvent(await loadPrizes(eventId), [prizeId], eventId);
+    writeSuccess(runtime, await api2.event.luckyDraw.updateLuckyDrawPrize.mutate({
+      id: prizeId,
+      name,
+      ...description === undefined ? {} : { description }
+    }));
+    return true;
+  }
+  if (action === "prizes" && subAction === "delete") {
+    assertPositionalCount(parsed, 3);
+    assertOnlyFlags(parsed, [
+      "event-id",
+      "prize-ids",
+      "allow-state-change",
+      "target"
+    ]);
+    const eventId = getRequiredFlag(parsed, "event-id");
+    const prizeIds = parseIdList(getRequiredFlag(parsed, "prize-ids"), "prize-ids");
+    assertStateChangeTarget(parsed, eventId);
+    await authenticate();
+    assertPrizesBelongToEvent(await loadPrizes(eventId), prizeIds, eventId);
+    writeSuccess(runtime, await api2.event.luckyDraw.deleteLuckyDrawPrize.mutate({ prizeIds }));
+    return true;
+  }
+  if (action === "prizes" && subAction === "reorder") {
+    assertPositionalCount(parsed, 3);
+    assertOnlyFlags(parsed, ["event-id", "prize-ids"]);
+    const eventId = getRequiredFlag(parsed, "event-id");
+    const prizeIds = parseIdList(getRequiredFlag(parsed, "prize-ids"), "prize-ids");
+    await authenticate();
+    const prizes = await loadPrizes(eventId);
+    assertPrizesBelongToEvent(prizes, prizeIds, eventId);
+    if (prizeIds.length !== prizes.length) {
+      throw new CliUsageError(`--prize-ids must list all ${prizes.length} active prizes in the new order.`);
+    }
+    const namesById = new Map(prizes.map((prize) => [prize.id, prize.name]));
+    writeSuccess(runtime, await api2.event.luckyDraw.updateLuckyDrawPrizesOrder.mutate({
+      eventId,
+      prizes: prizeIds.map((id, order) => ({
+        id,
+        order,
+        name: namesById.get(id) ?? ""
+      }))
+    }));
+    return true;
+  }
+  return false;
 };
 
 // src/commands/passport.ts
@@ -7309,93 +7920,6 @@ var getInstalledCliVersion = () => {
     return "unknown";
   }
 };
-var booleanFlags = new Set([
-  "allow-delete",
-  "allow-state-change",
-  "help",
-  "no-browser",
-  "public",
-  "version"
-]);
-var parseArguments = (args) => {
-  const positionals = [];
-  const flags = new Map;
-  for (let index = 0;index < args.length; index += 1) {
-    const token = args[index];
-    if (!token)
-      continue;
-    if (!token.startsWith("--")) {
-      positionals.push(token);
-      continue;
-    }
-    const [rawName, inlineValue] = token.slice(2).split("=", 2);
-    if (!rawName)
-      throw new CliUsageError("Flag names cannot be empty.");
-    if (inlineValue !== undefined) {
-      flags.set(rawName, inlineValue);
-      continue;
-    }
-    if (booleanFlags.has(rawName)) {
-      flags.set(rawName, true);
-      continue;
-    }
-    const nextValue = args[index + 1];
-    if (nextValue && !nextValue.startsWith("--")) {
-      flags.set(rawName, nextValue);
-      index += 1;
-    } else {
-      flags.set(rawName, true);
-    }
-  }
-  return { positionals, flags };
-};
-var getOptionalFlag = (parsed, name) => {
-  const value = parsed.flags.get(name);
-  if (value === undefined)
-    return;
-  if (value === true)
-    throw new CliUsageError(`--${name} requires a value.`);
-  return value;
-};
-var getRequiredFlag = (parsed, name) => {
-  const value = getOptionalFlag(parsed, name);
-  if (!value)
-    throw new CliUsageError(`--${name} is required.`);
-  return value;
-};
-var assertOnlyFlags = (parsed, allowedFlags) => {
-  const allowed = new Set(["api-url", ...allowedFlags]);
-  const unknown = [...parsed.flags.keys()].filter((name) => !allowed.has(name));
-  if (unknown.length > 0) {
-    throw new CliUsageError(`Unknown option${unknown.length === 1 ? "" : "s"}: ${unknown.map((name) => `--${name}`).join(", ")}.`);
-  }
-};
-var assertPositionalCount = (parsed, expectedCount) => {
-  if (parsed.positionals.length === expectedCount)
-    return;
-  throw new CliUsageError("Unexpected positional arguments.");
-};
-var parsePositiveInteger = (value, name) => {
-  const parsed = Number(value);
-  if (!Number.isSafeInteger(parsed) || parsed <= 0) {
-    throw new CliUsageError(`--${name} must be a positive integer.`);
-  }
-  return parsed;
-};
-var parseNonnegativeInteger = (value, name) => {
-  const parsed = Number(value);
-  if (!Number.isSafeInteger(parsed) || parsed < 0) {
-    throw new CliUsageError(`--${name} must be a non-negative integer.`);
-  }
-  return parsed;
-};
-var parseBoundedInteger = (value, name, minimum, maximum) => {
-  const parsed = parsePositiveInteger(value, name);
-  if (parsed > maximum || parsed < minimum) {
-    throw new CliUsageError(`--${name} must be an integer from ${minimum} to ${maximum}.`);
-  }
-  return parsed;
-};
 var parseJsonObject = (value, name) => {
   let parsed;
   try {
@@ -7475,13 +7999,6 @@ var parseLuckyDrawParticipants = (value) => {
     };
   });
 };
-var readParticipantsFile = async (path) => {
-  try {
-    return await readFile2(path, "utf8");
-  } catch {
-    throw new CliUsageError("--participants-file could not be read.");
-  }
-};
 var parseAppearanceMediaType = (value) => {
   if (value === "image" || value === "video")
     return value;
@@ -7501,6 +8018,33 @@ var parseArchiveStatus = (value) => {
   }
   return value;
 };
+var parseCreatableEventType = (value) => {
+  const result = activeEventTypeSchema.safeParse(value);
+  if (!result.success) {
+    throw new CliUsageError(`--type must be one of: ${activeEventTypeSchema.options.join(", ")}.`);
+  }
+  return result.data;
+};
+var parseEventTypeList = (value) => {
+  const types = value.split(",").map((type) => type.trim());
+  return [...new Set(types)].map((type) => {
+    const result = activeEventTypeSchema.safeParse(type);
+    if (!result.success) {
+      throw new CliUsageError(`--allowed-event-types entries must be one of: ${activeEventTypeSchema.options.join(", ")}.`);
+    }
+    return result.data;
+  });
+};
+var parseIsoDateTime = (value, name) => {
+  if (!/^\d{4}-\d\d-\d\dT\d\d:\d\d/.test(value)) {
+    throw new CliUsageError(`--${name} must be an ISO 8601 date-time such as 2026-11-20T18:00:00+08:00.`);
+  }
+  const parsed = new Date(value);
+  if (Number.isNaN(parsed.getTime())) {
+    throw new CliUsageError(`--${name} must be a valid date-time.`);
+  }
+  return parsed;
+};
 var runCommand = async (parsed, runtime, credentialStore, apiBaseUrl, configureAccessToken) => {
   const [group, action, subAction] = parsed.positionals;
   const cliVersion = getInstalledCliVersion();
@@ -7602,6 +8146,44 @@ Waiting for approval\u2026
     }));
     return;
   }
+  if ((group === "organization" || group === "org") && action === "create" && subAction === undefined) {
+    assertPositionalCount(parsed, 2);
+    assertOnlyFlags(parsed, ["name", "owner-email", "allowed-event-types"]);
+    const allowedEventTypes = getOptionalFlag(parsed, "allowed-event-types");
+    const input = {
+      name: getRequiredFlag(parsed, "name"),
+      ownerEmail: getRequiredFlag(parsed, "owner-email"),
+      ...allowedEventTypes === undefined ? {} : { allowedEventTypes: parseEventTypeList(allowedEventTypes) }
+    };
+    await ensureAuthentication();
+    writeSuccess(runtime, await api2.admin.organization.createOrganization.mutate(input));
+    return;
+  }
+  if (group === "event" && action === "create" && subAction === undefined) {
+    assertPositionalCount(parsed, 2);
+    assertOnlyFlags(parsed, [
+      "organization-id",
+      "name",
+      "type",
+      "start",
+      "end",
+      "location"
+    ]);
+    const end = getOptionalFlag(parsed, "end");
+    const input = {
+      organizationId: getRequiredFlag(parsed, "organization-id"),
+      name: getRequiredFlag(parsed, "name"),
+      type: parseCreatableEventType(getRequiredFlag(parsed, "type")),
+      location: getRequiredFlag(parsed, "location"),
+      eventDateRange: {
+        from: parseIsoDateTime(getRequiredFlag(parsed, "start"), "start"),
+        ...end === undefined ? {} : { to: parseIsoDateTime(end, "end") }
+      }
+    };
+    await ensureAuthentication();
+    writeSuccess(runtime, await api2.event.createEvent.mutate(input));
+    return;
+  }
   if (group === "event" && action === "list" && subAction === undefined) {
     assertPositionalCount(parsed, 2);
     assertOnlyFlags(parsed, [
@@ -7679,11 +8261,11 @@ Waiting for approval\u2026
     const filePath = getRequiredFlag(parsed, "file");
     const contentType = getRequiredFlag(parsed, "content-type");
     const mediaType = parseAppearanceMediaType(getRequiredFlag(parsed, "media-type"));
-    const file = await readFile2(filePath);
+    const file = await readFile4(filePath);
     await ensureAuthentication();
     const signed = await api2.attachment.getPresignedUrlToUpload.mutate({
       folder: `event-appearance/${mediaType === "image" ? "images" : "videos"}`,
-      fileName: basename(filePath),
+      fileName: basename2(filePath),
       contentType,
       size: file.byteLength,
       eventId
@@ -7714,6 +8296,13 @@ Waiting for approval\u2026
     writeSuccess(runtime, await api2.event.photoWall.getPhotoWallDisplayItems.query(input));
     return;
   }
+  if (group === "lucky-draw" && await runLuckyDrawSetupCommand({
+    parsed,
+    runtime,
+    authenticate: ensureAuthentication
+  })) {
+    return;
+  }
   if (group === "lucky-draw" && action === "pre-draw" && subAction === undefined) {
     assertPositionalCount(parsed, 2);
     assertOnlyFlags(parsed, ["event-id", "prize-count"]);
@@ -7734,21 +8323,11 @@ Waiting for approval\u2026
       "allow-state-change",
       "target"
     ]);
-    if (parsed.flags.get("allow-state-change") !== true) {
-      throw new CliUsageError("--allow-state-change is required as an explicit acknowledgement.");
-    }
     const eventId = getRequiredFlag(parsed, "event-id");
-    if (getRequiredFlag(parsed, "target") !== eventId) {
-      throw new CliUsageError("--target must exactly match --event-id.");
-    }
-    const participantsValue = getOptionalFlag(parsed, "participants");
-    const participantsFile = getOptionalFlag(parsed, "participants-file");
-    if (participantsValue === undefined === (participantsFile === undefined)) {
-      throw new CliUsageError("Provide exactly one of --participants or --participants-file.");
-    }
+    assertStateChangeTarget(parsed, eventId);
     const input = {
       eventId,
-      participants: parseLuckyDrawParticipants(participantsValue ?? await readParticipantsFile(getRequiredFlag(parsed, "participants-file")))
+      participants: parseLuckyDrawParticipants(await readInlineOrFile(parsed, "participants", "participants-file"))
     };
     await ensureAuthentication();
     writeSuccess(runtime, await api2.event.luckyDraw.createLuckyDrawParticipant.mutate(input));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@go-labs-sg/event-tech",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Event Tech CLI for managing Event Tech resources through the Go Labs API.",
   "type": "module",
   "main": "./dist/index.js",