@usefillo/cli 0.14.1 → 0.15.0

package/README.md

@@ -29,9 +29,10 @@ Commands: `init`, `login`, `logout`, `whoami`, `push <file|->`, `list`,
 `agent bootstrap`, `agent connect`, `agent event`, and `skill install`. Run
 `npx @usefillo/cli --help` for flags. The canonical skill is
 one portable Agent Skills bundle. The default command installs it in the shared
-`.agents/skills` path and Claude Code's `.claude/skills` path. Hosts with another
-location can use `skill install --dir <agent-skill-directory>`, so the same
-bundle works without provider-specific forks. See
+`.agents/skills` path and Claude Code's `.claude/skills` path — both get the
+same files, for cross-agent compatibility rather than duplication. Hosts with
+another location can use `skill install --dir <agent-skill-directory>`, so the
+same bundle works without provider-specific forks. See
 [fillo.so/agents](https://fillo.so/agents) for setup. The API
 commands target
 `https://fillo.so` by default (set `FILLO_API` to override).

package/dist/index.js

@@ -321,9 +321,9 @@ async function startLoopbackServer() {
     respond(200, "You can close this tab and return to your terminal.");
     handler?.resolve(code);
   });
-  await new Promise((resolve4, reject) => {
+  await new Promise((resolve5, reject) => {
     server.once("error", reject);
-    server.listen(0, "127.0.0.1", resolve4);
+    server.listen(0, "127.0.0.1", resolve5);
   });
   const port = server.address().port;
   const close = () => {
@@ -332,7 +332,7 @@ async function startLoopbackServer() {
     } catch {
     }
   };
-  const waitForCode = (state, timeoutMs) => new Promise((resolve4, reject) => {
+  const waitForCode = (state, timeoutMs) => new Promise((resolve5, reject) => {
     expectedState = state;
     const timer = setTimeout(() => {
       handler = null;
@@ -343,7 +343,7 @@ async function startLoopbackServer() {
       resolve: (code) => {
         clearTimeout(timer);
         close();
-        resolve4(code);
+        resolve5(code);
       },
       reject: (err) => {
         clearTimeout(timer);
@@ -583,23 +583,41 @@ Login failed: ${body.error}`);
   }
   die("\nLogin timed out \u2014 run `fillo login` again.");
 }
-async function fetchWorkspaceName(apiBase = API) {
+async function fetchWhoami(apiBase = API) {
   const res = await api("/cli/whoami", { token: requireTokenFor(apiBase) }, apiBase);
   if (res.status === 401) die("Token invalid \u2014 run `fillo login` again.");
   if (!res.ok) die(`whoami failed (${res.status}).`);
   const me = await readJson(res);
-  if (typeof me.workspace !== "string" || !terminalText(me.workspace)) {
-    die("Fillo returned an invalid workspace identity.");
-  }
-  return terminalText(me.workspace);
+  const workspace = typeof me.workspace === "string" ? terminalText(me.workspace) : "";
+  if (!workspace) die("Fillo returned an invalid workspace identity.");
+  return {
+    workspace,
+    canPublishFileFields: typeof me.canPublishFileFields === "boolean" ? me.canPublishFileFields : void 0
+  };
+}
+async function fetchWorkspaceName(apiBase = API) {
+  return (await fetchWhoami(apiBase)).workspace;
 }
 function printConnected(workspace) {
   console.log(`  ${okMark()} Connected to ${bold(workspace)}`);
 }
 async function whoami(flags) {
-  const workspace = await fetchWorkspaceName(API);
-  if (jsonMode(flags)) return emitResult({ connected: true, workspace });
-  printConnected(workspace);
+  const me = await fetchWhoami(API);
+  if (jsonMode(flags)) {
+    return emitResult({
+      connected: true,
+      workspace: me.workspace,
+      ...me.canPublishFileFields === void 0 ? {} : { canPublishFileFields: me.canPublishFileFields }
+    });
+  }
+  printConnected(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) {
+    console.log(
+      `  ${dim("File uploads: no destination yet \u2014 connect one (fillo storage connect) before publishing a file field.")}`
+    );
+  }
 }
 function logout() {
   const { token, tokenApi, ...rest } = readConfig();
@@ -624,6 +642,8 @@ var whoamiCommand = {
 
 // src/commands/init.ts
 import { execFile } from "child_process";
+import { existsSync } from "fs";
+import { basename, dirname, join as join2, resolve } from "path";
 import { promisify } from "util";
 
 // src/lib/prompt.ts
@@ -638,9 +658,9 @@ function promptInterface() {
     shared = createInterface({ input: process.stdin, output: process.stdout });
     shared.on("line", (line) => {
       if (pending) {
-        const resolve4 = pending;
+        const resolve5 = pending;
         pending = null;
-        resolve4({ line });
+        resolve5({ line });
       } else {
         lineQueue.push(line);
       }
@@ -653,9 +673,9 @@ function promptInterface() {
       sharedClosed = true;
       shared = null;
       if (pending) {
-        const resolve4 = pending;
+        const resolve5 = pending;
         pending = null;
-        resolve4({ eof: true });
+        resolve5({ eof: true });
       }
     });
   }
@@ -677,10 +697,10 @@ function ask(promptText) {
   if (!rl) return Promise.resolve({ eof: true });
   rl.setPrompt(promptText);
   rl.prompt();
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     pending = (answer) => {
       rl.setPrompt("");
-      resolve4(answer);
+      resolve5(answer);
     };
   });
 }
@@ -706,7 +726,7 @@ var ETX = String.fromCharCode(3);
 var DEL = String.fromCharCode(127);
 var BACKSPACE = "\b";
 function readSecret(promptText) {
-  return new Promise((resolve4, reject) => {
+  return new Promise((resolve5, reject) => {
     const input = process.stdin;
     if (typeof input.setRawMode !== "function") {
       reject(new Error("No interactive terminal to read a secret from."));
@@ -726,7 +746,7 @@ function readSecret(promptText) {
         if (ENTER.has(ch) || ch === EOT) {
           cleanup();
           process.stdout.write("\n");
-          resolve4(value);
+          resolve5(value);
           return;
         }
         if (ch === ETX) {
@@ -781,11 +801,17 @@ async function provisionWorkspace(flags, usageHint, apiBase = API) {
       }
     }
   }
+  const workspaceName = flagString(flags, "workspace-name") ?? defaultWorkspaceName();
   const res = await api(
     "/workspaces/provision",
     {
       method: "POST",
-      body: JSON.stringify({ email: email3, source: "cli", ...name ? { name } : {} })
+      body: JSON.stringify({
+        email: email3,
+        source: "cli",
+        ...name ? { name } : {},
+        ...workspaceName ? { workspaceName } : {}
+      })
     },
     apiBase
   );
@@ -800,7 +826,55 @@ async function provisionWorkspace(flags, usageHint, apiBase = API) {
     ...name ? { name } : {},
     ...claimToken ? { claimToken } : {}
   });
-  return { pk: body.key, email: email3, name, limits: body.limits };
+  const workspace = typeof body.workspaceName === "string" && terminalText(body.workspaceName) || workspaceName || fallbackWorkspaceName(name, email3);
+  return { pk: body.key, email: email3, name, workspace, limits: body.limits };
+}
+async function resolveWorkspaceIdentity(flags, usageHint, apiBase = API) {
+  const existing = await existingAccountWorkspace(apiBase);
+  if (existing) return { existing: true, workspace: existing };
+  const ws = await provisionWorkspace(flags, usageHint, apiBase);
+  return { existing: false, ...ws };
+}
+async function existingAccountWorkspace(apiBase) {
+  const cfg = readConfig();
+  if (!cfg.token || cfg.tokenApi?.replace(/\/$/, "") !== apiBase.replace(/\/$/, "")) {
+    return void 0;
+  }
+  const res = await api("/cli/whoami", { token: cfg.token }, apiBase).catch(() => null);
+  if (!res?.ok) return void 0;
+  const me = await res.json().catch(() => ({}));
+  return typeof me.workspace === "string" && terminalText(me.workspace) ? terminalText(me.workspace) : void 0;
+}
+function printExistingWorkspaceGuard(workspace) {
+  console.log(
+    `
+  ${danger(`Using your stored Fillo login \u2014 workspace "${terminalText(workspace)}".`)}`
+  );
+  console.log(
+    `  ${dim("This is a real, connected workspace, not a fresh preview: forms you push go live in it.")}`
+  );
+  console.log(
+    `  ${dim("Want an isolated preview instead? Run `fillo logout`, then re-run this command.")}`
+  );
+}
+function fallbackWorkspaceName(name, email3) {
+  const owner = name.split(/\s+/)[0]?.trim() || email3.split("@")[0]?.trim() || "New";
+  return `${owner}'s workspace`;
+}
+function defaultWorkspaceName() {
+  let current = resolve(process.cwd());
+  let root = current;
+  while (true) {
+    if (existsSync(join2(current, ".git"))) {
+      root = current;
+      break;
+    }
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  const cleaned = terminalText(basename(root)).slice(0, 80);
+  return cleaned || void 0;
 }
 function previewLimitLine(limits) {
   if (!limits) return null;
@@ -828,9 +902,23 @@ function claimCookieValue(res) {
 }
 async function init(flags) {
   const json = jsonMode(flags);
-  const ws = await provisionWorkspace(flags, EMAIL_REQUIRED);
+  const identity = await resolveWorkspaceIdentity(flags, EMAIL_REQUIRED);
+  if (identity.existing) {
+    if (json) return emitResult({ existing: true, workspace: identity.workspace });
+    printExistingWorkspaceGuard(identity.workspace);
+    console.log(`
+  ${bold("Next:")} fillo push form.json --handle my-form`);
+    console.log(
+      `  ${dim(`Pushes publish into ${terminalText(identity.workspace)} \u2014 the workspace above.`)}
+`
+    );
+    return;
+  }
+  const ws = identity;
   if (json) {
     return emitResult({
+      existing: false,
+      workspace: ws.workspace,
       pk: ws.pk,
       email: ws.email,
       name: ws.name || null,
@@ -839,7 +927,7 @@ async function init(flags) {
   }
   console.log(
     `
-  ${okMark()} Workspace ready. A workspace link was sent to ${bold(terminalText(ws.email))}.`
+  ${okMark()} New workspace ${bold(terminalText(ws.workspace))} ready. A link was sent to ${bold(terminalText(ws.email))}.`
   );
   const preview = previewLimitLine(ws.limits);
   if (preview) console.log(`  ${dim(preview)}`);
@@ -850,7 +938,7 @@ async function init(flags) {
 }
 var initCommand = {
   name: "init",
-  flags: ["email", "name"],
+  flags: ["email", "name", "workspace-name"],
   run: (_args, flags) => init(flags)
 };
 
@@ -858,7 +946,7 @@ var initCommand = {
 import { randomUUID } from "crypto";
 import {
   cpSync,
-  existsSync,
+  existsSync as existsSync2,
   lstatSync,
   mkdirSync as mkdirSync2,
   readdirSync,
@@ -868,7 +956,7 @@ import {
   rmSync
 } from "fs";
 import { homedir as homedir2 } from "os";
-import { dirname, isAbsolute, join as join2, relative, resolve, sep } from "path";
+import { dirname as dirname2, isAbsolute, join as join3, relative, resolve as resolve2, sep } from "path";
 import { fileURLToPath } from "url";
 var BUNDLED_SKILL_DIR = fileURLToPath(new URL("./skill/build-with-fillo", import.meta.url));
 var SKILL_AGENT_DIRECTORIES = {
@@ -892,11 +980,11 @@ function isSkillAgent(value) {
   return Object.prototype.hasOwnProperty.call(SKILL_AGENT_DIRECTORIES, value);
 }
 function findProjectRoot(start) {
-  let current = resolve(start);
+  let current = resolve2(start);
   while (true) {
-    if (existsSync(join2(current, ".git"))) return current;
-    const parent = dirname(current);
-    if (parent === current) return resolve(start);
+    if (existsSync2(join3(current, ".git"))) return current;
+    const parent = dirname2(current);
+    if (parent === current) return resolve2(start);
     current = parent;
   }
 }
@@ -912,7 +1000,7 @@ function parseSkillDirectories(flags) {
     if (parts.length === 0 || parts.some((part) => part === "..")) {
       die("--dir must name a skill directory inside the selected project or home scope.");
     }
-    return [join2(...parts)];
+    return [join3(...parts)];
   }
   if (!agent2) return [SKILL_AGENT_DIRECTORIES.shared, SKILL_AGENT_DIRECTORIES.claude];
   if (isSkillAgent(agent2)) return [SKILL_AGENT_DIRECTORIES[agent2]];
@@ -921,10 +1009,10 @@ function parseSkillDirectories(flags) {
   );
 }
 function skillFiles(root, relative2 = "") {
-  const directory = join2(root, relative2);
+  const directory = join3(root, relative2);
   const files = [];
   for (const entry of readdirSync(directory, { withFileTypes: true })) {
-    const next = join2(relative2, entry.name);
+    const next = join3(relative2, entry.name);
     if (entry.isDirectory()) files.push(...skillFiles(root, next));
     else if (entry.isFile()) files.push(next);
   }
@@ -936,7 +1024,7 @@ function sameSkillBundle(source, target) {
     const targetFiles = skillFiles(target);
     if (sourceFiles.length !== targetFiles.length) return false;
     return sourceFiles.every(
-      (file, index) => file === targetFiles[index] && readFileSync2(join2(source, file)).equals(readFileSync2(join2(target, file)))
+      (file, index) => file === targetFiles[index] && readFileSync2(join3(source, file)).equals(readFileSync2(join3(target, file)))
     );
   } catch {
     return false;
@@ -954,7 +1042,7 @@ function pathEntryExists(path) {
 var MANAGED_SKILL_MARKER = ".fillo-managed.json";
 function isCliManagedFilloSkill(target) {
   try {
-    const marker = JSON.parse(readFileSync2(join2(target, MANAGED_SKILL_MARKER), "utf8"));
+    const marker = JSON.parse(readFileSync2(join3(target, MANAGED_SKILL_MARKER), "utf8"));
     return marker.managedBy === "@usefillo/cli" && marker.skill === "build-with-fillo" && marker.format === 1 && marker.allowAutomaticUpdates === true;
   } catch {
     return false;
@@ -964,7 +1052,7 @@ function assertSafeSkillDestination(scopeRoot, parts) {
   const realScopeRoot = realpathSync(scopeRoot);
   let current = scopeRoot;
   for (const part of parts) {
-    current = join2(current, part);
+    current = join3(current, part);
     if (!pathEntryExists(current)) return;
     if (lstatSync(current).isSymbolicLink()) {
       throw new Error(`Refusing to install through symlinked path ${current}.`);
@@ -1006,12 +1094,12 @@ function installSkill(flags, opts = {}) {
   const skillDirectories = parseSkillDirectories(flags);
   const global = flags.global === true;
   const scopeRoot = global ? homedir2() : findProjectRoot(process.cwd());
-  if (!existsSync(BUNDLED_SKILL_DIR)) {
+  if (!existsSync2(BUNDLED_SKILL_DIR)) {
     die("This CLI package is missing its bundled Fillo skill. Reinstall @usefillo/cli@latest.");
   }
   const destinations = Array.from(new Set(skillDirectories)).map((skillDirectory) => {
-    const skillsRoot = resolve(scopeRoot, skillDirectory);
-    const target = join2(skillsRoot, "build-with-fillo");
+    const skillsRoot = resolve2(scopeRoot, skillDirectory);
+    const target = join3(skillsRoot, "build-with-fillo");
     const relativeSkillsRoot = relative(scopeRoot, skillsRoot);
     if (relativeSkillsRoot === ".." || relativeSkillsRoot.startsWith(`..${sep}`) || isAbsolute(relativeSkillsRoot)) {
       die("The skill destination must stay inside the selected project or home scope.");
@@ -1037,7 +1125,7 @@ function installSkill(flags, opts = {}) {
     if (destination.current) continue;
     mkdirSync2(destination.skillsRoot, { recursive: true });
     assertSafeSkillDestination(scopeRoot, destination.destinationParts.slice(0, 2));
-    const staging = join2(destination.skillsRoot, `.build-with-fillo.install-${randomUUID()}`);
+    const staging = join3(destination.skillsRoot, `.build-with-fillo.install-${randomUUID()}`);
     try {
       cpSync(BUNDLED_SKILL_DIR, staging, { recursive: true, errorOnExist: true });
       assertSafeSkillDestination(scopeRoot, destination.destinationParts);
@@ -1056,10 +1144,15 @@ function installSkill(flags, opts = {}) {
   console.log(`
   ${okMark()} ${action}.`);
   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.")}`
+    );
+  }
   console.log(`
   Ask your agent to use ${bold("build-with-fillo")}.`);
   console.log(
-    `  ${dim(`If it does not discover skills, point it to ${join2(targets[0], "SKILL.md")}.`)}
+    `  ${dim(`If it does not discover skills, point it to ${join3(targets[0], "SKILL.md")}.`)}
 `
   );
   return targets;
@@ -1085,7 +1178,8 @@ function skillHelp() {
                        ${dimRaw("--global   install for the current user")}
                        ${dimRaw("--force    replace a different existing copy")}
 
-  ${dimRaw("Default: open Agent Skills path (.agents/skills) plus Claude Code (.claude/skills).")}
+  ${dimRaw("Default: open Agent Skills path (.agents/skills) plus Claude Code (.claude/skills) \u2014")}
+  ${dimRaw("the same bundle in both, so either agent convention discovers it.")}
 `);
 }
 var skillCommand = {
@@ -1104,30 +1198,40 @@ async function bootstrapStandalone(flags, apiBase) {
     );
   }
   const json = jsonMode(flags);
-  const ws = await provisionWorkspace(flags, BOOTSTRAP_USAGE, apiBase);
+  const identity = await resolveWorkspaceIdentity(flags, BOOTSTRAP_USAGE, apiBase);
+  if (!json) {
+    if (identity.existing) printExistingWorkspaceGuard(identity.workspace);
+    else printNewWorkspace(identity);
+  }
   const targets = installSkill(flags, { quiet: json });
   if (json) {
-    return emitResult({
-      pk: ws.pk,
-      email: ws.email,
-      name: ws.name || null,
-      limits: ws.limits ?? null,
-      skill: { installed: true, targets }
-    });
+    return emitResult(
+      identity.existing ? { existing: true, workspace: identity.workspace, skill: { installed: true, targets } } : {
+        existing: false,
+        workspace: identity.workspace,
+        pk: identity.pk,
+        email: identity.email,
+        name: identity.name || null,
+        limits: identity.limits ?? null,
+        skill: { installed: true, targets }
+      }
+    );
   }
   console.log(
     `
-  ${bold("Ready.")} Workspace provisioned and the Build with Fillo skill installed.`
+  ${bold("Next:")} tell your agent what form to build${identity.existing ? ` in ${bold(terminalText(identity.workspace))}` : ""}, or push one directly:`
   );
+  console.log(`  ${dim("fillo push form.json --handle my-form")}
+`);
+}
+function printNewWorkspace(ws) {
+  console.log(`
+  ${okMark()} New workspace ${bold(terminalText(ws.workspace))} provisioned.`);
   console.log(
     `  ${dim(`A workspace link was sent to ${terminalText(ws.email)} \u2014 claim it anytime with \`fillo claim\`.`)}`
   );
   const preview = previewLimitLine(ws.limits);
   if (preview) console.log(`  ${dim(preview)}`);
-  console.log(`
-  ${bold("Next:")} tell your agent what form to build, or push one directly:`);
-  console.log(`  ${dim("fillo push form.json --handle my-form")}
-`);
 }
 var AGENT_ACTIONS = ["claim_required", "storage_required", "publish_required"];
 var AGENT_EVENT_STATUSES = [
@@ -1269,9 +1373,11 @@ function agentHelp() {
     agent bootstrap     Set up a workspace and install the Build with Fillo skill
                        ${dimRaw("--email you@company.com   provision a fresh workspace (a TTY confirms your git identity)")}
                        ${dimRaw('--name "Your Name"        optional display name')}
+                       ${dimRaw("--workspace-name <name>   name the new workspace (default: this repo/directory)")}
                        ${dimRaw("--api <url>               target a different Fillo deployment (default: FILLO_API or https://fillo.so)")}
                        ${dimRaw("--run <id> --token <token>   instead: attach to an open browser modal")}
                        ${dimRaw("--account   with --run/--token: approve an existing workspace in the browser")}
+                       ${dimRaw("A stored `fillo login` is reused as-is (and named) \u2014 run `fillo logout` first for an isolated preview.")}
     agent connect       Connect a coding-agent run to the open browser modal
                        ${dimRaw("--account   attach the workspace from `fillo login`")}
     agent event         Send a short progress update
@@ -1293,6 +1399,7 @@ var agentCommand = {
   flags: [
     "email",
     "name",
+    "workspace-name",
     "run",
     "token",
     "api",
@@ -1734,7 +1841,7 @@ var deleteCommand = {
 
 // src/commands/forms.ts
 import { readFileSync as readFileSync3 } from "fs";
-import { isAbsolute as isAbsolute2, resolve as resolve2 } from "path";
+import { isAbsolute as isAbsolute2, resolve as resolve3 } from "path";
 import { pathToFileURL } from "url";
 
 // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/core.js
@@ -4166,7 +4273,7 @@ async function loadResponseData(file) {
       die(`Couldn't read response data from stdin: ${error.message}`);
     }
   } else {
-    const abs = isAbsolute2(file) ? file : resolve2(process.cwd(), file);
+    const abs = isAbsolute2(file) ? file : resolve3(process.cwd(), file);
     if (!abs.endsWith(".json")) {
       die("Test response data must be a .json file (or - for JSON on stdin).");
     }
@@ -4245,7 +4352,7 @@ async function loadSchema(file, allowCode) {
       die(`Couldn't read the schema from stdin: ${error.message}`);
     }
   }
-  const abs = isAbsolute2(file) ? file : resolve2(process.cwd(), file);
+  const abs = isAbsolute2(file) ? file : resolve3(process.cwd(), file);
   if (!abs.endsWith(".json") && !allowCode) {
     die(
       `${file} is a code module \u2014 pushing it executes the file. Re-run with --allow-code if you trust it, or push a .json schema instead.`
@@ -4286,7 +4393,7 @@ function toPushItems(value, handle) {
     return { handle, schema: item };
   });
 }
-function printPushed(formId, url, updated, draft = false) {
+function printPushed(formId, url, updated, draft = false, storage2 = {}) {
   const label = draft ? "Created draft" : updated ? "Updated" : "Created";
   console.log(`
   ${okMark()} ${label} ${bold(formId)}`);
@@ -4295,6 +4402,8 @@ function printPushed(formId, url, updated, draft = false) {
       `  ${bold("Publish:")} fillo publish ${terminalText(formId)}   ${dim("(or publish it from the Fillo dashboard)")}`
     );
   } else if (url) console.log(`  Live at ${terminalText(url)}`);
+  if (storage2.warning) console.log(`  ${dim(`Before publishing: ${storage2.warning}`)}`);
+  if (storage2.warningUrl) console.log(`  Storage settings: ${terminalText(storage2.warningUrl)}`);
   console.log(`  Embed:  <FilloForm formId="${terminalText(formId)}" />
 `);
   console.log(`  Verify: [data-fillo-form-id="${terminalText(formId)}"] on the actual app route
@@ -4437,7 +4546,10 @@ async function push(file, flags) {
           results.push(body);
           emitProgress({ status: "pushed", formId: body.formId, draft: true });
         } else {
-          printPushed(body.formId, body.url, !!body.updated, true);
+          printPushed(body.formId, body.url, !!body.updated, true, {
+            warning: body.warning,
+            warningUrl: body.warningUrl
+          });
         }
       }
       if (results) emitResult({ forms: results });
@@ -4470,7 +4582,10 @@ async function push(file, flags) {
         results.push(body);
         emitProgress({ status: "pushed", formId: body.formId, published: true });
       } else {
-        printPushed(body.formId, body.url, !!body.updated);
+        printPushed(body.formId, body.url, !!body.updated, false, {
+          warning: body.warning,
+          warningUrl: body.warningUrl
+        });
       }
     }
     if (results) emitResult({ forms: results });
@@ -4786,7 +4901,7 @@ var membersCommand = {
 // src/commands/responses.ts
 import { once } from "events";
 import { createWriteStream } from "fs";
-import { isAbsolute as isAbsolute3, resolve as resolve3 } from "path";
+import { isAbsolute as isAbsolute3, resolve as resolve4 } from "path";
 var dateOnly4 = (iso) => iso.slice(0, 10);
 var dateTime = (iso) => iso.slice(0, 16).replace("T", " ");
 async function dieOnNotFound(res, handle, verb) {
@@ -4868,7 +4983,7 @@ async function exportCsv(handle, flags) {
     const body = await readJson(res);
     die(body.error ?? `responses export failed (${res.status}).`);
   }
-  const path = out ? isAbsolute3(out) ? out : resolve3(process.cwd(), out) : void 0;
+  const path = out ? isAbsolute3(out) ? out : resolve4(process.cwd(), out) : void 0;
   const file = path ? createWriteStream(path) : void 0;
   const target = file ?? process.stdout;
   let bytes = 0;
@@ -5330,6 +5445,13 @@ async function status3(flags) {
   const target = body.defaultStorageProvider;
   const targetLabel = target && target in PROVIDER_LABEL ? PROVIDER_LABEL[target] : target ?? "no durable storage yet";
   console.log(`  ${dim("Uploads for storage=null forms resolve to:")} ${targetLabel}`);
+  if (body.canPublishFileFields === true) {
+    console.log(`  ${dim("Can publish file fields:")} yes`);
+  } else if (body.canPublishFileFields === false) {
+    console.log(
+      `  ${dim("Can publish file fields:")} not yet \u2014 connect or choose a destination first`
+    );
+  }
   console.log("");
 }
 var S3_FIELDS = [

package/dist/skill/build-with-fillo/SKILL.md

@@ -17,7 +17,15 @@ Never require a provider-specific agent command.
 1. Inspect the host repository. Identify its framework, package manager, target
    route, UI conventions, existing Fillo packages, and any supplied form id,
    key, setup command, or run token.
-2. Establish the form's source of truth:
+2. If the form may need uploads, check storage readiness before choosing the
+   schema, not after a blocked publish. With a CLI login, `fillo whoami` or
+   `fillo storage status` (both `--json`) report `canPublishFileFields`:
+   `true` means a `file_upload` field can publish now; `false` means a
+   destination still needs connecting (a provider can show connected while
+   no default destination is resolved). Use that signal to decide on file
+   fields — do not defensively drop one just because storage looks unset; ask
+   the user to finish connecting it instead.
+3. Establish the form's source of truth:
    - Published form id or slug: render it directly. No client key is required.
    - React-owned schema: use `<Fillo.Form>` or `defineForm()` with
      `@usefillo/react`.
@@ -32,13 +40,13 @@ Never require a provider-specific agent command.
    client. A plain `FormSchema` plus a client is not a code-defined form and
    cannot resolve a target. Use explicit `renderOnly` only for a deliberately
    non-submitting UI preview.
-3. Ask only for missing product decisions that change the result: purpose,
+4. Ask only for missing product decisions that change the result: purpose,
    placement, required questions or files, conditional behavior, and what
    happens after submit. Infer routine implementation details from the repo.
-4. If the prompt supplies a handoff command, workspace key, form id, or run
+5. If the prompt supplies a handoff command, workspace key, form id, or run
    token, follow that handoff exactly. Do not create a second workspace or save
    a run token.
-5. Implement the smallest complete form, verify it in the host app, and report
+6. Implement the smallest complete form, verify it in the host app, and report
    any remaining dashboard action honestly.
 
 ## Load only the needed reference

package/dist/skill/build-with-fillo/references/auth-and-lifecycle.md

@@ -42,9 +42,13 @@ Never inspect `~/.fillo/config.json`, expose the account token, or call
 
 ## Claim the workspace from the terminal
 
-A capped preview workspace becomes a full account by being claimed. Claim it
-without leaving the terminal — this replaces sending the user to a browser to
-save the workspace:
+A capped preview workspace becomes a full account by being claimed. The
+preview cap is 10 responses total across every form in the workspace (not per
+form) plus a time window; past either limit, a new submission is rejected
+outright — HTTP 403 with `{error, closed: true}` — never queued or silently
+dropped, and the workspace's email is notified once. Claim it without leaving
+the terminal — this replaces sending the user to a browser to save the
+workspace:
 
 ```bash
 npx @usefillo/cli@latest claim
@@ -209,7 +213,11 @@ most one line at the end of the chat summary.
 - Add `--json` to a command to get one final JSON object on stdout (progress
   lines go to stderr as JSON). Parse that object instead of scraping human
   output when a step feeds later automation — for example, capture `formId` from
-  `push --json` or the key id from `keys list --json`.
+  `push --json` or the key id from `keys list --json`. `push --json` returns the
+  full lifecycle for each form in one round-trip — `formId`, `slug`, `status`,
+  `staged`, `accepting`, `uploadsAvailable`, `canPublishFileFields`, and any
+  storage `warning`/`warningUrl` — so a push needs no follow-up `status` call to
+  learn whether it staged, published, or is accepting responses.
 - The CLI enters agent mode automatically when stdout is not a TTY, or when
   `FILLO_AGENT=1` is set: no color, no spinners, and it never opens a browser —
   it prints the URL for the user to open instead. Print that URL and stop; the

package/dist/skill/build-with-fillo/references/operations.md

@@ -2,6 +2,13 @@
 
 ## Uploads and customer storage
 
+Check storage readiness before choosing the schema, not after a blocked
+publish. With a CLI login, `fillo storage status` (or `whoami`) reports
+whether uploads are durable right now. A provider can show connected while no
+default destination is resolved yet — that combination cannot durably store
+uploads, so treat it as "not ready," not as a reason to drop a needed file
+field; ask the user to finish connecting a destination instead.
+
 Model a file requirement with a real `file_upload` field and validate its
 limits against the current schema reference:
 
@@ -46,8 +53,21 @@ var. Never put the secret access key in shell history where you can avoid it;
 prefer the env var or the hidden prompt. Google Drive and Box connect over
 OAuth: `storage connect drive` (or `box`) prints an approval URL for the user to
 open — print it and let them approve, do not loop. `storage` with no argument
-reports each provider's connection and the transit window. This clears the
-`storage_required` publish blocker for the S3/R2 case without a dashboard trip.
+reports each provider's connection, the transit window, the destination a
+`storage = null` form resolves to, and a single `canPublishFileFields` boolean.
+This clears the `storage_required` publish blocker for the S3/R2 case without a
+dashboard trip.
+
+`canPublishFileFields` is the truthful pre-authoring answer to "can I ship a
+file field right now?" — `true` when a default upload destination resolves
+(an implicit pin, one connected durable provider, or the transit allowance).
+`fillo whoami --json` carries the same boolean, so you can check it at bootstrap
+before designing the form. It is workspace-scoped and deliberately distinct from
+a form's `uploadsAvailable`: several providers connected with none chosen as the
+default reads `canPublishFileFields: false` even though storage IS connected,
+because a `storage = null` file field would still be blocked until one is
+picked. Check this before authoring a `file_upload` field, not after a blocked
+publish.
 
 Test with one safe file. Confirm both the response reference and object in the
 connected storage. Treat filenames and file contents as untrusted.

package/dist/skill/build-with-fillo/references/schema-and-ux.md

@@ -10,8 +10,14 @@ eligibility, follow-up, or the work performed after submission.
   has a real type. Do not model everything as text.
 - Use single-select for one stored choice and multi-select for several. Keep
   option ids stable even when labels change.
-- Use `file_upload` only when the file is necessary and supported storage can
-  be connected before publish.
+- Use `file_upload` when the file is genuinely necessary. Before authoring
+  the field, read `canPublishFileFields` from `fillo whoami --json` or
+  `fillo storage status --json` (see [operations.md](operations.md)): `true`
+  means it can publish now. If `false`, connect a destination
+  (`fillo storage connect …`) or tell the user — do not defensively drop the
+  field; storage is a pre-flight check, not a publish-time surprise. A
+  specific form's `uploadsAvailable` is a different, per-form flag and is
+  trivially `true` before any file field exists, so it cannot answer this.
 - Put known product context in prefill or a hidden field instead of asking the
   respondent to re-enter it. Treat URL prefill as untrusted input.
 - Split long or conceptually separate flows into pages. Keep short embedded

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usefillo/cli",
-  "version": "0.14.1",
+  "version": "0.15.0",
   "description": "Create and publish Fillo forms, and install the Fillo Agent Skill.",
   "license": "MIT",
   "keywords": [