@pome-sh/cli 0.26.13 → 0.27.0

package/dist/chunk-SLTBPJKZ.js

@@ -0,0 +1,522 @@
+import { failureInjectionRuleSchema } from './chunk-CF6EIU2U.js';
+import { z } from 'zod';
+import { randomUUID, randomBytes } from 'node:crypto';
+
+var BASE62 = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+var ID_PREFIXES = {
+  customer: "cus_",
+  payment_method: "pm_",
+  payment_intent: "pi_",
+  charge: "ch_",
+  refund: "re_",
+  product: "prod_",
+  price: "price_",
+  subscription: "sub_",
+  subscription_item: "si_",
+  setup_intent: "seti_",
+  checkout_session: "cs_test_",
+  webhook_endpoint: "we_",
+  event: "evt_",
+  shared_payment_issued: "spt_",
+  shared_payment_granted: "spt_",
+  profile: "profile_",
+  balance_transaction: "txn_",
+  // API keys are minted via api-keys.ts but the prefix lives here for parity.
+  api_key: "sk_test_pome_",
+  api_key_restricted: "rk_test_pome_"
+};
+function randomBase62(count) {
+  const buf = randomBytes(count * 2);
+  let out = "";
+  let i = 0;
+  while (out.length < count && i < buf.length) {
+    const byte = buf[i++];
+    if (byte < 248) {
+      out += BASE62[byte % 62];
+    }
+  }
+  if (out.length < count) {
+    out += randomBase62(count - out.length);
+  }
+  return out;
+}
+function newId(kind) {
+  return `${ID_PREFIXES[kind]}${randomBase62(24)}`;
+}
+function newClientSecret(piId) {
+  return `${piId}_secret_${randomBase62(24)}`;
+}
+function newApiKey() {
+  return newId("api_key");
+}
+function nowIso() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function nowUnix() {
+  return Math.floor(Date.now() / 1e3);
+}
+function requestId() {
+  return `req_${randomUUID()}`;
+}
+
+// ../packages/twin-stripe/dist/src/api-keys.js
+function mintApiKey(db, input) {
+  const key = input.key ?? newApiKey();
+  const account_id = input.account_id ?? `acct_${input.sid}`;
+  const created_at = nowIso();
+  db.prepare(`INSERT INTO api_keys (key, sid, account_id, created_at, revoked_at)
+     VALUES (?, ?, ?, ?, NULL)
+     ON CONFLICT(key) DO UPDATE SET
+       sid = excluded.sid,
+       account_id = excluded.account_id,
+       revoked_at = NULL`).run(key, input.sid, account_id, created_at);
+  return { key, sid: input.sid, account_id, created_at, revoked_at: null };
+}
+function revokeApiKey(db, key) {
+  db.prepare(`UPDATE api_keys SET revoked_at = ? WHERE key = ?`).run(nowIso(), key);
+}
+function resolveSidFromKey(db, token) {
+  const row = db.prepare(`SELECT key, sid, account_id, created_at, revoked_at
+         FROM api_keys
+        WHERE key = ? AND revoked_at IS NULL`).get(token);
+  if (!row)
+    return void 0;
+  return { sid: row.sid, account_id: row.account_id };
+}
+function looksLikeApiKey(token) {
+  return token.startsWith("sk_test_pome_") || token.startsWith("rk_test_pome_") || // Tolerate raw Stripe-style sk_test_* / rk_test_* in case a downstream
+  // user mints their own non-pome-prefixed test keys via the admin API.
+  token.startsWith("sk_test_") || token.startsWith("rk_test_");
+}
+
+// ../packages/twin-stripe/dist/src/domain/schema.js
+var STRIPE_TABLES_SQL = `
+CREATE TABLE IF NOT EXISTS payment_intents (
+  id TEXT PRIMARY KEY,
+  account_id TEXT NOT NULL,
+  amount INTEGER NOT NULL,
+  currency TEXT NOT NULL,
+  status TEXT NOT NULL,
+  payment_method_types_json TEXT NOT NULL,
+  next_action_json TEXT,
+  latest_charge_id TEXT,
+  capture_method TEXT NOT NULL DEFAULT 'automatic',
+  confirmation_method TEXT NOT NULL DEFAULT 'automatic',
+  idempotency_key TEXT,
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  crypto_deposit_json TEXT,
+  client_secret TEXT NOT NULL,
+  created INTEGER NOT NULL,
+  updated INTEGER NOT NULL,
+  canceled_at INTEGER,
+  captured_at INTEGER,
+  payment_method_id TEXT,
+  customer_id TEXT,
+  last_payment_error_json TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_payment_intents_created ON payment_intents(created);
+CREATE INDEX IF NOT EXISTS idx_payment_intents_status ON payment_intents(status);
+CREATE INDEX IF NOT EXISTS idx_payment_intents_account_id ON payment_intents(account_id);
+
+CREATE TABLE IF NOT EXISTS charges (
+  id TEXT PRIMARY KEY,
+  account_id TEXT NOT NULL,
+  payment_intent_id TEXT NOT NULL,
+  amount INTEGER NOT NULL,
+  amount_captured INTEGER NOT NULL DEFAULT 0,
+  amount_refunded INTEGER NOT NULL DEFAULT 0,
+  status TEXT NOT NULL,
+  balance_transaction_id TEXT,
+  captured INTEGER NOT NULL DEFAULT 0,
+  currency TEXT NOT NULL,
+  created INTEGER NOT NULL,
+  payment_method_id TEXT,
+  payment_method_details_json TEXT,
+  failure_code TEXT,
+  failure_decline_code TEXT,
+  failure_message TEXT,
+  customer_id TEXT,
+  FOREIGN KEY (payment_intent_id) REFERENCES payment_intents(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_charges_pi ON charges(payment_intent_id);
+CREATE INDEX IF NOT EXISTS idx_charges_created ON charges(created);
+CREATE INDEX IF NOT EXISTS idx_charges_account_id ON charges(account_id);
+
+CREATE TABLE IF NOT EXISTS balance_transactions (
+  id TEXT PRIMARY KEY,
+  account_id TEXT NOT NULL,
+  type TEXT NOT NULL,
+  amount INTEGER NOT NULL,
+  fee INTEGER NOT NULL DEFAULT 0,
+  net INTEGER NOT NULL,
+  currency TEXT NOT NULL,
+  source_id TEXT,
+  source_type TEXT,
+  available_on INTEGER NOT NULL,
+  status TEXT NOT NULL DEFAULT 'available',
+  created INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_balance_tx_created ON balance_transactions(created);
+CREATE INDEX IF NOT EXISTS idx_balance_tx_source ON balance_transactions(source_id);
+CREATE INDEX IF NOT EXISTS idx_balance_tx_account_id ON balance_transactions(account_id);
+
+CREATE TABLE IF NOT EXISTS events (
+  id TEXT PRIMARY KEY,
+  account_id TEXT NOT NULL,
+  type TEXT NOT NULL,
+  data_json TEXT NOT NULL,
+  request_idempotency_key TEXT,
+  livemode INTEGER NOT NULL DEFAULT 0,
+  api_version TEXT NOT NULL,
+  created INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_events_type ON events(type);
+CREATE INDEX IF NOT EXISTS idx_events_created ON events(created);
+CREATE INDEX IF NOT EXISTS idx_events_account_id ON events(account_id);
+
+CREATE TABLE IF NOT EXISTS refunds (
+  id TEXT PRIMARY KEY,
+  account_id TEXT NOT NULL,
+  charge_id TEXT NOT NULL,
+  payment_intent_id TEXT NOT NULL,
+  amount INTEGER NOT NULL,
+  currency TEXT NOT NULL,
+  status TEXT NOT NULL,
+  reason TEXT,
+  balance_transaction_id TEXT,
+  idempotency_key TEXT,
+  created INTEGER NOT NULL,
+  FOREIGN KEY (charge_id) REFERENCES charges(id) ON DELETE CASCADE
+);
+
+CREATE INDEX IF NOT EXISTS idx_refunds_charge ON refunds(charge_id);
+CREATE INDEX IF NOT EXISTS idx_refunds_payment_intent ON refunds(payment_intent_id);
+CREATE INDEX IF NOT EXISTS idx_refunds_created ON refunds(created);
+CREATE INDEX IF NOT EXISTS idx_refunds_account_id ON refunds(account_id);
+
+CREATE TABLE IF NOT EXISTS customers (
+  id TEXT PRIMARY KEY,
+  account_id TEXT NOT NULL,
+  name TEXT,
+  email TEXT,
+  description TEXT,
+  phone TEXT,
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  deleted INTEGER NOT NULL DEFAULT 0,
+  created INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_customers_created ON customers(created);
+CREATE INDEX IF NOT EXISTS idx_customers_email ON customers(email);
+CREATE INDEX IF NOT EXISTS idx_customers_account_id ON customers(account_id);
+
+CREATE TABLE IF NOT EXISTS payment_methods (
+  id TEXT PRIMARY KEY,
+  account_id TEXT NOT NULL,
+  type TEXT NOT NULL,
+  card_brand TEXT NOT NULL,
+  card_last4 TEXT NOT NULL,
+  card_exp_month INTEGER NOT NULL,
+  card_exp_year INTEGER NOT NULL,
+  card_fingerprint TEXT NOT NULL,
+  customer_id TEXT,
+  detached INTEGER NOT NULL DEFAULT 0,
+  created INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_payment_methods_customer ON payment_methods(customer_id);
+CREATE INDEX IF NOT EXISTS idx_payment_methods_created ON payment_methods(created);
+CREATE INDEX IF NOT EXISTS idx_payment_methods_account_id ON payment_methods(account_id);
+
+-- Billing tables (warm surfaces, shape tier): plain stored rows served
+-- back in Stripe shape. No invoices table \u2014 invoices are reads-only and
+-- nothing in the twin mints one (loud shape divergence, see FIDELITY.md).
+
+CREATE TABLE IF NOT EXISTS products (
+  id TEXT PRIMARY KEY,
+  account_id TEXT NOT NULL,
+  name TEXT NOT NULL,
+  description TEXT,
+  active INTEGER NOT NULL DEFAULT 1,
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  created INTEGER NOT NULL,
+  updated INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_products_created ON products(created);
+CREATE INDEX IF NOT EXISTS idx_products_account_id ON products(account_id);
+
+CREATE TABLE IF NOT EXISTS prices (
+  id TEXT PRIMARY KEY,
+  account_id TEXT NOT NULL,
+  product_id TEXT NOT NULL,
+  currency TEXT NOT NULL,
+  unit_amount INTEGER,
+  recurring_interval TEXT,
+  recurring_interval_count INTEGER,
+  active INTEGER NOT NULL DEFAULT 1,
+  nickname TEXT,
+  lookup_key TEXT,
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  created INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_prices_created ON prices(created);
+CREATE INDEX IF NOT EXISTS idx_prices_product ON prices(product_id);
+CREATE INDEX IF NOT EXISTS idx_prices_account_id ON prices(account_id);
+
+CREATE TABLE IF NOT EXISTS subscriptions (
+  id TEXT PRIMARY KEY,
+  account_id TEXT NOT NULL,
+  customer_id TEXT NOT NULL,
+  status TEXT NOT NULL,
+  items_json TEXT NOT NULL,
+  cancel_at_period_end INTEGER NOT NULL DEFAULT 0,
+  canceled_at INTEGER,
+  ended_at INTEGER,
+  metadata_json TEXT NOT NULL DEFAULT '{}',
+  created INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_subscriptions_created ON subscriptions(created);
+CREATE INDEX IF NOT EXISTS idx_subscriptions_customer ON subscriptions(customer_id);
+CREATE INDEX IF NOT EXISTS idx_subscriptions_account_id ON subscriptions(account_id);
+`;
+var STRIPE_TABLES = [
+  "refunds",
+  "events",
+  "balance_transactions",
+  "charges",
+  "payment_intents",
+  "payment_methods",
+  "customers",
+  "subscriptions",
+  "prices",
+  "products"
+];
+function ensureStripeTables(db) {
+  db.pragma("busy_timeout = 5000");
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  db.exec(STRIPE_TABLES_SQL);
+  ensureMigratedColumns(db);
+}
+var MIGRATED_COLUMNS = {
+  payment_intents: [
+    ["payment_method_id", "payment_method_id TEXT"],
+    ["customer_id", "customer_id TEXT"],
+    ["last_payment_error_json", "last_payment_error_json TEXT"]
+  ],
+  charges: [
+    ["payment_method_id", "payment_method_id TEXT"],
+    ["payment_method_details_json", "payment_method_details_json TEXT"],
+    ["failure_code", "failure_code TEXT"],
+    ["failure_decline_code", "failure_decline_code TEXT"],
+    ["failure_message", "failure_message TEXT"],
+    ["customer_id", "customer_id TEXT"]
+  ],
+  refunds: [["balance_transaction_id", "balance_transaction_id TEXT"]]
+};
+function ensureMigratedColumns(db) {
+  for (const [table, columns] of Object.entries(MIGRATED_COLUMNS)) {
+    const existing = new Set(db.prepare(`SELECT name FROM pragma_table_info(?)`).all(table).map((row) => row.name));
+    if (existing.size === 0)
+      continue;
+    for (const [column, ddl] of columns) {
+      if (!existing.has(column))
+        db.exec(`ALTER TABLE ${table} ADD COLUMN ${ddl};`);
+    }
+  }
+}
+function resetStripeTables(db) {
+  for (const table of STRIPE_TABLES) {
+    db.exec(`DELETE FROM ${table};`);
+  }
+}
+
+// ../packages/twin-stripe/dist/src/seed.js
+var DEFAULT_SID = "default";
+var DEFAULT_API_KEY = "sk_test_pome_default";
+var PI_STATUSES = [
+  "requires_payment_method",
+  "requires_confirmation",
+  "requires_action",
+  "processing",
+  "requires_capture",
+  "canceled",
+  "succeeded"
+];
+var CHARGE_STATUSES = ["pending", "succeeded", "failed"];
+var REFUND_STATUSES = ["succeeded", "pending", "failed", "canceled"];
+var BALANCE_TX_STATUSES = ["pending", "available"];
+var paymentIntentSeedSchema = z.object({
+  id: z.string().min(1),
+  account_id: z.string().min(1),
+  amount: z.number().int(),
+  currency: z.string().min(1),
+  status: z.enum(PI_STATUSES),
+  payment_method_types: z.array(z.string()).default(["crypto"]),
+  next_action: z.unknown().nullable().optional(),
+  latest_charge_id: z.string().nullable().optional(),
+  capture_method: z.string().default("automatic"),
+  confirmation_method: z.string().default("automatic"),
+  idempotency_key: z.string().nullable().optional(),
+  metadata: z.record(z.string(), z.string()).default({}),
+  crypto_deposit: z.unknown().nullable().optional(),
+  client_secret: z.string().min(1),
+  created: z.number().int(),
+  updated: z.number().int(),
+  canceled_at: z.number().int().nullable().optional(),
+  captured_at: z.number().int().nullable().optional()
+});
+var chargeSeedSchema = z.object({
+  id: z.string().min(1),
+  account_id: z.string().min(1),
+  payment_intent_id: z.string().min(1),
+  amount: z.number().int(),
+  amount_captured: z.number().int().default(0),
+  amount_refunded: z.number().int().default(0),
+  status: z.enum(CHARGE_STATUSES),
+  balance_transaction_id: z.string().nullable().optional(),
+  captured: z.boolean().default(true),
+  currency: z.string().min(1),
+  created: z.number().int()
+});
+var refundSeedSchema = z.object({
+  id: z.string().min(1),
+  account_id: z.string().min(1),
+  charge_id: z.string().min(1),
+  payment_intent_id: z.string().min(1),
+  amount: z.number().int(),
+  currency: z.string().min(1),
+  status: z.enum(REFUND_STATUSES),
+  reason: z.string().nullable().optional(),
+  balance_transaction_id: z.string().nullable().optional(),
+  idempotency_key: z.string().nullable().optional(),
+  created: z.number().int()
+});
+var balanceTransactionSeedSchema = z.object({
+  id: z.string().min(1),
+  account_id: z.string().min(1),
+  type: z.string().min(1),
+  amount: z.number().int(),
+  fee: z.number().int().default(0),
+  net: z.number().int(),
+  currency: z.string().min(1),
+  source_id: z.string().nullable().optional(),
+  source_type: z.string().nullable().optional(),
+  available_on: z.number().int(),
+  status: z.enum(BALANCE_TX_STATUSES).default("available"),
+  created: z.number().int()
+});
+var seedSchema = z.object({
+  api_keys: z.array(z.object({
+    key: z.string().min(1),
+    sid: z.string().min(1),
+    account_id: z.string().min(1).optional()
+  })).default([]),
+  failure_injection: z.array(failureInjectionRuleSchema).default([]),
+  payment_intents: z.array(paymentIntentSeedSchema).default([]),
+  charges: z.array(chargeSeedSchema).default([]),
+  refunds: z.array(refundSeedSchema).default([]),
+  balance_transactions: z.array(balanceTransactionSeedSchema).default([])
+});
+function parseSeed(input) {
+  return seedSchema.parse(input);
+}
+function loadSeedFromEnv(env = process.env) {
+  const raw = env.POME_SEED_JSON;
+  if (raw === void 0 || raw === "") {
+    return defaultSeed();
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`POME_SEED_JSON is not valid JSON: ${err.message}`);
+  }
+  const unwrapped = unwrapStripeSeed(parsed);
+  return parseSeed(unwrapped);
+}
+function unwrapStripeSeed(value) {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const stripeKey = value.stripe;
+    if (stripeKey && typeof stripeKey === "object" && !Array.isArray(stripeKey)) {
+      const inner = stripeKey.seed;
+      if (inner !== void 0) {
+        return inner;
+      }
+    }
+  }
+  return value;
+}
+function defaultSeed() {
+  return {
+    api_keys: [
+      { key: DEFAULT_API_KEY, sid: DEFAULT_SID, account_id: `acct_${DEFAULT_SID}` }
+    ],
+    failure_injection: [],
+    payment_intents: [],
+    charges: [],
+    refunds: [],
+    balance_transactions: []
+  };
+}
+function applySeed(db, seed, failureInjection) {
+  ensureStripeTables(db);
+  for (const entry of seed.api_keys ?? []) {
+    mintApiKey(db, {
+      sid: entry.sid,
+      account_id: entry.account_id,
+      key: entry.key
+    });
+  }
+  for (const row of seed.payment_intents ?? []) {
+    insertSeedPaymentIntent(db, row);
+  }
+  for (const row of seed.charges ?? []) {
+    insertSeedCharge(db, row);
+  }
+  for (const row of seed.balance_transactions ?? []) {
+    insertSeedBalanceTransaction(db, row);
+  }
+  for (const row of seed.refunds ?? []) {
+    insertSeedRefund(db, row);
+  }
+  if (failureInjection) {
+    failureInjection.setRules(seed.failure_injection ?? []);
+  }
+}
+function insertSeedPaymentIntent(db, row) {
+  db.prepare(`INSERT INTO payment_intents (
+      id, account_id, amount, currency, status,
+      payment_method_types_json, next_action_json,
+      latest_charge_id, capture_method, confirmation_method,
+      idempotency_key, metadata_json, crypto_deposit_json,
+      client_secret, created, updated, canceled_at, captured_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(row.id, row.account_id, row.amount, row.currency, row.status, JSON.stringify(row.payment_method_types), row.next_action === void 0 || row.next_action === null ? null : JSON.stringify(row.next_action), row.latest_charge_id ?? null, row.capture_method, row.confirmation_method, row.idempotency_key ?? null, JSON.stringify(row.metadata), row.crypto_deposit === void 0 || row.crypto_deposit === null ? null : JSON.stringify(row.crypto_deposit), row.client_secret, row.created, row.updated, row.canceled_at ?? null, row.captured_at ?? null);
+}
+function insertSeedCharge(db, row) {
+  db.prepare(`INSERT INTO charges (
+      id, account_id, payment_intent_id, amount, amount_captured, amount_refunded,
+      status, balance_transaction_id, captured, currency, created
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(row.id, row.account_id, row.payment_intent_id, row.amount, row.amount_captured, row.amount_refunded, row.status, row.balance_transaction_id ?? null, row.captured ? 1 : 0, row.currency, row.created);
+}
+function insertSeedRefund(db, row) {
+  db.prepare(`INSERT INTO refunds (
+      id, account_id, charge_id, payment_intent_id, amount, currency,
+      status, reason, balance_transaction_id, idempotency_key, created
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(row.id, row.account_id, row.charge_id, row.payment_intent_id, row.amount, row.currency, row.status, row.reason ?? null, row.balance_transaction_id ?? null, row.idempotency_key ?? null, row.created);
+}
+function insertSeedBalanceTransaction(db, row) {
+  db.prepare(`INSERT INTO balance_transactions (
+      id, account_id, type, amount, fee, net, currency, source_id, source_type,
+      available_on, status, created
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(row.id, row.account_id, row.type, row.amount, row.fee, row.net, row.currency, row.source_id ?? null, row.source_type ?? null, row.available_on, row.status, row.created);
+}
+
+export { DEFAULT_API_KEY, DEFAULT_SID, applySeed, defaultSeed, ensureMigratedColumns, ensureStripeTables, loadSeedFromEnv, looksLikeApiKey, mintApiKey, newClientSecret, newId, nowIso, nowUnix, parseSeed, requestId, resetStripeTables, resolveSidFromKey, revokeApiKey, seedSchema };

package/dist/chunk-ZDS25NS5.js

@@ -0,0 +1,141 @@
+import { z } from 'zod';
+
+// ../packages/twin-slack/dist/src/seed.js
+var seedSchema = z.object({
+  team: z.object({
+    id: z.string().regex(/^T[A-Z0-9_]+$/).optional(),
+    name: z.string().default("Pome Twin Workspace"),
+    domain: z.string().default("pome-twin")
+  }).prefault({}),
+  users: z.array(z.object({
+    id: z.string().regex(/^[UB][A-Z0-9_]+$/).optional(),
+    name: z.string().min(1),
+    real_name: z.string().default(""),
+    email: z.string().email().optional(),
+    is_bot: z.boolean().default(false),
+    is_admin: z.boolean().default(false),
+    tz: z.string().default("America/Los_Angeles"),
+    profile: z.record(z.string(), z.unknown()).default({})
+  })).default([]),
+  channels: z.array(z.object({
+    id: z.string().regex(/^[CGDM][A-Z0-9_]+$/).optional(),
+    name: z.string().regex(/^[a-z0-9_-]{1,80}$/),
+    is_private: z.boolean().default(false),
+    topic: z.string().default(""),
+    purpose: z.string().default(""),
+    creator: z.string().optional(),
+    members: z.array(z.string()).default([]),
+    messages: z.array(z.object({
+      ts: z.string().optional(),
+      user: z.string(),
+      text: z.string(),
+      thread_ts: z.string().optional(),
+      reactions: z.array(z.object({ name: z.string(), user: z.string() })).default([])
+    })).default([])
+  })).default([]),
+  // Files present in the world before the agent runs. `user` and
+  // `channels` are seed HANDLES (a user/channel `name`) or ids — the same
+  // currency `channels[].members` and `channels[].messages[].user` already use.
+  files: z.array(z.object({
+    id: z.string().regex(/^F[A-Z0-9_]+$/).optional(),
+    name: z.string().min(1),
+    title: z.string().optional(),
+    filetype: z.string().min(1).default("text"),
+    user: z.string().optional(),
+    channels: z.array(z.string()).default([]),
+    content: z.string().optional()
+  })).default([]),
+  emoji: z.array(z.object({
+    name: z.string().regex(/^[a-z0-9_+-]{1,100}$/),
+    url: z.string().url().optional(),
+    alias: z.string().regex(/^[a-z0-9_+-]{1,100}$/).optional()
+  })).default([])
+});
+function parseSeed(input) {
+  return seedSchema.parse(input);
+}
+function loadSeedFromEnv(env = process.env) {
+  const raw = env.POME_SEED_JSON;
+  if (raw === void 0 || raw === "") {
+    return defaultSeedState();
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`POME_SEED_JSON is not valid JSON: ${err.message}`);
+  }
+  if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+    const obj = parsed;
+    if (obj.slack && typeof obj.slack === "object" && obj.slack !== null) {
+      const slack = obj.slack;
+      if ("seed" in slack) {
+        return parseSeed(slack.seed);
+      }
+    }
+  }
+  return parseSeed(parsed);
+}
+function defaultSeedState() {
+  return {
+    team: {
+      id: "T_POME",
+      name: "Pome Twin Workspace",
+      domain: "pome-twin"
+    },
+    users: [
+      {
+        id: "U_PRIMARY",
+        name: "pome-agent",
+        real_name: "Pome Agent",
+        email: "pome-agent@pome-twin.slack.com",
+        is_bot: false,
+        is_admin: true
+      },
+      {
+        id: "U_ALICE",
+        name: "alice",
+        real_name: "Alice",
+        email: "alice@pome-twin.slack.com"
+      },
+      {
+        id: "U_BOB",
+        name: "bob",
+        real_name: "Bob",
+        email: "bob@pome-twin.slack.com"
+      }
+    ],
+    channels: [
+      {
+        id: "C_GENERAL",
+        name: "general",
+        is_private: false,
+        topic: "Company-wide announcements and chatter.",
+        purpose: "This channel is for company-wide communication.",
+        creator: "U_PRIMARY",
+        members: ["U_PRIMARY", "U_ALICE", "U_BOB"],
+        messages: [
+          { user: "U_ALICE", text: "morning team" },
+          { user: "U_BOB", text: "morning :wave:" }
+        ]
+      },
+      {
+        id: "C_RANDOM",
+        name: "random",
+        is_private: false,
+        topic: "Non-work chatter and water cooler talk.",
+        purpose: "A place for non-work-related flimflam.",
+        creator: "U_PRIMARY",
+        members: [],
+        messages: []
+      }
+    ],
+    emoji: [
+      { name: "shipit", alias: "squirrel" },
+      { name: "squirrel" },
+      { name: "bowtie" }
+    ]
+  };
+}
+
+export { defaultSeedState, loadSeedFromEnv, parseSeed, seedSchema };

package/dist/{runDemo-XO5R5QTM.js → runDemo-O67ASC54.js}

@@ -1,19 +1,20 @@
 import { newGroupId, reassuranceBox, twinReadyLine, trialsHeaderLine, trialLine, summaryLines, evaluatingLine, criterionPhrase } from './chunk-RGZBC7NF.js';
 import { DemoCapacityError, capacityLabel, parseCapacityMarker, capacityKindFrom } from './chunk-ZX4WNSZ5.js';
-import { runTask, demoTaskPath, DEMO_TASK_NAME, DEMO_REPO } from './chunk-FQGR7KDT.js';
-import { getAvailablePort } from './chunk-XDU6TD4O.js';
-import './chunk-CBFKZZBR.js';
-import { createHostedClient, parseTaskFile, uploadRunBlobs, scoreFromFinalizeResponse, scoreStatus, outcomeOf } from './chunk-ANKO3RCB.js';
+import { runTask, demoTaskPath, DEMO_TASK_NAME, DEMO_REPO } from './chunk-N74LP4QH.js';
+import { createHostedClient, parseTaskFile, uploadRunBlobs, scoreFromFinalizeResponse, scoreStatus, outcomeOf } from './chunk-CTA54N4K.js';
 import './chunk-NW7HGA2K.js';
+import './chunk-3T5XN64P.js';
+import './chunk-G6GOCYIT.js';
+import { bootTwin } from './chunk-IK2F7ZA3.js';
+import './chunk-JE4H5ODK.js';
+import { getAvailablePort } from './chunk-XDU6TD4O.js';
 import { HostedQuotaError, HostedOrchError } from './chunk-BZO3YCJS.js';
-import './chunk-QXQAVKTE.js';
-import './chunk-NJ246QPJ.js';
-import './chunk-IZIZC7ZW.js';
-import { bootTwin } from './chunk-KIXYRPVY.js';
-import './chunk-EIUCTFQV.js';
-import './chunk-CFXEETE3.js';
+import './chunk-CBFKZZBR.js';
+import './chunk-HJX25USP.js';
+import './chunk-E665XWYU.js';
 import './chunk-6KJC4BTO.js';
 import './chunk-SG6ZTIMT.js';
+import './chunk-CF6EIU2U.js';
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { z } from 'zod';