copilotkit 4.15.0 → 4.17.0

package/onboarding/prompts/unsupported/no-validated-path.md

@@ -30,13 +30,13 @@ Before you show the best-effort plan, require this complete packet:
 - Give the ordered proof rules.
 
 After the developer approves the best-effort plan, run
-`npx --prefer-offline --yes copilotkit@4.15.0 onboard read fallback/best-effort`.
+`npx --prefer-offline --yes copilotkit@4.17.0 onboard read fallback/best-effort`.
 
 Send one short report. Run the friction command without another developer question. Do not
 ask the developer about telemetry: the command applies the setting they already have.
 
 ```text
-npx --prefer-offline --yes copilotkit@4.15.0 onboard friction --phase stop --category <slug> --message "<sentences>"
+npx --prefer-offline --yes copilotkit@4.17.0 onboard friction --phase stop --category <slug> --message "<sentences>"
 ```
 
 `--message` takes one or two sentences: the step you stopped at and what stopped it.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "copilotkit",
-  "version": "4.15.0",
+  "version": "4.17.0",
   "type": "module",
   "engines": {
     "node": ">=20.9.0"
@@ -16,9 +16,5 @@
   "optionalDependencies": {
     "@microsoft/teams.cli": "3.0.3"
   },
-  "dependencies": {
-    "@mastra/core": "1.48.0",
-    "@mastra/libsql": "1.14.3"
-  },
   "license": "SEE LICENSE IN LICENSE"
 }

package/release/release-tool.js

@@ -14811,7 +14811,7 @@ var FLAG_DEFINITIONS = defineFlags({
 
 // apps/cli/src/config.ts
 function getTemplateRef() {
-  return true ? "33db9a81ccfd2d6e820defe3c1616594909439af" : "main";
+  return true ? "0c8647a7f4ecf565e58405642539c9d9744f62c5" : "main";
 }
 
 // apps/cli/src/services/agentcore-config.ts
@@ -14980,6 +14980,13 @@ async function writeShowcaseConfig(projectDir, showcase) {
 // apps/cli/src/services/telemetry/event-properties.ts
 var TELEMETRY_ERROR_CODES = {
   TEMPLATE_FETCH_FAILED: "TEMPLATE_FETCH_FAILED",
+  /**
+   * Copying the fetched starter into the project folder failed. Separate from
+   * {@link TELEMETRY_ERROR_CODES.TEMPLATE_FETCH_FAILED}: a Windows antivirus
+   * lock (`EBUSY`) used to be filed as a failed download (PE-358). Buckets as
+   * `filesystem`, or `sandbox_denied` when a sandbox refused the write.
+   */
+  TEMPLATE_COPY_FAILED: "TEMPLATE_COPY_FAILED",
   GIT_FAILED: "GIT_FAILED",
   PREREQUISITE_MISSING: "PREREQUISITE_MISSING",
   INVALID_FRAMEWORK: "INVALID_FRAMEWORK",
@@ -15026,6 +15033,11 @@ function tagError(err, code) {
   err.code = code;
   return err;
 }
+function annotateFailure(err, cause) {
+  const annotated = err;
+  annotated.failureCause = { ...cause, ...annotated.failureCause };
+  return err;
+}
 
 // apps/cli/src/types.ts
 var AGENT_FRAMEWORKS = Object.keys(
@@ -15320,6 +15332,7 @@ var FRAMEWORK_TEMPLATES = {
     // key requirement here would falsely warn on valid Azure/`agent/.env`
     // setups — the guidance below points at `agent/.env` instead.
     environment: [],
+    modelKeyTargets: [{ key: "OPENAI_API_KEY", envFile: "agent/.env" }],
     setupNotes: [
       { text: "  Set up the agent model credentials in agent/.env:" },
       { text: "    OpenAI:  ", code: "OPENAI_API_KEY=sk-..." },
@@ -15382,7 +15395,7 @@ var FRAMEWORK_TEMPLATES = {
 import * as fs4 from "node:fs";
 import * as path4 from "node:path";
 import * as os from "node:os";
-import { execFileSync } from "node:child_process";
+import { execFileSync, spawn } from "node:child_process";
 
 // apps/cli/src/services/project-config.ts
 import * as fs3 from "node:fs";
@@ -15433,6 +15446,11 @@ function canonicalizeDir(dir) {
 }
 
 // apps/cli/src/services/project-scaffold.ts
+var DEFAULT_GIT_STALL_TIMEOUT_MS = 6e4;
+var NON_INTERACTIVE_GIT_ENV = {
+  GIT_TERMINAL_PROMPT: "0",
+  GCM_INTERACTIVE: "never"
+};
 var PROJECT_DIRECTORY_NAMES = /* @__PURE__ */ new Set([
   "agent",
   "api",
@@ -15450,12 +15468,17 @@ var PROJECT_MANIFEST_NAMES = /* @__PURE__ */ new Set([
   "Gemfile",
   "build.gradle",
   "composer.json",
+  "global.json",
   "go.mod",
   "package.json",
   "pom.xml",
   "pyproject.toml",
   "requirements.txt"
 ]);
+var PROJECT_MANIFEST_EXTENSIONS = [".csproj", ".sln"];
+function isProjectManifest(entry) {
+  return PROJECT_MANIFEST_NAMES.has(entry) || PROJECT_MANIFEST_EXTENSIONS.some((extension) => entry.endsWith(extension));
+}
 var ENV_TEMPLATE_SUFFIXES = [".example", ".sample", ".template"];
 function isCredentialEnvFile(entry) {
   if (!entry.startsWith(".env"))
@@ -15467,7 +15490,7 @@ function isCredentialEnvFile(entry) {
 function entryHoldsProject(entry) {
   if (isCredentialEnvFile(entry))
     return true;
-  return PROJECT_DIRECTORY_NAMES.has(entry) || PROJECT_MANIFEST_NAMES.has(entry);
+  return PROJECT_DIRECTORY_NAMES.has(entry) || isProjectManifest(entry);
 }
 var SYSTEM_FOLDERS = [
   "/Applications",
@@ -15511,24 +15534,68 @@ function readEntries(dir) {
   }
 }
 function findProjectsBelow(dir) {
+  return walkProjectsBelow(dir, readEntries(dir), {
+    stopAfter: Number.POSITIVE_INFINITY,
+    maxEntries: Number.POSITIVE_INFINITY
+  }).found.sort();
+}
+function readEntriesUpTo(dir, limit) {
+  if (limit === Number.POSITIVE_INFINITY) {
+    return {
+      entries: fs4.readdirSync(dir, { withFileTypes: true }),
+      exhausted: false
+    };
+  }
+  const handle = fs4.opendirSync(dir);
+  const entries = [];
+  try {
+    for (let entry = handle.readSync(); entry !== null; entry = handle.readSync()) {
+      if (entries.length >= limit)
+        return { entries, exhausted: true };
+      entries.push(entry);
+    }
+    return { entries, exhausted: false };
+  } finally {
+    handle.closeSync();
+  }
+}
+function walkProjectsBelow(dir, top, limits) {
   const found = [];
-  const visit = (relative, depth) => {
-    for (const entry of readEntries(path4.join(dir, relative))) {
+  let budget = limits.maxEntries - top.length;
+  let exhausted = budget < 0;
+  const readChild = (childDir) => {
+    try {
+      const read = readEntriesUpTo(childDir, budget);
+      budget -= read.entries.length;
+      if (read.exhausted)
+        exhausted = true;
+      return read.entries;
+    } catch {
+      return [];
+    }
+  };
+  const visit = (relative, entries, depth) => {
+    for (const entry of entries) {
+      if (found.length >= limits.stopAfter || exhausted)
+        return;
       if (!entry.isDirectory())
         continue;
       if (entry.name.startsWith(".") || entry.name === "node_modules")
         continue;
       const child = path4.join(relative, entry.name);
-      const names = readEntries(path4.join(dir, child)).map((e) => e.name);
-      if (names.some((n) => n === ".git" || PROJECT_MANIFEST_NAMES.has(n))) {
+      const childEntries = readChild(path4.join(dir, child));
+      if (exhausted)
+        return;
+      const names = childEntries.map((e) => e.name);
+      if (names.some((n) => n === ".git" || isProjectManifest(n))) {
         found.push(child);
       } else if (depth < PROJECTS_BELOW_DEPTH) {
-        visit(child, depth + 1);
+        visit(child, childEntries, depth + 1);
       }
     }
   };
-  visit("", 1);
-  return found.sort();
+  visit("", top, 1);
+  return { found, exhausted };
 }
 function readProjectDirContents(projectDir, homeDir = os.homedir()) {
   if (!fs4.existsSync(projectDir))
@@ -15577,6 +15644,7 @@ function occupiedMessage(projectDir, contents) {
 }
 async function scaffoldProject(options) {
   const { projectDir, template } = options;
+  const stallTimeoutMs = options.gitStallTimeoutMs ?? DEFAULT_GIT_STALL_TIMEOUT_MS;
   assertProjectDirAvailable(projectDir);
   const localTemplateDir = process.env["COPILOTKIT_TEMPLATE_DIR"];
   if (localTemplateDir !== void 0 && localTemplateDir !== "") {
@@ -15588,8 +15656,16 @@ async function scaffoldProject(options) {
         TELEMETRY_ERROR_CODES.TEMPLATE_FETCH_FAILED
       );
     }
-    fs4.mkdirSync(projectDir, { recursive: true });
-    await copyDirectory(localTemplateDir, projectDir, true);
+    try {
+      fs4.mkdirSync(projectDir, { recursive: true });
+      await copyDirectory(localTemplateDir, projectDir, true);
+    } catch (cause) {
+      throw wrapStepError(
+        cause,
+        TELEMETRY_ERROR_CODES.TEMPLATE_COPY_FAILED,
+        "copy"
+      );
+    }
     return;
   }
   const source = typeof template === "string" ? parseGitHubUrl(template) : {
@@ -15599,7 +15675,7 @@ async function scaffoldProject(options) {
     subdirectoryPath: template.path,
     mode: template.mode
   };
-  await cloneTemplate(source, projectDir);
+  await cloneTemplate(source, projectDir, stallTimeoutMs);
 }
 function pathEntryExists(entryPath) {
   try {
@@ -15612,61 +15688,85 @@ function pathEntryExists(entryPath) {
     throw error48;
   }
 }
-async function cloneTemplate(source, destinationPath) {
+async function cloneTemplate(source, destinationPath, stallTimeoutMs) {
   const { owner, repo, revision, subdirectoryPath, mode } = source;
   const tempDir = fs4.mkdtempSync(path4.join(os.tmpdir(), "copilotkit-clone-"));
   const isWholeRepo = mode === "whole-repository";
   const destinationExisted = pathEntryExists(destinationPath);
   try {
-    runGit(
+    await runGit(
       ["init"],
-      { cwd: tempDir, stdio: "pipe" },
-      TELEMETRY_ERROR_CODES.GIT_FAILED
+      { cwd: tempDir, stallTimeoutMs },
+      TELEMETRY_ERROR_CODES.GIT_FAILED,
+      "git_init"
     );
-    runGit(
+    await runGit(
       ["remote", "add", "origin", `https://github.com/${owner}/${repo}.git`],
-      { cwd: tempDir, stdio: "pipe" },
-      TELEMETRY_ERROR_CODES.GIT_FAILED
+      { cwd: tempDir, stallTimeoutMs },
+      TELEMETRY_ERROR_CODES.GIT_FAILED,
+      "remote_add"
     );
     if (!isWholeRepo) {
-      runGit(
+      await runGit(
         ["config", "core.sparseCheckout", "true"],
-        { cwd: tempDir, stdio: "pipe" },
-        TELEMETRY_ERROR_CODES.GIT_FAILED
-      );
-      fs4.writeFileSync(
-        path4.join(tempDir, ".git/info/sparse-checkout"),
-        subdirectoryPath
+        { cwd: tempDir, stallTimeoutMs },
+        TELEMETRY_ERROR_CODES.GIT_FAILED,
+        "sparse_config"
       );
+      try {
+        fs4.writeFileSync(
+          path4.join(tempDir, ".git/info/sparse-checkout"),
+          subdirectoryPath
+        );
+      } catch (cause) {
+        throw wrapStepError(
+          cause,
+          TELEMETRY_ERROR_CODES.GIT_FAILED,
+          "sparse_config"
+        );
+      }
     }
-    runGit(
-      ["fetch", "--depth=1", "origin", revision],
-      { cwd: tempDir, stdio: "pipe" },
-      TELEMETRY_ERROR_CODES.TEMPLATE_FETCH_FAILED
+    await runGit(
+      ["fetch", "--progress", "--depth=1", "origin", revision],
+      { cwd: tempDir, stallTimeoutMs },
+      TELEMETRY_ERROR_CODES.TEMPLATE_FETCH_FAILED,
+      "fetch"
     );
-    runGit(
-      ["checkout", "--detach", "FETCH_HEAD"],
-      { cwd: tempDir, stdio: "pipe" },
-      TELEMETRY_ERROR_CODES.GIT_FAILED
+    await runGit(
+      ["checkout", "--progress", "--detach", "FETCH_HEAD"],
+      { cwd: tempDir, stallTimeoutMs },
+      TELEMETRY_ERROR_CODES.GIT_FAILED,
+      "checkout"
     );
     const sourcePath = isWholeRepo ? tempDir : path4.join(tempDir, subdirectoryPath);
     if (!isWholeRepo && !fs4.existsSync(sourcePath)) {
-      throw tagError(
-        new Error(
-          `Template directory '${subdirectoryPath}' not found in the repository.`
+      throw annotateFailure(
+        tagError(
+          new Error(
+            `Template directory '${subdirectoryPath}' not found in the repository.`
+          ),
+          TELEMETRY_ERROR_CODES.TEMPLATE_FETCH_FAILED
         ),
-        TELEMETRY_ERROR_CODES.TEMPLATE_FETCH_FAILED
+        { failedStep: "subdirectory_missing" }
+      );
+    }
+    try {
+      fs4.mkdirSync(destinationPath, { recursive: true });
+      await copyDirectory(sourcePath, destinationPath, isWholeRepo);
+    } catch (cause) {
+      throw wrapStepError(
+        cause,
+        TELEMETRY_ERROR_CODES.TEMPLATE_COPY_FAILED,
+        "copy"
       );
     }
-    fs4.mkdirSync(destinationPath, { recursive: true });
-    await copyDirectory(sourcePath, destinationPath, isWholeRepo);
   } catch (cause) {
     if (!destinationExisted) {
       fs4.rmSync(destinationPath, { recursive: true, force: true });
     }
     const error48 = cause instanceof Error ? cause : new Error("Starter template checkout failed");
     const code = error48.code;
-    if (code === TELEMETRY_ERROR_CODES.TEMPLATE_FETCH_FAILED || code === TELEMETRY_ERROR_CODES.GIT_FAILED) {
+    if (code === TELEMETRY_ERROR_CODES.TEMPLATE_FETCH_FAILED || code === TELEMETRY_ERROR_CODES.TEMPLATE_COPY_FAILED || code === TELEMETRY_ERROR_CODES.GIT_FAILED) {
       throw error48;
     }
     throw tagError(error48, TELEMETRY_ERROR_CODES.TEMPLATE_FETCH_FAILED);
@@ -15695,12 +15795,88 @@ async function copyDirectory(source, destination, excludeGit = false) {
     }
   }
 }
-function runGit(args, opts, code) {
+function wrapStepError(cause, code, failedStep) {
+  const message = cause instanceof Error ? cause.message : `Starter step failed: ${failedStep}`;
+  const status = cause?.status;
+  return annotateFailure(tagError(new Error(message, { cause }), code), {
+    failedStep,
+    ...typeof status === "number" ? { gitExitCode: status } : {}
+  });
+}
+var GIT_STDERR_TAIL_LINES = 20;
+var GIT_PROGRESS_LINE = /^(remote: )?(Counting|Compressing|Receiving|Resolving|Enumerating|Updating files|Total)\b/;
+function gitStderrTail(stderr) {
+  return stderr.split(/\r|\n/).map((line) => line.trimEnd()).filter((line) => line !== "" && !GIT_PROGRESS_LINE.test(line)).slice(-GIT_STDERR_TAIL_LINES).join("\n");
+}
+var GIT_STDERR_MAX_CHARS = 64 * 1024;
+function stallError(command, failedStep, options) {
+  const seconds = Math.round(options.stallTimeoutMs / 1e3);
+  const advice = failedStep === "fetch" ? " Check your network connection to github.com. If you are behind a proxy, set HTTPS_PROXY to its address and run the command again." : "";
+  return Object.assign(
+    new Error(
+      `\`${command}\` stopped: git printed nothing for ${seconds} seconds.${advice}`
+    ),
+    { code: "ETIMEDOUT" }
+  );
+}
+async function runGit(args, options, code, failedStep) {
+  const command = `git ${args.join(" ")}`;
   try {
-    execFileSync("git", args, opts);
+    await new Promise((resolve5, reject) => {
+      const child = spawn("git", args, {
+        cwd: options.cwd,
+        env: { ...process.env, ...NON_INTERACTIVE_GIT_ENV },
+        stdio: ["ignore", "ignore", "pipe"],
+        windowsHide: true
+      });
+      let stderr = "";
+      let settled = false;
+      let watchdog;
+      const settle = (finish) => {
+        if (settled)
+          return;
+        settled = true;
+        clearTimeout(watchdog);
+        finish();
+      };
+      const armWatchdog = () => {
+        clearTimeout(watchdog);
+        watchdog = setTimeout(() => {
+          child.kill();
+          child.stderr.destroy();
+          child.unref();
+          settle(() => reject(stallError(command, failedStep, options)));
+        }, options.stallTimeoutMs);
+      };
+      armWatchdog();
+      child.stderr.setEncoding("utf8");
+      child.stderr.on("data", (chunk) => {
+        stderr = (stderr + chunk).slice(-GIT_STDERR_MAX_CHARS);
+        armWatchdog();
+      });
+      child.on("error", (error48) => settle(() => reject(error48)));
+      child.on(
+        "close",
+        (status) => settle(() => {
+          if (status === 0) {
+            resolve5();
+            return;
+          }
+          const tail = gitStderrTail(stderr);
+          reject(
+            Object.assign(
+              new Error(
+                `Command failed: ${command}${tail ? `
+${tail}` : ""}`
+              ),
+              { status }
+            )
+          );
+        })
+      );
+    });
   } catch (cause) {
-    const wrapped = cause instanceof Error ? cause : new Error(`git command failed: git ${args.join(" ")}`);
-    throw tagError(wrapped, code);
+    throw wrapStepError(cause, code, failedStep);
   }
 }
 function parseGitHubUrl(githubUrl) {