archondev 2.17.0 → 2.18.2

package/README.md

@@ -90,6 +90,7 @@ Copy governance files into any project. Works with your existing AI tools: **Cur
 | `archon session resume [id]` | Resume session on another device |
 | `archon execute ATOM --cloud` | Execute in cloud (creates PR when done) |
 | `archon cloud status` | List cloud executions |
+| `archon parallel cloud ATOM-001 ATOM-002` | Queue multiple atoms for cloud execution (Credits tier) |
 | `archon index init [--local\|--cloud]` | Initialize semantic indexing |
 | `archon index update [--cloud]` | Index changed files |
 | `archon index search "query" [--cloud]` | Semantic code search |

package/dist/a11y-O35BAA25.js

@@ -0,0 +1,14 @@
+import {
+  a11yBadge,
+  a11yCheck,
+  a11yFix,
+  a11yPreDeploy
+} from "./chunk-FWLLGLD5.js";
+import "./chunk-3ASILTFB.js";
+import "./chunk-4VNS5WPM.js";
+export {
+  a11yBadge,
+  a11yCheck,
+  a11yFix,
+  a11yPreDeploy
+};

package/dist/auth-HQBAG4CR.js

@@ -0,0 +1,14 @@
+import {
+  login,
+  logout,
+  status
+} from "./chunk-CZCY63EY.js";
+import "./chunk-M4LGRTLC.js";
+import "./chunk-LBBHM4I5.js";
+import "./chunk-SVU7MLG6.js";
+import "./chunk-4VNS5WPM.js";
+export {
+  login,
+  logout,
+  status
+};

package/dist/bug-5WRBCFRT.js

@@ -0,0 +1,12 @@
+import {
+  bugReport
+} from "./chunk-VF2OTDMS.js";
+import "./chunk-5CFGPXQ3.js";
+import "./chunk-2NSWZDP7.js";
+import "./chunk-HJARQDQR.js";
+import "./chunk-UFR2LX6G.js";
+import "./chunk-SVU7MLG6.js";
+import "./chunk-4VNS5WPM.js";
+export {
+  bugReport
+};

package/dist/{chunk-ER4ADSWH.js → chunk-2NSWZDP7.js}

@@ -1,159 +1,7 @@
 import {
   AnthropicClient,
-  generateId,
   getDefaultModel
-} from "./chunk-NIKN37AY.js";
-
-// src/core/atoms/types.ts
-var ATOM_TRANSITIONS = {
-  DRAFT: ["READY"],
-  READY: ["IN_PROGRESS", "BLOCKED"],
-  IN_PROGRESS: ["TESTING", "FAILED"],
-  TESTING: ["DONE", "FAILED"],
-  DONE: [],
-  // Terminal state
-  FAILED: ["IN_PROGRESS", "BLOCKED"],
-  // Can retry or escalate
-  BLOCKED: ["READY"]
-  // Can unblock and retry
-};
-var MAX_RETRIES = 3;
-
-// src/core/atoms/atoms.ts
-var MAX_RETRIES2 = MAX_RETRIES;
-var atomCounter = 0;
-function generateAtomId() {
-  atomCounter++;
-  return `ATOM-${String(atomCounter).padStart(3, "0")}`;
-}
-function createAtom(input, context) {
-  const now = /* @__PURE__ */ new Date();
-  const externalId = generateAtomId();
-  return {
-    id: generateId("atom"),
-    externalId,
-    title: input.title,
-    description: input.description ?? null,
-    goals: input.goals ?? [],
-    acceptanceCriteria: input.acceptanceCriteria,
-    ownershipPaths: input.ownershipPaths ?? [],
-    status: "DRAFT",
-    priority: input.priority ?? 100,
-    plan: null,
-    diffContract: null,
-    retryCount: 0,
-    errorMessage: null,
-    tags: input.tags ?? [],
-    metadata: input.metadata ?? {},
-    context: context ?? {},
-    createdAt: now,
-    updatedAt: now
-  };
-}
-function validateAtom(atom) {
-  const errors = [];
-  if (!atom.title || atom.title.trim() === "") {
-    errors.push({
-      field: "title",
-      message: "Title is required",
-      code: "REQUIRED"
-    });
-  }
-  if (!atom.acceptanceCriteria || atom.acceptanceCriteria.length === 0) {
-    errors.push({
-      field: "acceptanceCriteria",
-      message: "At least one acceptance criterion is required",
-      code: "REQUIRED"
-    });
-  }
-  atom.acceptanceCriteria.forEach((criterion, index) => {
-    if (typeof criterion !== "string" || criterion.trim() === "") {
-      errors.push({
-        field: `acceptanceCriteria[${index}]`,
-        message: "Acceptance criterion must be a non-empty string",
-        code: "INVALID_FORMAT"
-      });
-    }
-  });
-  if (atom.priority < 0) {
-    errors.push({
-      field: "priority",
-      message: "Priority must be a non-negative number",
-      code: "INVALID_VALUE"
-    });
-  }
-  const validStatuses = [
-    "DRAFT",
-    "READY",
-    "IN_PROGRESS",
-    "TESTING",
-    "DONE",
-    "FAILED",
-    "BLOCKED"
-  ];
-  if (!validStatuses.includes(atom.status)) {
-    errors.push({
-      field: "status",
-      message: `Invalid status: ${atom.status}`,
-      code: "INVALID_VALUE"
-    });
-  }
-  return {
-    valid: errors.length === 0,
-    errors
-  };
-}
-function validateTransition(currentStatus, newStatus) {
-  const allowedTransitions = ATOM_TRANSITIONS[currentStatus];
-  if (!allowedTransitions) {
-    return {
-      valid: false,
-      errors: [
-        {
-          field: "status",
-          message: `Unknown current status: ${currentStatus}`,
-          code: "INVALID_VALUE"
-        }
-      ]
-    };
-  }
-  if (!allowedTransitions.includes(newStatus)) {
-    return {
-      valid: false,
-      errors: [
-        {
-          field: "status",
-          message: `Cannot transition from ${currentStatus} to ${newStatus}. Allowed: ${allowedTransitions.join(", ") || "none"}`,
-          code: "INVALID_TRANSITION"
-        }
-      ]
-    };
-  }
-  return { valid: true, errors: [] };
-}
-function transitionAtom(atom, newStatus, errorMessage) {
-  const validation = validateTransition(atom.status, newStatus);
-  if (!validation.valid) {
-    const error = validation.errors[0];
-    throw new Error(error?.message ?? "Invalid transition");
-  }
-  const now = /* @__PURE__ */ new Date();
-  const updates = {
-    status: newStatus,
-    updatedAt: now
-  };
-  if (newStatus === "FAILED") {
-    updates.retryCount = atom.retryCount + 1;
-    updates.errorMessage = errorMessage ?? null;
-    if (updates.retryCount >= MAX_RETRIES2) {
-      updates.status = "BLOCKED";
-    }
-  }
-  if (newStatus === "IN_PROGRESS" && atom.status === "FAILED") {
-    updates.errorMessage = null;
-  }
-  return { ...atom, ...updates };
-}
+} from "./chunk-HJARQDQR.js";
 
 // src/agents/architect.ts
 import { readFile } from "fs/promises";
@@ -367,8 +215,5 @@ var ArchitectAgent = class {
 };
 
 export {
-  createAtom,
-  validateAtom,
-  transitionAtom,
   ArchitectAgent
 };

package/dist/chunk-3ASILTFB.js

@@ -0,0 +1,73 @@
+// src/cli/web-checks.ts
+import { existsSync } from "fs";
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join } from "path";
+import yaml from "yaml";
+var CONFIG_PATH = ".archon/config.yaml";
+function ensureWebChecks(config) {
+  if (!config.webChecks) {
+    config.webChecks = {};
+  }
+  if (!config.webChecks.promptMode) {
+    config.webChecks.promptMode = "ask";
+  }
+  if (!config.webChecks.lastRun) {
+    config.webChecks.lastRun = {};
+  }
+  return config.webChecks;
+}
+async function loadLocalConfig(cwd) {
+  const configPath = join(cwd, CONFIG_PATH);
+  if (!existsSync(configPath)) {
+    return {};
+  }
+  try {
+    const content = await readFile(configPath, "utf-8");
+    return yaml.parse(content) ?? {};
+  } catch {
+    return {};
+  }
+}
+async function saveLocalConfig(cwd, config) {
+  const configPath = join(cwd, CONFIG_PATH);
+  const archonDir = join(cwd, ".archon");
+  if (!existsSync(archonDir)) {
+    await mkdir(archonDir, { recursive: true });
+  }
+  await writeFile(configPath, yaml.stringify(config), "utf-8");
+}
+async function loadWebChecks(cwd) {
+  const config = await loadLocalConfig(cwd);
+  return ensureWebChecks(config);
+}
+async function setWebPromptMode(cwd, mode) {
+  const config = await loadLocalConfig(cwd);
+  const webChecks = ensureWebChecks(config);
+  webChecks.promptMode = mode;
+  await saveLocalConfig(cwd, config);
+}
+async function recordWebCheckResult(cwd, type, passed) {
+  const config = await loadLocalConfig(cwd);
+  const webChecks = ensureWebChecks(config);
+  if (!webChecks.lastRun) {
+    webChecks.lastRun = {};
+  }
+  webChecks.lastRun[type] = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    passed
+  };
+  await saveLocalConfig(cwd, config);
+}
+function formatWebCheckStatus(run) {
+  if (!run) return "Never run";
+  const date = new Date(run.timestamp);
+  const formatted = isNaN(date.getTime()) ? run.timestamp : `${date.toLocaleDateString()} ${date.toLocaleTimeString()}`;
+  return `${run.passed ? "Passed" : "Issues found"} \u2022 ${formatted}`;
+}
+
+export {
+  loadWebChecks,
+  setWebPromptMode,
+  recordWebCheckResult,
+  formatWebCheckStatus
+};

package/dist/{chunk-LHCXE6UL.js → chunk-3PZ7WU5I.js}

@@ -2,33 +2,35 @@ import {
   ArchitectureParser
 } from "./chunk-5EVHUDQX.js";
 import {
-  ArchitectAgent,
   createAtom,
   validateAtom
-} from "./chunk-ER4ADSWH.js";
+} from "./chunk-5CFGPXQ3.js";
+import {
+  ArchitectAgent
+} from "./chunk-2NSWZDP7.js";
 import {
   AnthropicClient,
   getDefaultModel
-} from "./chunk-NIKN37AY.js";
+} from "./chunk-HJARQDQR.js";
 import {
   KeyManager
 } from "./chunk-RDG5BUED.js";
-import {
-  createAuthedSupabaseClient,
-  isAuthenticated,
-  loadConfig
-} from "./chunk-SUGIWSCB.js";
 import {
   SUPABASE_ANON_KEY,
   SUPABASE_URL
 } from "./chunk-M4LGRTLC.js";
+import {
+  isAuthenticated,
+  loadConfig
+} from "./chunk-SVU7MLG6.js";
 
 // src/cli/plan.ts
 import chalk from "chalk";
-import { existsSync as existsSync2 } from "fs";
-import { readFile as readFile2, writeFile, mkdir } from "fs/promises";
-import { join as join2 } from "path";
+import { existsSync } from "fs";
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join } from "path";
 import { createInterface } from "readline";
+import { createClient } from "@supabase/supabase-js";
 
 // src/agents/sentinel.ts
 var SYSTEM_PROMPT = `You are the Sentinel, a paranoid and skeptical code reviewer responsible for finding issues in implementation plans.
@@ -732,31 +734,6 @@ var TrackedAdversarialPlanner = class {
   }
 };
 
-// src/core/config/roles.ts
-import { existsSync } from "fs";
-import { readFile } from "fs/promises";
-import { join } from "path";
-import yaml from "yaml";
-async function loadRoleOverrides(cwd = process.cwd()) {
-  const candidates = [
-    join(cwd, ".archon", "config.yaml"),
-    join(cwd, "archon.config.yaml")
-  ];
-  for (const path of candidates) {
-    if (!existsSync(path)) continue;
-    try {
-      const content = await readFile(path, "utf-8");
-      const parsed = yaml.parse(content);
-      if (parsed?.roles) {
-        return parsed.roles;
-      }
-    } catch {
-      continue;
-    }
-  }
-  return null;
-}
-
 // src/cli/plan.ts
 var ATOMS_DIR = ".archon/atoms";
 function createPrompt() {
@@ -778,8 +755,8 @@ async function plan(description, options) {
       console.log(chalk.yellow('Not authenticated. Run "archon login" first.'));
       console.log(chalk.dim("For local development, you can continue without authentication."));
     }
-    const archPath = join2(process.cwd(), "ARCHITECTURE.md");
-    if (!existsSync2(archPath)) {
+    const archPath = join(process.cwd(), "ARCHITECTURE.md");
+    if (!existsSync(archPath)) {
       console.error(chalk.red('ARCHITECTURE.md not found. Run "archon init" first.'));
       process.exit(1);
     }
@@ -804,26 +781,6 @@ async function plan(description, options) {
       }
       process.exit(1);
     }
-    if (options.edit) {
-      console.log(chalk.dim("\nEdit mode: update title and acceptance criteria (press Enter to keep current)."));
-      const newTitle = await prompt.ask(`Title [${atom.title}]: `);
-      if (newTitle.trim()) {
-        atom.title = newTitle.trim();
-      }
-      const acCurrent = atom.acceptanceCriteria.join(", ");
-      const newAc = await prompt.ask(`Acceptance criteria (comma-separated) [${acCurrent}]: `);
-      if (newAc.trim()) {
-        atom.acceptanceCriteria = newAc.split(",").map((ac) => ac.trim()).filter(Boolean);
-      }
-      const revalidation = validateAtom(atom);
-      if (!revalidation.valid) {
-        console.error(chalk.red("Invalid atom after edits:"));
-        for (const error of revalidation.errors) {
-          console.error(chalk.red(`  - ${error.field}: ${error.message}`));
-        }
-        process.exit(1);
-      }
-    }
     console.log(chalk.blue(`
 Atom created: ${atom.externalId}`));
     console.log(chalk.dim(`Title: ${atom.title}`));
@@ -849,17 +806,14 @@ Atom saved: ${atom.externalId}`));
     console.log(chalk.dim("Architect will generate a plan, Sentinel will validate it.\n"));
     const config = await loadConfig();
     let billingContext;
-    if (config.userId && config.accessToken) {
-      const supabase = createAuthedSupabaseClient(SUPABASE_URL, SUPABASE_ANON_KEY, config.accessToken);
+    if (config.userId) {
+      const supabase = createClient(SUPABASE_URL, SUPABASE_ANON_KEY);
       billingContext = {
         userId: config.userId,
         supabase
       };
     }
-    const roleOverrides = await loadRoleOverrides(process.cwd());
-    const architectConfig = roleOverrides?.architect?.model ? { model: roleOverrides.architect.model } : void 0;
-    const sentinelConfig = roleOverrides?.sentinel?.model ? { model: roleOverrides.sentinel.model } : void 0;
-    const planner = billingContext ? new TrackedAdversarialPlanner({ apiKey, billing: billingContext, architectConfig, sentinelConfig }) : new AdversarialPlanner({ apiKey, architectConfig, sentinelConfig });
+    const planner = billingContext ? new TrackedAdversarialPlanner({ apiKey, billing: billingContext }) : new AdversarialPlanner({ apiKey });
     if (billingContext && planner instanceof TrackedAdversarialPlanner) {
       const balanceCheck = await planner.checkBalance();
       if (!balanceCheck.sufficient && balanceCheck.tier === "CREDITS") {
@@ -973,24 +927,24 @@ function displayPlan(plan2) {
   console.log(chalk.bold("\nComplexity:"), plan2.estimated_complexity);
 }
 async function saveAtom(atom) {
-  const atomsDir = join2(process.cwd(), ATOMS_DIR);
-  if (!existsSync2(atomsDir)) {
+  const atomsDir = join(process.cwd(), ATOMS_DIR);
+  if (!existsSync(atomsDir)) {
     await mkdir(atomsDir, { recursive: true });
   }
-  const atomFile = join2(atomsDir, `${atom.externalId}.json`);
+  const atomFile = join(atomsDir, `${atom.externalId}.json`);
   await writeFile(atomFile, JSON.stringify(atom, null, 2));
 }
 async function loadAtom(atomId) {
-  const atomFile = join2(process.cwd(), ATOMS_DIR, `${atomId}.json`);
-  if (!existsSync2(atomFile)) {
+  const atomFile = join(process.cwd(), ATOMS_DIR, `${atomId}.json`);
+  if (!existsSync(atomFile)) {
     return null;
   }
-  const content = await readFile2(atomFile, "utf-8");
+  const content = await readFile(atomFile, "utf-8");
   return JSON.parse(content);
 }
 async function listLocalAtoms() {
-  const atomsDir = join2(process.cwd(), ATOMS_DIR);
-  if (!existsSync2(atomsDir)) {
+  const atomsDir = join(process.cwd(), ATOMS_DIR);
+  if (!existsSync(atomsDir)) {
     return [];
   }
   const { readdir } = await import("fs/promises");
@@ -1009,7 +963,6 @@ async function listLocalAtoms() {
 
 export {
   UsageRecorder,
-  loadRoleOverrides,
   plan,
   parseAtomDescription,
   loadAtom,

package/dist/{chunk-QGM4M3NI.js → chunk-4VNS5WPM.js}

@@ -13,6 +13,10 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -33,5 +37,6 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 export {
   __require,
   __commonJS,
+  __export,
   __toESM
 };

package/dist/chunk-4YEJ26F7.js

@@ -0,0 +1,183 @@
+import {
+  SUPABASE_ANON_KEY,
+  SUPABASE_URL
+} from "./chunk-M4LGRTLC.js";
+import {
+  getAuthToken,
+  loadConfig
+} from "./chunk-SVU7MLG6.js";
+
+// src/core/supabase/client.ts
+import { createClient } from "@supabase/supabase-js";
+function createAuthedSupabaseClient(supabaseUrl, supabaseAnonKey, accessToken) {
+  return createClient(supabaseUrl, supabaseAnonKey, {
+    global: { headers: { Authorization: `Bearer ${accessToken}` } }
+  });
+}
+
+// src/cli/cloud.ts
+import chalk from "chalk";
+function getClient(accessToken) {
+  return createAuthedSupabaseClient(SUPABASE_URL, SUPABASE_ANON_KEY, accessToken);
+}
+async function cloudStatus() {
+  const config = await loadConfig();
+  const authToken = getAuthToken(config);
+  if (!authToken) {
+    console.error(chalk.red('Not authenticated. Run "archon login" first.'));
+    process.exit(1);
+  }
+  const client = getClient(authToken);
+  const { data, error } = await client.from("cloud_executions").select("*").order("created_at", { ascending: false }).limit(20);
+  if (error) {
+    console.error(chalk.red("Failed to fetch cloud executions:"), error.message);
+    process.exit(1);
+  }
+  if (!data || data.length === 0) {
+    console.log(chalk.dim("No cloud executions found."));
+    return;
+  }
+  console.log(chalk.bold("\nCloud Executions:\n"));
+  for (const exec of data) {
+    const statusIcon = getStatusIcon(exec.status);
+    const duration = exec.compute_minutes ? `${exec.compute_minutes} min` : "-";
+    console.log(`${statusIcon} ${chalk.bold(exec.id.slice(0, 8))} - ${exec.atom_id}`);
+    console.log(chalk.dim(`   Project: ${exec.project_name ?? "unknown"}`));
+    console.log(chalk.dim(`   Status: ${exec.status} | Duration: ${duration}`));
+    if (exec.result_branch) {
+      console.log(chalk.dim(`   Branch: ${exec.result_branch}`));
+    }
+    if (exec.result_pr_url) {
+      console.log(chalk.dim(`   PR: ${exec.result_pr_url}`));
+    }
+    if (exec.error_message) {
+      console.log(chalk.red(`   Error: ${exec.error_message}`));
+    }
+    console.log();
+  }
+}
+async function cloudCancel(executionId) {
+  const config = await loadConfig();
+  const authToken = getAuthToken(config);
+  if (!authToken) {
+    console.error(chalk.red('Not authenticated. Run "archon login" first.'));
+    process.exit(1);
+  }
+  const client = getClient(authToken);
+  const { data: existing, error: fetchError } = await client.from("cloud_executions").select("id, status").eq("id", executionId).single();
+  if (fetchError || !existing) {
+    console.error(chalk.red(`Execution ${executionId} not found.`));
+    process.exit(1);
+  }
+  if (existing.status === "completed" || existing.status === "failed" || existing.status === "cancelled") {
+    console.log(chalk.yellow(`Execution is already ${existing.status}. Cannot cancel.`));
+    return;
+  }
+  const { error } = await client.from("cloud_executions").update({ status: "cancelled" }).eq("id", executionId);
+  if (error) {
+    console.error(chalk.red("Failed to cancel execution:"), error.message);
+    process.exit(1);
+  }
+  console.log(chalk.green(`\u2713 Execution ${executionId.slice(0, 8)} cancelled.`));
+}
+async function cloudLogs(executionId) {
+  const config = await loadConfig();
+  const authToken = getAuthToken(config);
+  if (!authToken) {
+    console.error(chalk.red('Not authenticated. Run "archon login" first.'));
+    process.exit(1);
+  }
+  const client = getClient(authToken);
+  const { data, error } = await client.from("cloud_executions").select("id, atom_id, status, logs").eq("id", executionId).single();
+  if (error || !data) {
+    console.error(chalk.red(`Execution ${executionId} not found.`));
+    process.exit(1);
+  }
+  const exec = data;
+  console.log(chalk.bold(`
+Logs for ${exec.id.slice(0, 8)} (${exec.atom_id}):
+`));
+  console.log(chalk.dim(`Status: ${exec.status}
+`));
+  const logs = exec.logs;
+  if (!logs || logs.length === 0) {
+    console.log(chalk.dim("No logs available yet."));
+    return;
+  }
+  for (const log of logs) {
+    const ts = log.timestamp ? chalk.dim(`[${log.timestamp}]`) : "";
+    const level = log.level === "error" ? chalk.red("ERROR") : log.level === "warn" ? chalk.yellow("WARN") : chalk.dim("INFO");
+    console.log(`${ts} ${level} ${log.message}`);
+  }
+}
+async function queueCloudExecution(atomId, projectName, options) {
+  const config = await loadConfig();
+  const authToken = getAuthToken(config);
+  if (!authToken) {
+    throw new Error('Not authenticated. Run "archon login" first.');
+  }
+  const client = getClient(authToken);
+  const insertData = {
+    atom_id: atomId,
+    project_name: projectName,
+    status: "queued"
+  };
+  if (options?.repoUrl) {
+    insertData["repo_url"] = options.repoUrl;
+  }
+  if (options?.repoBranch) {
+    insertData["repo_branch"] = options.repoBranch;
+  }
+  if (options?.atomData) {
+    insertData["atom_data"] = options.atomData;
+  }
+  const { data, error } = await client.from("cloud_executions").insert(insertData).select("id").single();
+  if (error) {
+    throw new Error(`Failed to queue execution: ${error.message}`);
+  }
+  return data.id;
+}
+async function getGitRemoteUrl(cwd = process.cwd()) {
+  try {
+    const { execSync } = await import("child_process");
+    const output = execSync("git remote get-url origin", { cwd, encoding: "utf-8" });
+    return output.trim();
+  } catch {
+    return null;
+  }
+}
+async function getGitBranch(cwd = process.cwd()) {
+  try {
+    const { execSync } = await import("child_process");
+    const output = execSync("git branch --show-current", { cwd, encoding: "utf-8" });
+    return output.trim() || "main";
+  } catch {
+    return "main";
+  }
+}
+function getStatusIcon(status) {
+  switch (status) {
+    case "queued":
+      return chalk.blue("\u23F3");
+    case "running":
+      return chalk.yellow("\u{1F504}");
+    case "completed":
+      return chalk.green("\u2713");
+    case "failed":
+      return chalk.red("\u2717");
+    case "cancelled":
+      return chalk.gray("\u2298");
+    default:
+      return chalk.dim("?");
+  }
+}
+
+export {
+  createAuthedSupabaseClient,
+  cloudStatus,
+  cloudCancel,
+  cloudLogs,
+  queueCloudExecution,
+  getGitRemoteUrl,
+  getGitBranch
+};