@testsmith/api-spector 0.9.0 → 0.9.2

package/out/main/register-handlers.js

@@ -23,7 +23,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const electron = require("electron");
-const handle = require("./chunks/handle-_4XMUlwm.js");
+const handle = require("./chunks/handle-HQp1EXf8.js");
 const promises = require("node:fs/promises");
 const path = require("node:path");
 const crypto = require("node:crypto");
@@ -31,12 +31,12 @@ const JSZip = require("jszip");
 const simpleGit = require("simple-git");
 const dataFiles = require("./chunks/data-files-BYqhsoPe.js");
 const requestCollection = require("./chunks/request-collection-zRRUfg0X.js");
-const requestExec = require("./chunks/request-exec-CcF1Fzve.js");
+const requestExec = require("./chunks/request-exec-B8DJ8Id2.js");
 const ipcValidate = require("./chunks/ipc-validate-sqUFqRmE.js");
 const uuid = require("uuid");
 const jsYaml = require("js-yaml");
 const undici = require("undici");
-const soapHandler = require("./chunks/soap-handler-BF5ii0UV.js");
+const soapHandler = require("./chunks/soap-handler-D_Hj9e8S.js");
 const runConcurrent = require("./chunks/run-concurrent-468tH0AX.js");
 const flowEngine = require("./chunks/flow-engine-BxwjEy37.js");
 const mockServer = require("./chunks/mock-server-C4kTFkod.js");
@@ -50,7 +50,7 @@ const os = require("node:os");
 const grpc = require("@grpc/grpc-js");
 const protoLoader = require("@grpc/proto-loader");
 const escape = require("./chunks/escape-DDVAlOvZ.js");
-const brokerClient = require("./chunks/broker-client-DqDgA2G6.js");
+const brokerClient = require("./chunks/broker-client-Cl6Fu3oD.js");
 const recorder = require("./chunks/recorder-BkO8G_mB.js");
 require("fs/promises");
 require("tls");
@@ -269,6 +269,62 @@ function defaultWorkspaceName() {
   }
   return "my-workspace.spector";
 }
+const SYNC_SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules"]);
+const SYNC_SKIP_FILES = /* @__PURE__ */ new Set(["history.json"]);
+function stripEnvSecrets(text) {
+  try {
+    const env = JSON.parse(text);
+    if (Array.isArray(env.variables)) {
+      env.variables = env.variables.map((v) => {
+        const rest = { ...v };
+        delete rest["secretEncrypted"];
+        delete rest["secretSalt"];
+        delete rest["secretIv"];
+        delete rest["secretHash"];
+        if (rest["secret"]) rest["value"] = "";
+        return rest;
+      });
+    }
+    return JSON.stringify(env, null, 2);
+  } catch {
+    return text;
+  }
+}
+function mergeEnvSecrets(remoteText, localText) {
+  if (!localText) return remoteText;
+  try {
+    const remote = JSON.parse(remoteText);
+    const local = JSON.parse(localText);
+    const byKey = /* @__PURE__ */ new Map();
+    for (const lv of local.variables ?? []) byKey.set(String(lv["key"]), lv);
+    remote.variables = (remote.variables ?? []).map((rv) => {
+      const lv = byKey.get(String(rv["key"]));
+      if (!lv) return rv;
+      const merged = { ...rv };
+      for (const f of ["secretEncrypted", "secretSalt", "secretIv", "secretHash"]) {
+        if (lv[f] !== void 0) merged[f] = lv[f];
+      }
+      if (rv["secret"] && lv["value"]) merged["value"] = lv["value"];
+      return merged;
+    });
+    return JSON.stringify(remote, null, 2);
+  } catch {
+    return remoteText;
+  }
+}
+async function walkWorkspaceFiles(dir, base, out) {
+  const entries = await promises.readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      if (SYNC_SKIP_DIRS.has(entry.name)) continue;
+      await walkWorkspaceFiles(path.join(dir, entry.name), base, out);
+    } else if (entry.isFile()) {
+      if (SYNC_SKIP_FILES.has(entry.name)) continue;
+      const full = path.join(dir, entry.name);
+      out[full.slice(base.length + 1).split(path.sep).join("/")] = await promises.readFile(full, "utf8");
+    }
+  }
+}
 function registerFileHandlers(ipc) {
   handle.handleIpc(ipc, handle.IPC.file.openWorkspace, async () => {
     const result = await electron.dialog.showOpenDialog({
@@ -383,6 +439,68 @@ Create a workspace in this folder and add "${path.basename(wsPath)}" to it? The
       if (err.code !== "ENOENT") throw err;
     }
   });
+  handle.handleIpc(ipc, handle.IPC.file.serializeWorkspace, async () => {
+    if (!workspaceDir || !workspaceFile) throw new Error("No workspace open");
+    const manifest = JSON.parse(await promises.readFile(workspaceFile, "utf8"));
+    const files = {};
+    await walkWorkspaceFiles(workspaceDir, workspaceDir, files);
+    const manifestName = path.basename(workspaceFile);
+    delete files[manifestName];
+    for (const rel of Object.keys(files)) {
+      if (rel.startsWith("environments/")) files[rel] = stripEnvSecrets(files[rel]);
+    }
+    const sharedSettings = { ...manifest.settings ?? {} };
+    delete sharedSettings["cloud"];
+    delete sharedSettings["sync"];
+    return { manifest: { ...manifest, settings: sharedSettings }, manifestName, files };
+  });
+  handle.handleIpc(ipc, handle.IPC.file.applyWorkspaceSnapshot, async (_e, snap) => {
+    if (!workspaceDir || !workspaceFile) throw new Error("No workspace open");
+    try {
+      const backupDir = path.join(electron.app.getPath("userData"), "sync-backups", path.basename(workspaceDir) + "-" + Date.now());
+      await promises.cp(workspaceDir, backupDir, {
+        recursive: true,
+        filter: (src) => {
+          const rel = src.slice(workspaceDir.length);
+          return !/[\\/](\.git|node_modules)([\\/]|$)/.test(rel);
+        }
+      });
+    } catch (err) {
+      console.warn("sync: workspace backup failed (continuing):", err);
+    }
+    const guard = path.resolve(workspaceDir) + (process.platform === "win32" ? "\\" : "/");
+    let filesWritten = 0;
+    for (const [rel, content] of Object.entries(snap.files ?? {})) {
+      const full = path.resolve(workspaceDir, rel);
+      if (!full.startsWith(guard)) continue;
+      let out = content;
+      if (rel.startsWith("environments/")) {
+        let localText = null;
+        try {
+          localText = await promises.readFile(full, "utf8");
+        } catch {
+        }
+        out = mergeEnvSecrets(content, localText);
+      }
+      await promises.mkdir(path.dirname(full), { recursive: true });
+      await atomicWrite(full, out);
+      filesWritten++;
+    }
+    const local = JSON.parse(await promises.readFile(workspaceFile, "utf8"));
+    const merged = {
+      ...local,
+      ...snap.manifest,
+      settings: { ...snap.manifest.settings ?? {}, ...local.settings ?? {} }
+    };
+    await atomicWrite(workspaceFile, JSON.stringify(merged, null, 2));
+    return {
+      ok: true,
+      filesWritten,
+      collections: Array.isArray(merged.collections) ? merged.collections.length : 0,
+      workspace: merged,
+      workspacePath: workspaceFile
+    };
+  });
   handle.handleIpc(ipc, handle.IPC.file.loadHistory, async () => {
     if (!workspaceDir) return [];
     try {
@@ -2677,7 +2795,7 @@ function registerImportHandlers(ipc) {
     if (opts.url?.trim()) {
       const url = opts.url.trim();
       const { validateWsdlFetchUrl } = await Promise.resolve().then(() => require("./chunks/ipc-validate-sqUFqRmE.js"));
-      const { fetchUrl } = await Promise.resolve().then(() => require("./chunks/soap-handler-BF5ii0UV.js")).then((n) => n.soapHandler);
+      const { fetchUrl } = await Promise.resolve().then(() => require("./chunks/soap-handler-D_Hj9e8S.js")).then((n) => n.soapHandler);
       validateWsdlFetchUrl(url);
       wsdlText = await fetchUrl(url);
       try {
@@ -7573,6 +7691,30 @@ function registerGitHandlers(ipc) {
   handle.handleIpc(ipc, handle.IPC.git.deleteBranch, async (_e, name, force = false) => {
     await git().deleteLocalBranch(name, force);
   });
+  handle.handleIpc(ipc, handle.IPC.git.stashList, async () => {
+    const raw = await git().raw(["stash", "list", "--format=%gd%gs"]);
+    return raw.split("\n").filter(Boolean).map((line, index) => {
+      const [ref = `stash@{${index}}`, subject = ""] = line.split("");
+      const m = /^(?:WIP on|On) ([^:]+): (.*)$/.exec(subject);
+      return {
+        index,
+        ref,
+        branch: m ? m[1] : "",
+        message: m ? m[2] : subject
+      };
+    });
+  });
+  handle.handleIpc(ipc, handle.IPC.git.stash, async (_e, message) => {
+    const args = ["stash", "push", "-u"];
+    if (message && message.trim()) args.push("-m", message.trim());
+    await git().raw(args);
+  });
+  handle.handleIpc(ipc, handle.IPC.git.stashPop, async (_e, ref) => {
+    await git().raw(["stash", "pop", ...ref ? [ref] : []]);
+  });
+  handle.handleIpc(ipc, handle.IPC.git.stashDrop, async (_e, ref) => {
+    await git().raw(["stash", "drop", ...ref ? [ref] : []]);
+  });
   handle.handleIpc(ipc, handle.IPC.git.fetch, async () => {
     await git().fetch(["--prune"]);
   });
@@ -7921,6 +8063,76 @@ function registerCloudHandlers(ipc) {
   handle.handleIpc(ipc, handle.IPC.cloud.openFlow, async (_e, name) => {
     await electron.shell.openExternal(CLOUD_ENDPOINT + "/flows/" + encodeURIComponent(slugify(name)));
   });
+  const stripRequest = (r) => {
+    const { examples: _examples, ...rest } = r;
+    return rest;
+  };
+  const stripFolder = (f) => {
+    const { dataSet: _d, dataSetRef: _r, ...rest } = f ?? {};
+    const folders = Array.isArray(rest["folders"]) ? rest["folders"].map(stripFolder) : [];
+    return { ...rest, folders };
+  };
+  const stripCollection = (col) => {
+    const { dataSet: _d, dataSetRef: _r, ...rest } = col;
+    const requests = {};
+    for (const [id, req] of Object.entries(col.requests ?? {})) requests[id] = stripRequest(req);
+    return { ...rest, requests, rootFolder: stripFolder(col.rootFolder) };
+  };
+  handle.handleIpc(ipc, handle.IPC.cloud.shareCollection, async (_e, col) => {
+    return cloudFetch("/api/share", "POST", { type: "collection", source_id: col.id, name: col.name, payload: stripCollection(col) });
+  });
+  handle.handleIpc(ipc, handle.IPC.cloud.shareRequest, async (_e, req) => {
+    return cloudFetch("/api/share", "POST", { type: "request", source_id: req.id, name: req.name, payload: stripRequest(req) });
+  });
+  handle.handleIpc(ipc, handle.IPC.cloud.shareFolder, async (_e, arg) => {
+    return cloudFetch("/api/share", "POST", { type: "folder", source_id: arg.sourceId, name: arg.name, payload: stripCollection(arg.payload) });
+  });
+  handle.handleIpc(ipc, handle.IPC.cloud.shareLookup, async (_e, arg) => {
+    const q = new URLSearchParams({ type: arg.type, source_id: arg.sourceId }).toString();
+    return cloudFetch("/api/share-lookup?" + q, "GET");
+  });
+  handle.handleIpc(ipc, handle.IPC.cloud.shareUpdate, async (_e, arg) => {
+    const token = String(arg.token).replace(/[^a-z0-9]/gi, "");
+    return cloudFetch("/api/share/" + encodeURIComponent(token), "PATCH", { expires_days: arg.expiresDays ?? 0 });
+  });
+  handle.handleIpc(ipc, handle.IPC.cloud.shareRevoke, async (_e, token) => {
+    const clean = String(token).replace(/[^a-z0-9]/gi, "");
+    return cloudFetch("/api/share/" + encodeURIComponent(clean), "DELETE");
+  });
+  handle.handleIpc(ipc, handle.IPC.cloud.workspaceList, async () => cloudFetch("/api/workspaces", "GET"));
+  handle.handleIpc(ipc, handle.IPC.cloud.workspaceCreate, async (_e, arg) => cloudFetch("/api/workspaces", "POST", { name: arg.name, payload: arg.payload, author: arg.author }));
+  handle.handleIpc(ipc, handle.IPC.cloud.workspacePull, async (_e, id) => cloudFetch("/api/workspaces/" + encodeURIComponent(String(id)), "GET"));
+  handle.handleIpc(ipc, handle.IPC.cloud.workspaceVersions, async (_e, id) => cloudFetch("/api/workspaces/" + encodeURIComponent(String(id)) + "/versions", "GET"));
+  handle.handleIpc(ipc, handle.IPC.cloud.workspaceRestore, async (_e, arg) => cloudFetch("/api/workspaces/" + encodeURIComponent(String(arg.id)) + "/restore", "POST", { version: arg.version }));
+  handle.handleIpc(ipc, handle.IPC.cloud.workspacePush, async (_e, arg) => {
+    const token = await requestExec.getSecret(CLOUD_TOKEN_REF);
+    if (!token) throw new Error("No cloud API token set. Add one in Settings → Cloud.");
+    const dispatcher = await requestExec.buildDispatcher();
+    const res = await undici.fetch(CLOUD_ENDPOINT + "/api/workspaces/" + encodeURIComponent(String(arg.id)), {
+      method: "PUT",
+      headers: { "Content-Type": "application/json", Accept: "application/json", Authorization: `Bearer ${token}` },
+      body: JSON.stringify({ base_version: arg.baseVersion, payload: arg.payload, author: arg.author }),
+      dispatcher
+    });
+    const json = await res.json().catch(() => ({}));
+    if (res.status === 409) return { conflict: true, currentVersion: json.current_version };
+    if (!res.ok) throw new Error(json.error || json.message || `Push failed (HTTP ${res.status}).`);
+    return { conflict: false, version: json.version };
+  });
+  handle.handleIpc(ipc, handle.IPC.cloud.importShare, async (_e, token) => {
+    const cleaned = String(token).replace(/[^a-z0-9]/gi, "");
+    if (!cleaned) throw new Error("Invalid share link.");
+    const dispatcher = await requestExec.buildDispatcher();
+    const res = await undici.fetch(CLOUD_ENDPOINT + "/api/share/" + encodeURIComponent(cleaned), {
+      method: "GET",
+      headers: { Accept: "application/json" },
+      dispatcher
+    });
+    if (!res.ok) {
+      throw new Error(res.status === 404 || res.status === 410 ? "This share link is invalid or has expired." : `Could not fetch the shared item (HTTP ${res.status}).`);
+    }
+    return res.json();
+  });
   handle.handleIpc(ipc, handle.IPC.cloud.pushMonitor, async (_e, input) => {
     const { request, environment, collectionVars, globals } = input;
     const envVars = await requestExec.buildEnvVars(environment);

package/out/main/runner.js

@@ -2,7 +2,7 @@
 "use strict";
 const promises = require("node:fs/promises");
 const path = require("node:path");
-const requestExec = require("./chunks/request-exec-CcF1Fzve.js");
+const requestExec = require("./chunks/request-exec-B8DJ8Id2.js");
 const requestCollection = require("./chunks/request-collection-zRRUfg0X.js");
 const escape = require("./chunks/escape-DDVAlOvZ.js");
 const runConcurrent = require("./chunks/run-concurrent-468tH0AX.js");
@@ -11,7 +11,7 @@ const cliCommon = require("./chunks/cli-common-GnihVSjU.js");
 require("undici");
 require("fs/promises");
 require("tls");
-require("./chunks/handle-_4XMUlwm.js");
+require("./chunks/handle-HQp1EXf8.js");
 require("node:fs");
 require("node:os");
 require("node:crypto");
@@ -551,7 +551,7 @@ async function main() {
   } else if (!envName && workspace.settings?.defaultEnvironment && !env) {
     console.warn(cliCommon.color(`Warning: default environment "${workspace.settings.defaultEnvironment}" not found. Running without environment.`, cliCommon.C.yellow));
   }
-  const version = `v${"0.9.0"}`;
+  const version = `v${"0.9.2"}`;
   console.log("");
   console.log(cliCommon.color("  API Test Runner" + (version ? ` ${version}` : ""), cliCommon.C.bold, cliCommon.C.white));
   console.log(cliCommon.color(`  Workspace:   ${wsPath}`, cliCommon.C.gray));

package/out/main/wsdl.js

@@ -4,10 +4,10 @@ const promises = require("node:fs/promises");
 const path = require("node:path");
 const https = require("node:https");
 const http = require("node:http");
-const soapHandler = require("./chunks/soap-handler-BF5ii0UV.js");
-const _import = require("./chunks/import-ujxXe3Uu.js");
+const soapHandler = require("./chunks/soap-handler-D_Hj9e8S.js");
+const _import = require("./chunks/import-DVpFH9Wb.js");
 const cliCommon = require("./chunks/cli-common-GnihVSjU.js");
-require("./chunks/handle-_4XMUlwm.js");
+require("./chunks/handle-HQp1EXf8.js");
 require("@xmldom/xmldom");
 require("uuid");
 require("./chunks/data-files-BYqhsoPe.js");

package/out/preload/index.js

@@ -9,6 +9,13 @@ const IPC = {
     /** Event (main→renderer): a `spector://open-from-git?url=…` deep link was
      *  received; the renderer runs the same open-from-Git flow as the button. */
     openFromGitDeepLink: "file:openFromGitDeepLink",
+    /** Event (main→renderer): a `spector://import?token=…` deep link was
+     *  received; the renderer imports the shared collection/request. */
+    importShareDeepLink: "file:importShareDeepLink",
+    /** Serialize the open workspace to a secret-free snapshot for cloud sync. */
+    serializeWorkspace: "file:serializeWorkspace",
+    /** Apply a pulled snapshot to disk (backs up first; merges local secrets). */
+    applyWorkspaceSnapshot: "file:applyWorkspaceSnapshot",
     getLastWorkspace: "file:getLastWorkspace",
     getRecentWorkspaces: "file:getRecentWorkspaces",
     saveWorkspace: "file:saveWorkspace",
@@ -241,6 +248,10 @@ const IPC = {
     branches: "git:branches",
     checkout: "git:checkout",
     deleteBranch: "git:deleteBranch",
+    stashList: "git:stashList",
+    stash: "git:stash",
+    stashPop: "git:stashPop",
+    stashDrop: "git:stashDrop",
     fetch: "git:fetch",
     pull: "git:pull",
     push: "git:push",
@@ -309,7 +320,28 @@ const IPC = {
     /** Open a flow's page in the cloud UI. */
     openFlow: "cloud:openFlow",
     /** Open the cloud deployment matrix in the browser. */
-    openMatrix: "cloud:openMatrix"
+    openMatrix: "cloud:openMatrix",
+    /** Share a collection as a public read-only link (POST /api/share). */
+    shareCollection: "cloud:shareCollection",
+    /** Share a single request as a public read-only link (POST /api/share). */
+    shareRequest: "cloud:shareRequest",
+    /** Share a folder subtree as a public read-only link (POST /api/share). */
+    shareFolder: "cloud:shareFolder",
+    /** Fetch a shared collection/request by token for import (GET /api/share/{token}). */
+    importShare: "cloud:importShare",
+    /** Look up an existing share for a local collection/request (GET /api/share-lookup). */
+    shareLookup: "cloud:shareLookup",
+    /** Restrict a share: set/clear its expiry (PATCH /api/share/{token}). */
+    shareUpdate: "cloud:shareUpdate",
+    /** Revoke a share link (DELETE /api/share/{token}). */
+    shareRevoke: "cloud:shareRevoke",
+    /** Cloud-synced workspaces (collaborate without git). */
+    workspaceList: "cloud:workspaceList",
+    workspaceCreate: "cloud:workspaceCreate",
+    workspacePull: "cloud:workspacePull",
+    workspacePush: "cloud:workspacePush",
+    workspaceVersions: "cloud:workspaceVersions",
+    workspaceRestore: "cloud:workspaceRestore"
   }
 };
 const api = {
@@ -325,7 +357,15 @@ const api = {
   offOpenFromGit: () => {
     electron.ipcRenderer.removeAllListeners(IPC.file.openFromGitDeepLink);
   },
+  onImportShare: (cb) => {
+    electron.ipcRenderer.on(IPC.file.importShareDeepLink, (_e, token) => cb(token));
+  },
+  offImportShare: () => {
+    electron.ipcRenderer.removeAllListeners(IPC.file.importShareDeepLink);
+  },
   saveWorkspace: (ws) => electron.ipcRenderer.invoke(IPC.file.saveWorkspace, ws),
+  serializeWorkspace: () => electron.ipcRenderer.invoke(IPC.file.serializeWorkspace),
+  applyWorkspaceSnapshot: (snap) => electron.ipcRenderer.invoke(IPC.file.applyWorkspaceSnapshot, snap),
   newWorkspace: () => electron.ipcRenderer.invoke(IPC.file.newWorkspace),
   closeWorkspace: () => electron.ipcRenderer.invoke(IPC.file.closeWorkspace),
   loadCollection: (relPath) => electron.ipcRenderer.invoke(IPC.file.loadCollection, relPath),
@@ -418,6 +458,19 @@ const api = {
   cloudRunFlow: (name) => electron.ipcRenderer.invoke(IPC.cloud.runFlow, name),
   cloudGetFlowRun: (arg) => electron.ipcRenderer.invoke(IPC.cloud.getFlowRun, arg),
   cloudOpenFlow: (name) => electron.ipcRenderer.invoke(IPC.cloud.openFlow, name),
+  cloudShareCollection: (collection) => electron.ipcRenderer.invoke(IPC.cloud.shareCollection, collection),
+  cloudShareRequest: (request) => electron.ipcRenderer.invoke(IPC.cloud.shareRequest, request),
+  cloudShareFolder: (arg) => electron.ipcRenderer.invoke(IPC.cloud.shareFolder, arg),
+  cloudImportShare: (token) => electron.ipcRenderer.invoke(IPC.cloud.importShare, token),
+  cloudShareLookup: (arg) => electron.ipcRenderer.invoke(IPC.cloud.shareLookup, arg),
+  cloudShareUpdate: (arg) => electron.ipcRenderer.invoke(IPC.cloud.shareUpdate, arg),
+  cloudShareRevoke: (token) => electron.ipcRenderer.invoke(IPC.cloud.shareRevoke, token),
+  cloudWorkspaceList: () => electron.ipcRenderer.invoke(IPC.cloud.workspaceList),
+  cloudWorkspaceCreate: (arg) => electron.ipcRenderer.invoke(IPC.cloud.workspaceCreate, arg),
+  cloudWorkspacePull: (id) => electron.ipcRenderer.invoke(IPC.cloud.workspacePull, id),
+  cloudWorkspacePush: (arg) => electron.ipcRenderer.invoke(IPC.cloud.workspacePush, arg),
+  cloudWorkspaceVersions: (id) => electron.ipcRenderer.invoke(IPC.cloud.workspaceVersions, id),
+  cloudWorkspaceRestore: (arg) => electron.ipcRenderer.invoke(IPC.cloud.workspaceRestore, arg),
   // ─── Mock servers ─────────────────────────────────────────────────────────────
   mockStart: (server) => electron.ipcRenderer.invoke(IPC.mock.start, server),
   mockStop: (id) => electron.ipcRenderer.invoke(IPC.mock.stop, id),
@@ -566,6 +619,10 @@ const api = {
   gitBranches: () => electron.ipcRenderer.invoke(IPC.git.branches),
   gitCheckout: (branch, create) => electron.ipcRenderer.invoke(IPC.git.checkout, branch, create),
   gitDeleteBranch: (name, force = false) => electron.ipcRenderer.invoke(IPC.git.deleteBranch, name, force),
+  gitStashList: () => electron.ipcRenderer.invoke(IPC.git.stashList),
+  gitStash: (message) => electron.ipcRenderer.invoke(IPC.git.stash, message),
+  gitStashPop: (ref) => electron.ipcRenderer.invoke(IPC.git.stashPop, ref),
+  gitStashDrop: (ref) => electron.ipcRenderer.invoke(IPC.git.stashDrop, ref),
   gitFetch: () => electron.ipcRenderer.invoke(IPC.git.fetch),
   gitPull: (rebase = false) => electron.ipcRenderer.invoke(IPC.git.pull, rebase),
   gitPush: (setUpstream) => electron.ipcRenderer.invoke(IPC.git.push, setUpstream),

package/out/renderer/assets/{GraphQLEditor-CmfodipY.js → GraphQLEditor-RRDuQogA.js}

@@ -1,5 +1,5 @@
 import { l as linter, E as EditorView, L as LanguageSupport, i as LRLanguage, s as styleTags, m as indentNodeProp, n as delimitedIndent, p as foldNodeProp, q as foldInside, S as StateField, u as LRParser, v as StateEffect, w as tags, a as reactExports, j as jsxRuntimeExports, e as ReactCodeMirror, o as oneDark, d as json } from "./codemirror-BKmwMUlV.js";
-import { u as useT, a as useStore, b as useActiveEnvironment, i as isSubscriptionQuery } from "./index-BV1FsSQR.js";
+import { u as useT, a as useStore, b as useActiveEnvironment, i as isSubscriptionQuery } from "./index-C6_D_4og.js";
 import "./ajv-CJPwFjiP.js";
 function devAssert(condition, message) {
   const booleanCondition = Boolean(condition);

package/out/renderer/assets/{SoapEditor-CVRCFvJy.js → SoapEditor-BncNQmjP.js}

@@ -1,5 +1,5 @@
 import { a as reactExports, j as jsxRuntimeExports, e as ReactCodeMirror, o as oneDark, x as xml } from "./codemirror-BKmwMUlV.js";
-import { u as useT, c as btnPrimaryCls, d as commentKeymap } from "./index-BV1FsSQR.js";
+import { u as useT, c as btnPrimaryCls, d as commentKeymap } from "./index-C6_D_4og.js";
 import "./ajv-CJPwFjiP.js";
 const SOAP_11_CONTENT_TYPE = "text/xml; charset=utf-8";
 const SOAP_12_CONTENT_TYPE = "application/soap+xml; charset=utf-8";