turnzero 0.21.6 → 0.22.0-next.1

package/dist/turnzero-cloud.mjs

@@ -2358,9 +2358,89 @@ var credentialFileName = (name) => {
 var looksLikeCredential = (name, data) => credentialFileName(name) || holdsPrivateKey(data);
 var credentialAdvice = (subject) => `Where ${subject} holds a secret, move it out of the application's folder before the next deploy, and store a secret value the application needs with ${SECRET_ACTION.store}. The ${HASH_SUBCOMMAND} subcommand with ${HASH_OPTION.list} prints every file the zip holds.`;
 var credentialLineOf = (names) => names.length === 0 ? null : names.length === 1 ? `${WARNING_LINE_HEAD}the zip holds a file that looks like a key or a credential, and the upload includes it: ${listedNames(names)}. ${credentialAdvice("it")}` : `${WARNING_LINE_HEAD}the zip holds ${names.length} files that look like keys or credentials, and the upload includes them: ${listedNames(names)}. ${credentialAdvice("one")}`;
+var LOCAL_WRITE_EXTENSIONS = Object.freeze([".js", ".mjs", ".cjs", ".ts"]);
+var LOCAL_WRITE_UNREAD_FOLDERS = Object.freeze(["client/", "lib/"]);
+var LOCAL_WRITE_CALLS = Object.freeze(["writeFile", "writeFileSync", "appendFile", "appendFileSync", "createWriteStream", "mkdir", "mkdirSync"]);
+var LOCAL_WRITE_BASES = Object.freeze(["__dirname", "import.meta.dirname", "process.cwd()"]);
+var LOCAL_WRITE_SET_ASIDE = Object.freeze(["tmpdir(", "process.env"]);
+var LOCAL_WRITE_ARGUMENT_MAX = 400;
+var readForLocalWrite = (name) => {
+  const last = lastSegmentOf(name);
+  return LOCAL_WRITE_EXTENSIONS.some((extension) => last.endsWith(extension)) && !LOCAL_WRITE_UNREAD_FOLDERS.some((folder) => name.startsWith(folder));
+};
+var firstArgumentOf = (text, from) => {
+  const open = [];
+  let quote = null;
+  const end = Math.min(text.length, from + LOCAL_WRITE_ARGUMENT_MAX);
+  for (let at = from; at < end; at += 1) {
+    const character = text[at];
+    if (quote !== null) {
+      if (character === "\\") at += 1;
+      else if (character === quote) quote = null;
+      else if (quote === "`" && character === "$" && text[at + 1] === "{") {
+        open.push("`");
+        quote = null;
+        at += 1;
+      }
+      continue;
+    }
+    if (character === "'" || character === '"' || character === "`") quote = character;
+    else if (character === "(" || character === "[" || character === "{") open.push(character);
+    else if (character === ")" || character === "]" || character === "}") {
+      if (open.length === 0) return character === ")" ? text.slice(from, at) : null;
+      if (open.pop() === "`") quote = "`";
+    } else if (character === "," && open.length === 0) return text.slice(from, at);
+  }
+  return null;
+};
+var literalTextOf = (argument) => {
+  const quote = argument[0];
+  if (argument.length < 2 || quote !== "'" && quote !== '"' && quote !== "`" || argument.at(-1) !== quote) return null;
+  const inner = argument.slice(1, -1);
+  if (quote === "`" && inner.includes("${")) return null;
+  for (let at = 0; at < inner.length; at += 1) {
+    if (inner[at] === "\\") at += 1;
+    else if (inner[at] === quote) return null;
+  }
+  return inner;
+};
+var relativePathText = (path) => path !== "" && !/^([/\\~]|[A-Za-z][A-Za-z0-9+.-]*:)/.test(path);
+var holdsBase = (argument, base) => {
+  for (let at = argument.indexOf(base); at >= 0; at = argument.indexOf(base, at + 1)) {
+    const before = argument[at - 1];
+    const after = argument[at + base.length];
+    if ((before === void 0 || !/[\w$.]/.test(before)) && (after === void 0 || !/[\w$]/.test(after))) return true;
+  }
+  return false;
+};
+var writesInsideFolder = (argument) => {
+  const trimmed = argument.trim();
+  if (LOCAL_WRITE_SET_ASIDE.some((aside) => trimmed.includes(aside))) return false;
+  const literal = literalTextOf(trimmed);
+  if (literal !== null) return relativePathText(literal);
+  return LOCAL_WRITE_BASES.some((base) => holdsBase(trimmed, base));
+};
+var LOCAL_WRITE_CALL = new RegExp(`(?<![\\w$])(${[...LOCAL_WRITE_CALLS].sort((a, b) => b.length - a.length).join("|")})\\s*\\(`, "g");
+var LOCAL_WRITE_OPENINGS = ["writeFile", "appendFile", "createWriteStream", "mkdir"].map((name) => Buffer.from(name, "ascii"));
+var localWriteLineIn = (data) => {
+  if (!LOCAL_WRITE_OPENINGS.some((opening) => data.includes(opening))) return null;
+  const text = data.toString("utf8");
+  let line = 1;
+  let counted = 0;
+  for (const match of text.matchAll(LOCAL_WRITE_CALL)) {
+    for (let at = text.indexOf("\n", counted); at >= 0 && at < match.index; at = text.indexOf("\n", at + 1)) line += 1;
+    counted = match.index;
+    const head = text.slice(text.lastIndexOf("\n", match.index - 1) + 1, match.index).trimStart();
+    if (head.startsWith("//") || head.startsWith("/*") || head.startsWith("*")) continue;
+    const argument = firstArgumentOf(text, match.index + match[0].length);
+    if (argument !== null && writesInsideFolder(argument)) return line;
+  }
+  return null;
+};
+var localWriteLineOf = (found) => found === null ? null : `${WARNING_LINE_HEAD}${shownNoteName(found.name)}, line ${found.line}, writes to a local file inside the application's folder. A running copy's disk is lost whenever the copy is replaced or stops: keep files in a storage area and records in a database, as read_documentation's pages /cloud/guides/store-files/ and /cloud/guides/add-a-database/ describe.`;
 var LIST_LINE_HEAD = "file: ";
 var listLineOf = (file) => `${LIST_LINE_HEAD}${file.size} ${shownWhole(file.name)}`;
-var NO_NOTES = Object.freeze({ leftOut: Object.freeze([]), rootZips: Object.freeze([]), credentialFiles: Object.freeze([]), unservedHealthPath: null });
+var NO_NOTES = Object.freeze({ leftOut: Object.freeze([]), rootZips: Object.freeze([]), credentialFiles: Object.freeze([]), localWrite: null, unservedHealthPath: null });
 var noteLinesOf = (notes, health, zipped = null) => {
   const lines = [];
   const files = zipped === null ? null : filesLineOf(zipped.map((file) => file.name));
@@ -2371,6 +2451,8 @@ var noteLinesOf = (notes, health, zipped = null) => {
   if (rootZip !== null) lines.push(rootZip);
   const credential = credentialLineOf(notes.credentialFiles);
   if (credential !== null) lines.push(credential);
+  const localWrite = localWriteLineOf(notes.localWrite);
+  if (localWrite !== null) lines.push(localWrite);
   if (health && notes.unservedHealthPath !== null) lines.push(healthLineOf(notes.unservedHealthPath));
   return lines;
 };
@@ -3376,6 +3458,7 @@ function zipFolder(root, seams = {}) {
   let held = healthPath !== null && segment !== null && files.some((file) => pathCountsForHealth(file.name, healthPath, segment));
   const zipped = [];
   const credentialFiles = [];
+  let localWrite = null;
   const places = [];
   const zip = zipFiles(
     files,
@@ -3383,6 +3466,10 @@ function zipFolder(root, seams = {}) {
     (file, data) => {
       zipped.push({ name: file.name, size: data.length });
       if (looksLikeCredential(file.name, data)) credentialFiles.push(file.name);
+      if (localWrite === null && readForLocalWrite(file.name)) {
+        const line = localWriteLineIn(data);
+        if (line !== null) localWrite = { name: file.name, line };
+      }
       if (segment !== null && !held && readForHealth(file.name) && holdsSegment(data, segment)) held = true;
     },
     (place) => places.push(place)
@@ -3396,6 +3483,7 @@ function zipFolder(root, seams = {}) {
       leftOut,
       rootZips: files.filter((file) => !file.name.includes("/") && zipFileName(file.name)).map((file) => file.name),
       credentialFiles,
+      localWrite,
       unservedHealthPath: segment !== null && !held ? healthPath : null
     }
   };
@@ -9278,7 +9366,7 @@ var SUBCOMMANDS = Object.freeze([
   WHOAMI_ROW
 ]);
 var SERVED = LINE_RUNNER;
-var NPX_FORM_SENTENCE = `Where the command is not installed, install it with ${installLineOf(DEFAULT_COMMAND_ORIGIN)}, or run the same line through npx: write ${commandRunnerOf("latest")} for ${LINE_RUNNER}.`;
+var NPX_FORM_SENTENCE = `Where the command is not installed, install it with ${installLineOf(DEFAULT_COMMAND_ORIGIN)}. A person or a job may instead run the same line through npx: write ${commandRunnerOf("latest")} for ${LINE_RUNNER}. A tool where the command is not installed uses deploy_files within its caps, or the deploy skill's setup steps, never the npx line.`;
 var namedWithActs = (subcommand) => subcommand.acts ? `${subcommand.name} ${subcommand.acts.join("|")}` : subcommand.name;
 var shown = (option) => option.flag ? option.name : `${option.name} ${option.value}`;
 var listed = (names) => names.length < 3 ? names.join(" and ") : `${names.slice(0, -1).join(", ")}, and ${names[names.length - 1]}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "turnzero",
-  "version": "0.21.6",
+  "version": "0.22.0-next.1",
   "type": "module",
   "description": "The Turn Zero Cloud command, which an AI coding tool runs on your machine to deploy an application, store a secret, upload a file, download an export, take a library entry, write a local run's settings, start the application locally, and scaffold a new service from a template.",
   "license": "Apache-2.0",