@usefillo/cli 0.16.0 → 0.19.0

package/dist/index.js

@@ -182,10 +182,13 @@ var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   // (`--device` is the alias). Presence-only.
   "headless",
   "device",
-  // Workspace commands (storage/slack/delete): presence-only switches.
+  // Workspace commands (storage/slack/discord/delete): presence-only switches.
   "force-path-style",
   "channels",
   "refresh",
+  // `discord enable --auto-join`: widens a role grant so a non-member can be
+  // added to the server. Presence-only — it is never "=false".
+  "auto-join",
   "yes",
   "also-unpublish",
   "cancel"
@@ -292,8 +295,8 @@ async function startLoopbackServer() {
   let handler = null;
   let served = false;
   const server = createServer((req, res) => {
-    const respond = (status4, message) => {
-      res.statusCode = status4;
+    const respond = (status5, message) => {
+      res.statusCode = status5;
       res.setHeader("Content-Type", "text/html; charset=utf-8");
       res.setHeader("Cache-Control", "no-store");
       res.end(resultPage(message));
@@ -592,6 +595,11 @@ async function fetchWhoami(apiBase = API) {
   if (!workspace) die("Fillo returned an invalid workspace identity.");
   return {
     workspace,
+    ...typeof me.workspaceId === "string" ? { workspaceId: terminalText(me.workspaceId) } : {},
+    ...typeof me.workspaceSlug === "string" ? { workspaceSlug: terminalText(me.workspaceSlug) } : {},
+    ...typeof me.project === "string" ? { project: terminalText(me.project) } : {},
+    ...typeof me.projectId === "string" ? { projectId: terminalText(me.projectId) } : {},
+    ...typeof me.projectSlug === "string" ? { projectSlug: terminalText(me.projectSlug) } : {},
     canPublishFileFields: typeof me.canPublishFileFields === "boolean" ? me.canPublishFileFields : void 0
   };
 }
@@ -607,10 +615,15 @@ async function whoami(flags) {
     return emitResult({
       connected: true,
       workspace: me.workspace,
+      ...me.workspaceId ? { workspaceId: me.workspaceId } : {},
+      ...me.workspaceSlug ? { workspaceSlug: me.workspaceSlug } : {},
+      ...me.project ? { project: me.project } : {},
+      ...me.projectId ? { projectId: me.projectId } : {},
+      ...me.projectSlug ? { projectSlug: me.projectSlug } : {},
       ...me.canPublishFileFields === void 0 ? {} : { canPublishFileFields: me.canPublishFileFields }
     });
   }
-  printConnected(me.workspace);
+  printConnected(me.project ? `${me.workspace} / ${me.project}` : me.workspace);
   if (me.canPublishFileFields === true) {
     console.log(`  ${dim("File uploads: storage ready \u2014 a file field can publish now.")}`);
   } else if (me.canPublishFileFields === false) {
@@ -1153,7 +1166,7 @@ function installSkill(flags, opts = {}) {
   for (const target of targets) console.log(`  ${dim(target)}`);
   if (targets.length > 1) {
     console.log(
-      `  ${dim("Same bundle in both \u2014 cross-agent compatibility, not duplication.")}`
+      `  ${dim("Same bundle in both \u2014 cross-agent compatibility, not duplication (want one folder? --agent <name> or --dir <path>).")}`
     );
   }
   console.log(`
@@ -1294,21 +1307,21 @@ async function agent(subcommand, flags) {
     die("--account can only be used with `fillo agent bootstrap` or `fillo agent connect`.");
   }
   if (subcommand === "event") {
-    const status4 = enumFlag(flags, "status", AGENT_EVENT_STATUSES);
+    const status5 = enumFlag(flags, "status", AGENT_EVENT_STATUSES);
     const message = flagString(flags, "message");
-    if (!status4)
+    if (!status5)
       die('Usage: fillo agent event --status <status> --message "<what the human does next>"');
     const action = enumFlag(flags, "action", AGENT_ACTIONS);
     const formStatus = enumFlag(flags, "form-status", FORM_STATUSES);
     const formId = optionalStringFlag(flags, "form-id");
-    if ((status4 === "done" || status4 === "needs_action") && !formId) {
-      die(`--form-id is required when --status is ${status4}.`);
+    if ((status5 === "done" || status5 === "needs_action") && !formId) {
+      die(`--form-id is required when --status is ${status5}.`);
     }
-    if (status4 === "needs_action" && !action) {
+    if (status5 === "needs_action" && !action) {
       die("--action is required when --status is needs_action.");
     }
     await postAgentEvent(apiBase, run, token, {
-      status: status4,
+      status: status5,
       message,
       appUrl: flagString(flags, "app-url"),
       action,
@@ -1469,13 +1482,13 @@ async function claim(flags) {
   const grant = await readJson(codeRes);
   const emailFlag = flagString(flags, "email");
   const savedEmail = cfg.email;
-  const { approval, sentTo, notice } = await sendClaimEmail(
+  const { approval, sentTo, notice: notice2 } = await sendClaimEmail(
     grant,
     cfg.claimToken,
     emailFlag,
     savedEmail
   );
-  const alreadyClaimed = approval === "device" && notice === "already_claimed";
+  const alreadyClaimed = approval === "device" && notice2 === "already_claimed";
   if (json) {
     emitProgress({
       status: "awaiting_claim",
@@ -1483,11 +1496,11 @@ async function claim(flags) {
       ...sentTo ? { email: sentTo } : {},
       verification_uri: grant.verification_uri,
       approval,
-      ...notice ? { notice } : {},
+      ...notice2 ? { notice: notice2 } : {},
       note: AGENT_WAIT_LINE
     });
   } else {
-    printGuidance(grant, approval, sentTo, notice);
+    printGuidance(grant, approval, sentTo, notice2);
   }
   await pollForGrant(grant, cfg.pk, approval, alreadyClaimed, json);
 }
@@ -1535,10 +1548,10 @@ async function sendClaimEmail(grant, claimToken, emailFlag, savedEmail) {
   if (!res.ok) die(body.error ?? `Couldn't send the claim email (${res.status}).`);
   return { approval: "device", sentTo: email3 };
 }
-function printGuidance(grant, approval, sentTo, notice) {
-  if (notice === "already_claimed") {
+function printGuidance(grant, approval, sentTo, notice2) {
+  if (notice2 === "already_claimed") {
     console.log("\n  This workspace is already claimed.");
-  } else if (notice === "recent_email") {
+  } else if (notice2 === "recent_email") {
     console.log(
       `
   A claim email was already sent recently${sentTo ? ` to ${bold(terminalText(sentTo))}` : ""} \u2014 open that one.`
@@ -1552,7 +1565,7 @@ function printGuidance(grant, approval, sentTo, notice) {
   console.log(`
   Your code:  ${bold(grant.user_code)}
 `);
-  if (notice === "already_claimed") {
+  if (notice2 === "already_claimed") {
     console.log(`  Sign in at ${terminalText(grant.verification_uri)} and enter the code`);
     console.log("  to approve this terminal.");
   } else if (approval === "page") {
@@ -1612,11 +1625,11 @@ Claim failed: ${body.error}`);
       }
       if (!claimedAnnounced && Date.now() >= nextStatusAt) {
         nextStatusAt = Date.now() + statusEvery;
-        const status4 = await api(`/workspaces/claim-status?key=${encodeURIComponent(pk)}`).catch(
+        const status5 = await api(`/workspaces/claim-status?key=${encodeURIComponent(pk)}`).catch(
           () => null
         );
-        if (status4?.ok) {
-          const state = await status4.json().catch(() => ({}));
+        if (status5?.ok) {
+          const state = await status5.json().catch(() => ({}));
           if (state.claimed === true) {
             claimedAnnounced = true;
             if (json) {
@@ -1858,6 +1871,403 @@ var deleteCommand = {
   help: deleteHelp
 };
 
+// src/lib/browser-connect.ts
+var sleep3 = (ms) => new Promise((r) => setTimeout(r, ms));
+function pollIntervalMs2(fallback) {
+  const raw = process.env.FILLO_POLL_INTERVAL_MS;
+  if (raw === void 0 || raw === "") return fallback;
+  const value = Number(raw);
+  return Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+async function connectViaBrowser(opts) {
+  const interval = pollIntervalMs2(opts.intervalMs ?? 5e3);
+  const deadline = Date.now() + (opts.timeoutMs ?? 6e5);
+  const dots = !opts.json && !agentMode();
+  if (opts.json) {
+    emitProgress({
+      status: "awaiting_connect",
+      provider: opts.what,
+      url: opts.startUrl,
+      note: "Open the URL in your signed-in browser; this command waits. Do not retry in a loop."
+    });
+  } else {
+    console.log(`
+  Connect ${terminalText(opts.what)} in your signed-in browser:
+`);
+    console.log(`  ${terminalText(opts.startUrl)}
+`);
+    console.log("  Open in your signed-in browser and approve access \u2014 this command waits.");
+    if (agentMode()) {
+      console.log(
+        "  Do not retry in a loop; ask the human to complete the browser step. This command waits."
+      );
+    }
+  }
+  if (dots) process.stdout.write("  Waiting for the connection");
+  for (; ; ) {
+    let connected2 = false;
+    try {
+      connected2 = await opts.poll();
+    } catch {
+    }
+    if (connected2) {
+      const { result, lines } = opts.onConnected();
+      if (opts.json) {
+        emitProgress({ status: "connected" });
+        emitResult(result);
+        return;
+      }
+      if (dots) process.stdout.write("\n");
+      for (const line of lines) console.log(line);
+      return;
+    }
+    if (Date.now() >= deadline) break;
+    if (dots) process.stdout.write(".");
+    await sleep3(interval);
+  }
+  if (opts.json) {
+    emitResult({ connected: false, error: "timeout" });
+    process.exit(1);
+  }
+  if (dots) process.stdout.write("\n");
+  console.log(
+    `  Timed out waiting for ${terminalText(opts.what)} to connect. Finish the browser step, then re-run this command.`
+  );
+  process.exit(1);
+}
+
+// src/commands/discord.ts
+var WEBHOOK_URL_ENV = "FILLO_DISCORD_WEBHOOK_URL";
+var SNOWFLAKE = /^\d{17,20}$/;
+var EARLY_SIGNAL_CHOICES = ["5", "10", "25", "off"];
+function notice(json, line) {
+  if (json) emitProgress({ status: "notice", notice: line });
+  else console.log(`  ${line}`);
+}
+async function fetchConnection(token) {
+  const res = await api("/cli/discord", { token });
+  if (res.status === 401) die("Token invalid \u2014 run `fillo login` again.");
+  const body = await readJson(res);
+  if (!res.ok) die(body.error ?? `discord status failed (${res.status}).`);
+  return body;
+}
+async function fetchDestination(token, form) {
+  const res = await api(`/cli/forms/${encodeURIComponent(form)}/discord`, { token });
+  if (res.status === 401) die("Token invalid \u2014 run `fillo login` again.");
+  const body = await readJson(res);
+  if (res.status === 404) die(body.error ?? "Form not found in the selected project.");
+  if (!res.ok) die(body.error ?? `discord status failed (${res.status}).`);
+  return body;
+}
+async function putDestination(token, form, patch) {
+  const res = await api(`/cli/forms/${encodeURIComponent(form)}/discord`, {
+    method: "PUT",
+    token,
+    body: JSON.stringify(patch)
+  });
+  if (res.status === 401) die("Token invalid \u2014 run `fillo login` again.");
+  const body = await readJson(res);
+  if (res.status === 404) die(body.error ?? "Form not found in the selected project.");
+  if (!res.ok) die(body.error ?? `discord update failed (${res.status}).`);
+  return body;
+}
+async function projectId(token) {
+  const res = await api("/cli/whoami", { token });
+  const body = await readJson(res);
+  if (res.status === 401) die("Token invalid \u2014 run `fillo login` again.");
+  if (!res.ok || typeof body.projectId !== "string" || !body.projectId) {
+    die(body.error ?? "Couldn't resolve the selected Fillo project.");
+  }
+  return body.projectId;
+}
+async function connect(flags) {
+  const json = jsonMode(flags);
+  const token = requireToken();
+  const connection = await fetchConnection(token);
+  if (!connection.appConfigured) {
+    die(
+      "This Fillo deployment has no Discord app, so there's no one-click channel picker. Run `fillo discord webhook` to paste a channel webhook URL instead."
+    );
+  }
+  const startUrl = `${API}/api/integrations/discord/start?return=terminal&project=${encodeURIComponent(
+    await projectId(token)
+  )}`;
+  let connected2 = null;
+  await connectViaBrowser({
+    json,
+    what: "Discord",
+    startUrl,
+    poll: async () => {
+      const snapshot = await fetchConnection(token);
+      connected2 = snapshot;
+      return snapshot.connected === true;
+    },
+    onConnected: () => {
+      const label = connected2?.channelLabel ?? null;
+      return {
+        result: {
+          connected: true,
+          webhookId: connected2?.webhookId ?? null,
+          channelLabel: label
+        },
+        lines: [
+          `  ${okMark()} Discord connected${label ? ` (${terminalText(label)})` : ""}.`,
+          "  Turn a form on with `fillo discord enable <form>`."
+        ]
+      };
+    }
+  });
+}
+async function webhook(flags) {
+  const json = jsonMode(flags);
+  const token = requireToken();
+  let url = process.env[WEBHOOK_URL_ENV]?.trim() ?? "";
+  if (!url) {
+    if (json || !isInteractive()) {
+      die(
+        `Set ${WEBHOOK_URL_ENV} to the channel webhook URL and re-run. It is never accepted as an argument \u2014 arguments land in shell history and \`ps\` output.`
+      );
+    }
+    url = await readSecret("  Discord webhook URL (hidden): ").catch(() => "");
+    if (!url) {
+      die(`No webhook URL entered. Paste it at the prompt, or set ${WEBHOOK_URL_ENV} and re-run.`);
+    }
+  }
+  const label = flagString(flags, "label");
+  const res = await api("/cli/discord/webhook", {
+    method: "POST",
+    token,
+    body: JSON.stringify({ url, ...label ? { label } : {} })
+  });
+  const body = await readJson(res);
+  if (res.status === 401) die("Token invalid \u2014 run `fillo login` again.");
+  if (!res.ok || !body.webhookId) die(body.error ?? `discord webhook failed (${res.status}).`);
+  if (json) return emitResult(body);
+  console.log(
+    `  ${okMark()} Connected Discord${body.label ? ` (${terminalText(body.label)})` : ""}.`
+  );
+  console.log("  Turn a form on with `fillo discord enable <form>`.");
+}
+function printDestination(body) {
+  if (!body.connected) {
+    console.log(
+      "  Discord is not connected to this project. Run `fillo discord connect` (or `fillo discord webhook` to paste a channel URL)."
+    );
+    return;
+  }
+  if (!body.enabled) {
+    console.log(
+      `  Discord is connected${body.connectionLabel ? ` (${terminalText(body.connectionLabel)})` : ""} but this form isn't sending. Turn it on with \`fillo discord enable <form>\`.`
+    );
+    return;
+  }
+  console.log(
+    `  ${okMark()} Sending to Discord${body.channelLabel ? ` \u2014 ${terminalText(body.channelLabel)}` : ""}`
+  );
+  const fields = body.includedFieldIds ?? [];
+  console.log(
+    `  ${dim("Fields:")}        ${fields.length > 0 ? terminalText(fields.join(", ")) : "link only"}`
+  );
+  console.log(
+    `  ${dim("Early signal:")}  ${body.earlySignalLimit ? `first ${body.earlySignalLimit} responses in full (${body.earlySignalDelivered} sent)` : "off"}`
+  );
+  const grant = body.roleGrant;
+  console.log(
+    `  ${dim("Role grant:")}    ${grant ? `${terminalText(grant.roleId)} in ${terminalText(grant.guildId)}${grant.autoJoin ? " (auto-join)" : ""}` : "off"}`
+  );
+  if (!body.webhookMatches) {
+    console.log(
+      `
+  ${bold("This form points at a different webhook than the project does.")} It keeps failing until you re-run \`fillo discord enable <form>\`.`
+    );
+  }
+}
+async function status(form, flags) {
+  if (!form) die("Usage: fillo discord status <form> \u2014 a form id, slug, or push handle.");
+  const body = await fetchDestination(requireToken(), form);
+  if (jsonMode(flags)) return emitResult(body);
+  printDestination(body);
+}
+function parseFields(raw) {
+  if (raw.trim().toLowerCase() === "none") return [];
+  return raw.split(",").map((id) => id.trim()).filter(Boolean);
+}
+function parseRole(raw) {
+  if (raw.trim().toLowerCase() === "none") return null;
+  const [guildId, roleId, ...extra] = raw.trim().split("/");
+  if (extra.length > 0 || !guildId || !roleId || !SNOWFLAKE.test(guildId) || !SNOWFLAKE.test(roleId)) {
+    die(
+      "--role must be <guildId>/<roleId> (Discord ids), or none to clear it. List them with `fillo discord roles [guildId]`."
+    );
+  }
+  return { guildId, roleId };
+}
+async function enable(form, flags) {
+  const json = jsonMode(flags);
+  if (!form)
+    die("Usage: fillo discord enable <form> [--fields a,b,c] [--early-signal 5|10|25|off]");
+  const token = requireToken();
+  const current = await fetchDestination(token, form);
+  if (!current.connected || !current.connectionWebhookId) {
+    die(
+      "Discord isn't connected to this project. Run `fillo discord connect`, or `fillo discord webhook` to paste a channel URL."
+    );
+  }
+  const patch = {};
+  if (!current.enabled || !current.webhookMatches) {
+    patch.enabled = true;
+    patch.webhookId = current.connectionWebhookId;
+  }
+  const rawFields = flagString(flags, "fields");
+  if (rawFields !== void 0) patch.includeFieldIds = parseFields(rawFields);
+  const rawEarly = flagString(flags, "early-signal");
+  if (rawEarly !== void 0) {
+    if (!EARLY_SIGNAL_CHOICES.includes(rawEarly)) {
+      die(`--early-signal must be one of: ${EARLY_SIGNAL_CHOICES.join(", ")}`);
+    }
+    patch.earlySignalLimit = rawEarly === "off" ? null : Number(rawEarly);
+  }
+  const rawRole = flagString(flags, "role");
+  const autoJoin = flags["auto-join"] === true;
+  if (rawRole !== void 0) {
+    const grant = parseRole(rawRole);
+    patch.roleGrant = grant ? { ...grant, ...autoJoin ? { autoJoin: true } : {} } : null;
+  } else if (autoJoin) {
+    die(
+      "--auto-join needs --role <guildId>/<roleId> \u2014 it widens that grant, it isn't a setting on its own."
+    );
+  }
+  if (Object.keys(patch).length === 0) {
+    if (json) return emitResult(current);
+    printDestination(current);
+    return;
+  }
+  if (typeof patch.earlySignalLimit === "number") {
+    notice(
+      json,
+      `Early signal sends every answer to this channel for the first ${patch.earlySignalLimit} responses.`
+    );
+  }
+  if (patch.roleGrant && autoJoin) {
+    notice(
+      json,
+      "Auto-join adds respondents to your Discord server with that role \u2014 Discord asks each person's permission first."
+    );
+  } else if (patch.roleGrant) {
+    notice(
+      json,
+      "Respondents who verify with Discord get that role once their response is accepted."
+    );
+  }
+  const body = await putDestination(token, form, patch);
+  if (json) return emitResult(body);
+  printDestination(body);
+}
+async function disable(form, flags) {
+  if (!form) die("Usage: fillo discord disable <form> \u2014 a form id, slug, or push handle.");
+  const token = requireToken();
+  const body = await putDestination(token, form, { enabled: false });
+  if (jsonMode(flags)) return emitResult(body);
+  console.log(
+    `  ${okMark()} This form no longer posts to Discord. The workspace's webhook stays connected.`
+  );
+}
+async function roles(guildId, flags) {
+  const json = jsonMode(flags);
+  const token = requireToken();
+  const path = guildId ? `/cli/discord/roles?guildId=${encodeURIComponent(guildId)}` : "/cli/discord/roles";
+  const res = await api(path, { token });
+  if (res.status === 401) die("Token invalid \u2014 run `fillo login` again.");
+  const body = await readJson(res);
+  if (!res.ok) die(body.error ?? `discord roles failed (${res.status}).`);
+  if (json) return emitResult(body);
+  if (!guildId) {
+    const guilds = body.guilds ?? [];
+    if (guilds.length === 0) {
+      console.log(
+        "  No Discord servers yet \u2014 connect a channel webhook first with `fillo discord connect`."
+      );
+      return;
+    }
+    console.log("");
+    printTable(
+      ["SERVER", "ID"],
+      guilds.map((guild) => [terminalText(guild.name ?? "(name unavailable)"), guild.id])
+    );
+    if (body.guildsUnavailable === true) {
+      console.log(
+        `
+  ${dim("Discord didn't answer, so some names are missing. Ids still work.")}`
+      );
+    }
+    console.log(`
+  ${dim("List a server's roles: fillo discord roles <id>")}`);
+    return;
+  }
+  const list5 = body.roles ?? [];
+  if (list5.length === 0) {
+    console.log("  That server has no roles Fillo could list.");
+    return;
+  }
+  console.log("");
+  printTable(
+    ["ROLE", "ID", "GRANTABLE"],
+    list5.map((role) => [terminalText(role.name), role.id, role.grantable ? "yes" : "no"])
+  );
+  console.log(`
+  ${dim(`Use one: fillo discord enable <form> --role ${guildId}/<roleId>`)}`);
+  console.log(
+    `  ${dim("A role marked no sits above Fillo's own role, or belongs to another integration.")}`
+  );
+}
+async function discord(subcommand, args, flags) {
+  if (subcommand === void 0 || subcommand === "help") return discordHelp();
+  if (subcommand === "connect") return connect(flags);
+  if (subcommand === "webhook") return webhook(flags);
+  if (subcommand === "status") return status(args[0], flags);
+  if (subcommand === "enable") return enable(args[0], flags);
+  if (subcommand === "disable") return disable(args[0], flags);
+  if (subcommand === "roles") return roles(args[0], flags);
+  die(
+    `Unknown discord command: ${terminalText(subcommand)} (expected connect, webhook, status, enable, disable, or roles).`
+  );
+}
+function discordHelp() {
+  console.log(`
+  ${boldRaw("fillo discord")} \u2014 post responses to a Discord channel, from the terminal
+
+  ${boldRaw("Commands")}
+    discord connect          Let Discord pick the channel and create the webhook
+                       ${dimRaw("opens an OAuth URL to approve; needs a Discord app on this deploy")}
+    discord webhook          Connect a channel webhook you paste
+                       ${dimRaw("--label <name>   what Fillo shows for this channel")}
+                       ${dimRaw(`reads the URL from a hidden prompt, or ${WEBHOOK_URL_ENV}`)}
+    discord status <form>    What this form sends, to where, with which extras
+    discord enable <form>    Start sending \u2014 and set any of the options below
+                       ${dimRaw("--fields a,b,c            up to three field ids (none = link only)")}
+                       ${dimRaw("--early-signal 5|10|25    first N responses arrive in full (off to stop)")}
+                       ${dimRaw("--role <guildId>/<roleId> grant that role on an accepted response")}
+                       ${dimRaw("--auto-join               with --role: add non-members to the server")}
+    discord disable <form>   Stop this form posting (the webhook stays connected)
+    discord roles [guildId]  Your servers, or one server's roles and what Fillo can grant
+
+  ${dimRaw("The webhook URL is the whole credential, so it is NEVER an argument \u2014")}
+  ${dimRaw("arguments land in shell history and `ps` output. Paste it at the hidden")}
+  ${dimRaw(`prompt, or set ${WEBHOOK_URL_ENV} for an unattended run.`)}
+  ${dimRaw("--early-signal and --auto-join widen what leaves Fillo, so each prints a")}
+  ${dimRaw("one-line notice saying what was agreed to. Ask the human before setting them.")}
+  ${dimRaw("Re-enabling against a different webhook clears early signal \u2014 that consent")}
+  ${dimRaw("was given for one channel and is never carried into another.")}
+  ${dimRaw("--json prints the raw server response on stdout.")}
+`);
+}
+var discordCommand = {
+  name: "discord",
+  flags: ["label", "fields", "early-signal", "role", "auto-join"],
+  run: (args, flags) => discord(args[0], args.slice(1), flags),
+  help: discordHelp
+};
+
 // src/commands/forms.ts
 import { readFileSync as readFileSync3 } from "fs";
 import { isAbsolute as isAbsolute2, resolve as resolve3 } from "path";
@@ -3258,6 +3668,48 @@ function sortForPicker(countries) {
   return [...countries].sort((a, b) => collator.compare(a.name, b.name));
 }
 var byIso = new Map(PHONE_COUNTRIES.map((c) => [c.iso2, c]));
+var DEFAULT_STRINGS = {
+  back: "Back",
+  next: "Next",
+  submit: "Submit",
+  submitting: "Submitting\u2026",
+  uploading: "Uploading\u2026",
+  optional: " (optional)",
+  other: "Other",
+  otherPrompt: "Other \u2014 please specify",
+  otherPlaceholder: "Your answer",
+  choosePlaceholder: "Choose\u2026",
+  successTitle: "Thanks!",
+  successMessage: "Your response has been recorded.",
+  closed: "This form is no longer accepting responses.",
+  notLive: "This form isn't live yet.",
+  notOpenTitle: "This form isn't open yet",
+  notOpenBody: "The form owner is still setting things up. Please check back soon.",
+  closedTitle: "Responses are closed",
+  submitFailed: "This form can't submit right now. Please try again in a moment.",
+  loadFailedNotFound: "Form not found. Check the link or ask the form owner for help.",
+  loadFailedNetwork: "Couldn't reach the server \u2014 check your connection and try again.",
+  loadFailed: "This form could not be loaded.",
+  renderFailed: "This form could not be rendered.",
+  resumeNotice: "Picked up where you left off.",
+  editNotice: "You're updating your earlier response.",
+  resumeStartOver: "Start over",
+  challengeUnavailable: "The verification check couldn't load. Refresh the page and try again."
+};
+var DEFAULT_RESPONDENT_ERROR_STRINGS = {
+  submitFailed: DEFAULT_STRINGS.submitFailed,
+  loadFailedNotFound: DEFAULT_STRINGS.loadFailedNotFound,
+  loadFailedNetwork: DEFAULT_STRINGS.loadFailedNetwork,
+  formUnavailable: "This form is unavailable.",
+  formClosed: DEFAULT_STRINGS.closed,
+  submitRateLimited: "Too many responses are being submitted right now. Wait a moment, then try again.",
+  respondentUnrecognized: "This form couldn't verify who is responding. Ask the form owner for help.",
+  fileUnavailable: "One of the uploaded files is no longer available. Remove it and upload it again.",
+  scopeMissing: "We couldn't tell which entry this response belongs to. Answer the required field and try again.",
+  challengeIncomplete: "Please complete the verification check, then submit.",
+  challengeRetry: "That verification didn't go through. Please complete the check again and resubmit.",
+  reviewAnswers: "We couldn't submit \u2014 please review your answers."
+};
 var fileValueSchema = object({
   fileId: string2().check(_minLength(1)),
   name: string2(),
@@ -3322,7 +3774,7 @@ var schemaShape = object({
 });
 var MAX_SCHEMA_VERSION = 1;
 var FILLO_SCHEMA_VERSION = 1;
-var FILLO_SDK_VERSION = true ? "0.14.0" : "0.0.0-dev";
+var FILLO_SDK_VERSION = true ? "0.19.0" : "0.0.0-dev";
 function str(value, max, fallback = "") {
   return typeof value === "string" ? value.trim().slice(0, max) : fallback;
 }
@@ -4183,7 +4635,7 @@ async function list(flags) {
   }
 }
 var liveDot = () => ansiEnabled() ? "\x1B[32m\u25CF\x1B[0m" : "\u25CF";
-async function status(handle, flags) {
+async function status2(handle, flags) {
   if (!handle) die("Usage: fillo status <formId|handle>");
   const res = await api(`/cli/forms/${encodeURIComponent(handle)}`, { token: requireToken() });
   if (res.status === 401) die("Token invalid \u2014 run `fillo login` again.");
@@ -4395,6 +4847,7 @@ async function loadSchema(file, allowCode) {
     die(`Couldn't read ${file}: ${e.message}`);
   }
 }
+var PUSH_STORAGE_VALUES = /* @__PURE__ */ new Set(["gdrive", "box", "s3", "r2"]);
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -4404,7 +4857,19 @@ function toPushItems(value, handle) {
   return values.map((item, index) => {
     if (isRecord(item) && "schema" in item) {
       const ownHandle = typeof item.id === "string" ? item.id : void 0;
-      return { handle: handle ?? ownHandle, schema: item.schema, theme: item.theme };
+      if (item.storage !== void 0 && !PUSH_STORAGE_VALUES.has(String(item.storage))) {
+        die(`Item ${index + 1} has an unsupported storage destination.`);
+      }
+      if (item.purpose !== void 0 && item.purpose !== "file_request") {
+        die(`Item ${index + 1} has an unsupported form purpose.`);
+      }
+      return {
+        handle: handle ?? ownHandle,
+        schema: item.schema,
+        theme: item.theme,
+        ...typeof item.storage === "string" ? { storage: item.storage } : {},
+        ...item.purpose === "file_request" ? { purpose: item.purpose } : {}
+      };
     }
     if (values.length > 1 && !handle) {
       die(`Item ${index + 1} needs an id or --handle.`);
@@ -4414,9 +4879,9 @@ function toPushItems(value, handle) {
 }
 function printNotices(notices) {
   if (!Array.isArray(notices)) return;
-  for (const notice of notices) {
-    if (typeof notice === "string" && notice.trim()) {
-      console.log(`  ${bold("Note:")} ${terminalText(notice)}`);
+  for (const notice2 of notices) {
+    if (typeof notice2 === "string" && notice2.trim()) {
+      console.log(`  ${bold("Note:")} ${terminalText(notice2)}`);
     }
   }
 }
@@ -4501,7 +4966,9 @@ async function pushWithSync(items, credential, requestedStage, results) {
         ...credential.key ? { key: credential.key } : {},
         id: handle,
         schema: item.schema,
-        theme: item.theme ?? null
+        theme: item.theme ?? null,
+        ...item.storage ? { storage: item.storage } : {},
+        ...item.purpose ? { purpose: item.purpose } : {}
       })
     });
     const body = await readJson(res);
@@ -4566,6 +5033,8 @@ async function push(file, flags) {
           body: JSON.stringify({
             schema: item.schema,
             theme: item.theme ?? null,
+            ...item.storage ? { storage: item.storage } : {},
+            ...item.purpose ? { purpose: item.purpose } : {},
             publish: false
           })
         });
@@ -4593,6 +5062,8 @@ async function push(file, flags) {
           schema: item.schema,
           theme: item.theme ?? null,
           handle: item.handle,
+          ...item.storage ? { storage: item.storage } : {},
+          ...item.purpose ? { purpose: item.purpose } : {},
           publish: true
         })
       });
@@ -4608,11 +5079,16 @@ async function push(file, flags) {
         }
         die(body.error ?? `push failed (${res.status}).`);
       }
+      const draft = body.status === "draft";
       if (results) {
         results.push(body);
-        emitProgress({ status: "pushed", formId: body.formId, published: true });
+        emitProgress({
+          status: "pushed",
+          formId: body.formId,
+          ...draft ? { draft: true } : { published: true }
+        });
       } else {
-        printPushed(body.formId, body.url, !!body.updated, false, {
+        printPushed(body.formId, body.url, !!body.updated, draft, {
           warning: body.warning,
           warningUrl: body.warningUrl,
           notices: body.notices
@@ -4643,7 +5119,7 @@ var listCommand = {
 var statusCommand = {
   name: "status",
   flags: [],
-  run: (args, flags) => status(args[0], flags)
+  run: (args, flags) => status2(args[0], flags)
 };
 var publishCommand = {
   name: "publish",
@@ -4656,6 +5132,61 @@ var testResponseCommand = {
   run: (args) => testResponse(args[0], args[1])
 };
 
+// src/commands/branding.ts
+function printState(body) {
+  const plan = body.plan === "pro" ? "Everything" : "Free";
+  console.log(`  Plan:   ${plan}`);
+  console.log(`  Badge:  ${body.poweredBy ? "shown" : "hidden"}`);
+  if (body.canHide === false) {
+    console.log(dim("  Turning it off needs the Everything plan (Settings \u2192 Plan)."));
+  }
+}
+async function branding(subcommand, flags) {
+  if (subcommand === "help") return brandingHelp();
+  if (subcommand !== void 0 && subcommand !== "on" && subcommand !== "off") {
+    die(`Unknown branding command: ${subcommand} (expected on, off, or nothing for status).`);
+  }
+  const token = requireToken();
+  const res = subcommand === void 0 ? await api("/cli/workspace/branding", { token }) : await api("/cli/workspace/branding", {
+    method: "PATCH",
+    token,
+    body: JSON.stringify({ show: subcommand === "on" })
+  });
+  const body = await readJson(res);
+  if (res.status === 401) die("Token invalid \u2014 run `fillo login` again.");
+  if (!res.ok) die(body.error ?? `branding ${subcommand ?? "status"} failed (${res.status}).`);
+  if (jsonMode(flags)) return emitResult(body);
+  console.log("");
+  if (subcommand !== void 0) {
+    console.log(
+      `  ${okMark()} Badge ${body.poweredBy ? "shown" : "hidden"} on Fillo-rendered forms.
+`
+    );
+  }
+  printState(body);
+  console.log("");
+}
+function brandingHelp() {
+  console.log(`
+  ${boldRaw("fillo branding")} \u2014 the workspace's "Powered by Fillo" badge
+
+  ${boldRaw("Commands")}
+    branding           Print the current badge state
+    branding off       Hide the badge on Fillo-rendered forms (Everything plan)
+    branding on        Show the badge again
+
+  ${dimRaw("Hiding needs the Everything plan; a workspace owner or admin selects")}
+  ${dimRaw("that in Settings \u2192 Plan. Headless embeds never show a badge.")}
+  ${dimRaw("--json prints the raw server response on stdout.")}
+`);
+}
+var brandingCommand = {
+  name: "branding",
+  flags: [],
+  run: (args, flags) => branding(args[0], flags),
+  help: brandingHelp
+};
+
 // src/commands/keys.ts
 var PRESETS = ["read", "agent", "full"];
 var EXPIRY_CHOICES = ["30d", "90d", "never"];
@@ -4804,7 +5335,7 @@ async function keys(subcommand, args, flags) {
 }
 function keysHelp() {
   console.log(`
-  ${boldRaw("fillo keys")} \u2014 workspace API keys (fsk_) for coding agents and integrations
+  ${boldRaw("fillo keys")} \u2014 project API keys (fsk_) for coding agents and integrations
 
   ${boldRaw("Commands")}
     keys create --name <name>   Mint a key \u2014 the plaintext is shown once, store it
@@ -5244,73 +5775,16 @@ var settingsCommand = {
   help: settingsHelp
 };
 
-// src/lib/browser-connect.ts
-var sleep3 = (ms) => new Promise((r) => setTimeout(r, ms));
-function pollIntervalMs2(fallback) {
-  const raw = process.env.FILLO_POLL_INTERVAL_MS;
-  if (raw === void 0 || raw === "") return fallback;
-  const value = Number(raw);
-  return Number.isFinite(value) && value >= 0 ? value : fallback;
-}
-async function connectViaBrowser(opts) {
-  const interval = pollIntervalMs2(opts.intervalMs ?? 5e3);
-  const deadline = Date.now() + (opts.timeoutMs ?? 6e5);
-  const dots = !opts.json && !agentMode();
-  if (opts.json) {
-    emitProgress({
-      status: "awaiting_connect",
-      provider: opts.what,
-      url: opts.startUrl,
-      note: "Open the URL in your signed-in browser; this command waits. Do not retry in a loop."
-    });
-  } else {
-    console.log(`
-  Connect ${terminalText(opts.what)} in your signed-in browser:
-`);
-    console.log(`  ${terminalText(opts.startUrl)}
-`);
-    console.log("  Open in your signed-in browser and approve access \u2014 this command waits.");
-    if (agentMode()) {
-      console.log(
-        "  Do not retry in a loop; ask the human to complete the browser step. This command waits."
-      );
-    }
-  }
-  if (dots) process.stdout.write("  Waiting for the connection");
-  for (; ; ) {
-    let connected2 = false;
-    try {
-      connected2 = await opts.poll();
-    } catch {
-    }
-    if (connected2) {
-      const { result, lines } = opts.onConnected();
-      if (opts.json) {
-        emitProgress({ status: "connected" });
-        emitResult(result);
-        return;
-      }
-      if (dots) process.stdout.write("\n");
-      for (const line of lines) console.log(line);
-      return;
-    }
-    if (Date.now() >= deadline) break;
-    if (dots) process.stdout.write(".");
-    await sleep3(interval);
-  }
-  if (opts.json) {
-    emitResult({ connected: false, error: "timeout" });
-    process.exit(1);
+// src/commands/slack.ts
+async function slackStartUrl(token) {
+  const res = await api("/cli/whoami", { token });
+  const body = await readJson(res);
+  if (res.status === 401) die("Token invalid \u2014 run `fillo login` again.");
+  if (!res.ok || typeof body.projectId !== "string" || !body.projectId) {
+    die(body.error ?? "Couldn't resolve the selected Fillo project.");
   }
-  if (dots) process.stdout.write("\n");
-  console.log(
-    `  Timed out waiting for ${terminalText(opts.what)} to connect. Finish the browser step, then re-run this command.`
-  );
-  process.exit(1);
+  return `${API}/api/integrations/slack/start?return=terminal&project=${encodeURIComponent(body.projectId)}`;
 }
-
-// src/commands/slack.ts
-var SLACK_START_URL = `${API}/api/integrations/slack/start?return=terminal`;
 async function refresh(flags) {
   const json = jsonMode(flags);
   const token = requireToken();
@@ -5318,8 +5792,9 @@ async function refresh(flags) {
   const body = await readJson(res);
   if (res.status === 401) die("Token invalid \u2014 run `fillo login` again.");
   if (res.status === 409) {
+    const startUrl = await slackStartUrl(token);
     die(
-      `${body.error ?? "Reconnect Slack in the browser to refresh channels."} Reconnect at ${SLACK_START_URL}`
+      `${body.error ?? "Reconnect Slack in the browser to refresh channels."} Reconnect at ${startUrl}`
     );
   }
   if (res.status === 429) {
@@ -5351,7 +5826,7 @@ function printChannels(channels) {
   console.log("");
   printTable(["NAME", "ID", "VISIBILITY"], rows);
 }
-async function status2(flags) {
+async function status3(flags) {
   const json = jsonMode(flags);
   const showChannels = flags.channels === true;
   const token = requireToken();
@@ -5376,13 +5851,14 @@ async function status2(flags) {
     );
   }
 }
-async function connect(flags) {
+async function connect2(flags) {
   const json = jsonMode(flags);
   const token = requireToken();
+  const startUrl = await slackStartUrl(token);
   await connectViaBrowser({
     json,
     what: "Slack",
-    startUrl: SLACK_START_URL,
+    startUrl,
     poll: async () => {
       const res = await api("/cli/slack", { token });
       if (res.status === 401) die("Token invalid \u2014 run `fillo login` again.");
@@ -5401,12 +5877,12 @@ async function connect(flags) {
 }
 async function slack(subcommand, flags) {
   if (subcommand === "help") return slackHelp();
-  if (subcommand === "connect") return connect(flags);
+  if (subcommand === "connect") return connect2(flags);
   if (subcommand !== void 0 && subcommand !== "status") {
     die(`Unknown slack command: ${terminalText(subcommand)} (expected status or connect).`);
   }
   if (flags.refresh === true) return refresh(flags);
-  return status2(flags);
+  return status3(flags);
 }
 function slackHelp() {
   console.log(`
@@ -5455,7 +5931,7 @@ async function fetchStatus(token) {
   if (!res.ok || !body.providers) die(body.error ?? `storage status failed (${res.status}).`);
   return body;
 }
-async function status3(flags) {
+async function status4(flags) {
   const token = requireToken();
   const body = await fetchStatus(token);
   if (jsonMode(flags)) return emitResult(body);
@@ -5622,7 +6098,7 @@ async function connectBrowserProvider(provider, flags) {
     }
   });
 }
-async function connect2(providerArg, flags) {
+async function connect3(providerArg, flags) {
   const provider = resolveProviderArg(providerArg);
   if (!provider) {
     die("Usage: fillo storage connect <s3|drive|box>  (r2 and gdrive are accepted aliases).");
@@ -5645,9 +6121,9 @@ async function disconnect(providerArg, flags) {
   console.log(`  ${okMark()} Disconnected ${PROVIDER_LABEL[provider]} storage.`);
 }
 async function storage(subcommand, args, flags) {
-  if (subcommand === void 0 || subcommand === "status") return status3(flags);
+  if (subcommand === void 0 || subcommand === "status") return status4(flags);
   if (subcommand === "help") return storageHelp();
-  if (subcommand === "connect") return connect2(args[0], flags);
+  if (subcommand === "connect") return connect3(args[0], flags);
   if (subcommand === "disconnect") return disconnect(args[0], flags);
   die(
     `Unknown storage command: ${terminalText(subcommand)} (expected status, connect, or disconnect).`
@@ -5682,6 +6158,63 @@ var storageCommand = {
   help: storageHelp
 };
 
+// src/commands/tokens.ts
+var TOOLS = ["zapier", "n8n"];
+async function createConnector(flags) {
+  const json = jsonMode(flags);
+  const tool = enumFlag(flags, "tool", TOOLS);
+  if (!tool) die(`Usage: fillo tokens create-connector --tool ${TOOLS.join("|")}`);
+  const res = await api("/cli/tokens/connector", {
+    method: "POST",
+    token: requireToken(),
+    body: JSON.stringify({ tool })
+  });
+  const body = await readJson(res);
+  if (res.status === 401) die(body.error ?? "Invalid or missing CLI token \u2014 run `fillo login`");
+  if (!res.ok || !body.token) die(body.error ?? `tokens create-connector failed (${res.status}).`);
+  if (!/^fcli_[A-Za-z0-9._~-]{8,512}$/.test(body.token)) {
+    die("Fillo returned an unexpected token format.");
+  }
+  if (json) return emitResult(body);
+  console.log(
+    `
+  ${okMark()} Created a ${bold(terminalText(body.label ?? tool))} connector token`
+  );
+  console.log(`
+  ${body.token}
+`);
+  console.log(`  ${bold("Store it now")} \u2014 Fillo cannot show this token again.`);
+  console.log(
+    "  Treat it like a password: it can read and change this project's forms and responses."
+  );
+  console.log("  Revoke it any time in Settings \u2192 Connections.\n");
+}
+async function tokens(subcommand, flags) {
+  if (subcommand === void 0 || subcommand === "help") return tokensHelp();
+  if (subcommand === "create-connector") return createConnector(flags);
+  die(`Unknown tokens command: ${terminalText(subcommand)} (expected create-connector).`);
+}
+function tokensHelp() {
+  console.log(`
+  ${boldRaw("fillo tokens")} \u2014 credentials for no-code connectors
+
+  ${boldRaw("Commands")}
+    tokens create-connector --tool ${TOOLS.join("|")}
+                       Mint the connector's API token \u2014 shown once, store it
+
+  ${dimRaw("The token is non-expiring so a live automation doesn't break silently, and")}
+  ${dimRaw("stays revocable in Settings \u2192 Connections. For coding agents and your own")}
+  ${dimRaw("integrations use `fillo keys create` instead \u2014 those are scoped.")}
+  ${dimRaw("--json prints the raw server response on stdout, token included.")}
+`);
+}
+var tokensCommand = {
+  name: "tokens",
+  flags: ["tool"],
+  run: (args, flags) => tokens(args[0], flags),
+  help: tokensHelp
+};
+
 // src/commands/webhooks.ts
 var dateTime2 = (iso) => iso.slice(0, 16).replace("T", " ");
 async function list3(handle, flags) {
@@ -5812,6 +6345,115 @@ var webhooksCommand = {
   help: webhooksHelp
 };
 
+// src/commands/projects.ts
+function authFailure(status5) {
+  if (status5 === 401) die("Token invalid \u2014 run `fillo login` again.");
+}
+function saveSelectedProject(project) {
+  if (!project.publishableKey.startsWith("pk_")) {
+    die("Fillo returned an invalid publishable key; the selected project was not saved locally.");
+  }
+  const {
+    claimUrl: _claimUrl,
+    email: _email2,
+    name: _name,
+    claimToken: _claimToken,
+    ...current
+  } = readConfig();
+  writeConfig({ ...current, pk: project.publishableKey });
+}
+async function list4(flags) {
+  const res = await api("/cli/projects", { token: requireToken() });
+  const body = await readJson(res);
+  authFailure(res.status);
+  if (!res.ok || !Array.isArray(body.projects)) {
+    die(body.error ?? `project list failed (${res.status}).`);
+  }
+  if (jsonMode(flags)) return emitResult(body);
+  console.log(`
+  ${bold("Projects")}`);
+  printTable(
+    ["", "NAME", "SLUG", "ID"],
+    body.projects.map((project) => [
+      project.current ? "*" : "",
+      terminalText(project.name),
+      terminalText(project.slug),
+      terminalText(project.id)
+    ])
+  );
+  console.log(`
+  ${dim("* selected for this CLI login")}`);
+  console.log(`  ${dim("Switch with `fillo project select <id-or-slug>`.")}
+`);
+}
+async function create(name, flags) {
+  if (!name) die('Usage: fillo project create "Project name"');
+  const res = await api("/cli/projects", {
+    method: "POST",
+    token: requireToken(),
+    body: JSON.stringify({ name, source: "cli" })
+  });
+  const body = await readJson(res);
+  authFailure(res.status);
+  if (!res.ok || !body.project || body.selected !== true) {
+    die(body.error ?? `project create failed (${res.status}).`);
+  }
+  saveSelectedProject(body.project);
+  if (jsonMode(flags)) return emitResult(body);
+  console.log(`  ${okMark()} Created and selected ${bold(terminalText(body.project.name))}.`);
+  console.log(`  ${dim("Forms, keys, origins, identities, and agent access are isolated here.")}`);
+  console.log(`  ${dim("Members, billing, storage, and usage totals stay with the workspace.")}`);
+}
+async function select(target, flags) {
+  if (!target) die("Usage: fillo project select <id|slug|unique-name>");
+  const res = await api("/cli/projects/select", {
+    method: "POST",
+    token: requireToken(),
+    body: JSON.stringify({ project: target, source: "cli" })
+  });
+  const body = await readJson(res);
+  authFailure(res.status);
+  if (!res.ok || !body.project || body.selected !== true) {
+    die(body.error ?? `project select failed (${res.status}).`);
+  }
+  saveSelectedProject(body.project);
+  if (jsonMode(flags)) return emitResult(body);
+  console.log(`  ${okMark()} Selected ${bold(terminalText(body.project.name))}.`);
+  console.log(`  ${dim("Future CLI commands use this project until you select another.")}`);
+}
+async function projects(subcommand, args, flags) {
+  if (subcommand === void 0 || subcommand === "list" || subcommand === "ls") {
+    return list4(flags);
+  }
+  if (subcommand === "help") return projectHelp();
+  if (subcommand === "create") return create(args.join(" ").trim() || void 0, flags);
+  if (subcommand === "select" || subcommand === "use") {
+    return select(args.join(" ").trim() || void 0, flags);
+  }
+  die(`Unknown project command: ${terminalText(subcommand)} (expected list, create, or select).`);
+}
+function projectHelp() {
+  console.log(`
+  ${boldRaw("fillo project")} \u2014 create and select isolated sites/apps
+
+  ${boldRaw("Commands")}
+    project                         List projects in the current workspace
+    project create <name>           Create and select a project
+    project select <id|slug|name>   Select a project for future commands
+
+  ${dimRaw("Requires an ordinary `fillo login`. Project-pinned agent handoff")}
+  ${dimRaw("tokens cannot list, create, or select sibling projects.")}
+  ${dimRaw("--json prints the server response on stdout.")}
+`);
+}
+var projectCommand = {
+  name: "project",
+  aliases: ["projects"],
+  flags: [],
+  run: (args, flags) => projects(args[0], args.slice(1), flags),
+  help: projectHelp
+};
+
 // src/index.ts
 var REGISTRY = [
   initCommand,
@@ -5819,6 +6461,7 @@ var REGISTRY = [
   loginCommand,
   logoutCommand,
   whoamiCommand,
+  projectCommand,
   keysCommand,
   pushCommand,
   listCommand,
@@ -5830,8 +6473,11 @@ var REGISTRY = [
   skillCommand,
   storageCommand,
   slackCommand,
+  discordCommand,
+  tokensCommand,
   webhooksCommand,
   settingsCommand,
+  brandingCommand,
   membersCommand,
   deleteCommand
 ];
@@ -5862,15 +6508,17 @@ function help() {
                        ${dimRaw("--headless       approve a code instead of the local browser handoff")}
                        ${dimRaw("--run <id> --token <token>   bind a fresh agent handoff login")}
     logout             Forget the stored credentials
-    whoami             Show the signed-in workspace
-    keys <cmd>         Workspace API keys for agents/CI: create, list, revoke
+    whoami             Show the signed-in workspace and selected project
+    project <cmd>      Isolated sites/apps: list, create, select
+                       ${dimRaw("project create <name> \xB7 project select <id|slug|name>")}
+    keys <cmd>         Project API keys for agents/CI: create, list, revoke
                        ${dimRaw("keys create --name <n> --preset read|agent|full")}
     push <file|->      Create/update a form from JSON (file or stdin)
                        ${dimRaw("--handle <name>  idempotent id for re-pushes")}
                        ${dimRaw("--stage          stage beside the live form for dashboard review")}
                        ${dimRaw("--draft          alias with a handle; legacy one-off draft without")}
                        ${dimRaw("--allow-code     allow a .mjs/.js schema (executes the file)")}
-    list               List the workspace's forms and their live URLs
+    list               List the project's forms and their live URLs
     status <form>      Show one form's status, live URL, and publish blockers
                        ${dimRaw("<form> is a form id or handle")}
     publish <form>     Publish staged changes (or a draft form) \u2014 prints the live URL
@@ -5886,9 +6534,13 @@ function help() {
     storage <cmd>      Inspect/connect upload destinations (status, connect, disconnect)
                        ${dimRaw("storage connect s3 \xB7 connect drive|box \xB7 disconnect <p>")}
     slack <cmd>        Slack notifications: status, --channels, --refresh, connect
+    discord <cmd>      Discord destination: connect, webhook, status, enable, disable, roles
+                       ${dimRaw("discord enable <form> --fields a,b --early-signal 10 --role <g>/<r>")}
+    tokens <cmd>       Connector credentials: create-connector --tool zapier|n8n
     webhooks <cmd>     A form's signed webhooks: list, add, set, remove
                        ${dimRaw("webhooks add <form> --url <u>   shows the signing secret once")}
     settings <cmd>     A form's operational settings: get, set key=value
+    branding [on|off]  The workspace's "Powered by Fillo" badge (off needs Everything)
     members <cmd>      Workspace members: list, invite <email>, cancel-invite <id>
     delete <cmd>       Irreversible deletes: delete form <form> \xB7 delete workspace
                        ${dimRaw("typed confirmation required; --confirm for agents, --yes never skips")}