@mercury-fw/cli 0.29.4 → 0.31.0

package/src/e2e/session.ts

@@ -0,0 +1,104 @@
+/**
+ * The REPL session `mfw e2e` drives: the app's REPL as a child process (in
+ * the app's container, through `docker compose run`), fed one turn at a time.
+ * A turn writes its line and then `/dump <file>` together: the REPL handles
+ * one line after the other, so the dump runs once the turn is over, and its
+ * "wrote … to <file>" line is the turn's end, unlike the prompt, which an
+ * answer's own text could look like. The dump is read from the host side of
+ * the folder the REPL writes it into.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { Session } from "./runner.ts";
+
+export type ReplSessionOptions = {
+  /** The command that starts the REPL. */
+  argv: string[];
+  cwd: string;
+  /** Where the dumps are, on this side, and as the REPL sees the same folder. */
+  hostDir: string;
+  replDir: string;
+  /** Prefix of this session's dump files, unique among sessions sharing the folder. */
+  name: string;
+  /** How long one turn may take. */
+  timeoutMs: number;
+};
+
+/** Starts the REPL and returns the session over it once the REPL is ready
+ * (its first prompt is out), so a turn's time is only the turn's; throws
+ * when the REPL exits or doesn't get there in time. */
+export async function openReplSession(opts: ReplSessionOptions): Promise<Session> {
+  const proc = Bun.spawn(opts.argv, { cwd: opts.cwd, stdin: "pipe", stdout: "pipe", stderr: "pipe" });
+  let stdout = "";
+  let stderr = "";
+  let exited: number | undefined;
+  /** Wakes whoever waits for more output or for the exit. */
+  let notify = () => {};
+  const pump = async (stream: ReadableStream<Uint8Array>, add: (text: string) => void) => {
+    const decoder = new TextDecoder();
+    for await (const chunk of stream) {
+      add(decoder.decode(chunk, { stream: true }));
+      notify();
+    }
+  };
+  void pump(proc.stdout, (t) => (stdout += t));
+  void pump(proc.stderr, (t) => (stderr += t));
+  void proc.exited.then((code) => {
+    exited = code;
+    notify();
+  });
+
+  /** Waits until `done` holds on the output so far; throws when the REPL exits or time runs out. */
+  const waitFor = async <T>(done: () => T | undefined): Promise<T> => {
+    const deadline = Date.now() + opts.timeoutMs;
+    for (;;) {
+      const result = done();
+      if (result !== undefined) return result;
+      if (exited !== undefined) throw new Error(`the REPL exited with code ${exited}: ${stderr.trim().split("\n").slice(-3).join(" ")}`);
+      const left = deadline - Date.now();
+      if (left <= 0) throw new Error(`no reply within ${opts.timeoutMs / 1000} s`);
+      await new Promise<void>((resolve) => {
+        const timer = setTimeout(resolve, left);
+        notify = () => {
+          clearTimeout(timer);
+          resolve();
+        };
+      });
+    }
+  };
+
+  // What the REPL prints while starting isn't part of any turn. One that
+  // doesn't get there is stopped: a docker compose run container otherwise
+  // keeps running.
+  try {
+    await waitFor(() => (/> $/.test(stdout) ? true : undefined));
+  } catch (err) {
+    proc.kill();
+    throw err;
+  }
+
+  let turns = 0;
+  return {
+    turn: async (line) => {
+      turns++;
+      const file = `${opts.name}-turn-${turns}.json`;
+      const marker = `to ${opts.replDir}/${file}`;
+      const from = stdout.length;
+      proc.stdin.write(`${line}\n/dump ${opts.replDir}/${file}\n`);
+      proc.stdin.flush();
+      return waitFor(() => {
+        const at = stdout.indexOf(marker, from);
+        if (at === -1) return undefined;
+        // What the turn printed: everything before the dump's own line.
+        const output = stdout.slice(from, stdout.lastIndexOf("wrote ", at));
+        return { dump: JSON.parse(readFileSync(join(opts.hostDir, file), "utf-8")) as unknown, output };
+      });
+    },
+    close: async () => {
+      if (exited !== undefined) return;
+      proc.stdin.end();
+      const done = await Promise.race([proc.exited, new Promise((r) => setTimeout(() => r("timeout"), 10_000))]);
+      if (done === "timeout") proc.kill();
+    },
+  };
+}

package/src/finish.ts

@@ -0,0 +1,144 @@
+/**
+ * What `mfw create` does once the app's files are written: `bun install`, then
+ * a git repository on `main` with a first commit and, when given, its origin
+ * (never pushed: that stays the user's). Every step is best effort: a failure
+ * never undoes what came before, and the report says what happened, which
+ * `finishMessage` turns into the command's last words, next steps included.
+ */
+
+/** Runs `argv` in `cwd`; resolves with its exit code and its output (stdout
+ * and stderr together), or with an empty output when `live` sends it straight
+ * to the terminal. A missing binary resolves with a non-zero code. */
+export type Run = (argv: string[], cwd: string, opts?: { live?: boolean }) => Promise<{ code: number; output: string }>;
+
+/** Why git is skipped for an app created inside another repository: on
+ * purpose, so there's nothing to finish by hand. */
+export const INSIDE_A_REPOSITORY = "the folder is already inside a git repository";
+
+/** What to do after writing: `remote` is taken as typed. */
+export type FinishOptions = {
+  install: boolean;
+  git: boolean;
+  remote?: string;
+  /** The first commit's message, one `-m` per paragraph. */
+  commitMessage: string[];
+};
+
+/** A step that ran (`done`), wasn't asked for (`off`), was skipped with a
+ * reason, or failed with the command's output. */
+type Outcome = "done" | "off" | { failed: string };
+
+export type FinishReport = {
+  install: Outcome;
+  git: Outcome | { skipped: string };
+  remote: Outcome;
+};
+
+/** The real runner: a child process with its output captured. */
+export const spawnRun: Run = async (argv, cwd, opts) => {
+  try {
+    if (opts?.live) {
+      const proc = Bun.spawn(argv, { cwd, stdin: "ignore", stdout: "inherit", stderr: "inherit" });
+      return { code: await proc.exited, output: "" };
+    }
+    const proc = Bun.spawn(argv, { cwd, stdin: "ignore", stdout: "pipe", stderr: "pipe" });
+    const [stdout, stderr, code] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited,
+    ]);
+    return { code, output: stdout + stderr };
+  } catch (err) {
+    return { code: 127, output: err instanceof Error ? err.message : String(err) };
+  }
+};
+
+/** Runs the steps after writing the app in `dir`; see the file's comment. */
+export async function finishApp(dir: string, opts: FinishOptions, run: Run): Promise<FinishReport> {
+  const report: FinishReport = { install: "off", git: "off", remote: "off" };
+  if (opts.install) {
+    // Live: an install can take a while, and its progress is worth seeing.
+    const installed = await run(["bun", "install"], dir, { live: true });
+    report.install = installed.code === 0 ? "done" : { failed: `exit code ${installed.code}` };
+  }
+  if (!opts.git) return report;
+
+  const skipped = await whyNoGit(dir, run);
+  if (skipped !== undefined) {
+    report.git = { skipped };
+    return report;
+  }
+  const commit = opts.commitMessage.flatMap((paragraph) => ["-m", paragraph]);
+  const steps: [label: string, argv: string[]][] = [
+    ["git init", ["git", "init", "-q", "-b", "main"]],
+    ["git add -A", ["git", "add", "-A"]],
+    ["git commit", ["git", "commit", "-q", ...commit]],
+  ];
+  for (const [label, argv] of steps) {
+    const step = await run(argv, dir);
+    if (step.code !== 0) {
+      report.git = { failed: `${label}: ${step.output.trim()}` };
+      return report;
+    }
+  }
+  report.git = "done";
+
+  if (opts.remote !== undefined) {
+    const added = await run(["git", "remote", "add", "origin", opts.remote], dir);
+    report.remote = added.code === 0 ? "done" : { failed: added.output.trim() };
+  }
+  return report;
+}
+
+/** Why the repository can't be created in `dir`, or undefined when it can.
+ * Whether git can commit (an identity, hooks, signing) is git's to say: the
+ * commit runs, and its refusal is reported as it is. */
+async function whyNoGit(dir: string, run: Run): Promise<string | undefined> {
+  if ((await run(["git", "--version"], dir)).code !== 0) return "git isn't installed";
+  // An app created inside a monorepo belongs to that repository, not a nested one.
+  if ((await run(["git", "rev-parse", "--is-inside-work-tree"], dir)).code === 0) return INSIDE_A_REPOSITORY;
+  return undefined;
+}
+
+/** `outcome` as a status line's value, or undefined for a step that was off. */
+function statusOf(outcome: FinishReport[keyof FinishReport], done: string): string | undefined {
+  if (outcome === "off") return undefined;
+  if (outcome === "done") return done;
+  if ("skipped" in outcome) return `skipped, ${outcome.skipped}`;
+  return `failed (${outcome.failed})`;
+}
+
+/** The command's closing output: where the app is, what the steps after
+ * writing did, and what's left to run. */
+export function finishMessage(app: { name: string; dir: string; remote?: string; report: FinishReport }): string {
+  const { report } = app;
+  const insideRepository = typeof report.git === "object" && "skipped" in report.git && report.git.skipped === INSIDE_A_REPOSITORY;
+  // A repository that git didn't finish (not installed, a step refused) is
+  // finished by hand; one skipped on purpose isn't.
+  const byHand = report.git !== "done" && report.git !== "off" && !insideRepository;
+  const status = [
+    ["bun install", statusOf(report.install, "done")],
+    ["git", statusOf(report.git, "first commit on main")],
+    ["origin", insideRepository && app.remote !== undefined ? "not added, the app is in that repository" : statusOf(report.remote, app.remote ?? "")],
+  ].flatMap(([step, value]) => (value === undefined ? [] : [`  ${step}: ${value}\n`]));
+
+  const next = [`cd ${app.dir}`];
+  if (report.install !== "done") next.push("bun install");
+  if (byHand) {
+    next.push("git init -b main", "git add -A", 'git commit -m "Scaffold with mfw create"');
+    if (app.remote !== undefined) next.push(`git remote add origin ${app.remote}`);
+  } else if (report.git === "done") {
+    if (report.install !== "done") next.push('git add bun.lock && git commit -m "Add bun.lock"');
+    if (app.remote !== undefined && report.remote !== "done") next.push(`git remote add origin ${app.remote}`);
+  }
+  next.push("cp .env.example .env    # then fill it in", "mfw start               # bunx mfw start, without a global mfw");
+  if (report.git === "done" && report.remote === "done") next.push("git push -u origin main");
+
+  return `Created ${app.name} in ${app.dir}
+${status.join("")}
+Next:
+${next.map((line) => `  ${line}\n`).join("")}
+Optional, to have mfw everywhere:
+  bun add -g @mercury-fw/cli
+`;
+}

package/src/main.ts

@@ -1,7 +1,7 @@
 /**
  * The `mfw` command. `create <folder>` writes a new Mercury app from the
  * template, asking what to put in it (or taking the answers from flags with
- * `--yes`); `bun install` in the new app is left to the user. The other
+ * `--yes`), then installs it and commits it to a new repository (`finish.ts`). The other
  * commands operate an existing app from inside its folder (see
  * `app/commands.ts`). The command line itself is declared in `program.ts`.
  */
@@ -16,6 +16,7 @@ import { appVersions, cliVersion, newerCli, registryFrom } from "./versions.ts";
 import { appCommands, terminalDeps, type AppDeps } from "./app/commands.ts";
 import { findApp, type App } from "./app/find-app.ts";
 import { askAnswers, DEFAULT_ASSISTANT_NAME, DEFAULT_ROLE, type Answers } from "./wizard.ts";
+import { finishApp, finishMessage, spawnRun, type Run } from "./finish.ts";
 import { targetError, writeApp } from "./write.ts";
 
 /** The answers taken from the flags alone, defaults for the rest. */
@@ -26,6 +27,7 @@ function answersFromFlags(args: CreateArgs, defaultName: string): Answers {
     role: args.role ?? DEFAULT_ROLE,
     channels: args.channels ?? [],
     plugins: args.plugins ?? [],
+    ...(args.gitRemote !== undefined ? { gitRemote: args.gitRemote } : {}),
   };
 }
 
@@ -90,9 +92,18 @@ async function relaunchIfStale(rawArgs: string[], relaunch: Relaunch, globalInst
   return relaunch(["bunx", cli, "create", ...rawArgs], env);
 }
 
+/** What's wrong with `--git-remote`, or undefined. It's taken as typed, but
+ * one starting with "-" would reach git as an option. */
+function remoteError(args: CreateArgs): string | undefined {
+  if (args.gitRemote === undefined) return undefined;
+  if (!args.git) return "--git-remote needs the repository: drop --no-git";
+  if (args.gitRemote.startsWith("-")) return `--git-remote "${args.gitRemote}" isn't a remote`;
+  return undefined;
+}
+
 /** `mfw create`: returns the exit code. `rawArgs` are the arguments after
  * `create` as typed, for a relaunch. */
-async function create(args: CreateArgs, rawArgs: string[], relaunch: Relaunch, globalInstall: boolean): Promise<number> {
+async function create(args: CreateArgs, rawArgs: string[], relaunch: Relaunch, globalInstall: boolean, run: Run): Promise<number> {
   const relaunched = await relaunchIfStale(rawArgs, relaunch, globalInstall);
   if (relaunched !== undefined) return relaunched;
   // The folder is created in kebab case, only its own name: the parent path is
@@ -105,7 +116,10 @@ async function create(args: CreateArgs, rawArgs: string[], relaunch: Relaunch, g
   const dir = join(dirname(typed), folder);
   // What the command line already settles is checked before any question, so
   // the wizard is never answered for nothing.
-  const early = targetError(dir) ?? selectionError(args.channels ?? [], args.plugins ?? []);
+  const early =
+    targetError(dir) ??
+    selectionError(args.channels ?? [], args.plugins ?? []) ??
+    remoteError(args);
   if (early !== undefined) {
     throw new Error(early);
   }
@@ -118,16 +132,21 @@ async function create(args: CreateArgs, rawArgs: string[], relaunch: Relaunch, g
   ).map((e) => e.package);
   const versions = await appVersions(chosen, { registry: registryFrom(process.env.MFW_REGISTRY) });
   writeApp(dir, renderApp({ ...answers, versions }));
-  console.log(`Created ${answers.name} in ${dir}
-
-Next:
-  cd ${dir}
-  bun install
-  cp .env.example .env    # then fill it in
-  mfw start               # bunx mfw start, without a global mfw
-
-Optional, to have mfw everywhere:
-  bun add -g @mercury-fw/cli`);
+  const none = (ids: string[]) => (ids.length > 0 ? ids.join(", ") : "none");
+  const report = await finishApp(
+    dir,
+    {
+      install: args.install,
+      git: args.git,
+      ...(answers.gitRemote !== undefined ? { remote: answers.gitRemote } : {}),
+      commitMessage: [
+        `Scaffold with mfw create ${cliVersion()}`,
+        `Channels: ${none(answers.channels)}\nPlugins: ${none(answers.plugins)}`,
+      ],
+    },
+    run,
+  );
+  process.stdout.write(finishMessage({ name: answers.name, dir, remote: answers.gitRemote, report }));
   return 0;
 }
 
@@ -203,13 +222,14 @@ export async function main(
     deps,
     relaunch = spawnRelaunch,
     globalInstall = isGlobalInstall(),
-  }: { cwd?: string; deps?: AppDeps; relaunch?: Relaunch; globalInstall?: boolean } = {},
+    run = spawnRun,
+  }: { cwd?: string; deps?: AppDeps; relaunch?: Relaunch; globalInstall?: boolean; run?: Run } = {},
 ): Promise<number> {
   const handedOver = await handOverToAppCli(argv, cwd, relaunch);
   if (handedOver !== undefined) return handedOver;
   const rawCreateArgs = argv.slice(argv.indexOf("create") + 1);
   return runProgram(argv, {
-    create: (args) => create(args, rawCreateArgs, relaunch, globalInstall),
+    create: (args) => create(args, rawCreateArgs, relaunch, globalInstall, run),
     upgrade: () => upgrade(relaunch),
     app: () => appCommands(findApp(cwd), deps ?? terminalDeps()),
   });

package/src/program.ts

@@ -24,12 +24,14 @@ export type ProgramHandlers = {
   app: () => AppCommands;
 };
 
-/** `--limit`'s value: a positive whole number. */
-function positiveInt(value: string): string {
-  if (!/^\d+$/.test(value) || Number(value) < 1) {
-    throw new InvalidArgumentError(`--limit takes a positive whole number (got "${value}").`);
-  }
-  return value;
+/** A parser for `flag`'s value: a positive whole number, kept as typed. */
+function positiveInt(flag: string): (value: string) => string {
+  return (value) => {
+    if (!/^\d+$/.test(value) || Number(value) < 1) {
+      throw new InvalidArgumentError(`${flag} takes a positive whole number (got "${value}").`);
+    }
+    return value;
+  };
 }
 
 /** The help's closing paragraph for the commands that run inside an app. */
@@ -50,7 +52,7 @@ function buildProgram(handlers: ProgramHandlers, result: { code: number }): Comm
     .command("create")
     .summary("writes a new Mercury app")
     .description(
-      "Writes a new Mercury app into <folder>, which has to be missing or empty (its own name is turned into kebab case). Without options it asks for the app name, the assistant's name and role, and which channels and tool plugins to include; then it writes mercury.config.ts for that selection, the persona (persona/identity.md, persona/tone.md), the service and REPL entrypoints, a Dockerfile, a compose file with Qdrant, and an env example listing every variable the app reads. Nothing is installed: run bun install in the new app.",
+      "Writes a new Mercury app into <folder>, which has to be missing or empty (its own name is turned into kebab case). Without options it asks for the app name, the assistant's name and role, and which channels and tool plugins to include; then it writes mercury.config.ts for that selection, the persona (persona/identity.md, persona/tone.md), the service and REPL entrypoints, a Dockerfile, a compose file with Qdrant, and an env example listing every variable the app reads. Then it runs bun install, and creates a git repository on main with a first commit, adding the origin when given (nothing is pushed).",
     )
     .argument("<folder>", "where to write the app")
     .option("--name <name>", "app name, as in package.json (default: the folder's name)")
@@ -61,6 +63,9 @@ function buildProgram(handlers: ProgramHandlers, result: { code: number }): Comm
       `comma-separated: ${CATALOG.filter((e) => e.kind === "channel").map((e) => e.id).join(", ")}`,
     )
     .option("--plugins <ids>", `comma-separated: ${CATALOG.filter((e) => e.kind === "tool").map((e) => e.id).join(", ")}`)
+    .option("--git-remote <url>", "the repository's origin, taken as typed (default: none)")
+    .option("--no-install", "don't run bun install")
+    .option("--no-git", "don't create the git repository")
     .option("-y, --yes", "don't ask: use the flags and the defaults")
     .addHelpText(
       "after",
@@ -196,7 +201,7 @@ Examples:
       "Prints a collection's points, each as its id and one line per payload field: newest first where the collection has a timestamp index, in Qdrant's own order otherwise.",
     )
     .argument("<collection>", "as mfw memory list prints it")
-    .option("--limit <n>", "how many points (default: 20)", positiveInt)
+    .option("--limit <n>", "how many points (default: 20)", positiveInt("--limit"))
     .action(async (collection: string, opts: { limit?: string }) =>
       inApp((app) => app.memory(["read", collection, ...(opts.limit === undefined ? [] : ["--limit", opts.limit])]))(),
     );
@@ -264,6 +269,33 @@ Examples:
       )(),
     );
 
+  program
+    .command("local-packages")
+    .summary("installs @mercury-fw packages from local tarballs")
+    .description(
+      "Makes the app install the packages in <folder>'s tarballs (bun pm pack) instead of the registry's: copies them into .packs/ (the image copies it too), points each package at its tarball with overrides in package.json, so packages that depend on it get it as well, and runs bun install. Run it again after packing anew. --off removes them and installs from the registry.",
+    )
+    .argument("[folder]", "the folder holding the .tgz files")
+    .option("--off", "go back to the registry's packages")
+    .addHelpText("after", `\nExamples:\n  mfw local-packages ../mercury-fw/apps/testbed/.packs\n  mfw local-packages --off${INSIDE_AN_APP}`)
+    .action(async (folder: string | undefined, opts: { off?: boolean }) => {
+      if ((folder === undefined) === (opts.off !== true)) throw new Error("local-packages takes a folder of tarballs, or --off");
+      await inApp((app) => (folder === undefined ? app.localPackagesOff() : app.localPackages(folder)))();
+    });
+
+  program
+    .command("e2e")
+    .summary("runs the app's end-to-end tests against its model")
+    .description(
+      "Runs e2e tests: each case's turns go to the app's real model through its REPL (in the container, like mfw repl), and its checks run on the tool calls each turn made and the answer it gave. Without files, every e2e/*.e2e.ts in the app. Prints every check, exits 1 when a case didn't pass enough runs, and keeps the turns and checks in e2e/results/<time>/. The app must be built and its env file filled in, as for mfw repl.",
+    )
+    .argument("[tests...]", "test files (default: e2e/*.e2e.ts)")
+    .option("--repeat <n>", "runs of each case, overriding its own repeat", positiveInt("--repeat"))
+    .addHelpText("after", `\nExamples:\n  mfw e2e\n  mfw e2e e2e/jira.e2e.ts --repeat 3${INSIDE_AN_APP}`)
+    .action(async (tests: string[], opts: { repeat?: string }) =>
+      inApp((app) => app.e2e(tests, opts.repeat === undefined ? {} : { repeat: Number(opts.repeat) }))(),
+    );
+
   return program;
 }
 

package/src/wizard.ts

@@ -9,13 +9,15 @@ import { CATALOG, type CatalogEntry } from "./catalog.ts";
 import { appNameError } from "./render.ts";
 import type { CreateArgs } from "./args.ts";
 
-/** The answers `renderApp` needs, apart from the package versions. */
+/** The answers `renderApp` needs, apart from the package versions, and the
+ * repository's origin (none when absent). */
 export type Answers = {
   name: string;
   assistantName: string;
   role: string;
   channels: string[];
   plugins: string[];
+  gitRemote?: string;
 };
 
 export const DEFAULT_ASSISTANT_NAME = "Mercury";
@@ -67,6 +69,16 @@ export async function askAnswers(args: CreateArgs, dir: string): Promise<Answers
   if (channels === undefined) return cancelled();
   const plugins = await pick("tool", "Tool plugins (space to select)", args.plugins ?? []);
   if (plugins === undefined) return cancelled();
+  // Asked only when there will be a repository and the flag didn't say.
+  let gitRemote = args.gitRemote;
+  if (args.git && gitRemote === undefined) {
+    const typed = await p.text({
+      message: "Git remote for origin (empty: none, add it later)",
+      validate: (v) => (v?.trim().startsWith("-") ? "That's not a remote: git would read it as an option" : undefined),
+    });
+    if (p.isCancel(typed)) return cancelled();
+    if (typed && typed.trim()) gitRemote = typed.trim();
+  }
 
   p.note(
     [
@@ -74,12 +86,13 @@ export async function askAnswers(args: CreateArgs, dir: string): Promise<Answers
       `Assistant: You are ${assistantName}, ${role}.`,
       `Channels: ${channels.length > 0 ? channels.join(", ") : "none"}`,
       `Tool plugins: ${plugins.length > 0 ? plugins.join(", ") : "none"}`,
+      ...(args.git ? [`Origin: ${gitRemote ?? "none"}`] : []),
     ].join("\n"),
     "Summary",
   );
   const ok = await p.confirm({ message: `Create it in ${dir}?` });
   if (p.isCancel(ok) || !ok) return cancelled();
-  return { name, assistantName, role, channels, plugins };
+  return { name, assistantName, role, channels, plugins, ...(gitRemote !== undefined ? { gitRemote } : {}) };
 }
 
 function cancelled(): undefined {

package/template/Dockerfile.tpl

@@ -12,8 +12,11 @@ RUN groupadd -r mercury && useradd -r -g mercury mercury
 WORKDIR /app
 
 # Each tool plugin downloads its pinned CLI in its postinstall (allowed by
-# package.json's trustedDependencies); the binaries go on PATH.
+# package.json's trustedDependencies); the binaries go on PATH. .packs/ holds
+# local tarballs when the app installs them (mfw local-packages), and is
+# skipped when it isn't there.
 COPY --chown=mercury:mercury package.json bun.lock* ./
+COPY --chown=mercury:mercury .pack[s] ./.packs/
 RUN bun install --production && chown -R mercury:mercury node_modules
 RUN find /app/node_modules -path '*/@mercury-fw/*/bin/*' -type f -exec ln -sf {} /usr/local/bin/ \;
 

package/template/gitignore.tpl

@@ -4,3 +4,5 @@ node_modules
 !.env.example
 *.log
 .DS_Store
+.packs/
+e2e/results/