@akanjs/cli 3.0.0-beta.2 → 3.0.0-beta.21

package/index-3hx1z96c.js

@@ -0,0 +1,87 @@
+// @bun
+// pkgs/@akanjs/devkit/cloud/configLock.ts
+import { mkdir, open, readFile, rm, stat } from "fs/promises";
+import path from "path";
+
+class ConfigLock {
+  static waitTimeoutMs = 30000;
+  static #unknownHolderStaleMs = 1e4;
+  static #pollMs = 50;
+  static async run(lockPath, fn) {
+    await mkdir(path.dirname(lockPath), { recursive: true, mode: 448 });
+    const deadline = Date.now() + ConfigLock.waitTimeoutMs;
+    while (!await ConfigLock.#take(lockPath)) {
+      if (Date.now() >= deadline) {
+        const holder = (await ConfigLock.#holder(lockPath))?.pid ?? "unknown";
+        throw new Error(`${lockPath} is held by process ${holder}; if no akan command is running, delete it and retry.`);
+      }
+      await ConfigLock.#reclaimIfAbandoned(lockPath);
+      await Bun.sleep(ConfigLock.#pollMs);
+    }
+    try {
+      return await fn();
+    } finally {
+      await rm(lockPath, { force: true });
+    }
+  }
+  static async#take(lockPath) {
+    const handle = await open(lockPath, "wx", 384).catch((error) => {
+      if (error.code === "EEXIST")
+        return null;
+      throw error;
+    });
+    if (!handle)
+      return false;
+    try {
+      await handle.writeFile(JSON.stringify({ pid: process.pid, at: Date.now() }));
+    } finally {
+      await handle.close();
+    }
+    return true;
+  }
+  static async#reclaimIfAbandoned(lockPath) {
+    if (!await ConfigLock.#abandoned(lockPath))
+      return;
+    const guard = `${lockPath}.reclaim`;
+    if (!await ConfigLock.#take(guard)) {
+      if (await ConfigLock.#abandoned(guard))
+        await rm(guard, { force: true });
+      return;
+    }
+    try {
+      if (await ConfigLock.#abandoned(lockPath))
+        await rm(lockPath, { force: true });
+    } finally {
+      await rm(guard, { force: true });
+    }
+  }
+  static async#abandoned(lockPath) {
+    const info = await stat(lockPath).catch(() => null);
+    if (!info)
+      return false;
+    const holder = await ConfigLock.#holder(lockPath);
+    if (!holder)
+      return Date.now() - info.mtimeMs > ConfigLock.#unknownHolderStaleMs;
+    return !ConfigLock.#isAlive(holder.pid);
+  }
+  static async#holder(lockPath) {
+    try {
+      const parsed = JSON.parse(await readFile(lockPath, "utf8"));
+      return typeof parsed.pid === "number" && typeof parsed.at === "number" ? { pid: parsed.pid, at: parsed.at } : null;
+    } catch {
+      return null;
+    }
+  }
+  static #isAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+      return false;
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (error) {
+      return error.code === "EPERM";
+    }
+  }
+}
+
+export { ConfigLock };

package/{index-kcxmv48c.js → index-3t7g9e4r.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
-  FileSys
-} from "./index-q0y2jq9j.js";
+  FileSys2
+} from "./index-5b6tavv3.js";
 
 // pkgs/@akanjs/devkit/dependencyScanner.ts
 import { builtinModules } from "module";
@@ -10,7 +10,10 @@ import ignore from "ignore";
 import ts from "typescript";
 var testFileRegex = /\.(?:test|spec)\.[cm]?[tj]sx?$/;
 var skipDirs = ["node_modules", "dist", "build", ".git", ".next", "public", "ios", "android", "__fixtures__"];
-var isSkippedPath = (filePath) => skipDirs.some((dir) => filePath.includes(`/${dir}/`) || filePath.startsWith(`${dir}/`));
+var isSkippedPath = (filePath) => {
+  const posixPath = filePath.split(path.sep).join("/");
+  return skipDirs.some((dir) => posixPath.includes(`/${dir}/`) || posixPath.startsWith(`${dir}/`));
+};
 var builtinModuleSet = new Set([...builtinModules, ...builtinModules.map((mod) => `node:${mod}`)]);
 var stripShebang = (source) => source.replace(/^#!.*(?:\r?\n|$)/, "");
 
@@ -54,24 +57,21 @@ class TypeScriptDependencyScanner2 {
   async getPackageBuildDependencies(projectName) {
     const runtimeDeps = new Set;
     const devDeps = new Set;
-    const sourceFiles = await this.#findTypeScriptFiles(this.#directory, {
-      excludeBuildFiles: true,
-      excludeTestFiles: true
-    });
-    const cssFiles = await this.#findCssFiles(this.#directory);
+    const sourceFiles = await this.#findFiles("**/*.{ts,tsx}", { excludeBuildFiles: true, excludeTestFiles: true });
+    const cssFiles = await this.#findFiles("**/*.css");
     for (const filePath of sourceFiles) {
-      const fileContent = await FileSys.readText(filePath);
+      const fileContent = await FileSys2.readText(filePath);
       const { imports, typeImports } = this.#extractImports(fileContent, filePath);
       this.#addNormalizedImports(runtimeDeps, imports, projectName);
       this.#addNormalizedImports(devDeps, typeImports, projectName);
     }
     for (const filePath of cssFiles) {
-      const fileContent = await FileSys.readText(filePath);
+      const fileContent = await FileSys2.readText(filePath);
       this.#addNormalizedImports(runtimeDeps, this.#extractCssPluginImports(fileContent), projectName);
     }
     const buildFilePath = path.join(this.#directory, "build.ts");
-    if (await FileSys.fileExists(buildFilePath)) {
-      const fileContent = await FileSys.readText(buildFilePath);
+    if (await FileSys2.fileExists(buildFilePath)) {
+      const fileContent = await FileSys2.readText(buildFilePath);
       const { imports, typeImports } = this.#extractImports(fileContent, buildFilePath);
       this.#addNormalizedImports(devDeps, [...imports, ...typeImports], projectName);
     }
@@ -95,7 +95,7 @@ class TypeScriptDependencyScanner2 {
     if (!await Bun.file(packageJsonPath).exists())
       return false;
     try {
-      const packageJson = await FileSys.readJson(packageJsonPath);
+      const packageJson = await FileSys2.readJson(packageJsonPath);
       return packageJson.name === dep && !!packageJson.version;
     } catch {
       return false;
@@ -106,27 +106,21 @@ class TypeScriptDependencyScanner2 {
     return this.#getImportSetsFromDependencies(depSets, fileDependencies);
   }
   #getImportSetsFromDependencies(depSets, fileDependencies) {
-    const importedDepSets = new Array(depSets.length);
-    for (let i = 0;i < depSets.length; i++)
-      importedDepSets[i] = new Set;
-    fileDependencies.forEach((imps) => {
-      imps.forEach((imp) => {
+    const importedDepSets = depSets.map(() => new Set);
+    for (const imps of fileDependencies.values())
+      for (const imp of imps) {
         if (imp.startsWith("."))
-          return;
-        const moduleName = imp;
-        const moduleNameParts = moduleName.split("/");
-        const subModuleLength = moduleNameParts.length;
-        for (let i = 0;i < subModuleLength; i++) {
-          const importName = moduleNameParts.slice(0, i + 1).join("/");
-          for (let j = 0;j < depSets.length; j++) {
-            if (depSets[j]?.has(importName)) {
-              importedDepSets[j]?.add(importName);
-              return;
-            }
-          }
+          continue;
+        const parts = imp.split("/");
+        for (let length = 1;length <= parts.length; length++) {
+          const importName = parts.slice(0, length).join("/");
+          const setIndex = depSets.findIndex((depSet) => depSet.has(importName));
+          if (setIndex === -1)
+            continue;
+          importedDepSets[setIndex]?.add(importName);
+          break;
         }
-      });
-    });
+      }
     return importedDepSets;
   }
   async getDependencies() {
@@ -134,43 +128,25 @@ class TypeScriptDependencyScanner2 {
     this.#fileRuntimeDependencies.clear();
     this.#fileTypeDependencies.clear();
     this.#visitedFiles.clear();
-    const files = await this.#findTypeScriptFiles(this.#directory);
-    for (const file of files)
+    for (const file of await this.#findFiles("**/*.{ts,tsx}"))
       await this.#analyzeFile(file, this.#directory);
     return this.#fileDependencies;
   }
-  async#findTypeScriptFiles(directory, {
+  async#findFiles(pattern, {
     excludeBuildFiles = false,
     excludeTestFiles = false
   } = {}) {
     const files = [];
-    const glob = new Bun.Glob("**/*.{ts,tsx}");
-    for await (const filePath of glob.scan({ cwd: directory, onlyFiles: true })) {
+    for await (const filePath of new Bun.Glob(pattern).scan({ cwd: this.#directory, onlyFiles: true })) {
       if (isSkippedPath(filePath))
         continue;
       if (excludeBuildFiles && filePath === "build.ts")
         continue;
       if (excludeTestFiles && testFileRegex.test(filePath))
         continue;
-      const fullPath = path.join(directory, filePath);
-      const relativePath = path.relative(this.#workspaceRoot, fullPath);
-      if (this.#ig.ignores(relativePath))
-        continue;
-      files.push(fullPath);
-    }
-    return files;
-  }
-  async#findCssFiles(directory) {
-    const files = [];
-    const glob = new Bun.Glob("**/*.css");
-    for await (const filePath of glob.scan({ cwd: directory, onlyFiles: true })) {
-      if (isSkippedPath(filePath))
-        continue;
-      const fullPath = path.join(directory, filePath);
-      const relativePath = path.relative(this.#workspaceRoot, fullPath);
-      if (this.#ig.ignores(relativePath))
-        continue;
-      files.push(fullPath);
+      const fullPath = path.join(this.#directory, filePath);
+      if (!this.#ig.ignores(path.relative(this.#workspaceRoot, fullPath)))
+        files.push(fullPath);
     }
     return files;
   }
@@ -179,7 +155,7 @@ class TypeScriptDependencyScanner2 {
       return;
     this.#visitedFiles.add(filePath);
     try {
-      const fileContent = await FileSys.readText(filePath);
+      const fileContent = await FileSys2.readText(filePath);
       const { imports, typeImports } = this.#extractImports(fileContent, filePath);
       const resolvedImports = await this.#resolveImports(imports, filePath, baseDir);
       const resolvedTypeImports = await this.#resolveImports(typeImports, filePath, baseDir);
@@ -191,19 +167,17 @@ class TypeScriptDependencyScanner2 {
   }
   async#resolveImports(imports, filePath, baseDir) {
     return await Promise.all(imports.map(async (importPath) => {
-      if (importPath.startsWith(".")) {
-        const resolvedPath = `./${path.join(path.relative(baseDir, filePath), importPath)}`;
-        return await this.#ensureExtension(resolvedPath);
-      }
-      return importPath;
+      if (!importPath.startsWith("."))
+        return importPath;
+      return await this.#ensureExtension(`./${path.join(path.relative(baseDir, filePath), importPath)}`);
     }));
   }
   async#ensureExtension(filePath) {
-    if (await FileSys.fileExists(`${filePath}.ts`))
+    if (await FileSys2.fileExists(`${filePath}.ts`))
       return `${filePath}.ts`;
-    else if (await FileSys.fileExists(`${filePath}.tsx`))
+    else if (await FileSys2.fileExists(`${filePath}.tsx`))
       return `${filePath}.tsx`;
-    else if (await FileSys.fileExists(filePath))
+    else if (await FileSys2.fileExists(filePath))
       return filePath;
     return `${filePath}.ts`;
   }
@@ -262,22 +236,14 @@ class TypeScriptDependencyScanner2 {
 `;
       const projectImports = imports.filter((i) => !i.startsWith("react") && !i.startsWith("@"));
       const externalImports = imports.filter((i) => i.startsWith("react") || i.startsWith("@"));
-      if (projectImports.length > 0) {
+      if (projectImports.length > 0)
         graph += `  Project dependencies:
-`;
-        projectImports.forEach((imp) => {
-          graph += `    \u2192 ${imp}
-`;
-        });
-      }
-      if (externalImports.length > 0) {
+${projectImports.map((imp) => `    \u2192 ${imp}
+`).join("")}`;
+      if (externalImports.length > 0)
         graph += `  External dependencies:
-`;
-        externalImports.forEach((imp) => {
-          graph += `    \u2192 ${imp}
-`;
-        });
-      }
+${externalImports.map((imp) => `    \u2192 ${imp}
+`).join("")}`;
       graph += `
 `;
     }

package/{index-ne2qy0nk.js → index-4dn1p115.js}

@@ -2,7 +2,7 @@
 import {
   runner,
   script
-} from "./index-mak3cd28.js";
+} from "./index-rmcw8yc8.js";
 import {
   AGENT_BLOCK_START,
   AGENT_BLOCK_END,
@@ -13,17 +13,17 @@ import {
   CLAUDE_COMMENT_RULE,
   AppExecutor,
   LibExecutor
-} from "./index-2tv3fdx4.js";
+} from "./index-ga6hygxr.js";
 import {
   collectRecipeSources2,
   scanRecipes2
-} from "./index-by5gpp8x.js";
+} from "./index-hj6w4ka1.js";
 import {
   AkanContextAnalyzer
-} from "./index-ktb5njgy.js";
+} from "./index-9629w7ns.js";
 import {
-  Prompter
-} from "./index-h7yw2z9n.js";
+  Prompter2
+} from "./index-0bq14vr1.js";
 
 // pkgs/@akanjs/cli/agent/agent.script.ts
 import { Logger as Logger2 } from "akanjs/common";
@@ -106,10 +106,10 @@ ${scopeIndexPointer}
 `;
 };
 var renderGuides = async (context) => {
-  const conventions = (await Prompter.getInstruction("conventions")).trim();
+  const conventions = (await Prompter2.getInstruction("conventions")).trim();
   if (context.pkgs.some((pkg) => pkg.name === "akanjs"))
     return conventions;
-  const onboarding = (await Prompter.getInstruction("workspaceOnboarding")).trim();
+  const onboarding = (await Prompter2.getInstruction("workspaceOnboarding")).trim();
   const appName = context.apps[0]?.name ?? "app";
   return `${conventions}
 
@@ -117,7 +117,7 @@ ${onboarding.replaceAll("<%= appName %>", appName)}`;
 };
 var renderManagedBlock = async (workspace) => {
   const context = await AkanContextAnalyzer.analyze(workspace);
-  const frameworkGuide = await Prompter.getInstruction("framework");
+  const frameworkGuide = await Prompter2.getInstruction("framework");
   const appNames = context.apps.map((app) => app.name);
   const sampleCleanup = await renderSampleCleanup(workspace, appNames);
   const recipeIndex = await renderRecipeIndex(workspace);
@@ -126,7 +126,7 @@ var renderManagedBlock = async (workspace) => {
   const block = `## Workspace
 
 - Repo: ${context.repoName}
-- Apps: ${context.apps.map((app) => app.name).join(", ") || "none"}
+- Apps: ${appNames.join(", ") || "none"}
 - Libraries: ${context.libs.map((lib) => lib.name).join(", ") || "none"}
 - Packages: ${context.pkgs.map((pkg) => pkg.name).join(", ") || "none"}
 
@@ -138,7 +138,7 @@ ${sampleCleanup}## Akan Module Abstracts
 - Update the abstract when business invariants, workflows, or public behavior change.
 - Do not update the abstract for formatting-only, import-only, or style-only changes.
 - Service modules live in \`lib/_<service>\`, but their abstract file is \`<service>.abstract.md\`.
-- Keep an abstract short. Run \`akan compact <app-or-lib>\` to rewrite bloated abstracts down to the invariants the code cannot show; \`akan quality scan\` warns past 300 lines.
+- Keep an abstract short \u2014 the invariants the code cannot show, and nothing it already states. \`akan quality scan\` warns past 300 lines.
 
 ## Generated Files
 
@@ -148,7 +148,7 @@ If generated output is stale or broken, update the owning source file and run \`
 ${recipeIndex}## MCP Workflow Policy
 
 - **Prefer an Akan workflow to a direct source edit.** A direct edit is denied when an allowlisted workflow or repair tool can make the change.
-- Inspect with \`akan mcp --mode plan\` (\`list_workflows\`, \`explain_workflow\`, \`plan_workflow\`); apply with \`akan mcp --mode apply\`, which allowlists \`apply_workflow\`, \`run_validation\`, and the repair tools.
+- Inspect with \`akan mcp --mode plan\` (\`list_workflows\`, \`explain_workflow\`, \`plan_workflow\`); apply with \`akan mcp --mode apply\`, which allowlists \`apply_workflow\`, \`run_validation\`, and three of the five repair tools \u2014 \`repair_generated\`, \`repair_imports\` and \`repair_module_shape\`. \`akan repair format\` and \`akan repair dictionary\` are CLI-only.
 - If \`plan_workflow\` returns \`planPath\` or \`next.tool=apply_workflow\`, call \`apply_workflow({ planPath })\` before editing source. Then run \`run_validation\` with \`validationTarget\` when present, otherwise \`applyReportPath\`.
 - Split a compound request into workflows and apply each \`planPath\` in order, such as \`create-module\` followed by \`add-field\`.
 - When no workflow exists, or apply reports unsupported/no-op/failed diagnostics needing manual action, keep edits scoped to owning source files and never patch generated files directly.

package/{index-q0y2jq9j.js → index-5b6tavv3.js}

@@ -1,9 +1,12 @@
 // @bun
 // pkgs/@akanjs/devkit/fileSys.ts
 import { lstat, rename, rm, stat } from "fs/promises";
+import nodePath from "path";
+import { fileURLToPath } from "url";
 import { Logger } from "akanjs/common";
+var getDirname2 = (url) => nodePath.dirname(fileURLToPath(url));
 
-class FileSys {
+class FileSys2 {
   static logger = new Logger("FileSys");
   static async fileExists(path) {
     return await Bun.file(path).exists();
@@ -24,7 +27,7 @@ class FileSys {
     try {
       return await Bun.file(path).json();
     } catch (error) {
-      FileSys.logger.error(`Failed to read JSON file: ${path}`);
+      FileSys2.logger.error(`Failed to read JSON file: ${path}`);
       throw error;
     }
   }
@@ -52,4 +55,4 @@ class FileSys {
   }
 }
 
-export { FileSys };
+export { getDirname2, FileSys2 };

package/index-7cqjvraf.js

@@ -0,0 +1,69 @@
+// @bun
+import {
+  jsonText
+} from "./index-yy4s1j72.js";
+import {
+  akanMcpInstallTargets
+} from "./index-9629w7ns.js";
+import {
+  script
+} from "./index-rmcw8yc8.js";
+import {
+  ContextRunner2
+} from "./index-dg97qp24.js";
+
+// pkgs/@akanjs/cli/context/context.script.ts
+import { Logger } from "akanjs/common";
+var resolveMcpInstallTargets = (target) => {
+  if (!target || target === "all")
+    return [...akanMcpInstallTargets];
+  if (akanMcpInstallTargets.includes(target))
+    return [target];
+  throw new Error(`Unknown MCP install target: ${target}. Use cursor, claude, codex, or all.`);
+};
+var mcpTargetLabels = {
+  cursor: "Cursor",
+  claude: "Claude Code",
+  codex: "Codex"
+};
+
+class ContextScript extends script("context", [ContextRunner2]) {
+  async context(workspace, options = {}) {
+    Logger.rawLog(await this.contextRunner.getContext(workspace, options));
+  }
+  async doctor(workspace, options = {}) {
+    Logger.rawLog(await this.contextRunner.doctor(workspace, options));
+  }
+  async mcpInstall(workspace, target, { force = false, mode = "apply" } = {}) {
+    const targets = resolveMcpInstallTargets(target);
+    const written = [];
+    for (const t of targets) {
+      const configPath = await this.contextRunner.installMcp(workspace, t, { force, mode });
+      written.push(`${mcpTargetLabels[t]}: ${configPath}`);
+    }
+    Logger.rawLog(`Akan MCP server installed (${mode} mode):
+${written.map((line) => `- ${line}`).join(`
+`)}`);
+  }
+  async mcp(workspace, { mode = "apply" } = {}) {
+    await this.contextRunner.runMcp(workspace, { mode });
+  }
+  async mcpCall(workspace, tool, {
+    mode = "readonly",
+    args = null,
+    format = "json"
+  } = {}) {
+    let parsedArgs = {};
+    if (args) {
+      const parsed = JSON.parse(args);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("MCP call args must be a JSON object.");
+      }
+      parsedArgs = parsed;
+    }
+    const result = await this.contextRunner.callMcpTool(workspace, tool, parsedArgs, { mode });
+    Logger.rawLog(format === "json" ? jsonText(result) : String(result));
+  }
+}
+
+export { ContextScript };

package/index-7md2g9vw.js

@@ -0,0 +1,6 @@
+// @bun
+// pkgs/@akanjs/devkit/stripAnsi.ts
+var ansi = new RegExp(`${String.fromCharCode(27)}(?:[@-Z\\\\-_]|\\[[\\s\\S]*?[@-~])`, "g");
+var stripAnsi = (text) => text.replace(ansi, "");
+
+export { stripAnsi };

package/{index-zry5nz81.js → index-8kb5p54p.js}

@@ -1,44 +1,33 @@
 // @bun
 import {
   GlobalConfig,
-  CloudApi,
-  AiSession
-} from "./index-kn1h7p1x.js";
-import {
-  PkgExecutor
-} from "./index-2tv3fdx4.js";
+  CloudApi
+} from "./index-22d57v4c.js";
 import {
   script
-} from "./index-mak3cd28.js";
+} from "./index-rmcw8yc8.js";
+import {
+  PkgExecutor
+} from "./index-ga6hygxr.js";
 import {
   ApplicationScript
-} from "./index-v0qh106m.js";
+} from "./index-z50k041j.js";
 import {
   PackageScript
-} from "./index-ws5e0j51.js";
+} from "./index-mgfx3mfs.js";
 import {
   CloudRunner
-} from "./index-2hq52jq3.js";
+} from "./index-yjkte9aj.js";
 
 // pkgs/@akanjs/cli/cloud/cloud.script.ts
 import { Logger } from "akanjs/common";
-class CloudScript extends script("cloud", [CloudRunner, ApplicationScript, PackageScript]) {
+class CloudScript2 extends script("cloud", [CloudRunner, ApplicationScript, PackageScript]) {
   async login(workspace, host = GlobalConfig.akanCloudHost) {
     await this.cloudRunner.login(host, workspace);
   }
   async logout(workspace, host = GlobalConfig.akanCloudHost) {
     await this.cloudRunner.logout(host);
   }
-  async setLlm(workspace) {
-    await this.cloudRunner.setLlm();
-  }
-  resetLlm(workspace) {
-    this.cloudRunner.resetLlm();
-  }
-  async ask(question, workspace) {
-    const session = new AiSession("general", { workspace, isContinued: true });
-    await session.ask(question);
-  }
   async downloadEnv(workspace, workspaceId = workspace.getWorkspaceId({ allowEmpty: true }), { host = GlobalConfig.akanCloudHost } = {}) {
     if (workspaceId) {
       await this.login(workspace, host);
@@ -48,29 +37,61 @@ class CloudScript extends script("cloud", [CloudRunner, ApplicationScript, Packa
     }
     await this.cloudRunner.downloadEnvByScp(workspace);
   }
-  async uploadEnv(workspace, { host = GlobalConfig.akanCloudHost } = {}) {
-    const workspaceId = workspace.getWorkspaceId({ allowEmpty: true });
-    const { path } = await this.cloudRunner.gatherEnvFiles(workspace);
+  async uploadEnv(workspace, {
+    host = GlobalConfig.akanCloudHost,
+    workspaceId = workspace.getWorkspaceId({ allowEmpty: true }),
+    scope,
+    archivePath
+  } = {}) {
+    if (scope && !workspaceId)
+      throw new Error("A scoped env upload needs a cloud workspace id \u2014 the scp target is workspace-wide.");
+    const { files, path } = await this.cloudRunner.gatherEnvFiles(workspace, { scope, archivePath });
     if (workspaceId) {
       await this.login(workspace, host);
       const cloudApi = await CloudApi.fromHost(workspace, host);
       await this.cloudRunner.uploadEnv(cloudApi, workspaceId, path);
-      return;
+      return { workspaceId, files };
     }
     await this.cloudRunner.uploadEnvByScp(workspace, path);
+    return { workspaceId: null, files };
   }
-  async deployAkan(workspace, { test = true, registryUrl } = {}) {
+  async deployAkan(workspace, {
+    test = true,
+    registryUrl,
+    platforms = []
+  } = {}) {
     const akanPkgs = await this.cloudRunner.getAkanPkgs(workspace);
     await this.packageScript.updateWorskpaceRootPackageJson(workspace);
     const pkgs = akanPkgs.map((pkgName) => PkgExecutor.from(workspace, pkgName));
-    if (test)
-      for (const pkg of pkgs)
-        await this.applicationScript.test(pkg);
+    if (test) {
+      const platformRun = platforms.length ? await this.cloudRunner.startPlatformTests(workspace, platforms, akanPkgs) : null;
+      let localFailure = null;
+      try {
+        for (const pkg of pkgs)
+          await this.applicationScript.test(pkg);
+      } catch (error) {
+        localFailure = error;
+      }
+      if (platformRun)
+        await this.cloudRunner.settlePlatformTests(platformRun, {
+          interactive: !localFailure,
+          recordStreaks: !localFailure,
+          checkDrift: true
+        });
+      if (localFailure)
+        throw localFailure;
+    }
     for (const pkg of pkgs)
       await this.packageScript.buildPackage(pkg);
     await this.packageScript.verifyAkanPublishPackages(workspace);
     await this.cloudRunner.deployAkan(workspace, akanPkgs, { registryUrl });
   }
+  async testPlatforms(workspace, { platforms, pkgs }) {
+    if (!platforms.length)
+      throw new Error("No platform to test on \u2014 pass --platforms linux,windows");
+    const run = await this.cloudRunner.startPlatformTests(workspace, platforms, pkgs ?? await this.cloudRunner.getAkanPkgs(workspace));
+    await this.cloudRunner.settlePlatformTests(run, { interactive: false, recordStreaks: false, checkDrift: false });
+  }
   async update(workspace, tag = "latest", { registryUrl } = {}) {
     const spinner = workspace.spinning("Updating Akan.js packages and CLI...");
     await this.cloudRunner.update(workspace, tag, { registryUrl });
@@ -80,4 +101,4 @@ class CloudScript extends script("cloud", [CloudRunner, ApplicationScript, Packa
   }
 }
 
-export { CloudScript };
+export { CloudScript2 };