nimblybase 0.1.9 → 0.1.11

package/README.md

@@ -122,7 +122,10 @@ cannot be combined with `--authorize`.
 If approval is denied or fails, the project and link are retained. Retry
 `nimbly login` with the API printed by the CLI; do not recreate the project.
 A returning repository grant uses read endpoints for `nimbly init`, so it does
-not need workspace creation permission or another browser approval.
+not need workspace creation permission or another browser approval. Its JSON
+keeps the shared ready/provisioning/attention-required status and next actions;
+paused projects direct the agent to diagnosis, and default provisioning waits
+remain in effect.
 
 ## Scripting
 
@@ -173,6 +176,15 @@ fails closed rather than open.
 
 ## Edge functions
 
+CLI 0.1.11+ can prepare a bundle without signing in or uploading source:
+
+```sh
+nimbly functions deploy ./webhook.ts --dry-run --json
+```
+
+The preview reports the bundled module count, byte size, SHA256 and local checks.
+It does not prove provider runtime compatibility, authorization or live health.
+
 ```bash
 nimbly functions deploy ./webhook.js
 nimbly functions
@@ -191,6 +203,41 @@ It receives **this project's own resources** and nothing else: `env.DB`,
 them. It cannot reach another project's anything, and it does not receive
 the platform-wide bindings our own Worker carries.
 
+## Prepare a static site before publishing
+
+```sh
+nimbly deploy ./my-app --dry-run --json
+# Explicitly execute the detected package build script, then prepare its output:
+nimbly deploy ./my-app --build --dry-run --json
+# Publish after reviewing the local preview and confirming the linked project:
+nimbly whoami
+nimbly deploy ./my-app
+```
+
+CLI 0.1.11+ previews the exact file hashes, sizes, SPA setting, index presence
+and exclusions. It reads no NimblyBase credentials and makes no management or
+provider requests. `--build` explicitly runs repository code; that script may
+itself use the network. Without `--build`, a preview never executes scripts.
+Build output goes to stderr so stdout remains one JSON document.
+
+Sites are limited to 20,000 files, 25 MiB per file and 100 MiB total; functions
+to 1,000,000 bundled bytes. Site previews and uploads omit environment files,
+credential configuration, private-key files, source maps, `.git` and
+`node_modules`. Symlinks and unsafe URL filenames are refused. An upload uses
+the byte snapshot that was scanned and hashed, even if a local file changes.
+
+Both site and function preparation refuse recognised management/provider
+credential patterns without printing their values. Public application keys
+remain allowed. Pattern scanning cannot detect every secret, encoded value or
+private business datum; review what belongs in a public artifact.
+
+`--dry-run` is refused on all other commands, including delete and rollback.
+The preview proves local preparation only: it does not verify host installation,
+project authorization, provider runtime compatibility or live health. A
+cloud-only agent still needs a proven repository/build/upload path; connecting
+to MCP alone does not supply one. The checks here guard the CLI upload path;
+they do not add a server-side policy to direct HTTP or MCP uploads.
+
 ## When something is broken
 
 ```bash

package/dist/index.js

@@ -67,6 +67,7 @@ function parse(argv) {
         plan: { type: "string" },
         spa: { type: "boolean" },
         build: { type: "boolean" },
+        "dry-run": { type: "boolean" },
         "token-only": { type: "boolean" },
         device: { type: "boolean" },
         off: { type: "boolean" },
@@ -141,6 +142,7 @@ function parse(argv) {
       plan: v.plan,
       spa: v.spa === true ? true : void 0,
       build: v.build === true ? true : void 0,
+      dryRun: v["dry-run"] === true ? true : void 0,
       tokenOnly: v["token-only"] === true ? true : void 0,
       device: v.device === true ? true : void 0,
       off: v.off === true ? true : void 0,
@@ -246,6 +248,7 @@ YOUR APP'S USERS
 EDGE FUNCTIONS
   functions                What is deployed, and whether it is live
   functions deploy <file>  Publish a module to a PUBLIC URL at /fn/<name>
+                           --dry-run to bundle and inspect without uploading
   functions schedule <name> "<cron>"
                            Run it on a schedule, UTC. --off to stop
   functions delete <name>  Remove one
@@ -258,6 +261,7 @@ STATIC HOSTING
   deploy [dir]             Publish a built site. --dir to choose the folder,
                            --build to run its package script first, --spa if
                            a client-side router owns the URLs
+                           --dry-run to inspect hashes/limits without uploading
   site                     What is deployed
   site releases            What has been published, and what is live
   site rollback [id]       Put an earlier release back; no id means the previous one
@@ -294,6 +298,8 @@ OPTIONS
   --type <anon|service>    Key type (default anon)
   -f, --file <path>        Schema file (default schema.json beside the link)
   --dir <path>             Repository to inspect, or built directory to publish
+  --dry-run                Offline preview for deploy/functions deploy only
+                           --build still explicitly runs the site's build script
   --intent <full-app|backend-only>  Hosting intent for assessment and creation
   --database <d1|postgres|retain-external|none>  Declared database requirement
   --recipe <static-d1>      Explicit new-app recipe; cannot override existing code
@@ -378,7 +384,7 @@ function when(iso) {
 
 // src/api.ts
 var DEFAULT_API_URL = "https://api-uat.nimblybase.com";
-var VERSION = "0.1.9";
+var VERSION = "0.1.11";
 function dashboardUrl(api) {
   const match = /^https:\/\/api(-[a-z0-9]+)?\.(.+)$/.exec(api);
   return match ? `https://app${match[1] ?? ""}.${match[2]}` : null;
@@ -813,7 +819,7 @@ async function deviceLogin(input, fetchImpl = fetch) {
     throw new Error("the device verification page is outside the authorization origin");
   }
   const now = input.now ?? (() => performance.now());
-  const sleep = input.sleep ?? ((ms) => new Promise((resolve9) => setTimeout(resolve9, ms)));
+  const sleep = input.sleep ?? ((ms) => new Promise((resolve10) => setTimeout(resolve10, ms)));
   const deadline = now() + device.expires_in * 1e3;
   let interval = Math.max(5, device.interval ?? 5) * 1e3;
   input.announce({ verificationUri: verification.toString(), userCode: device.user_code, expiresInSeconds: device.expires_in });
@@ -1221,7 +1227,7 @@ async function readPipedInput() {
   return value.length > 0 ? value : null;
 }
 function promptSecret(question) {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     const rl = createInterface({ input: process.stdin, output: process.stderr, terminal: true });
     let promptShown = false;
     const output = rl;
@@ -1238,7 +1244,7 @@ function promptSecret(question) {
       output.output.write = write;
       process.stderr.write("\n");
       rl.close();
-      resolve9(answer.trim());
+      resolve10(answer.trim());
     });
     rl.on("SIGINT", () => {
       rl.close();
@@ -7918,19 +7924,24 @@ async function init(flags, name) {
     await assertMayCreateLink(root, { relink: flags.relink });
   }
   if (ctx.credentialScope === "repository" && !name) {
-    const project = await resolveProject(ctx, explicitProject ?? linkedProject);
+    const initial = await resolveProject(ctx, explicitProject ?? linkedProject);
+    const project = flags.wait === false ? initial : await waitForActive(ctx, initial);
     const backend = await ctx.client.describeProject(project.id);
+    const status4 = project.status === "active" ? "ready" : project.status === "provisioning" ? "provisioning" : "attention_required";
+    const result2 = { status: status4, project, backend, nextActions: status4 === "ready" ? [
+      { code: "inspect_backend", command: "nimbly describe", description: "Inspect available services before designing the backend." },
+      { code: "plan_schema", command: "nimbly db status", description: "Inspect the schema before applying changes." }
+    ] : status4 === "provisioning" ? [
+      { code: "wait_for_project", command: `nimbly project ${project.slug}`, description: "Wait for the project to become active." }
+    ] : [
+      { code: "diagnose_project", command: `nimbly diagnose ${project.slug}`, description: `The project is ${project.status}; inspect before using it.` }
+    ] };
     if (isJsonMode()) {
-      json({
-        status: project.status === "active" ? "ready" : project.status,
-        project,
-        backend,
-        linkedTo: ctx.link?.path ?? null,
-        authorization: { state: "authorized", projectId: project.id }
-      });
+      json({ ...result2, linkedTo: ctx.link?.path ?? null, authorization: { state: "authorized", projectId: project.id } });
     } else {
       out(`${paint("green", "\u2713")} ${project.slug} is ${statusPaint(project.status)}`);
-      note("This repository is already authorized. Next: nimbly describe.");
+      note("This repository is already authorized.");
+      for (const action of result2.nextActions) note(`Next: ${action.command} \u2014 ${action.description}`);
     }
     return;
   }
@@ -8719,8 +8730,66 @@ function render4(f) {
 
 // src/commands/functions.ts
 import { readFile as readFile5 } from "node:fs/promises";
+import { createHash as createHash4 } from "node:crypto";
 import { basename as basename2, dirname as dirname7, extname as extname2, resolve as resolve7 } from "node:path";
 import { build as bundle } from "esbuild";
+
+// src/artifact-safety.ts
+import { constants } from "node:fs";
+import { lstat, open as open2 } from "node:fs/promises";
+var CREDENTIALS = [
+  { kind: "NimblyBase management credential", pattern: /nb_(?:svc|pat|oat|ort)_[A-Za-z0-9_-]{20,}|nb_plat_\d{1,12}_[0-9a-f]{64}/ },
+  { kind: "provider secret key", pattern: /(?:sk|rk)_(?:test|live)_[A-Za-z0-9]{20,}/ },
+  { kind: "AWS access key", pattern: /(?:AKIA|ASIA)[A-Z0-9]{16}/ },
+  { kind: "GitHub credential", pattern: /gh[pousr]_[A-Za-z0-9]{20,}|github_pat_[A-Za-z0-9_]{20,}/ },
+  { kind: "Slack credential", pattern: /xox[baprs]-[A-Za-z0-9-]{20,}/ },
+  { kind: "private key", pattern: /-----BEGIN (?:[A-Z0-9]+ )*PRIVATE KEY-----/ },
+  { kind: "signed JWT credential", pattern: /eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{20,}/ }
+];
+function assertNoEmbeddedCredentials(bytes, label) {
+  const content = Buffer.from(bytes).toString("latin1");
+  const found = CREDENTIALS.find(({ pattern }) => pattern.test(content));
+  if (found) {
+    const safeLabel = CREDENTIALS.reduce((text, { pattern }) => text.replace(new RegExp(pattern.source, "g"), "[redacted]"), label);
+    throw new CliError(
+      `${safeLabel} contains a recognised ${found.kind}; no artifact was uploaded.`,
+      EXIT.usage,
+      "Remove credentials from the build. Use function environment secrets for private values. Public app keys are allowed; this pattern check does not detect every possible secret."
+    );
+  }
+}
+async function readArtifactFile(file, maxBytes, label) {
+  const before = await lstat(file);
+  if (before.isSymbolicLink()) throw new CliError(`${label} is a symlink; nothing was uploaded.`, EXIT.usage);
+  if (!before.isFile()) throw new CliError(`${label} is not a regular file.`, EXIT.usage);
+  const handle = await open2(file, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0)).catch(() => {
+    throw new CliError(`Could not safely read ${label}; nothing was uploaded.`, EXIT.usage);
+  });
+  try {
+    const info = await handle.stat();
+    if (!info.isFile() || info.dev !== before.dev || info.ino !== before.ino) {
+      throw new CliError(`${label} changed while being read; retry after the build finishes.`, EXIT.usage);
+    }
+    if (info.size > maxBytes) throw new CliError(`${label} is over the ${maxBytes}-byte artifact limit.`, EXIT.usage);
+    const chunks = [];
+    let size = 0;
+    while (true) {
+      const buffer = Buffer.allocUnsafe(Math.min(64 * 1024, maxBytes - size + 1));
+      const { bytesRead } = await handle.read(buffer, 0, buffer.length, null);
+      if (!bytesRead) break;
+      size += bytesRead;
+      if (size > maxBytes) throw new CliError(`${label} is over the ${maxBytes}-byte artifact limit.`, EXIT.usage);
+      chunks.push(buffer.subarray(0, bytesRead));
+    }
+    const bytes = Buffer.concat(chunks, size);
+    assertNoEmbeddedCredentials(bytes, label);
+    return bytes;
+  } finally {
+    await handle.close();
+  }
+}
+
+// src/commands/functions.ts
 var NAME = /^[a-z][a-z0-9-]{0,30}$/;
 var MAX_FUNCTION_BYTES = 1e6;
 async function list4(flags) {
@@ -8784,6 +8853,31 @@ async function deploy(flags, file) {
       "Remove unused dependencies or split this function before deploying."
     );
   }
+  const bytes = Buffer.from(built.source, "utf8");
+  assertNoEmbeddedCredentials(bytes, "The bundled function");
+  if (flags.dryRun) {
+    const preview = {
+      kind: "edge-function",
+      dryRun: true,
+      published: false,
+      name,
+      modules: built.modules,
+      bytes: bytes.length,
+      sha256: createHash4("sha256").update(bytes).digest("hex"),
+      hasDefaultExport: true,
+      limits: { bytes: MAX_FUNCTION_BYTES },
+      credentialCheck: "No recognised credential patterns detected; not a complete secret audit.",
+      scope: "Local bundle only; provider runtime, project authorization and live health are not verified."
+    };
+    if (isJsonMode()) json(preview);
+    else {
+      out(`Prepared ${name}: ${built.modules} modules, ${human(bytes.length)}. Nothing uploaded.`);
+      out(`  SHA256 ${preview.sha256}`);
+      note(preview.credentialCheck);
+      note(preview.scope);
+    }
+    return;
+  }
   const ctx = await context(flags.api);
   const project = await resolveProject(ctx, flags.project);
   note(`Deploying ${name} to ${project.slug} (${built.modules} modules, ${human(Buffer.byteLength(built.source, "utf8"))})\u2026`);
@@ -9246,11 +9340,11 @@ function propertyName(name) {
 }
 
 // src/commands/deploy.ts
-import { readdir as readdir2, readFile as readFile6, stat as stat4 } from "node:fs/promises";
-import { createHash as createHash4 } from "node:crypto";
+import { readdir as readdir2, readFile as readFile6, lstat as lstat2 } from "node:fs/promises";
+import { createHash as createHash5 } from "node:crypto";
 import { spawn as spawn2 } from "node:child_process";
-import { join as join5, relative as relative2, sep } from "node:path";
-var SKIP = /* @__PURE__ */ new Set([".git", "node_modules", ".DS_Store", ".env", ".env.local", "Thumbs.db"]);
+import { join as join5, relative as relative2, resolve as resolve8, sep } from "node:path";
+var SKIP = /* @__PURE__ */ new Set([".git", "node_modules", ".ds_store", "thumbs.db", ".npmrc", ".netrc", ".envrc", ".aws", ".ssh", ".nimblybase", "credentials.json"]);
 var MAX_FILES = 2e4;
 var MAX_FILE_BYTES = 25 * 1024 * 1024;
 var MAX_SITE_BYTES = 100 * 1024 * 1024;
@@ -9263,7 +9357,7 @@ async function deploy2(flags, dir) {
     for (const warning of detection.warnings) note(`${paint("yellow", "!")} ${warning}`);
   }
   if (flags.build) await buildSite(root, detection.buildScript ?? null, detection.buildCommand);
-  const files2 = await collect(source2);
+  const { files: files2, omitted } = await collect(source2);
   if (files2.length === 0) {
     throw new CliError(
       `${source2} has nothing to publish.`,
@@ -9272,20 +9366,46 @@ async function deploy2(flags, dir) {
     );
   }
   const index = files2.find((f) => f.path === "/index.html");
-  if (!index && !flags.yes && !isJsonMode()) {
+  if (!index && !flags.dryRun && !flags.yes && !isJsonMode()) {
     note(`${paint("yellow", "!")} No index.html in ${source2}; nothing will answer at /.`);
     if (!await confirm("Publish anyway?")) {
       note("Not published.");
       return;
     }
   }
-  const ctx = await context(flags.api);
-  const project = await resolveProject(ctx, flags.project);
   const singlePageApp = flags.spa ?? detection.singlePageApp;
   const manifest = {
     singlePageApp,
     files: Object.fromEntries(files2.map((f) => [f.path, { hash: f.hash, size: f.size }]))
   };
+  if (flags.dryRun) {
+    const preview = {
+      kind: "static-site",
+      dryRun: true,
+      published: false,
+      buildExecuted: flags.build === true,
+      files: files2.length,
+      bytes: files2.reduce((sum, file) => sum + file.size, 0),
+      hasIndex: Boolean(index),
+      manifest,
+      omitted,
+      limits: { files: MAX_FILES, fileBytes: MAX_FILE_BYTES, totalBytes: MAX_SITE_BYTES },
+      credentialCheck: "No recognised credential patterns detected; not a complete secret audit.",
+      scope: "Local artifact only; project authorization, hosting compatibility and live health are not verified."
+    };
+    if (isJsonMode()) json(preview);
+    else {
+      out(`Prepared ${preview.files} files (${human2(preview.bytes)}). Nothing uploaded.`);
+      for (const file of files2) out(`  ${file.path}  ${file.size} bytes  ${file.hash}`);
+      for (const path of omitted) note(`Omitted ${path}`);
+      if (!index) note("No index.html: this artifact will not answer at /.");
+      note(preview.credentialCheck);
+      note(preview.scope);
+    }
+    return;
+  }
+  const ctx = await context(flags.api);
+  const project = await resolveProject(ctx, flags.project);
   const { missing } = await ctx.client.planSite(project.id, manifest);
   const bytes = files2.filter((f) => missing.includes(f.hash)).reduce((sum, f) => sum + f.size, 0);
   if (!isJsonMode()) {
@@ -9294,7 +9414,7 @@ async function deploy2(flags, dir) {
   let done = 0;
   for (const hash of missing) {
     const file = files2.find((f) => f.hash === hash);
-    await ctx.client.putSiteBlob(project.id, hash, await readFile6(file.absolute));
+    await ctx.client.putSiteBlob(project.id, hash, file.bytes);
     done += 1;
     if (!isJsonMode()) note(`  ${done}/${missing.length} ${file.path}`);
   }
@@ -9418,17 +9538,18 @@ async function buildSite(root, script, display) {
   const entries = await readdir2(root);
   const runner = packageRunner(entries);
   if (!isJsonMode()) note(`Running ${runner.label} run ${script}\u2026`);
-  const code = await new Promise((resolve9, reject) => {
+  const code = await new Promise((resolve10, reject) => {
     const child = spawn2(runner.command, [...runner.args, "run", script], {
       cwd: root,
-      stdio: "inherit",
+      // A build's progress must not corrupt a JSON preview on stdout.
+      stdio: ["inherit", isJsonMode() ? 2 : "inherit", "inherit"],
       // Node cannot execute .cmd shims directly on Windows. The command and
       // every argument here come from our fixed framework/runner tables, so
       // the Windows command shell receives no repository-controlled text.
       shell: process.platform === "win32"
     });
     child.once("error", reject);
-    child.once("close", (status4) => resolve9(status4 ?? 1));
+    child.once("close", (status4) => resolve10(status4 ?? 1));
   }).catch((err) => {
     throw new CliError(
       `Could not start ${display ?? `${runner.label} run ${script}`}.`,
@@ -9459,19 +9580,32 @@ function packageRunner(entries) {
   return { command: win ? "npm.cmd" : "npm", args: [], label: "npm" };
 }
 async function collect(dir) {
-  const root = await stat4(dir).catch(() => null);
-  if (!root?.isDirectory()) return [];
+  dir = resolve8(dir);
+  const root = await lstat2(dir).catch(() => null);
+  if (root?.isSymbolicLink()) throw new CliError("The output directory is a symlink; nothing was uploaded.", EXIT.usage);
+  if (!root?.isDirectory()) return { files: [], omitted: [] };
   const found = [];
+  const omitted = [];
+  let total = 0;
   async function walk(current) {
     for (const entry of await readdir2(current, { withFileTypes: true })) {
-      if (SKIP.has(entry.name)) continue;
+      const name = entry.name.toLowerCase();
+      const path = toUrlPath(relative2(dir, join5(current, entry.name)));
+      if (SKIP.has(name) || name === ".env" || name.startsWith(".env.") || name.endsWith(".map") || /\.(?:pem|p12|pfx|key)$/.test(name) || /^id_(?:rsa|ed25519|ecdsa|dsa)$/.test(name)) {
+        omitted.push(path);
+        continue;
+      }
+      if ([...entry.name].some((char) => char.charCodeAt(0) < 32 || char.charCodeAt(0) === 127 || "?#\\".includes(char))) {
+        throw new CliError("An artifact filename contains unsafe URL characters; nothing was uploaded.", EXIT.usage);
+      }
       const absolute = join5(current, entry.name);
+      const info = await lstat2(absolute);
+      if (info.isSymbolicLink()) throw new CliError(`${path} is a symlink; nothing was uploaded.`, EXIT.usage);
       if (entry.isDirectory()) {
         await walk(absolute);
         continue;
       }
       if (!entry.isFile()) continue;
-      const info = await stat4(absolute);
       if (info.size > MAX_FILE_BYTES) {
         throw new CliError(
           `${relative2(dir, absolute)} is ${human2(info.size)}, over the ${human2(MAX_FILE_BYTES)} limit.`,
@@ -9485,17 +9619,20 @@ async function collect(dir) {
           "Static hosting is for a built site, not a source tree."
         );
       }
+      assertSiteSize([total, info.size]);
+      const bytes = await readArtifactFile(absolute, Math.min(MAX_FILE_BYTES, MAX_SITE_BYTES - total), path);
+      total += bytes.length;
       found.push({
-        path: toUrlPath(relative2(dir, absolute)),
-        absolute,
-        hash: createHash4("sha256").update(await readFile6(absolute)).digest("hex"),
-        size: info.size
+        path,
+        bytes,
+        hash: createHash5("sha256").update(bytes).digest("hex"),
+        size: bytes.length
       });
     }
   }
   await walk(dir);
   assertSiteSize(found.map((file) => file.size));
-  return found.sort((a, b) => a.path.localeCompare(b.path));
+  return { files: found.sort((a, b) => a.path.localeCompare(b.path)), omitted: omitted.sort() };
 }
 function assertSiteSize(sizes) {
   const total = sizes.reduce((sum, size) => sum + size, 0);
@@ -9957,8 +10094,8 @@ async function remove4(flags, name) {
 }
 
 // src/commands/architect.ts
-import { readdir as readdir3, readFile as readFile8, stat as stat5 } from "node:fs/promises";
-import { join as join6, resolve as resolve8 } from "node:path";
+import { readdir as readdir3, readFile as readFile8, stat as stat4 } from "node:fs/promises";
+import { join as join6, resolve as resolve9 } from "node:path";
 var FEATURE_PATTERNS = {
   auth: /\b(auth(?:entication|enticated|orization|orized)?|log-?ins?|sign-?ins?|sign-?ups?|sessions?|user accounts?|passport|clerk|auth0)\b/i,
   storage: /\b(uploads?|attachments?|buckets?|object storage|file (?:uploads?|attachments?|storage)|s3|r2|multer|media)\b/i,
@@ -9972,7 +10109,7 @@ var FEATURE_PATTERNS = {
   crawler: /\b(crawls?|crawlers?|scrapes?|playwright|puppeteer|browser automation)\b/i
 };
 async function architect(flags, ...words) {
-  const root = resolve8(flags.dir ?? ".");
+  const root = resolve9(flags.dir ?? ".");
   const requirements = words.filter((word) => Boolean(word)).join(" ").trim();
   const ctx = await context(flags.api);
   if (!flags.project && !ctx.link) {
@@ -9990,7 +10127,7 @@ async function architect(flags, ...words) {
   render6(proposal);
 }
 async function inspectRepository(root, requirements) {
-  const rootStat = await stat5(root).catch(() => null);
+  const rootStat = await stat4(root).catch(() => null);
   if (!rootStat?.isDirectory()) {
     throw new CliError(`Cannot inspect ${root}.`, EXIT.notFound, "Pass --dir with a readable repository directory.");
   }
@@ -10272,6 +10409,9 @@ async function run3(argv) {
     return name || flags.help ? EXIT.ok : EXIT.usage;
   }
   try {
+    if (flags.dryRun && !(name === "deploy" || name === "functions" && command[1] === "deploy")) {
+      throw new CliError("--dry-run is only supported for deploy and functions deploy.", EXIT.usage);
+    }
     const group = GROUPS[name];
     if (group) {
       const sub = command[1] ?? "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nimblybase",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "The NimblyBase command line - projects, keys and backends from a terminal.",
   "license": "UNLICENSED",
   "repository": {