@usefillo/cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fillo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.js

@@ -0,0 +1,257 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { isAbsolute, join, resolve } from "path";
+import { spawn } from "child_process";
+import { pathToFileURL } from "url";
+var API = (process.env.FILLO_API ?? "https://fillo.so").replace(/\/$/, "");
+var CONFIG_DIR = join(homedir(), ".fillo");
+var CONFIG_PATH = join(CONFIG_DIR, "config.json");
+var bold = (s) => `\x1B[1m${s}\x1B[0m`;
+var dim = (s) => `\x1B[2m${s}\x1B[0m`;
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function die(msg) {
+  console.error(`\x1B[31m\u2717\x1B[0m ${msg}`);
+  process.exit(1);
+}
+function readConfig() {
+  try {
+    return JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeConfig(c) {
+  mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  writeFileSync(CONFIG_PATH, JSON.stringify(c, null, 2), { mode: 384 });
+  try {
+    chmodSync(CONFIG_PATH, 384);
+  } catch {
+  }
+}
+function requireToken() {
+  const t = readConfig().token;
+  if (!t) die("Not logged in. Run `fillo login` first.");
+  return t;
+}
+function openBrowser(url) {
+  if (!/^https?:\/\//i.test(url)) return;
+  try {
+    if (process.platform === "win32") {
+      spawn("cmd", ["/c", "start", "", url], { stdio: "ignore", detached: true }).unref();
+    } else {
+      const cmd = process.platform === "darwin" ? "open" : "xdg-open";
+      spawn(cmd, [url], { stdio: "ignore", detached: true }).unref();
+    }
+  } catch {
+  }
+}
+async function api(path, init2 = {}) {
+  const { token, ...rest } = init2;
+  return fetch(`${API}/api/v1${path}`, {
+    ...rest,
+    headers: {
+      "Content-Type": "application/json",
+      ...token ? { Authorization: `Bearer ${token}` } : {},
+      ...rest.headers
+    }
+  });
+}
+async function login() {
+  const res = await api("/device/code", { method: "POST" });
+  if (!res.ok) die(`Couldn't start login (${res.status}).`);
+  const d = await res.json();
+  console.log(`
+  Your code:  ${bold(d.user_code)}`);
+  console.log(`  Approve it at ${d.verification_uri} \u2014 opening your browser\u2026
+`);
+  openBrowser(d.verification_uri_complete);
+  const deadline = Date.now() + d.expires_in * 1e3;
+  let interval = d.interval * 1e3;
+  process.stdout.write("  Waiting for approval");
+  while (Date.now() < deadline) {
+    await sleep(interval);
+    process.stdout.write(".");
+    const r = await api("/device/token", {
+      method: "POST",
+      body: JSON.stringify({ device_code: d.device_code })
+    });
+    const body = await r.json();
+    if (body.access_token) {
+      writeConfig({ token: body.access_token });
+      console.log("\n");
+      await whoami();
+      console.log(`
+  ${dim("Now run:")} fillo push form.json
+`);
+      return;
+    }
+    if (body.error === "slow_down") interval += 2e3;
+    else if (body.error && body.error !== "authorization_pending") die(`
+Login failed: ${body.error}`);
+  }
+  die("\nLogin timed out \u2014 run `fillo login` again.");
+}
+async function whoami() {
+  const res = await api("/cli/whoami", { token: requireToken() });
+  if (res.status === 401) die("Token invalid \u2014 run `fillo login` again.");
+  if (!res.ok) die(`whoami failed (${res.status}).`);
+  const me = await res.json();
+  console.log(`  \x1B[32m\u2713\x1B[0m ${bold(me.email)}  ${dim("\xB7")}  ${me.workspace}`);
+}
+async function list() {
+  const res = await api("/cli/forms", { token: requireToken() });
+  if (!res.ok) die(`list failed (${res.status}).`);
+  const { forms } = await res.json();
+  if (!forms.length) return console.log("  No forms yet.");
+  for (const f of forms) {
+    console.log(`  ${f.status === "published" ? "\x1B[32m\u25CF\x1B[0m" : "\u25CB"} ${f.name}  ${dim(f.id)}`);
+  }
+}
+async function loadSchema(file, allowCode) {
+  const abs = isAbsolute(file) ? file : resolve(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.`
+    );
+  }
+  try {
+    if (abs.endsWith(".json")) return JSON.parse(readFileSync(abs, "utf8"));
+    const mod = await import(pathToFileURL(abs).href);
+    return mod.default ?? mod.schema ?? mod.form;
+  } catch (e) {
+    die(`Couldn't read ${file}: ${e.message}`);
+  }
+}
+function printPushed(formId, url, updated, staged) {
+  console.log(`
+  \x1B[32m\u2713\x1B[0m ${updated ? "Updated" : "Created"} ${bold(formId)}`);
+  if (staged) console.log(`  ${dim("Staged as a draft \u2014 publish it from the dashboard.")}`);
+  else if (url) console.log(`  Live at ${url}`);
+  console.log(`  Embed:  <FilloForm formId="${formId}" />
+`);
+}
+async function push(file, flags) {
+  if (!file) die("Usage: fillo push <form.json> [--handle name] [--draft] [--allow-code]");
+  const schema = await loadSchema(file, flags["allow-code"] === true);
+  const handle = typeof flags.handle === "string" ? flags.handle : void 0;
+  const cfg = readConfig();
+  if (cfg.token) {
+    const res = await api("/cli/forms", {
+      method: "POST",
+      token: cfg.token,
+      body: JSON.stringify({ schema, handle, publish: !flags.draft })
+    });
+    const body = await res.json();
+    if (!res.ok || !body.formId) die(body.error ?? `push failed (${res.status}).`);
+    return printPushed(body.formId, body.url, !!body.updated, !!flags.draft);
+  }
+  if (cfg.pk) {
+    if (!handle) die("Pushing with a provisioned key needs --handle <name>.");
+    const res = await api("/forms/sync", {
+      method: "POST",
+      body: JSON.stringify({ key: cfg.pk, id: handle, schema })
+    });
+    const body = await res.json();
+    if (!res.ok || !body.formId) die(body.error ?? `push failed (${res.status}).`);
+    return printPushed(body.formId, body.slug ? `${API}/f/${body.slug}` : void 0, false, !!body.staged);
+  }
+  die("Not set up yet. Run `fillo init` (no account needed) or `fillo login`.");
+}
+async function init(flags) {
+  const email = typeof flags.email === "string" ? flags.email : void 0;
+  const res = await api("/workspaces/provision", {
+    method: "POST",
+    body: JSON.stringify({ email, source: "cli" })
+  });
+  const body = await res.json();
+  if (!res.ok || !body.key) die(body.error ?? `init failed (${res.status}).`);
+  writeConfig({ ...readConfig(), pk: body.key, claimUrl: body.claim?.url ?? void 0 });
+  console.log(`
+  \x1B[32m\u2713\x1B[0m Workspace ready \u2014 no signup needed.`);
+  if (body.limits) {
+    const days = Math.max(1, Math.round((Date.parse(body.limits.expiresAt) - Date.now()) / 864e5));
+    console.log(`  ${dim(`Preview: up to ${body.limits.responses} responses for ~${days} days.`)}`);
+  }
+  console.log(`
+  ${bold("Next:")} fillo push form.json --handle my-form`);
+  if (body.claim?.url) {
+    console.log(`
+  ${dim("Keep your responses \u2014 claim it (signup, one click):")}`);
+    console.log(`  ${body.claim.url}
+`);
+  }
+}
+function help() {
+  console.log(`
+  ${bold("fillo")} \u2014 create Fillo forms from your terminal
+
+  ${bold("Commands")}
+    init               Provision a workspace with NO signup \u2014 instant, for first runs
+                       ${dim("--email <addr>   optional: also mail a claim link as backup")}
+    login              Connect to an existing account (opens the browser)
+    logout             Forget the stored credentials
+    whoami             Show the signed-in account + workspace
+    push <file>        Create/update a form from a JSON schema
+                       ${dim("--handle <name>  idempotent id for re-pushes")}
+                       ${dim("--draft          stage as a draft instead of publishing")}
+                       ${dim("--allow-code     allow a .mjs/.js schema (executes the file)")}
+    list               List the workspace's forms
+
+  ${dim(`API: ${API}  \xB7  set FILLO_API to override`)}
+`);
+}
+function parseFlags(args) {
+  const flags = {};
+  const positional = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (!a.startsWith("--")) {
+      positional.push(a);
+      continue;
+    }
+    const eq = a.indexOf("=");
+    if (eq !== -1) {
+      flags[a.slice(2, eq)] = a.slice(eq + 1);
+      continue;
+    }
+    const key = a.slice(2);
+    const next = args[i + 1];
+    if (next !== void 0 && !next.startsWith("--")) {
+      flags[key] = next;
+      i++;
+    } else flags[key] = true;
+  }
+  return { positional, flags };
+}
+async function main() {
+  const [cmd, ...rest] = process.argv.slice(2);
+  const { positional, flags } = parseFlags(rest);
+  switch (cmd) {
+    case "init":
+      return init(flags);
+    case "login":
+      return login();
+    case "logout":
+      writeConfig({});
+      return console.log("  Logged out.");
+    case "whoami":
+      return whoami();
+    case "push":
+      return push(positional[0], flags);
+    case "list":
+    case "ls":
+      return list();
+    case void 0:
+    case "help":
+    case "--help":
+    case "-h":
+      return help();
+    default:
+      console.error(`Unknown command: ${cmd}`);
+      return help();
+  }
+}
+main().catch((e) => die(e instanceof Error ? e.message : String(e)));

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@usefillo/cli",
+  "version": "0.1.0",
+  "description": "Create and publish Fillo forms from your terminal — auth once, then your coding agent does the rest.",
+  "license": "MIT",
+  "keywords": [
+    "forms",
+    "cli",
+    "fillo"
+  ],
+  "homepage": "https://fillo.so",
+  "type": "module",
+  "bin": {
+    "fillo": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.0",
+    "tsup": "^8.4.0",
+    "typescript": "^5.8.3"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit"
+  }
+}