npm - @greatstore/cli - Versions diffs - 0.0.9 → 0.0.11-beta.0 - Mend

@greatstore/cli 0.0.9 → 0.0.11-beta.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/README.md CHANGED Viewed

@@ -11,6 +11,13 @@ gs push
 gs publish my-widget
 ```
+## Release channels
+- `npm install -g @greatstore/cli` — the stable production release (`@latest`).
+- `npm install -g @greatstore/cli@beta` — the prerelease channel for testing in-flight changes before they cut over to `@latest`.
+Cut a beta by bumping `cli/package.json` to `<x.y.z>-beta.<n>` (e.g. `0.0.12-beta.0`), then push tag `cli-v0.0.12-beta.0`. The publish workflow extracts the prerelease identifier from the version and publishes under that dist-tag, so `@latest` is unaffected. Drop the `-beta.<n>` suffix and tag again to promote to `@latest`.
 ## Commands
 | Command                                       | What it does                                                  |

package/dist/cli.js CHANGED Viewed

@@ -71,7 +71,9 @@ var SUCCESS_HTML = `<!doctype html>
 <style>body{font:14px/1.5 system-ui;margin:4rem auto;max-width:32rem;color:#222;text-align:center}
 h1{font-size:1.4rem}code{background:#f4f4f4;padding:.1em .3em;border-radius:.2em}</style></head>
 <body><h1>You're signed in.</h1>
-<p>You can close this window and return to your terminal.</p></body></html>`;
+<p>This window will close automatically. If it doesn't, you can close it and return to your terminal.</p>
+<script>setTimeout(function(){window.close();},250);</script>
+</body></html>`;
 var FAILURE_HTML = `<!doctype html>
 <html lang="en"><head><meta charset="utf-8"><title>GreatStore CLI</title>
 <style>body{font:14px/1.5 system-ui;margin:4rem auto;max-width:32rem;color:#222;text-align:center}
@@ -90,7 +92,7 @@ async function captureLoopbackToken(options) {
   const open = options.openBrowser ?? ((url) => openInBrowser(url, options.browserCmdEnv));
   const server = http.createServer();
   try {
-    await new Promise((resolve5) => server.listen(0, "127.0.0.1", resolve5));
+    await new Promise((resolve4) => server.listen(0, "127.0.0.1", resolve4));
     const address = server.address();
     const redirectUri = `http://127.0.0.1:${address.port}${CALLBACK_PATH}`;
     const authUrl = `${options.navBaseUrl}/connect_oauth_done?redirect_uri=${encodeURIComponent(redirectUri)}&state=${encodeURIComponent(state)}`;
@@ -102,7 +104,7 @@ async function captureLoopbackToken(options) {
   }
 }
 function waitForCallback(server, expectedState, timeoutMs) {
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve4, reject) => {
     let settled = false;
     const settle = (fn) => {
       if (settled) return;
@@ -148,7 +150,7 @@ function waitForCallback(server, expectedState, timeoutMs) {
       res.writeHead(200, { "content-type": "text/html" });
       res.end(SUCCESS_HTML);
       clearTimeout(timer);
-      settle(() => resolve5({ token }));
+      settle(() => resolve4({ token }));
     });
   });
 }
@@ -271,16 +273,11 @@ var StoreResolutionError = class extends Error {
     this.name = "StoreResolutionError";
   }
 };
-function resolveStore(input = {}) {
-  const flag = input.flag?.trim();
-  if (flag) return flag;
+function requireProjectStore(input = {}) {
   const fromRc = findGsrc(input.cwd ?? process.cwd());
   if (fromRc) return fromRc;
-  const env = input.env ?? process.env;
-  const fromEnv = env.GS_STORE?.trim();
-  if (fromEnv) return fromEnv;
   throw new StoreResolutionError(
-    'No store selected. Pass `--store <slug>`, set GS_STORE, or create a .gsrc file with {"store":"..."}.'
+    "No .gsrc found in this directory or any ancestor. Run `gs init --store <slug>` first to scaffold a GreatStore project."
   );
 }
 function findGsrc(cwd) {
@@ -477,7 +474,7 @@ function whoamiCommand() {
 // src/commands/list.ts
 async function listCommand(args) {
-  const slug = resolveStore({ flag: flagString(args.flags, "store") });
+  const slug = requireProjectStore();
   const url = `${apiBaseFor(slug)}/api/builder/components`;
   const data = await request(url);
   if (flagBool(args.flags, "json")) {
@@ -514,34 +511,181 @@ function pad(s, width) {
 }
 // src/commands/pull.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+// src/sync.ts
+import * as crypto2 from "crypto";
 import * as fs3 from "fs";
 import * as path3 from "path";
-async function pullCommand(args) {
-  const name = args.positional[0];
-  if (!name) {
-    throw new Error("Usage: gs pull <name> [--draft|--live|--version N] [-o <dir>]");
+var SYNC_FILE = ".gssync.json";
+function hashString(text) {
+  return crypto2.createHash("sha256").update(text).digest("hex");
+}
+function hashFile(filePath) {
+  if (!fs3.existsSync(filePath)) return null;
+  return hashString(fs3.readFileSync(filePath, "utf8"));
+}
+function computeComponentHashes(componentDir) {
+  const manifestHash = hashFile(path3.join(componentDir, "manifest.json"));
+  if (manifestHash === null) {
+    throw new Error(`Missing manifest.json in ${componentDir}`);
   }
-  const slug = resolveStore({ flag: flagString(args.flags, "store") });
-  const out = flagString(args.flags, "out") ?? ".";
-  const query = buildRevisionQuery(args);
-  const url = `${apiBaseFor(slug)}/api/builder/components/${encodeURIComponent(name)}${query}`;
-  const data = await request(url);
-  fs3.mkdirSync(out, { recursive: true });
+  return {
+    manifestHash,
+    sourceHash: hashFile(path3.join(componentDir, "component.tsx"))
+  };
+}
+function readSyncState(componentDir) {
+  const file = path3.join(componentDir, SYNC_FILE);
+  if (!fs3.existsSync(file)) return null;
+  try {
+    const parsed = JSON.parse(fs3.readFileSync(file, "utf8"));
+    if (typeof parsed.version === "number" && typeof parsed.manifestHash === "string" && typeof parsed.sourceHash === "string") {
+      return {
+        version: parsed.version,
+        manifestHash: parsed.manifestHash,
+        sourceHash: parsed.sourceHash
+      };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function writeSyncState(componentDir, state) {
   fs3.writeFileSync(
-    path3.join(out, "manifest.json"),
-    JSON.stringify(data.manifest, null, 2) + "\n"
+    path3.join(componentDir, SYNC_FILE),
+    JSON.stringify(state, null, 2) + "\n"
   );
-  fs3.writeFileSync(path3.join(out, "bundle.js"), data.bundle);
-  const wrote = ["manifest.json", "bundle.js"];
-  if (data.source !== null) {
-    fs3.writeFileSync(path3.join(out, "component.tsx"), data.source);
-    wrote.push("component.tsx");
+}
+function hasLocalChanges(componentDir, state) {
+  const hashes = safeComputeHashes(componentDir);
+  if (!hashes) return false;
+  if (state === null) return true;
+  if (hashes.manifestHash !== state.manifestHash) return true;
+  const localSource = hashes.sourceHash ?? "";
+  const storedSource = state.sourceHash ?? "";
+  return localSource !== storedSource;
+}
+function safeComputeHashes(componentDir) {
+  try {
+    return computeComponentHashes(componentDir);
+  } catch {
+    return null;
+  }
+}
+// src/commands/pull.ts
+async function pullCommand(args) {
+  const slug = requireProjectStore();
+  const force = flagBool(args.flags, "force");
+  const target = args.positional[0];
+  const root = process.cwd();
+  if (!target || target === "*") {
+    return pullAll({ slug, root, args, force });
+  }
+  ensureComponentsDir(root);
+  const outcome = await pullOne({
+    slug,
+    componentDir: path4.join(root, "components", target),
+    name: target,
+    revisionQuery: buildRevisionQuery(args),
+    force
+  });
+  printOutcome(outcome, force);
+  if (outcome.status === "failed") process.exitCode = 1;
+}
+async function pullAll(opts) {
+  const { slug, root, args, force } = opts;
+  if (flagString(args.flags, "version")) {
+    throw new Error(
+      "--version is per-component; pass it together with `gs pull <name>`."
+    );
+  }
+  ensureComponentsDir(root);
+  const revisionQuery = buildRevisionQuery(args);
+  const listUrl = `${apiBaseFor(slug)}/api/builder/components`;
+  const list = await request(listUrl);
+  if (list.components.length === 0) {
+    process.stdout.write(`(no components in ${slug})
+`);
+    return;
+  }
+  const outcomes = [];
+  for (const entry of list.components) {
+    const componentDir = path4.join(root, "components", entry.name);
+    const outcome = await pullOne({
+      slug,
+      componentDir,
+      name: entry.name,
+      revisionQuery,
+      force
+    });
+    outcomes.push(outcome);
+    printOutcome(outcome, force);
   }
-  const sourceNote = data.source === null ? " (no source \u2014 this version was pushed without component.tsx)" : "";
+  const pulled = outcomes.filter((o) => o.status === "pulled").length;
+  const skipped = outcomes.filter((o) => o.status === "skipped").length;
+  const failed = outcomes.filter((o) => o.status === "failed").length;
+  const summary = [`${pulled} pulled`, `${skipped} skipped`];
+  if (failed > 0) summary.push(`${failed} failed`);
   process.stdout.write(
-    `Pulled ${name} v${data.version} \u2192 ${path3.resolve(out)}/{${wrote.join(", ")}}${sourceNote}
+    `
+${summary.join(", ")} (of ${outcomes.length}) \u2190 ${slug}
 `
   );
+  if (failed > 0) process.exitCode = 1;
+}
+async function pullOne(opts) {
+  const { slug, componentDir, name, revisionQuery, force } = opts;
+  if (!force && fs4.existsSync(componentDir)) {
+    const sync = readSyncState(componentDir);
+    if (hasLocalChanges(componentDir, sync)) {
+      return {
+        name,
+        status: "skipped",
+        message: "local has uncommitted changes; pass --force to overwrite"
+      };
+    }
+  }
+  const url = `${apiBaseFor(slug)}/api/builder/components/${encodeURIComponent(name)}${revisionQuery}`;
+  let data;
+  try {
+    data = await request(url);
+  } catch (err) {
+    return {
+      name,
+      status: "failed",
+      message: err instanceof Error ? err.message : String(err)
+    };
+  }
+  fs4.mkdirSync(componentDir, { recursive: true });
+  const manifestText = JSON.stringify(data.manifest, null, 2) + "\n";
+  fs4.writeFileSync(path4.join(componentDir, "manifest.json"), manifestText);
+  fs4.writeFileSync(path4.join(componentDir, "bundle.js"), data.bundle);
+  const wrote = ["manifest.json", "bundle.js"];
+  let sourceHash = "";
+  if (data.source !== null) {
+    fs4.writeFileSync(path4.join(componentDir, "component.tsx"), data.source);
+    wrote.push("component.tsx");
+    sourceHash = hashString(data.source);
+  }
+  writeSyncState(componentDir, {
+    version: data.version,
+    manifestHash: hashString(manifestText),
+    sourceHash
+  });
+  const onDisk = computeComponentHashes(componentDir);
+  writeSyncState(componentDir, {
+    version: data.version,
+    manifestHash: onDisk.manifestHash,
+    sourceHash: onDisk.sourceHash ?? ""
+  });
+  return { name, status: "pulled", version: data.version, wrote };
+}
+function ensureComponentsDir(root) {
+  fs4.mkdirSync(path4.join(root, "components"), { recursive: true });
 }
 function buildRevisionQuery(args) {
   const version = flagString(args.flags, "version");
@@ -550,65 +694,227 @@ function buildRevisionQuery(args) {
   if (flagBool(args.flags, "live")) return `?revision=live`;
   return "";
 }
+function printOutcome(outcome, force) {
+  switch (outcome.status) {
+    case "pulled": {
+      const files = outcome.wrote ? `{${outcome.wrote.join(", ")}}` : "";
+      process.stdout.write(
+        `  pulled    ${outcome.name} v${outcome.version} ${files}
+`
+      );
+      return;
+    }
+    case "skipped":
+      process.stdout.write(`  skipped   ${outcome.name}: ${outcome.message}
+`);
+      return;
+    case "failed":
+      process.stdout.write(
+        `  failed    ${outcome.name}: ${outcome.message ?? "unknown error"}
+`
+      );
+      return;
+  }
+  void force;
+}
 // src/commands/push.ts
-import * as fs4 from "fs";
-import * as path4 from "path";
+import * as fs5 from "fs";
+import * as path5 from "path";
 async function pushCommand(args) {
-  const slug = resolveStore({ flag: flagString(args.flags, "store") });
-  const manifestPath = path4.resolve(flagString(args.flags, "manifest") ?? "manifest.json");
-  const bundlePath = path4.resolve(flagString(args.flags, "bundle") ?? "bundle.js");
-  const sourcePath = path4.resolve(flagString(args.flags, "source") ?? "component.tsx");
-  if (!fs4.existsSync(manifestPath)) {
-    throw new Error(`Manifest not found: ${manifestPath}`);
+  const slug = requireProjectStore();
+  const root = process.cwd();
+  rejectLegacyLayout(root);
+  const componentsDir = path5.join(root, "components");
+  if (!fs5.existsSync(componentsDir)) {
+    throw new Error(
+      "No components/ directory here. Run `gs init <name>` to scaffold the project root and your first component."
+    );
+  }
+  const named = args.positional[0];
+  const manifestOverride = flagString(args.flags, "manifest");
+  const bundleOverride = flagString(args.flags, "bundle");
+  if (!named && (manifestOverride || bundleOverride)) {
+    throw new Error(
+      "--manifest / --bundle can only be used together with `gs push <name>`."
+    );
+  }
+  if (named) {
+    const outcome = await pushOne({
+      slug,
+      root,
+      name: named,
+      ...manifestOverride !== void 0 ? { manifestPath: manifestOverride } : {},
+      ...bundleOverride !== void 0 ? { bundlePath: bundleOverride } : {},
+      force: true
+    });
+    printOutcome2(outcome);
+    if (outcome.status === "failed") process.exitCode = 1;
+    return;
+  }
+  const names = listLocalComponents(componentsDir);
+  if (names.length === 0) {
+    process.stdout.write(
+      "(no components in ./components \u2014 run `gs init <name>` to add one)\n"
+    );
+    return;
+  }
+  const outcomes = [];
+  for (const name of names) {
+    const outcome = await pushOne({ slug, root, name, force: false });
+    outcomes.push(outcome);
+    printOutcome2(outcome);
+  }
+  const pushed = outcomes.filter((o) => o.status === "pushed").length;
+  const unchanged = outcomes.filter((o) => o.status === "unchanged").length;
+  const failed = outcomes.filter((o) => o.status === "failed").length;
+  const summary = [`${pushed} pushed`, `${unchanged} unchanged`];
+  if (failed > 0) summary.push(`${failed} failed`);
+  process.stdout.write(`
+${summary.join(", ")} (of ${outcomes.length}) \u2192 ${slug}
+`);
+  if (failed > 0) process.exitCode = 1;
+}
+async function pushOne(opts) {
+  const { slug, root, name, force } = opts;
+  const componentDir = path5.join(root, "components", name);
+  if (!fs5.existsSync(componentDir)) {
+    return {
+      name,
+      status: "failed",
+      message: `components/${name}/ does not exist`
+    };
+  }
+  const manifestPath = opts.manifestPath ? path5.resolve(opts.manifestPath) : path5.join(componentDir, "manifest.json");
+  const bundlePath = opts.bundlePath ? path5.resolve(opts.bundlePath) : path5.join(componentDir, "bundle.js");
+  const sourcePath = path5.join(componentDir, "component.tsx");
+  if (!fs5.existsSync(manifestPath)) {
+    return { name, status: "failed", message: `manifest not found: ${manifestPath}` };
   }
-  if (!fs4.existsSync(bundlePath)) {
-    throw new Error(`Bundle not found: ${bundlePath} (did you run \`npm run build\`?)`);
+  if (!fs5.existsSync(bundlePath)) {
+    return {
+      name,
+      status: "failed",
+      message: `bundle not found: ${bundlePath} (did you run \`npm run build\`?)`
+    };
   }
-  const manifestText = fs4.readFileSync(manifestPath, "utf8");
+  const manifestText = fs5.readFileSync(manifestPath, "utf8");
   let manifestName;
   try {
     const parsed = JSON.parse(manifestText);
     if (typeof parsed.name === "string") manifestName = parsed.name;
   } catch (err) {
-    throw new Error(`Manifest is not valid JSON: ${err.message}`);
-  }
-  const name = args.positional[0] ?? manifestName;
-  if (!name) {
-    throw new Error("Could not determine component name. Pass it positionally or set `name` in manifest.json.");
+    return {
+      name,
+      status: "failed",
+      message: `manifest is not valid JSON: ${err.message}`
+    };
   }
   if (manifestName && manifestName !== name) {
-    throw new Error(
-      `Manifest name "${manifestName}" does not match argument "${name}". The server will reject this.`
-    );
+    return {
+      name,
+      status: "failed",
+      message: `manifest name "${manifestName}" does not match folder name "${name}"`
+    };
+  }
+  if (!force) {
+    const hashes2 = computeComponentHashes(componentDir);
+    const sync = readSyncState(componentDir);
+    const unchanged = sync !== null && sync.manifestHash === hashes2.manifestHash && sync.sourceHash === (hashes2.sourceHash ?? "");
+    if (unchanged) {
+      return { name, status: "unchanged" };
+    }
   }
-  const bundleText = fs4.readFileSync(bundlePath, "utf8");
-  const sourceText = fs4.existsSync(sourcePath) ? fs4.readFileSync(sourcePath, "utf8") : null;
+  const bundleText = fs5.readFileSync(bundlePath, "utf8");
+  const sourceText = fs5.existsSync(sourcePath) ? fs5.readFileSync(sourcePath, "utf8") : null;
   const form = new FormData();
-  form.append("manifest", new Blob([manifestText], { type: "application/json" }), "manifest.json");
-  form.append("bundle", new Blob([bundleText], { type: "text/javascript" }), "bundle.js");
+  form.append(
+    "manifest",
+    new Blob([manifestText], { type: "application/json" }),
+    "manifest.json"
+  );
+  form.append(
+    "bundle",
+    new Blob([bundleText], { type: "text/javascript" }),
+    "bundle.js"
+  );
   if (sourceText !== null) {
     form.append(
       "source",
       new Blob([sourceText], { type: "text/plain; charset=utf-8" }),
-      path4.basename(sourcePath)
+      "component.tsx"
     );
   }
   const url = `${apiBaseFor(slug)}/api/builder/components/${encodeURIComponent(name)}`;
-  const data = await request(url, { method: "POST", multipart: form });
-  const sourceNote = sourceText === null ? " (no source uploaded \u2014 `component.tsx` not found in cwd)" : "";
-  process.stdout.write(
-    `Pushed ${name} v${data.version} (draft) to ${slug}${sourceNote}. View: ${data.permalink}
-Run \`gs publish ${name}\` to promote.
+  let data;
+  try {
+    data = await request(url, { method: "POST", multipart: form });
+  } catch (err) {
+    return {
+      name,
+      status: "failed",
+      message: err instanceof Error ? err.message : String(err)
+    };
+  }
+  const hashes = computeComponentHashes(componentDir);
+  writeSyncState(componentDir, {
+    version: data.version,
+    manifestHash: hashes.manifestHash,
+    sourceHash: hashes.sourceHash ?? ""
+  });
+  return {
+    name,
+    status: "pushed",
+    version: data.version,
+    permalink: data.permalink
+  };
+}
+function listLocalComponents(componentsDir) {
+  return fs5.readdirSync(componentsDir).filter((entry) => {
+    const dir = path5.join(componentsDir, entry);
+    return fs5.statSync(dir).isDirectory() && fs5.existsSync(path5.join(dir, "manifest.json"));
+  }).sort();
+}
+function rejectLegacyLayout(root) {
+  const rootManifest = path5.join(root, "manifest.json");
+  const componentsDir = path5.join(root, "components");
+  if (fs5.existsSync(rootManifest) && !fs5.existsSync(componentsDir)) {
+    throw new Error(
+      [
+        "Detected the old single-component layout (manifest.json at the project root).",
+        "The Builder CLI now uses a multi-component layout: scaffold a fresh dir with",
+        "`gs init`, then move your component into `components/<name>/`. Re-run `gs push`",
+        "from the new project root."
+      ].join(" ")
+    );
+  }
+}
+function printOutcome2(outcome) {
+  switch (outcome.status) {
+    case "pushed":
+      process.stdout.write(
+        `  pushed    ${outcome.name} v${outcome.version} \u2192 ${outcome.permalink ?? ""}
 `
-  );
+      );
+      return;
+    case "unchanged":
+      process.stdout.write(`  unchanged ${outcome.name}
+`);
+      return;
+    case "failed":
+      process.stdout.write(
+        `  failed    ${outcome.name}: ${outcome.message ?? "unknown error"}
+`
+      );
+      return;
+  }
 }
 // src/commands/publish.ts
 async function publishCommand(args) {
   const name = args.positional[0];
   if (!name) throw new Error("Usage: gs publish <name> [--version N]");
-  const slug = resolveStore({ flag: flagString(args.flags, "store") });
+  const slug = requireProjectStore();
   const url = `${apiBaseFor(slug)}/api/builder/components/${encodeURIComponent(name)}/publish`;
   const versionFlag = flagString(args.flags, "version");
   let body = void 0;
@@ -632,7 +938,7 @@ async function publishCommand(args) {
 async function unpublishCommand(args) {
   const name = args.positional[0];
   if (!name) throw new Error("Usage: gs unpublish <name>");
-  const slug = resolveStore({ flag: flagString(args.flags, "store") });
+  const slug = requireProjectStore();
   const url = `${apiBaseFor(slug)}/api/builder/components/${encodeURIComponent(name)}/unpublish`;
   await request(url, { method: "POST", body: {} });
   process.stdout.write(`Unpublished ${name}. The draft and version history are retained.
@@ -644,7 +950,7 @@ import * as readline from "readline";
 async function deleteCommand(args) {
   const name = args.positional[0];
   if (!name) throw new Error("Usage: gs delete <name> [--yes]");
-  const slug = resolveStore({ flag: flagString(args.flags, "store") });
+  const slug = requireProjectStore();
   if (!flagBool(args.flags, "yes")) {
     const confirmed = await prompt(
       `Soft-delete component "${name}" in store "${slug}"? Type "yes" to confirm: `
@@ -660,71 +966,116 @@ async function deleteCommand(args) {
 `);
 }
 function prompt(question) {
-  return new Promise((resolve5) => {
+  return new Promise((resolve4) => {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     rl.question(question, (answer) => {
       rl.close();
-      resolve5(answer);
+      resolve4(answer);
     });
   });
 }
 // src/commands/init.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
+import * as fs6 from "fs";
+import * as path6 from "path";
 var NAME_REGEX = /^[a-z][a-z0-9_]*$/;
 function initCommand(args) {
   const name = args.positional[0];
-  if (!name) {
-    throw new Error("Usage: gs init <name> [--out <dir>] [--store <slug>] [--force]");
-  }
-  if (!NAME_REGEX.test(name)) {
+  if (name !== void 0 && !NAME_REGEX.test(name)) {
     throw new Error(`Invalid component name: "${name}" (must match ${NAME_REGEX}).`);
   }
-  const outRel = flagString(args.flags, "out") ?? name;
-  const out = path5.resolve(outRel);
   const force = flagBool(args.flags, "force");
   const storeFlag = flagString(args.flags, "store");
-  ensureWritable(out, force);
-  fs5.mkdirSync(out, { recursive: true });
-  for (const [relPath, content] of files({ name, store: storeFlag })) {
-    const full = path5.join(out, relPath);
-    fs5.mkdirSync(path5.dirname(full), { recursive: true });
-    fs5.writeFileSync(full, content);
+  const outRel = flagString(args.flags, "out") ?? ".";
+  const root = path6.resolve(outRel);
+  const rootExisted = hasRootScaffold(root);
+  ensureRoot(root, rootExisted, force, { store: storeFlag });
+  if (!name) {
+    const created = rootExisted ? "Updated" : "Scaffolded";
+    process.stdout.write(
+      [
+        `${created} GreatStore project root in ${root}.`,
+        "",
+        "Next steps:",
+        `  cd ${path6.relative(process.cwd(), root) || "."}`,
+        "  npm install",
+        "  gs init <component_name>     # add your first component",
+        ""
+      ].join("\n")
+    );
+    return;
   }
+  const componentDir = path6.join(root, "components", name);
+  ensureComponent(componentDir, name, force);
+  const projectLabel = path6.relative(process.cwd(), root) || ".";
   process.stdout.write(
     [
-      `Scaffolded "${name}" in ${out}.`,
+      `Added component "${name}" at components/${name}/.`,
       "",
       "Next steps:",
-      `  cd ${path5.relative(process.cwd(), out) || "."}`,
-      "  npm install",
+      ...rootExisted ? [] : [`  cd ${projectLabel}`, "  npm install"],
+      `  # edit components/${name}/component.tsx and manifest.json`,
       "  npm run build",
       "  gs push",
       ""
     ].join("\n")
   );
 }
-function ensureWritable(dir, force) {
-  if (!fs5.existsSync(dir)) return;
-  const entries = fs5.readdirSync(dir);
-  if (entries.length === 0) return;
-  if (force) return;
-  throw new Error(
-    `Refusing to scaffold into non-empty directory ${dir}. Pass --force to override.`
-  );
+function hasRootScaffold(dir) {
+  return fs6.existsSync(path6.join(dir, "package.json")) && fs6.existsSync(path6.join(dir, "build.mjs"));
+}
+function ensureRoot(root, rootExisted, force, opts) {
+  fs6.mkdirSync(root, { recursive: true });
+  if (rootExisted) {
+    fs6.mkdirSync(path6.join(root, "components"), { recursive: true });
+    return;
+  }
+  if (!force) {
+    const entries = fs6.readdirSync(root).filter((e) => e !== ".gsrc");
+    if (entries.length > 0) {
+      throw new Error(
+        `Refusing to scaffold project root into non-empty directory ${root}. Pass --force to override.`
+      );
+    }
+  }
+  for (const [relPath, content] of rootFiles({ store: opts.store })) {
+    const full = path6.join(root, relPath);
+    fs6.mkdirSync(path6.dirname(full), { recursive: true });
+    if (force || !fs6.existsSync(full)) {
+      fs6.writeFileSync(full, content);
+    }
+  }
+  fs6.mkdirSync(path6.join(root, "components"), { recursive: true });
 }
-function files(opts) {
-  const { name, store } = opts;
+function ensureComponent(componentDir, name, force) {
+  if (fs6.existsSync(componentDir) && !force) {
+    const entries = fs6.readdirSync(componentDir);
+    if (entries.length > 0) {
+      throw new Error(
+        `Refusing to overwrite existing components/${name}/. Pass --force to override.`
+      );
+    }
+  }
+  fs6.mkdirSync(componentDir, { recursive: true });
+  for (const [relPath, content] of componentFiles(name)) {
+    fs6.writeFileSync(path6.join(componentDir, relPath), content);
+  }
+}
+function rootFiles(opts) {
   return [
-    ["manifest.json", manifest(name)],
-    ["component.tsx", component(name)],
-    ["vite.config.ts", viteConfig()],
-    ["tsconfig.json", tsconfig()],
-    ["package.json", packageJson(name)],
-    [".gsrc", gsrc(store)],
+    ["package.json", rootPackageJson()],
+    ["build.mjs", buildScript()],
+    ["vite.config.ts", viteEditorConfig()],
+    ["tsconfig.json", rootTsconfig()],
+    [".gsrc", gsrc(opts.store)],
     [".gitignore", gitignore()],
-    ["README.md", readme(name)]
+    ["README.md", rootReadme()]
+  ];
+}
+function componentFiles(name) {
+  return [
+    ["manifest.json", manifest(name)],
+    ["component.tsx", component(name)]
   ];
 }
 function manifest(name) {
@@ -765,51 +1116,86 @@ export default function ${pascal(name)}(_props: Props): React.ReactElement {
 }
 `;
 }
-function viteConfig() {
-  return `import { defineConfig } from "vite";
+function buildScript() {
+  return `import { build } from "vite";
 import react from "@vitejs/plugin-react";
+import * as fs from "node:fs";
+import * as path from "node:path";
-// Builds a single ESM bundle suitable for \`gs push\`.
-//
-// React / react-dom / react/jsx-runtime are EXTERNALIZED and rewritten
-// at build time to point at GreatStore's runtime shim at
-// \`/assets/remote-components/_runtime.js\`. The shim re-exports the host
-// chat tree's React instance off \`window.__GS_REMOTE_RUNTIME__\`, so
-// the component and the host share one React. Bundling React in
-// instead would crash on the first hook call because the bundled-in
-// React's dispatcher is null when the chat tree drives the render.
-//
-// Do NOT remove the \`paths\` mapping \u2014 without it the browser tries to
-// resolve a bare \`react\` specifier and fails before the component
-// renders.
-export default defineConfig({
-  plugins: [react()],
-  build: {
-    lib: {
-      entry: "component.tsx",
-      formats: ["es"],
-      fileName: () => "bundle.js",
-    },
-    outDir: ".",
-    emptyOutDir: false,
-    rollupOptions: {
-      external: ["react", "react-dom", "react/jsx-runtime"],
-      output: {
-        entryFileNames: "bundle.js",
-        paths: {
-          react: "/assets/remote-components/_runtime.js",
-          "react-dom": "/assets/remote-components/_runtime.js",
-          "react/jsx-runtime": "/assets/remote-components/_runtime.js",
+const COMPONENTS_DIR = path.resolve("components");
+function listComponents() {
+  if (!fs.existsSync(COMPONENTS_DIR)) return [];
+  return fs
+    .readdirSync(COMPONENTS_DIR)
+    .filter((entry) => {
+      const dir = path.join(COMPONENTS_DIR, entry);
+      return (
+        fs.statSync(dir).isDirectory() &&
+        fs.existsSync(path.join(dir, "component.tsx"))
+      );
+    })
+    .sort();
+}
+const components = listComponents();
+if (components.length === 0) {
+  console.log("(no components in ./components \u2014 run \`gs init <name>\` to add one)");
+  process.exit(0);
+}
+const target = process.argv[2];
+const queue = target ? components.filter((c) => c === target) : components;
+if (target && queue.length === 0) {
+  console.error(\`No component named "\${target}" in ./components\`);
+  process.exit(1);
+}
+for (const name of queue) {
+  const dir = path.join(COMPONENTS_DIR, name);
+  await build({
+    plugins: [react()],
+    logLevel: "warn",
+    build: {
+      lib: {
+        entry: path.join(dir, "component.tsx"),
+        formats: ["es"],
+        fileName: () => "bundle.js",
+      },
+      outDir: dir,
+      emptyOutDir: false,
+      rollupOptions: {
+        external: ["react", "react-dom", "react/jsx-runtime"],
+        output: {
+          entryFileNames: "bundle.js",
+          paths: {
+            react: "/assets/remote-components/_runtime.js",
+            "react-dom": "/assets/remote-components/_runtime.js",
+            "react/jsx-runtime": "/assets/remote-components/_runtime.js",
+          },
         },
       },
+      minify: true,
+      sourcemap: false,
     },
-    minify: true,
-    sourcemap: false,
-  },
+  });
+  console.log(\`built components/\${name}/bundle.js\`);
+}
+`;
+}
+function viteEditorConfig() {
+  return `import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+// Real builds happen in build.mjs (one Vite invocation per component).
+// This file exists only so editors / language servers can resolve the
+// React plugin when inspecting components/*/component.tsx.
+export default defineConfig({
+  plugins: [react()],
 });
 `;
 }
-function tsconfig() {
+function rootTsconfig() {
   return JSON.stringify(
     {
       compilerOptions: {
@@ -824,22 +1210,22 @@ function tsconfig() {
         isolatedModules: true,
         noEmit: true
       },
-      include: ["component.tsx", "vite.config.ts"]
+      include: ["components/**/component.tsx", "vite.config.ts", "build.mjs"]
     },
     null,
     2
   ) + "\n";
 }
-function packageJson(name) {
+function rootPackageJson() {
   return JSON.stringify(
     {
-      name,
+      name: "greatstore-components",
       version: "0.0.1",
       private: true,
       type: "module",
       scripts: {
-        build: "vite build",
-        push: "vite build && gs push"
+        build: "node build.mjs",
+        push: "node build.mjs && gs push"
       },
       dependencies: {
         react: "^19.0.0",
@@ -861,22 +1247,34 @@ function gsrc(store) {
   return JSON.stringify({ store: store ?? "<your-store-slug>" }, null, 2) + "\n";
 }
 function gitignore() {
-  return ["node_modules/", "bundle.js", "*.tsbuildinfo", ".DS_Store", ""].join("\n");
+  return [
+    "node_modules/",
+    "components/*/bundle.js",
+    "components/*/.gssync.json",
+    "*.tsbuildinfo",
+    ".DS_Store",
+    ""
+  ].join("\n");
 }
-function readme(name) {
-  return `# ${name}
+function rootReadme() {
+  return `# GreatStore components
-A GreatStore custom component scaffolded with \`gs init\`.
+Custom React components published to your GreatStore tenant. Each
+component lives in its own folder under \`components/\`.
 \`\`\`
 npm install
-npm run build   # produces bundle.js
-gs push          # uploads as a draft revision
-gs publish ${name}
+gs init <component_name>      # add a new component
+npm run build                 # builds every component/<name>/bundle.js
+gs push                       # uploads every changed component as a draft
+gs publish <component_name>   # promote a specific component to live
 \`\`\`
-Edit \`component.tsx\` for the UI and \`manifest.json\` for the metadata
-that the LLM sees (especially \`description\` and \`inputSchema\`).
+- \`gs push\` (no args) hashes each component and only uploads the ones
+  that have changed since the last sync.
+- \`gs pull\` (no args) refreshes every remote component into
+  \`components/<name>/\`. Components with unsaved local edits are skipped
+  with a warning; pass \`--force\` to overwrite.
 `;
 }
 function pascal(name) {
@@ -884,7 +1282,7 @@ function pascal(name) {
 }
 // src/index.ts
-var VERSION = true ? "0.0.9" : "0.0.0-dev";
+var VERSION = true ? "0.0.11-beta.0" : "0.0.0-dev";
 var HELP = `gs \u2014 GreatStore CLI (v${VERSION})
 Usage:
@@ -894,28 +1292,27 @@ Commands:
   login                          Open browser, capture nav token, persist credentials.
   logout                         Wipe ~/.greatstore/credentials.json.
   whoami                         Print the identity stored locally.
-  init <name>                    Scaffold a component project.
+  init [<name>]                  Scaffold project root; add \`components/<name>/\` if name given.
   list                           List components in the current store.
-  pull <name>                    Download manifest.json + bundle.js.
-  push [<name>]                  Upload manifest.json + bundle.js as a new draft.
+  pull [<name>|*]                Download remote component(s) into \`components/<name>/\`. No args = all.
+  push [<name>]                  Upload changed components from \`components/\`. No args = all (skips unchanged).
   publish <name>                 Promote the draft (or --version N) to live.
   unpublish <name>               Clear the live pointer.
   delete <name>                  Soft-delete the component.
 Common flags:
-  --store <slug>                 Target store (else .gsrc or GS_STORE).
+  --store <slug>                 \`init\` only \u2014 writes the slug into .gsrc. Other commands read .gsrc.
   --json                         Machine-readable output for \`list\`.
   --draft | --live | --version N Revision selector for \`pull\`.
   -o, --out <dir>                Output directory for \`pull\` / \`init\`.
   --manifest <path>              Path to manifest for \`push\`.
   --bundle <path>                Path to bundle for \`push\`.
-  --force                        Overwrite for \`init\`; skip confirmation for \`delete\`.
+  --force                        Overwrite for \`init\` / \`pull\`; skip confirmation for \`delete\`.
   --yes                          Skip confirmation for \`delete\`.
   -h, --help                     Show this help.
   -v, --version                  Print version.
 Environment:
-  GS_STORE                       Fallback for --store.
   GS_API_BASE                    Override API base (full URL, no trailing slash).
   GS_NAV_BASE                    Override nav OAuth base.
   GS_BROWSER_CMD                 Override the browser-open command.

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@greatstore/cli",
-  "version": "0.0.9",
+  "version": "0.0.11-beta.0",
   "description": "CLI for authoring and shipping GreatStore custom components.",
   "license": "UNLICENSED",
   "type": "module",