menloapp 1.6.0 → 1.7.0

package/README.md

@@ -23,8 +23,15 @@ npm i -g menloapp
 menloapp deploy
 ```
 
-Run deploy in your app’s public GitHub repository. It returns a live link like
+Run deploy in your app’s folder. It returns a live link like
 **https://menloapp.lol/your-app**. Share it. New commits update the same app page.
+
+Deploy takes care of the Git and GitHub steps, asking before each one. A plain
+folder gets a Git repository (with a standard Xcode `.gitignore` that keeps
+`.env`, signing keys and provisioning profiles out). Uncommitted changes can be
+committed with your message, a missing GitHub repository is created as a public
+repository under your account, and unpushed commits are pushed. Deploy never
+commits files that look like secrets and stops on files GitHub would reject.
 Interactive Mac deploy copies the link and prints a ready-to-share X link.
 Empty app descriptions are filled from your public GitHub repository description;
 supplied copy is preserved.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "menloapp",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "MENLO: share living iOS apps from GitHub and try them on your own iPhone",
   "type": "module",
   "bin": {

package/src/constants.js

@@ -1,4 +1,4 @@
-export const NPM_CLI_VERSION = "1.6.0";
+export const NPM_CLI_VERSION = "1.7.0";
 export const PRODUCT_VERSION = "1.3.0";
 export const MANIFEST_URL = "https://tohseno.com/releases/cli-1.3.0.json";
 export const MANIFEST_ORIGINS = new Set(["https://tohseno.com"]);

package/src/github.js

@@ -6,6 +6,7 @@ import { choose, continueAfter, deployUI, openBrowser, shellQuote } from "./depl
 
 import { setupPresentation, readCommittedPresentation, updatePresentationLinks, fillPresentationDescription, fillPresentationIcon, commitPresentation, previewNeedsRefresh } from "./project-presentation.js";
 import { recordExperience } from "./record.js";
+import { createGitHubRepository, initRepository, offerCommit, pushBranch } from "./repository-setup.js";
 import { previewTools } from "./experience-agent.js";
 
 export const MENLO_ORIGIN = "https://menloapp.lol";
@@ -121,6 +122,11 @@ export async function authenticate(ui, { fetcher = fetch, execute = run, env = p
   catch (error) { if (error.status === 401) throw new Error(`GitHub did not accept the new sign-in.\n${instructions}`); throw error; }
 }
 
+function isAncestor(root, ancestor, commit) {
+  try { execFileSync("git", ["-C", root, "merge-base", "--is-ancestor", ancestor, commit], { stdio: "ignore", timeout: 20_000 }); return true; }
+  catch { return false; }
+}
+
 function git(directory, ...args) {
   try { return run("git", ["-C", directory, ...args]); }
   catch { throw new Error("Open your app's Git repository, then run menloapp deploy. It needs a GitHub origin and at least one commit."); }
@@ -138,9 +144,34 @@ async function inspectRepository(options) {
   return { root, directory, explicitContainer, repository: githubRepository(remote) };
 }
 
+/**
+ * Take the folder as far as a GitHub repository with at least one commit,
+ * asking before each step: git init, first commit, public GitHub repository.
+ */
+async function prepareRepository(options, ui, { credential, user, fetcher, description }) {
+  let input;
+  try { input = await realpath(options.directory); } catch { throw new Error(`App directory not found: ${options.directory}\nRun menloapp deploy from your app's repository.`); }
+  const directory = /\.(xcodeproj|xcworkspace)$/.test(input) ? path.dirname(input) : input;
+  let root = optionalRun(run, "git", ["-C", directory, "rev-parse", "--show-toplevel"]);
+  if (!root) root = await initRepository(directory, ui);
+  if (!optionalRun(run, "git", ["-C", root, "rev-parse", "--verify", "-q", "HEAD"])) {
+    if (!ui.interactive) throw new Error("This repository has no commits yet.\nCommit your app (git add -A && git commit -m \"First version\"), then run menloapp deploy.");
+    if (!await offerCommit(root, ui, { first: true, name: path.basename(root) })) throw new Error("Deploy needs a first commit. Nothing was published.");
+  }
+  if (!optionalRun(run, "git", ["-C", root, "remote", "get-url", "origin"])) {
+    const call = (url, init) => api(url, { ...init, headers: { ...headers(credential), "Content-Type": "application/json" } }, fetcher);
+    await createGitHubRepository(root, ui, { credential, user, api: call, describe: description });
+  }
+  return inspectRepository(options);
+}
+
 export async function inspectProject(options, ui = deployUI(options)) {
   const { root, directory, explicitContainer, repository } = await inspectRepository(options);
   while (git(root, "status", "--porcelain", "--untracked-files=normal")) {
+    if (ui.interactive) {
+      try { if (await offerCommit(root, ui, { name: path.basename(root) })) continue; }
+      catch (error) { ui.log(`\n${error.message}`); }
+    }
     await continueAfter(ui, "Your app has uncommitted changes. MENLO shares the code pushed to GitHub.\nIn another terminal, review git status, commit the files you want to share, and push them. Local files will not be uploaded automatically.");
   }
   const commit = git(root, "rev-parse", "HEAD");
@@ -232,21 +263,43 @@ export async function deploy(args, dependencies = {}) {
   const ui = dependencies.ui || deployUI(options);
   const fetcher = dependencies.fetcher || fetch;
   if (options.help) {
-    ui.print("MENLO deploy\n\nmenloapp deploy [path]\n\nSign in to GitHub, choose your app if needed, and get a production app link.\nMENLO guides you through each step. Later pushes appear automatically.\n\nOptions: --project path/App.xcodeproj, --scheme Name, --app-slug your-app,\n         --name Name, --dry-run (local checks only), --json (no prompts)\n         --record (regenerate the automatic preview), --no-preview,\n         --seconds 3–60, --simulator UDID");
+    ui.print("MENLO deploy\n\nmenloapp deploy [path]\n\nSign in to GitHub, choose your app if needed, and get a production app link.\nMENLO sets up Git and a public GitHub repository if needed, asking first.\nLater pushes appear automatically.\n\nOptions: --project path/App.xcodeproj, --scheme Name, --app-slug your-app,\n         --name Name, --dry-run (local checks only), --json (no prompts)\n         --record (regenerate the automatic preview), --no-preview,\n         --seconds 3–60, --simulator UDID");
     return 0;
   }
   if (options.dryRun) { ui.print(JSON.stringify(await inspectProject(options, ui), null, 2)); return 0; }
-  const local = await inspectRepository(options);
-  ui.log(`MENLO deploy\nRepository: ${local.repository}`);
-  const { credential } = await authenticate(ui, { ...dependencies, fetcher });
+  // A non-GitHub origin fails before sign-in; a missing repository or origin is set up after it.
+  const existingRoot = optionalRun(run, "git", ["-C", options.directory, "rev-parse", "--show-toplevel"]);
+  const existingRemote = existingRoot && optionalRun(run, "git", ["-C", existingRoot, "remote", "get-url", "origin"]);
+  if (existingRemote) githubRepository(existingRemote);
+  ui.log("MENLO deploy");
+  const { credential, user } = await authenticate(ui, { ...dependencies, fetcher });
+  const local = await prepareRepository(options, ui, { credential, user, fetcher, description: "" });
+  ui.log(`Repository: ${local.repository}`);
   const repo = await publicRepository(local.repository, credential, ui, fetcher);
+  const sleep = dependencies.sleep || (ms => new Promise(resolve => setTimeout(resolve, ms)));
+  let pushed = 0;
   let project;
   while (true) {
     project = await inspectProject(options, ui);
     if (project.repository !== local.repository) throw new Error("The GitHub origin changed during deployment. Run menloapp deploy again to connect the new repository.");
-    const head = await api(`https://api.github.com/repos/${project.repository}/commits/${encodeURIComponent(repo.default_branch)}`, { headers: headers(credential) }, fetcher);
-    if (head.sha === project.commit) break;
+    let head;
+    try { head = await api(`https://api.github.com/repos/${project.repository}/commits/${encodeURIComponent(repo.default_branch)}`, { headers: headers(credential) }, fetcher); }
+    catch (error) { if (error.status !== 409 && error.status !== 404) throw error; head = null; /* An empty GitHub repository. */ }
+    if (head?.sha === project.commit) break;
+    // GitHub can take a moment to report a branch that was just pushed.
+    if (pushed && pushed < 4) { pushed++; await sleep(1500); continue; }
     const branch = git(local.root, "branch", "--show-current");
+    const ahead = branch === repo.default_branch && (!head || isAncestor(local.root, head.sha, project.commit));
+    if (ahead && ui.interactive && pushed === 0) {
+      const count = Number(optionalRun(run, "git", ["-C", local.root, "rev-list", "--count", head ? `${head.sha}..HEAD` : "HEAD"])) || 1;
+      const answer = await ui.ask(`Push ${count === 1 ? "your new commit" : `${count} new commits`} to GitHub's ${branch} branch? [Y/n] `);
+      if (!answer || /^y(es)?$/i.test(answer)) {
+        pushBranch(local.root, project.repository, branch, credential);
+        pushed = 1;
+        continue;
+      }
+    }
+    pushed = 0;
     const instruction = branch === repo.default_branch
       ? `Push your committed changes: git push origin ${shellQuote(branch)}\nIf GitHub has newer commits, bring them in first: git pull --ff-only origin ${shellQuote(branch)}`
       : `MENLO follows ${repo.default_branch}. Merge your changes into that branch and push it, then switch this checkout to ${repo.default_branch}.`;
@@ -271,7 +324,7 @@ export async function deploy(args, dependencies = {}) {
     }
   }
   if (generated.length) {
-    (dependencies.commitPresentation || commitPresentation)(local.root, [...new Set(generated)], repo.default_branch);
+    (dependencies.commitPresentation || commitPresentation)(local.root, [...new Set(generated)], repo.default_branch, { repository: local.repository, credential });
     project = await inspectProject(options, ui);
   }
   ui.log(`App: ${project.name}\nProject: ${project.project} · ${project.scheme}\nConnecting this app to MENLO…`);
@@ -309,7 +362,7 @@ export async function deploy(args, dependencies = {}) {
   }
   if (result.public_url !== `${MENLO_ORIGIN}/${project.slug}`) throw new Error("MENLO did not confirm the expected app link. Run menloapp deploy again to verify it.");
   if (await updatePresentationLinks(local.root, project.repository, result.public_url)) {
-    (dependencies.commitPresentation || commitPresentation)(local.root, ["menloapp/app.json"], repo.default_branch);
+    (dependencies.commitPresentation || commitPresentation)(local.root, ["menloapp/app.json"], repo.default_branch, { repository: local.repository, credential });
     ui.log("Saved your GitHub and MENLO links to menloapp/app.json.");
   }
   result = { ...result, githubRepo: `https://github.com/${project.repository}`, menloLink: result.public_url };

package/src/project-presentation.js

@@ -1,6 +1,7 @@
 import { execFileSync } from "node:child_process";
 import { lstat, mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
+import { pushBranch } from "./repository-setup.js";
 import { PRESENTATION_PATH, MAX_PRESENTATION_BYTES, MAX_IMAGE_BYTES, MAX_VIDEO_BYTES, validatePresentation, presentationFiles, validateMediaBytes } from "./presentation.js";
 
 export function projectRoot(directory) {
@@ -134,7 +135,7 @@ export function previewNeedsRefresh(root, commit, presentation) {
   } catch { return true; }
 }
 
-export function commitPresentation(root, files, branch) {
+export function commitPresentation(root, files, branch, { repository, credential } = {}) {
   const allowed = new Set(files);
   for (const file of allowed) if (!file.startsWith("menloapp/") || file.split("/").some(part => part === ".." || part === ".")) throw new Error("Only generated app presentation files can be committed by deploy.");
   const git = (...args) => execFileSync("git", ["-C", root, ...args], { encoding: "utf8", timeout: 60_000, stdio: ["ignore", "pipe", "pipe"] }).trim();
@@ -145,7 +146,9 @@ export function commitPresentation(root, files, branch) {
   if (!trackedChanges.length && !untracked.length) return false;
   git("add", "--", ...allowed);
   git("commit", "-m", "Update MENLO app page", "--only", "--", ...allowed);
-  try { git("push", "origin", branch); }
-  catch { throw new Error(`The app page is committed locally, but the push did not complete. Run git push origin ${branch}, then menloapp deploy.`); }
+  try {
+    if (repository) pushBranch(root, repository, branch, credential);
+    else git("push", "origin", branch);
+  } catch { throw new Error(`The app page is committed locally, but the push did not complete. Run git push origin ${branch}, then menloapp deploy.`); }
   return true;
 }

package/src/repository-setup.js

@@ -0,0 +1,158 @@
+import { execFileSync } from "node:child_process";
+import { stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+
+// Deploy can take a plain folder all the way to a public GitHub repository.
+// Every step that publishes code asks first, and nothing secret-looking is committed.
+
+const GITHUB_FILE_LIMIT = 100 * 1024 * 1024;
+
+export const XCODE_GITIGNORE = `# Xcode
+build/
+DerivedData/
+xcuserdata/
+*.xcuserstate
+*.xcscmblueprint
+*.xccheckout
+.build/
+.swiftpm/xcode/
+
+# macOS
+.DS_Store
+
+# Secrets and signing material stay on this Mac
+.env
+.env.*
+*.p8
+*.p12
+*.pem
+*.key
+*.cer
+*.mobileprovision
+*.provisionprofile
+`;
+
+// Files that usually hold credentials. Deploy refuses to publish them automatically.
+const RISKY = [
+  /(?:^|\/)\.env(?:\.|$)/, /\.(?:p8|p12|pem|key|cer|mobileprovision|provisionprofile|keystore|jks)$/i,
+  /(?:^|\/)(?:credentials|secrets?)(?:\.[a-z]+)?$/i, /(?:^|\/)id_(?:rsa|ed25519|ecdsa)$/,
+];
+export const riskyFile = file => RISKY.some(pattern => pattern.test(file));
+
+const gitIn = (root, args, options = {}) => execFileSync("git", ["-C", root, ...args], { encoding: "utf8", timeout: 120_000, maxBuffer: 64 * 1024 * 1024, stdio: ["ignore", "pipe", "pipe"], ...options }).trim();
+
+/** Files that `git add -A` would stage, relative to the repository root. */
+function pendingFiles(root) {
+  const untracked = gitIn(root, ["ls-files", "--others", "--exclude-standard", "-z"]).split("\0").filter(Boolean);
+  let changed = [];
+  try { changed = gitIn(root, ["diff", "HEAD", "--name-only", "-z"]).split("\0").filter(Boolean); }
+  catch { changed = gitIn(root, ["ls-files", "-z"]).split("\0").filter(Boolean); }
+  return [...new Set([...changed, ...untracked])].sort();
+}
+
+async function checkPublishable(root, files) {
+  const risky = files.filter(riskyFile);
+  if (risky.length) throw new Error(`These files look like secrets, so Menlo will not publish them:\n${risky.slice(0, 10).map(file => `  ${file}`).join("\n")}\nAdd them to .gitignore (or remove them), then run menloapp deploy again.`);
+  const large = [];
+  for (const file of files) {
+    const info = await stat(path.join(root, file)).catch(() => null);
+    if (info?.isFile() && info.size > GITHUB_FILE_LIMIT) large.push(file);
+  }
+  if (large.length) throw new Error(`GitHub does not accept files over 100 MB:\n${large.map(file => `  ${file}`).join("\n")}\nAdd them to .gitignore, then run menloapp deploy again.`);
+}
+
+function summary(files) {
+  const shown = files.slice(0, 12).map(file => `  ${file}`).join("\n");
+  return files.length > 12 ? `${shown}\n  …and ${files.length - 12} more` : shown;
+}
+
+const yes = (answer, fallback) => answer === "" ? fallback : /^y(es)?$/i.test(answer);
+
+/** Make a plain app folder into a Git repository with one reviewed first commit. */
+export async function initRepository(directory, ui) {
+  if (!ui.interactive) throw new Error("This folder is not a Git repository yet.\nRun menloapp deploy in a terminal and Menlo will set it up, or run:\n  git init && git add -A && git commit -m \"First version\"");
+  const projects = execFileSync("find", [directory, "-maxdepth", "4", "(", "-name", "*.xcodeproj", "-o", "-name", "*.xcworkspace", ")", "-not", "-path", "*/DerivedData/*", "-not", "-path", "*/build/*", "-not", "-path", "*.xcodeproj/*"], { encoding: "utf8", timeout: 20_000 }).trim();
+  if (!projects) throw new Error("No Xcode project was found in this folder.\nRun menloapp deploy from your iOS app's folder.");
+  ui.log(`\nThis folder is not a Git repository yet. Menlo shares apps from public GitHub source,\nso it will set one up here (with a standard Xcode .gitignore that keeps secrets out).`);
+  if (!yes(await ui.ask("Set up Git here? [Y/n] "), true)) throw new Error("Deploy stopped. Nothing was changed.");
+  gitIn(directory, ["init", "-q", "--initial-branch=main"]);
+  const ignore = path.join(directory, ".gitignore");
+  try { await writeFile(ignore, XCODE_GITIGNORE, { flag: "wx" }); }
+  catch (error) { if (error.code !== "EEXIST") throw error; }
+  return directory;
+}
+
+/**
+ * Offer to commit pending work. Returns true when a commit was made.
+ * `first` describes a brand-new repository's first commit.
+ */
+export async function offerCommit(root, ui, { first = false, name = "app" } = {}) {
+  const files = pendingFiles(root);
+  if (!files.length) return false;
+  await checkPublishable(root, files);
+  ui.log(`\n${first ? "Files for the first version" : "Uncommitted changes"} (${files.length}):\n${summary(files)}`);
+  const question = first ? `Commit ${files.length === 1 ? "this file" : `these ${files.length} files`}? [Y/n] ` : `Commit ${files.length === 1 ? "this change" : `these ${files.length} changes`} and publish them to GitHub? [y/N] `;
+  if (!yes(await ui.ask(question), first)) return false;
+  const message = (first ? "" : await ui.ask(`Commit message [Update ${name}]: `)) || (first ? `First version of ${name}` : `Update ${name}`);
+  gitIn(root, ["add", "-A"]);
+  try { gitIn(root, ["commit", "-q", "-m", message]); }
+  catch (error) {
+    const detail = String(error.stderr || "").trim();
+    throw new Error(`Git could not commit${detail ? `:\n${detail}` : "."}${/user\.(?:name|email)|identity/i.test(detail) ? "\nSet your Git name and email, then run menloapp deploy again:\n  git config --global user.name \"Your Name\"\n  git config --global user.email you@example.com" : ""}`);
+  }
+  return true;
+}
+
+/**
+ * Push a branch to GitHub. Use the person's own Git credentials first; if
+ * those are not set up, use the GitHub sign-in deploy already verified for this
+ * one push, passed through the environment and never saved.
+ */
+export function pushBranch(root, repository, branch, credential, { upstream = false } = {}) {
+  const target = `HEAD:refs/heads/${branch}`;
+  const quiet = { ...process.env, GIT_TERMINAL_PROMPT: "0", GCM_INTERACTIVE: "never" };
+  try { gitIn(root, ["push", "-q", ...(upstream ? ["-u"] : []), "origin", target], { env: quiet, timeout: 600_000 }); return; }
+  catch { /* Fall back to the verified sign-in below. */ }
+  if (!credential) throw new Error(`Git could not push to GitHub. Run git push origin ${branch}, then menloapp deploy.`);
+  const header = `AUTHORIZATION: basic ${Buffer.from(`x-access-token:${credential}`).toString("base64")}`;
+  const env = { ...quiet, GIT_CONFIG_COUNT: "2", GIT_CONFIG_KEY_0: "credential.helper", GIT_CONFIG_VALUE_0: "", GIT_CONFIG_KEY_1: "http.https://github.com/.extraheader", GIT_CONFIG_VALUE_1: header };
+  try { gitIn(root, ["push", "-q", `https://github.com/${repository}.git`, target], { env, timeout: 600_000 }); }
+  catch { throw new Error(`GitHub did not accept the push to ${repository}.\nRun git push origin ${branch} to see why, then menloapp deploy again.`); }
+  // Keep `git status` accurate after a push that bypassed the remote's configured URL.
+  try { gitIn(root, ["fetch", "-q", "origin", branch], { env: quiet, timeout: 60_000 }); } catch { /* Cosmetic only. */ }
+}
+
+/** A GitHub repository name derived from the folder, e.g. "My App!" → "My-App". */
+export function repositoryName(directory) {
+  return path.basename(directory).replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^[-.]+|-+$/g, "").slice(0, 100) || "my-app";
+}
+
+/** Create the public GitHub repository for this folder, connect it as origin, and push. */
+export async function createGitHubRepository(root, ui, { credential, user, api, describe = "" }) {
+  if (!ui.interactive) throw new Error(`This repository has no GitHub origin.\nRun menloapp deploy in a terminal and Menlo will create the public GitHub repository, or run:\n  gh repo create --public --source=. --remote=origin --push`);
+  let name = repositoryName(root);
+  ui.log(`\nThis app is not on GitHub yet. Menlo shares apps from public GitHub source:\nanyone can read the code and its history.`);
+  while (true) {
+    const answer = await ui.ask(`Create the public repository github.com/${user.login}/${name}? [Y/n, or type another name] `);
+    if (/^n(o)?$/i.test(answer)) throw new Error("Deploy stopped. Nothing was published.");
+    if (answer && !/^y(es)?$/i.test(answer)) {
+      if (!/^[A-Za-z0-9._-]{1,100}$/.test(answer) || /^\.+$/.test(answer)) { ui.log("Use letters, numbers, dots, hyphens and underscores."); continue; }
+      name = answer;
+    }
+    try {
+      await api("https://api.github.com/user/repos", { method: "POST", body: JSON.stringify({ name, private: false, ...(describe ? { description: describe.slice(0, 350) } : {}) }) });
+      break;
+    } catch (error) {
+      if (error.status === 422) { ui.log(`You already have a repository named ${name} on GitHub. Choose another name.`); name = `${name}-app`; continue; }
+      if (error.status === 403 || error.status === 404) throw new Error(`Your GitHub sign-in cannot create repositories.\nCreate it at https://github.com/new (public), then run:\n  git remote add origin https://github.com/${user.login}/${name}.git\n  menloapp deploy`);
+      throw error;
+    }
+  }
+  const repository = `${user.login}/${name}`;
+  gitIn(root, ["remote", "add", "origin", `https://github.com/${repository}.git`]);
+  const branch = gitIn(root, ["branch", "--show-current"]) || "main";
+  ui.log(`Created https://github.com/${repository}\nPushing ${branch}…`);
+  pushBranch(root, repository, branch, credential, { upstream: true });
+  return repository;
+}